{"version":3,"file":"scripts.js","mappings":"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","sources":["webpack://datetracker/./src/scripts.ts","webpack://datetracker/webpack/bootstrap","webpack://datetracker/./node_modules/@kurkle/color/dist/color.esm.js","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.core.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.math.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.collection.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.extras.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.easing.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.color.ts","webpack://datetracker/./node_modules/chart.js/src/core/core.animations.defaults.js","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.intl.ts","webpack://datetracker/./node_modules/chart.js/src/core/core.ticks.js","webpack://datetracker/./node_modules/chart.js/src/core/core.defaults.js","webpack://datetracker/./node_modules/chart.js/src/core/core.layouts.defaults.js","webpack://datetracker/./node_modules/chart.js/src/core/core.scale.defaults.js","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.canvas.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.options.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.config.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.curve.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.dom.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.interpolation.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.rtl.ts","webpack://datetracker/./node_modules/chart.js/src/helpers/helpers.segment.js","webpack://datetracker/./node_modules/chart.js/src/core/core.animator.js","webpack://datetracker/./node_modules/chart.js/src/core/core.animation.js","webpack://datetracker/./node_modules/chart.js/src/core/core.animations.js","webpack://datetracker/./node_modules/chart.js/src/core/core.datasetController.js","webpack://datetracker/./node_modules/chart.js/src/controllers/controller.bar.js","webpack://datetracker/./node_modules/chart.js/src/controllers/controller.doughnut.js","webpack://datetracker/./node_modules/chart.js/src/controllers/controller.polarArea.js","webpack://datetracker/./node_modules/chart.js/src/core/core.interaction.js","webpack://datetracker/./node_modules/chart.js/src/core/core.layouts.js","webpack://datetracker/./node_modules/chart.js/src/platform/platform.base.js","webpack://datetracker/./node_modules/chart.js/src/platform/platform.basic.js","webpack://datetracker/./node_modules/chart.js/src/platform/platform.dom.js","webpack://datetracker/./node_modules/chart.js/src/core/core.element.ts","webpack://datetracker/./node_modules/chart.js/src/core/core.scale.autoskip.js","webpack://datetracker/./node_modules/chart.js/src/core/core.scale.js","webpack://datetracker/./node_modules/chart.js/src/core/core.typedRegistry.js","webpack://datetracker/./node_modules/chart.js/src/core/core.registry.js","webpack://datetracker/./node_modules/chart.js/src/core/core.plugins.js","webpack://datetracker/./node_modules/chart.js/src/core/core.config.js","webpack://datetracker/./node_modules/chart.js/src/core/core.controller.js","webpack://datetracker/./node_modules/chart.js/src/platform/index.js","webpack://datetracker/./node_modules/chart.js/src/elements/element.arc.ts","webpack://datetracker/./node_modules/chart.js/src/elements/element.line.js","webpack://datetracker/./node_modules/chart.js/src/elements/element.point.ts","webpack://datetracker/./node_modules/chart.js/src/elements/element.bar.js","webpack://datetracker/./node_modules/chart.js/src/plugins/plugin.colors.ts","webpack://datetracker/./node_modules/chart.js/src/plugins/plugin.title.js","webpack://datetracker/./node_modules/chart.js/src/plugins/plugin.subtitle.js","webpack://datetracker/./node_modules/chart.js/src/plugins/plugin.tooltip.js","webpack://datetracker/./node_modules/chart.js/src/scales/scale.category.js","webpack://datetracker/./node_modules/chart.js/src/scales/scale.linearbase.js","webpack://datetracker/./node_modules/chart.js/src/scales/scale.linear.js","webpack://datetracker/./node_modules/chart.js/src/scales/scale.logarithmic.js","webpack://datetracker/./node_modules/chart.js/src/scales/scale.radialLinear.js","webpack://datetracker/./node_modules/chartjs-plugin-datalabels/dist/chartjs-plugin-datalabels.esm.js","webpack://datetracker/./src/exports.ts","webpack://datetracker/./node_modules/chart.js/src/controllers/controller.pie.js","webpack://datetracker/./node_modules/chart.js/src/controllers/controller.line.js"],"sourcesContent":["document.addEventListener(\"DOMContentLoaded\", function () {\n  const browseButtons = document.querySelectorAll(\".userCard\");\n  if (browseButtons) {\n    browseButtons.forEach((button) => {\n      const browse = button.querySelector(\".hover-light\");\n      button.addEventListener(\"mouseenter\", (event) => {\n        browse?.classList.add(\"hovered\");\n      });\n      button.addEventListener(\"mouseleave\", (event) => {\n        browse?.classList.remove(\"hovered\");\n      });\n    });\n  }\n\n  const tokenInput: HTMLInputElement | null = document.getElementById(\n    \"ethnicity-input\"\n  ) as HTMLInputElement;\n  const tokenList: HTMLElement & TokenList = document.getElementById(\n    \"ethnicity-list\"\n  ) as HTMLElement & TokenList;\n  const tokenField: HTMLInputElement | null = document.getElementById(\n    \"ethnicities\"\n  ) as HTMLInputElement;\n\n  if (tokenList) {\n    tokenList.removeToken = function(token: HTMLElement) {\n      this.removeChild(token);\n    }\n  }\n\n  function addToken(tokenValue: string): void {\n    tokenValue = tokenValue.trim().capitalize();\n    if (tokenValue) {\n      const token = document.createElement(\"div\");\n      token.classList.add(\"token\");\n      const tokenLabel = document.createElement(\"div\");\n      tokenLabel.textContent = tokenValue;\n      tokenLabel.classList.add(\"token-label\");\n      token.appendChild(tokenLabel);\n      const closeToken = document.createElement(\"div\");\n      closeToken.innerHTML = `<i class='bx bx-x-circle align-middle'></i>`;\n      token.appendChild(closeToken);\n      closeToken.classList.add(\"token-close\");\n      const input = document.createElement(\"input\");\n      input.setAttribute(\"name\", \"ethnicity\");\n      input.setAttribute(\"type\", \"hidden\");\n      input.setAttribute(\"value\", tokenValue);\n      token.appendChild(input);\n      tokenList.appendChild(token);\n      if (tokenInput) {\n        tokenInput.value = \"\";\n      }\n      closeToken.addEventListener(\"click\", function () {\n        tokenList.removeToken(token);\n      });\n    }\n  }\n\n  if (tokenInput) {\n    tokenInput.addEventListener(\"blur\", function (event) {\n      event.preventDefault();\n      addToken(tokenInput.value);\n    });\n    tokenInput.addEventListener(\"keydown\", function (event) {\n      if (event.key === \"Enter\") {\n        event.preventDefault();\n        addToken(tokenInput.value);\n      }\n    });\n  }\n});\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","/*!\n * @kurkle/color v0.3.2\n * https://github.com/kurkle/color#readme\n * (c) 2023 Jukka Kurkela\n * Released under the MIT License\n */\nfunction round(v) {\n  return v + 0.5 | 0;\n}\nconst lim = (v, l, h) => Math.max(Math.min(v, h), l);\nfunction p2b(v) {\n  return lim(round(v * 2.55), 0, 255);\n}\nfunction b2p(v) {\n  return lim(round(v / 2.55), 0, 100);\n}\nfunction n2b(v) {\n  return lim(round(v * 255), 0, 255);\n}\nfunction b2n(v) {\n  return lim(round(v / 2.55) / 100, 0, 1);\n}\nfunction n2p(v) {\n  return lim(round(v * 100), 0, 100);\n}\n\nconst map$1 = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15};\nconst hex = [...'0123456789ABCDEF'];\nconst h1 = b => hex[b & 0xF];\nconst h2 = b => hex[(b & 0xF0) >> 4] + hex[b & 0xF];\nconst eq = b => ((b & 0xF0) >> 4) === (b & 0xF);\nconst isShort = v => eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a);\nfunction hexParse(str) {\n  var len = str.length;\n  var ret;\n  if (str[0] === '#') {\n    if (len === 4 || len === 5) {\n      ret = {\n        r: 255 & map$1[str[1]] * 17,\n        g: 255 & map$1[str[2]] * 17,\n        b: 255 & map$1[str[3]] * 17,\n        a: len === 5 ? map$1[str[4]] * 17 : 255\n      };\n    } else if (len === 7 || len === 9) {\n      ret = {\n        r: map$1[str[1]] << 4 | map$1[str[2]],\n        g: map$1[str[3]] << 4 | map$1[str[4]],\n        b: map$1[str[5]] << 4 | map$1[str[6]],\n        a: len === 9 ? (map$1[str[7]] << 4 | map$1[str[8]]) : 255\n      };\n    }\n  }\n  return ret;\n}\nconst alpha = (a, f) => a < 255 ? f(a) : '';\nfunction hexString(v) {\n  var f = isShort(v) ? h1 : h2;\n  return v\n    ? '#' + f(v.r) + f(v.g) + f(v.b) + alpha(v.a, f)\n    : undefined;\n}\n\nconst HUE_RE = /^(hsla?|hwb|hsv)\\(\\s*([-+.e\\d]+)(?:deg)?[\\s,]+([-+.e\\d]+)%[\\s,]+([-+.e\\d]+)%(?:[\\s,]+([-+.e\\d]+)(%)?)?\\s*\\)$/;\nfunction hsl2rgbn(h, s, l) {\n  const a = s * Math.min(l, 1 - l);\n  const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);\n  return [f(0), f(8), f(4)];\n}\nfunction hsv2rgbn(h, s, v) {\n  const f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);\n  return [f(5), f(3), f(1)];\n}\nfunction hwb2rgbn(h, w, b) {\n  const rgb = hsl2rgbn(h, 1, 0.5);\n  let i;\n  if (w + b > 1) {\n    i = 1 / (w + b);\n    w *= i;\n    b *= i;\n  }\n  for (i = 0; i < 3; i++) {\n    rgb[i] *= 1 - w - b;\n    rgb[i] += w;\n  }\n  return rgb;\n}\nfunction hueValue(r, g, b, d, max) {\n  if (r === max) {\n    return ((g - b) / d) + (g < b ? 6 : 0);\n  }\n  if (g === max) {\n    return (b - r) / d + 2;\n  }\n  return (r - g) / d + 4;\n}\nfunction rgb2hsl(v) {\n  const range = 255;\n  const r = v.r / range;\n  const g = v.g / range;\n  const b = v.b / range;\n  const max = Math.max(r, g, b);\n  const min = Math.min(r, g, b);\n  const l = (max + min) / 2;\n  let h, s, d;\n  if (max !== min) {\n    d = max - min;\n    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n    h = hueValue(r, g, b, d, max);\n    h = h * 60 + 0.5;\n  }\n  return [h | 0, s || 0, l];\n}\nfunction calln(f, a, b, c) {\n  return (\n    Array.isArray(a)\n      ? f(a[0], a[1], a[2])\n      : f(a, b, c)\n  ).map(n2b);\n}\nfunction hsl2rgb(h, s, l) {\n  return calln(hsl2rgbn, h, s, l);\n}\nfunction hwb2rgb(h, w, b) {\n  return calln(hwb2rgbn, h, w, b);\n}\nfunction hsv2rgb(h, s, v) {\n  return calln(hsv2rgbn, h, s, v);\n}\nfunction hue(h) {\n  return (h % 360 + 360) % 360;\n}\nfunction hueParse(str) {\n  const m = HUE_RE.exec(str);\n  let a = 255;\n  let v;\n  if (!m) {\n    return;\n  }\n  if (m[5] !== v) {\n    a = m[6] ? p2b(+m[5]) : n2b(+m[5]);\n  }\n  const h = hue(+m[2]);\n  const p1 = +m[3] / 100;\n  const p2 = +m[4] / 100;\n  if (m[1] === 'hwb') {\n    v = hwb2rgb(h, p1, p2);\n  } else if (m[1] === 'hsv') {\n    v = hsv2rgb(h, p1, p2);\n  } else {\n    v = hsl2rgb(h, p1, p2);\n  }\n  return {\n    r: v[0],\n    g: v[1],\n    b: v[2],\n    a: a\n  };\n}\nfunction rotate(v, deg) {\n  var h = rgb2hsl(v);\n  h[0] = hue(h[0] + deg);\n  h = hsl2rgb(h);\n  v.r = h[0];\n  v.g = h[1];\n  v.b = h[2];\n}\nfunction hslString(v) {\n  if (!v) {\n    return;\n  }\n  const a = rgb2hsl(v);\n  const h = a[0];\n  const s = n2p(a[1]);\n  const l = n2p(a[2]);\n  return v.a < 255\n    ? `hsla(${h}, ${s}%, ${l}%, ${b2n(v.a)})`\n    : `hsl(${h}, ${s}%, ${l}%)`;\n}\n\nconst map = {\n  x: 'dark',\n  Z: 'light',\n  Y: 're',\n  X: 'blu',\n  W: 'gr',\n  V: 'medium',\n  U: 'slate',\n  A: 'ee',\n  T: 'ol',\n  S: 'or',\n  B: 'ra',\n  C: 'lateg',\n  D: 'ights',\n  R: 'in',\n  Q: 'turquois',\n  E: 'hi',\n  P: 'ro',\n  O: 'al',\n  N: 'le',\n  M: 'de',\n  L: 'yello',\n  F: 'en',\n  K: 'ch',\n  G: 'arks',\n  H: 'ea',\n  I: 'ightg',\n  J: 'wh'\n};\nconst names$1 = {\n  OiceXe: 'f0f8ff',\n  antiquewEte: 'faebd7',\n  aqua: 'ffff',\n  aquamarRe: '7fffd4',\n  azuY: 'f0ffff',\n  beige: 'f5f5dc',\n  bisque: 'ffe4c4',\n  black: '0',\n  blanKedOmond: 'ffebcd',\n  Xe: 'ff',\n  XeviTet: '8a2be2',\n  bPwn: 'a52a2a',\n  burlywood: 'deb887',\n  caMtXe: '5f9ea0',\n  KartYuse: '7fff00',\n  KocTate: 'd2691e',\n  cSO: 'ff7f50',\n  cSnflowerXe: '6495ed',\n  cSnsilk: 'fff8dc',\n  crimson: 'dc143c',\n  cyan: 'ffff',\n  xXe: '8b',\n  xcyan: '8b8b',\n  xgTMnPd: 'b8860b',\n  xWay: 'a9a9a9',\n  xgYF: '6400',\n  xgYy: 'a9a9a9',\n  xkhaki: 'bdb76b',\n  xmagFta: '8b008b',\n  xTivegYF: '556b2f',\n  xSange: 'ff8c00',\n  xScEd: '9932cc',\n  xYd: '8b0000',\n  xsOmon: 'e9967a',\n  xsHgYF: '8fbc8f',\n  xUXe: '483d8b',\n  xUWay: '2f4f4f',\n  xUgYy: '2f4f4f',\n  xQe: 'ced1',\n  xviTet: '9400d3',\n  dAppRk: 'ff1493',\n  dApskyXe: 'bfff',\n  dimWay: '696969',\n  dimgYy: '696969',\n  dodgerXe: '1e90ff',\n  fiYbrick: 'b22222',\n  flSOwEte: 'fffaf0',\n  foYstWAn: '228b22',\n  fuKsia: 'ff00ff',\n  gaRsbSo: 'dcdcdc',\n  ghostwEte: 'f8f8ff',\n  gTd: 'ffd700',\n  gTMnPd: 'daa520',\n  Way: '808080',\n  gYF: '8000',\n  gYFLw: 'adff2f',\n  gYy: '808080',\n  honeyMw: 'f0fff0',\n  hotpRk: 'ff69b4',\n  RdianYd: 'cd5c5c',\n  Rdigo: '4b0082',\n  ivSy: 'fffff0',\n  khaki: 'f0e68c',\n  lavFMr: 'e6e6fa',\n  lavFMrXsh: 'fff0f5',\n  lawngYF: '7cfc00',\n  NmoncEffon: 'fffacd',\n  ZXe: 'add8e6',\n  ZcSO: 'f08080',\n  Zcyan: 'e0ffff',\n  ZgTMnPdLw: 'fafad2',\n  ZWay: 'd3d3d3',\n  ZgYF: '90ee90',\n  ZgYy: 'd3d3d3',\n  ZpRk: 'ffb6c1',\n  ZsOmon: 'ffa07a',\n  ZsHgYF: '20b2aa',\n  ZskyXe: '87cefa',\n  ZUWay: '778899',\n  ZUgYy: '778899',\n  ZstAlXe: 'b0c4de',\n  ZLw: 'ffffe0',\n  lime: 'ff00',\n  limegYF: '32cd32',\n  lRF: 'faf0e6',\n  magFta: 'ff00ff',\n  maPon: '800000',\n  VaquamarRe: '66cdaa',\n  VXe: 'cd',\n  VScEd: 'ba55d3',\n  VpurpN: '9370db',\n  VsHgYF: '3cb371',\n  VUXe: '7b68ee',\n  VsprRggYF: 'fa9a',\n  VQe: '48d1cc',\n  VviTetYd: 'c71585',\n  midnightXe: '191970',\n  mRtcYam: 'f5fffa',\n  mistyPse: 'ffe4e1',\n  moccasR: 'ffe4b5',\n  navajowEte: 'ffdead',\n  navy: '80',\n  Tdlace: 'fdf5e6',\n  Tive: '808000',\n  TivedBb: '6b8e23',\n  Sange: 'ffa500',\n  SangeYd: 'ff4500',\n  ScEd: 'da70d6',\n  pOegTMnPd: 'eee8aa',\n  pOegYF: '98fb98',\n  pOeQe: 'afeeee',\n  pOeviTetYd: 'db7093',\n  papayawEp: 'ffefd5',\n  pHKpuff: 'ffdab9',\n  peru: 'cd853f',\n  pRk: 'ffc0cb',\n  plum: 'dda0dd',\n  powMrXe: 'b0e0e6',\n  purpN: '800080',\n  YbeccapurpN: '663399',\n  Yd: 'ff0000',\n  Psybrown: 'bc8f8f',\n  PyOXe: '4169e1',\n  saddNbPwn: '8b4513',\n  sOmon: 'fa8072',\n  sandybPwn: 'f4a460',\n  sHgYF: '2e8b57',\n  sHshell: 'fff5ee',\n  siFna: 'a0522d',\n  silver: 'c0c0c0',\n  skyXe: '87ceeb',\n  UXe: '6a5acd',\n  UWay: '708090',\n  UgYy: '708090',\n  snow: 'fffafa',\n  sprRggYF: 'ff7f',\n  stAlXe: '4682b4',\n  tan: 'd2b48c',\n  teO: '8080',\n  tEstN: 'd8bfd8',\n  tomato: 'ff6347',\n  Qe: '40e0d0',\n  viTet: 'ee82ee',\n  JHt: 'f5deb3',\n  wEte: 'ffffff',\n  wEtesmoke: 'f5f5f5',\n  Lw: 'ffff00',\n  LwgYF: '9acd32'\n};\nfunction unpack() {\n  const unpacked = {};\n  const keys = Object.keys(names$1);\n  const tkeys = Object.keys(map);\n  let i, j, k, ok, nk;\n  for (i = 0; i < keys.length; i++) {\n    ok = nk = keys[i];\n    for (j = 0; j < tkeys.length; j++) {\n      k = tkeys[j];\n      nk = nk.replace(k, map[k]);\n    }\n    k = parseInt(names$1[ok], 16);\n    unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF];\n  }\n  return unpacked;\n}\n\nlet names;\nfunction nameParse(str) {\n  if (!names) {\n    names = unpack();\n    names.transparent = [0, 0, 0, 0];\n  }\n  const a = names[str.toLowerCase()];\n  return a && {\n    r: a[0],\n    g: a[1],\n    b: a[2],\n    a: a.length === 4 ? a[3] : 255\n  };\n}\n\nconst RGB_RE = /^rgba?\\(\\s*([-+.\\d]+)(%)?[\\s,]+([-+.e\\d]+)(%)?[\\s,]+([-+.e\\d]+)(%)?(?:[\\s,/]+([-+.e\\d]+)(%)?)?\\s*\\)$/;\nfunction rgbParse(str) {\n  const m = RGB_RE.exec(str);\n  let a = 255;\n  let r, g, b;\n  if (!m) {\n    return;\n  }\n  if (m[7] !== r) {\n    const v = +m[7];\n    a = m[8] ? p2b(v) : lim(v * 255, 0, 255);\n  }\n  r = +m[1];\n  g = +m[3];\n  b = +m[5];\n  r = 255 & (m[2] ? p2b(r) : lim(r, 0, 255));\n  g = 255 & (m[4] ? p2b(g) : lim(g, 0, 255));\n  b = 255 & (m[6] ? p2b(b) : lim(b, 0, 255));\n  return {\n    r: r,\n    g: g,\n    b: b,\n    a: a\n  };\n}\nfunction rgbString(v) {\n  return v && (\n    v.a < 255\n      ? `rgba(${v.r}, ${v.g}, ${v.b}, ${b2n(v.a)})`\n      : `rgb(${v.r}, ${v.g}, ${v.b})`\n  );\n}\n\nconst to = v => v <= 0.0031308 ? v * 12.92 : Math.pow(v, 1.0 / 2.4) * 1.055 - 0.055;\nconst from = v => v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);\nfunction interpolate(rgb1, rgb2, t) {\n  const r = from(b2n(rgb1.r));\n  const g = from(b2n(rgb1.g));\n  const b = from(b2n(rgb1.b));\n  return {\n    r: n2b(to(r + t * (from(b2n(rgb2.r)) - r))),\n    g: n2b(to(g + t * (from(b2n(rgb2.g)) - g))),\n    b: n2b(to(b + t * (from(b2n(rgb2.b)) - b))),\n    a: rgb1.a + t * (rgb2.a - rgb1.a)\n  };\n}\n\nfunction modHSL(v, i, ratio) {\n  if (v) {\n    let tmp = rgb2hsl(v);\n    tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1));\n    tmp = hsl2rgb(tmp);\n    v.r = tmp[0];\n    v.g = tmp[1];\n    v.b = tmp[2];\n  }\n}\nfunction clone(v, proto) {\n  return v ? Object.assign(proto || {}, v) : v;\n}\nfunction fromObject(input) {\n  var v = {r: 0, g: 0, b: 0, a: 255};\n  if (Array.isArray(input)) {\n    if (input.length >= 3) {\n      v = {r: input[0], g: input[1], b: input[2], a: 255};\n      if (input.length > 3) {\n        v.a = n2b(input[3]);\n      }\n    }\n  } else {\n    v = clone(input, {r: 0, g: 0, b: 0, a: 1});\n    v.a = n2b(v.a);\n  }\n  return v;\n}\nfunction functionParse(str) {\n  if (str.charAt(0) === 'r') {\n    return rgbParse(str);\n  }\n  return hueParse(str);\n}\nclass Color {\n  constructor(input) {\n    if (input instanceof Color) {\n      return input;\n    }\n    const type = typeof input;\n    let v;\n    if (type === 'object') {\n      v = fromObject(input);\n    } else if (type === 'string') {\n      v = hexParse(input) || nameParse(input) || functionParse(input);\n    }\n    this._rgb = v;\n    this._valid = !!v;\n  }\n  get valid() {\n    return this._valid;\n  }\n  get rgb() {\n    var v = clone(this._rgb);\n    if (v) {\n      v.a = b2n(v.a);\n    }\n    return v;\n  }\n  set rgb(obj) {\n    this._rgb = fromObject(obj);\n  }\n  rgbString() {\n    return this._valid ? rgbString(this._rgb) : undefined;\n  }\n  hexString() {\n    return this._valid ? hexString(this._rgb) : undefined;\n  }\n  hslString() {\n    return this._valid ? hslString(this._rgb) : undefined;\n  }\n  mix(color, weight) {\n    if (color) {\n      const c1 = this.rgb;\n      const c2 = color.rgb;\n      let w2;\n      const p = weight === w2 ? 0.5 : weight;\n      const w = 2 * p - 1;\n      const a = c1.a - c2.a;\n      const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;\n      w2 = 1 - w1;\n      c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5;\n      c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5;\n      c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5;\n      c1.a = p * c1.a + (1 - p) * c2.a;\n      this.rgb = c1;\n    }\n    return this;\n  }\n  interpolate(color, t) {\n    if (color) {\n      this._rgb = interpolate(this._rgb, color._rgb, t);\n    }\n    return this;\n  }\n  clone() {\n    return new Color(this.rgb);\n  }\n  alpha(a) {\n    this._rgb.a = n2b(a);\n    return this;\n  }\n  clearer(ratio) {\n    const rgb = this._rgb;\n    rgb.a *= 1 - ratio;\n    return this;\n  }\n  greyscale() {\n    const rgb = this._rgb;\n    const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);\n    rgb.r = rgb.g = rgb.b = val;\n    return this;\n  }\n  opaquer(ratio) {\n    const rgb = this._rgb;\n    rgb.a *= 1 + ratio;\n    return this;\n  }\n  negate() {\n    const v = this._rgb;\n    v.r = 255 - v.r;\n    v.g = 255 - v.g;\n    v.b = 255 - v.b;\n    return this;\n  }\n  lighten(ratio) {\n    modHSL(this._rgb, 2, ratio);\n    return this;\n  }\n  darken(ratio) {\n    modHSL(this._rgb, 2, -ratio);\n    return this;\n  }\n  saturate(ratio) {\n    modHSL(this._rgb, 1, ratio);\n    return this;\n  }\n  desaturate(ratio) {\n    modHSL(this._rgb, 1, -ratio);\n    return this;\n  }\n  rotate(deg) {\n    rotate(this._rgb, deg);\n    return this;\n  }\n}\n\nfunction index_esm(input) {\n  return new Color(input);\n}\n\nexport { Color, b2n, b2p, index_esm as default, hexParse, hexString, hsl2rgb, hslString, hsv2rgb, hueParse, hwb2rgb, lim, n2b, n2p, nameParse, p2b, rgb2hsl, rgbParse, rgbString, rotate, round };\n","/**\n * @namespace Chart.helpers\n */\n\nimport type {AnyObject} from '../types/basic.js';\nimport type {ActiveDataPoint, ChartEvent} from '../types/index.js';\n\n/**\n * An empty function that can be used, for example, for optional callback.\n */\nexport function noop() {\n  /* noop */\n}\n\n/**\n * Returns a unique id, sequentially generated from a global variable.\n */\nexport const uid = (() => {\n  let id = 0;\n  return () => id++;\n})();\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 */\nexport function isNullOrUndef(value: unknown): value is null | undefined {\n  return value === null || typeof value === 'undefined';\n}\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 */\nexport function isArray<T = unknown>(value: unknown): value is T[] {\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/**\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 */\nexport function isObject(value: unknown): value is AnyObject {\n  return value !== null && Object.prototype.toString.call(value) === '[object Object]';\n}\n\n/**\n * Returns true if `value` is a finite number, else returns false\n * @param value  - The value to test.\n */\nfunction isNumberFinite(value: unknown): value is number {\n  return (typeof value === 'number' || value instanceof Number) && isFinite(+value);\n}\nexport {\n  isNumberFinite as isFinite,\n};\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 */\nexport function finiteOrDefault(value: unknown, defaultValue: number) {\n  return isNumberFinite(value) ? value : defaultValue;\n}\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 */\nexport function valueOrDefault<T>(value: T | undefined, defaultValue: T) {\n  return typeof value === 'undefined' ? defaultValue : value;\n}\n\nexport const toPercentage = (value: number | string, dimension: number) =>\n  typeof value === 'string' && value.endsWith('%') ?\n    parseFloat(value) / 100\n    : +value / dimension;\n\nexport const toDimension = (value: number | string, dimension: number) =>\n  typeof value === 'string' && value.endsWith('%') ?\n    parseFloat(value) / 100 * dimension\n    : +value;\n\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 */\nexport function callback<T extends (this: TA, ...restArgs: unknown[]) => R, TA, R>(\n  fn: T | undefined,\n  args: unknown[],\n  thisArg?: TA\n): R | undefined {\n  if (fn && typeof fn.call === 'function') {\n    return fn.apply(thisArg, args);\n  }\n}\n\n/**\n * Note(SB) for performance sake, this method should only be used when loopable type\n * is unknown or in none intensive code (not called often and small loopable). Else\n * it's preferable to use a regular for() loop and save extra function calls.\n * @param loopable - The object or array to be iterated.\n * @param fn - The function to call for each item.\n * @param [thisArg] - The value of `this` provided for the call to `fn`.\n * @param [reverse] - If true, iterates backward on the loopable.\n */\nexport function each<T, TA>(\n  loopable: Record<string, T>,\n  fn: (this: TA, v: T, i: string) => void,\n  thisArg?: TA,\n  reverse?: boolean\n): void;\nexport function each<T, TA>(\n  loopable: T[],\n  fn: (this: TA, v: T, i: number) => void,\n  thisArg?: TA,\n  reverse?: boolean\n): void;\nexport function each<T, TA>(\n  loopable: T[] | Record<string, T>,\n  fn: (this: TA, v: T, i: any) => void,\n  thisArg?: TA,\n  reverse?: boolean\n) {\n  let i: number, len: number, keys: string[];\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/**\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 */\nexport function _elementsEqual(a0: ActiveDataPoint[], a1: ActiveDataPoint[]) {\n  let i: number, ilen: number, v0: ActiveDataPoint, v1: ActiveDataPoint;\n\n  if (!a0 || !a1 || a0.length !== a1.length) {\n    return false;\n  }\n\n  for (i = 0, ilen = a0.length; i < ilen; ++i) {\n    v0 = a0[i];\n    v1 = a1[i];\n\n    if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Returns a deep copy of `source` without keeping references on objects and arrays.\n * @param source - The value to clone.\n */\nexport function clone<T>(source: T): T {\n  if (isArray(source)) {\n    return source.map(clone) as unknown as T;\n  }\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\n    for (; k < klen; ++k) {\n      target[keys[k]] = clone(source[keys[k]]);\n    }\n\n    return target;\n  }\n\n  return source;\n}\n\nfunction isValidKey(key: string) {\n  return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1;\n}\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 */\nexport function _merger(key: string, target: AnyObject, source: AnyObject, options: AnyObject) {\n  if (!isValidKey(key)) {\n    return;\n  }\n\n  const tval = target[key];\n  const sval = source[key];\n\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}\n\nexport interface MergeOptions {\n  merger?: (key: string, target: AnyObject, source: AnyObject, options?: AnyObject) => void;\n}\n\n/**\n * Recursively deep copies `source` properties into `target` with the given `options`.\n * IMPORTANT: `target` is not cloned and will be updated with `source` properties.\n * @param target - The target object in which all sources are merged into.\n * @param source - Object(s) to merge into `target`.\n * @param [options] - Merging options:\n * @param [options.merger] - The merge method (key, target, source, options)\n * @returns The `target` object.\n */\nexport function merge<T>(target: T, source: [], options?: MergeOptions): T;\nexport function merge<T, S1>(target: T, source: S1, options?: MergeOptions): T & S1;\nexport function merge<T, S1>(target: T, source: [S1], options?: MergeOptions): T & S1;\nexport function merge<T, S1, S2>(target: T, source: [S1, S2], options?: MergeOptions): T & S1 & S2;\nexport function merge<T, S1, S2, S3>(target: T, source: [S1, S2, S3], options?: MergeOptions): T & S1 & S2 & S3;\nexport function merge<T, S1, S2, S3, S4>(\n  target: T,\n  source: [S1, S2, S3, S4],\n  options?: MergeOptions\n): T & S1 & S2 & S3 & S4;\nexport function merge<T>(target: T, source: AnyObject[], options?: MergeOptions): AnyObject;\nexport function merge<T>(target: T, source: AnyObject[], options?: MergeOptions): AnyObject {\n  const sources = isArray(source) ? source : [source];\n  const ilen = sources.length;\n\n  if (!isObject(target)) {\n    return target as AnyObject;\n  }\n\n  options = options || {};\n  const merger = options.merger || _merger;\n  let current: AnyObject;\n\n  for (let i = 0; i < ilen; ++i) {\n    current = sources[i];\n    if (!isObject(current)) {\n      continue;\n    }\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 as AnyObject);\n    }\n  }\n\n  return target;\n}\n\n/**\n * Recursively deep copies `source` properties into `target` *only* if not defined in target.\n * IMPORTANT: `target` is not cloned and will be updated with `source` properties.\n * @param target - The target object in which all sources are merged into.\n * @param source - Object(s) to merge into `target`.\n * @returns The `target` object.\n */\nexport function mergeIf<T>(target: T, source: []): T;\nexport function mergeIf<T, S1>(target: T, source: S1): T & S1;\nexport function mergeIf<T, S1>(target: T, source: [S1]): T & S1;\nexport function mergeIf<T, S1, S2>(target: T, source: [S1, S2]): T & S1 & S2;\nexport function mergeIf<T, S1, S2, S3>(target: T, source: [S1, S2, S3]): T & S1 & S2 & S3;\nexport function mergeIf<T, S1, S2, S3, S4>(target: T, source: [S1, S2, S3, S4]): T & S1 & S2 & S3 & S4;\nexport function mergeIf<T>(target: T, source: AnyObject[]): AnyObject;\nexport function mergeIf<T>(target: T, source: AnyObject[]): AnyObject {\n  // eslint-disable-next-line @typescript-eslint/no-use-before-define\n  return merge<T>(target, source, {merger: _mergerIf});\n}\n\n/**\n * Merges source[key] in target[key] only if target[key] is undefined.\n * @private\n */\nexport function _mergerIf(key: string, target: AnyObject, source: AnyObject) {\n  if (!isValidKey(key)) {\n    return;\n  }\n\n  const tval = target[key];\n  const sval = source[key];\n\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/**\n * @private\n */\nexport function _deprecated(scope: string, value: unknown, previous: string, current: string) {\n  if (value !== undefined) {\n    console.warn(scope + ': \"' + previous +\n      '\" is deprecated. Please use \"' + current + '\" instead');\n  }\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/**\n * @private\n */\nexport function _splitKey(key: string) {\n  const parts = key.split('.');\n  const keys: string[] = [];\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}\n\nfunction _getKeyResolver(key: string) {\n  const keys = _splitKey(key);\n  return obj => {\n    for (const k of keys) {\n      if (k === '') {\n        // For backward compatibility:\n        // Chart.helpers.core resolveObjectKey should break at empty key\n        break;\n      }\n      obj = obj && obj[k];\n    }\n    return obj;\n  };\n}\n\nexport function resolveObjectKey(obj: AnyObject, key: string): any {\n  const resolver = keyResolvers[key] || (keyResolvers[key] = _getKeyResolver(key));\n  return resolver(obj);\n}\n\n/**\n * @private\n */\nexport function _capitalize(str: string) {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\n\nexport const defined = (value: unknown) => typeof value !== 'undefined';\n\nexport const isFunction = (value: unknown): value is (...args: any[]) => any => typeof value === 'function';\n\n// Adapted from https://stackoverflow.com/questions/31128855/comparing-ecma6-sets-for-equality#31129384\nexport const setsEqual = <T>(a: Set<T>, b: Set<T>) => {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const item of a) {\n    if (!b.has(item)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * @param e - The event\n * @private\n */\nexport function _isClickEvent(e: ChartEvent) {\n  return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu';\n}\n","import type {Point} from '../types/geometric.js';\nimport {isFinite as isFiniteNumber} from './helpers.core.js';\n\n/**\n * @alias Chart.helpers.math\n * @namespace\n */\n\nexport const PI = Math.PI;\nexport const TAU = 2 * PI;\nexport const PITAU = TAU + PI;\nexport const INFINITY = Number.POSITIVE_INFINITY;\nexport const RAD_PER_DEG = PI / 180;\nexport const HALF_PI = PI / 2;\nexport const QUARTER_PI = PI / 4;\nexport const TWO_THIRDS_PI = PI * 2 / 3;\n\nexport const log10 = Math.log10;\nexport const sign = Math.sign;\n\nexport function almostEquals(x: number, y: number, epsilon: number) {\n  return Math.abs(x - y) < epsilon;\n}\n\n/**\n * Implementation of the nice number algorithm used in determining where axis labels will go\n */\nexport function niceNum(range: number) {\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/**\n * Returns an array of factors sorted from 1 to sqrt(value)\n * @private\n */\nexport function _factorize(value: number) {\n  const result: number[] = [];\n  const sqrt = Math.sqrt(value);\n  let i: number;\n\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)) { // if value is a square number\n    result.push(sqrt);\n  }\n\n  result.sort((a, b) => a - b).pop();\n  return result;\n}\n\nexport function isNumber(n: unknown): n is number {\n  return !isNaN(parseFloat(n as string)) && isFinite(n as number);\n}\n\nexport function almostWhole(x: number, epsilon: number) {\n  const rounded = Math.round(x);\n  return ((rounded - epsilon) <= x) && ((rounded + epsilon) >= x);\n}\n\n/**\n * @private\n */\nexport function _setMinAndMaxByKey(\n  array: Record<string, number>[],\n  target: { min: number, max: number },\n  property: string\n) {\n  let i: number, ilen: number, value: number;\n\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}\n\nexport function toRadians(degrees: number) {\n  return degrees * (PI / 180);\n}\n\nexport function toDegrees(radians: number) {\n  return radians * (180 / PI);\n}\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 */\nexport function _decimalPlaces(x: number) {\n  if (!isFiniteNumber(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\n// Gets the angle from vertical upright to the point about a centre.\nexport function getAngleFromPoint(\n  centrePoint: Point,\n  anglePoint: Point\n) {\n  const distanceFromXCenter = anglePoint.x - centrePoint.x;\n  const distanceFromYCenter = anglePoint.y - centrePoint.y;\n  const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);\n\n  let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);\n\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\n  return {\n    angle,\n    distance: radialDistanceFromCenter\n  };\n}\n\nexport function distanceBetweenPoints(pt1: Point, pt2: Point) {\n  return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));\n}\n\n/**\n * Shortest distance between angles, in either direction.\n * @private\n */\nexport function _angleDiff(a: number, b: number) {\n  return (a - b + PITAU) % TAU - PI;\n}\n\n/**\n * Normalize angle to be between 0 and 2*PI\n * @private\n */\nexport function _normalizeAngle(a: number) {\n  return (a % TAU + TAU) % TAU;\n}\n\n/**\n * @private\n */\nexport function _angleBetween(angle: number, start: number, end: number, sameAngleIsFullCircle?: boolean) {\n  const a = _normalizeAngle(angle);\n  const s = _normalizeAngle(start);\n  const e = _normalizeAngle(end);\n  const angleToStart = _normalizeAngle(s - a);\n  const angleToEnd = _normalizeAngle(e - a);\n  const startToAngle = _normalizeAngle(a - s);\n  const endToAngle = _normalizeAngle(a - e);\n  return a === s || a === e || (sameAngleIsFullCircle && s === e)\n    || (angleToStart > angleToEnd && startToAngle < endToAngle);\n}\n\n/**\n * Limit `value` between `min` and `max`\n * @param value\n * @param min\n * @param max\n * @private\n */\nexport function _limitValue(value: number, min: number, max: number) {\n  return Math.max(min, Math.min(max, value));\n}\n\n/**\n * @param {number} value\n * @private\n */\nexport function _int16Range(value: number) {\n  return _limitValue(value, -32768, 32767);\n}\n\n/**\n * @param value\n * @param start\n * @param end\n * @param [epsilon]\n * @private\n */\nexport function _isBetween(value: number, start: number, end: number, epsilon = 1e-6) {\n  return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;\n}\n","import {_capitalize} from './helpers.core.js';\n\n/**\n * Binary search\n * @param table - the table search. must be sorted!\n * @param value - value to find\n * @param cmp\n * @private\n */\nexport function _lookup(\n  table: number[],\n  value: number,\n  cmp?: (value: number) => boolean\n): {lo: number, hi: number};\nexport function _lookup<T>(\n  table: T[],\n  value: number,\n  cmp: (value: number) => boolean\n): {lo: number, hi: number};\nexport function _lookup(\n  table: unknown[],\n  value: number,\n  cmp?: (value: number) => boolean\n) {\n  cmp = cmp || ((index) => table[index] < value);\n  let hi = table.length - 1;\n  let lo = 0;\n  let mid: number;\n\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\n  return {lo, 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 */\nexport const _lookupByKey = (\n  table: Record<string, number>[],\n  key: string,\n  value: number,\n  last?: boolean\n) =>\n  _lookup(table, value, last\n    ? index => {\n      const ti = table[index][key];\n      return ti < value || ti === value && table[index + 1][key] === value;\n    }\n    : index => table[index][key] < value);\n\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 */\nexport const _rlookupByKey = (\n  table: Record<string, number>[],\n  key: string,\n  value: number\n) =>\n  _lookup(table, value, index => table[index][key] >= value);\n\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 */\nexport function _filterBetween(values: number[], min: number, max: number) {\n  let start = 0;\n  let end = values.length;\n\n  while (start < end && values[start] < min) {\n    start++;\n  }\n  while (end > start && values[end - 1] > max) {\n    end--;\n  }\n\n  return start > 0 || end < values.length\n    ? values.slice(start, end)\n    : values;\n}\n\nconst arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'] as const;\n\nexport interface ArrayListener<T> {\n  _onDataPush?(...item: T[]): void;\n  _onDataPop?(): void;\n  _onDataShift?(): void;\n  _onDataSplice?(index: number, deleteCount: number, ...items: T[]): void;\n  _onDataUnshift?(...item: T[]): void;\n}\n\n/**\n * Hooks the array methods that add or remove values ('push', pop', 'shift', 'splice',\n * 'unshift') and notify the listener AFTER the array has been altered. Listeners are\n * called on the '_onData*' callbacks (e.g. _onDataPush, etc.) with same arguments.\n */\nexport function listenArrayEvents<T>(array: T[], listener: ArrayListener<T>): void;\nexport function listenArrayEvents(array, listener) {\n  if (array._chartjs) {\n    array._chartjs.listeners.push(listener);\n    return;\n  }\n\n  Object.defineProperty(array, '_chartjs', {\n    configurable: true,\n    enumerable: false,\n    value: {\n      listeners: [listener]\n    }\n  });\n\n  arrayEvents.forEach((key) => {\n    const method = '_onData' + _capitalize(key);\n    const base = array[key];\n\n    Object.defineProperty(array, key, {\n      configurable: true,\n      enumerable: false,\n      value(...args) {\n        const res = base.apply(this, args);\n\n        array._chartjs.listeners.forEach((object) => {\n          if (typeof object[method] === 'function') {\n            object[method](...args);\n          }\n        });\n\n        return res;\n      }\n    });\n  });\n}\n\n\n/**\n * Removes the given array event listener and cleanup extra attached properties (such as\n * the _chartjs stub and overridden methods) if array doesn't have any more listeners.\n */\nexport function unlistenArrayEvents<T>(array: T[], listener: ArrayListener<T>): void;\nexport function unlistenArrayEvents(array, listener) {\n  const stub = array._chartjs;\n  if (!stub) {\n    return;\n  }\n\n  const listeners = stub.listeners;\n  const index = listeners.indexOf(listener);\n  if (index !== -1) {\n    listeners.splice(index, 1);\n  }\n\n  if (listeners.length > 0) {\n    return;\n  }\n\n  arrayEvents.forEach((key) => {\n    delete array[key];\n  });\n\n  delete array._chartjs;\n}\n\n/**\n * @param items\n */\nexport function _arrayUnique<T>(items: T[]) {\n  const set = new Set<T>(items);\n\n  if (set.size === items.length) {\n    return items;\n  }\n\n  return Array.from(set);\n}\n","import type {ChartMeta, PointElement} from '../types/index.js';\n\nimport {_limitValue} from './helpers.math.js';\nimport {_lookupByKey} from './helpers.collection.js';\n\nexport function fontString(pixelSize: number, fontStyle: string, fontFamily: string) {\n  return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;\n}\n\n/**\n* Request animation polyfill\n*/\nexport const requestAnimFrame = (function() {\n  if (typeof window === 'undefined') {\n    return function(callback) {\n      return callback();\n    };\n  }\n  return window.requestAnimationFrame;\n}());\n\n/**\n * Throttles calling `fn` once per animation frame\n * Latest arguments are used on the actual call\n */\nexport function throttled<TArgs extends Array<any>>(\n  fn: (...args: TArgs) => void,\n  thisArg: any,\n) {\n  let argsToUse = [] as TArgs;\n  let ticking = false;\n\n  return function(...args: TArgs) {\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/**\n * Debounces calling `fn` for `delay` ms\n */\nexport function debounce<TArgs extends Array<any>>(fn: (...args: TArgs) => void, delay: number) {\n  let timeout;\n  return function(...args: TArgs) {\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/**\n * Converts 'start' to 'left', 'end' to 'right' and others to 'center'\n * @private\n */\nexport const _toLeftRightCenter = (align: 'start' | 'end' | 'center') => align === 'start' ? 'left' : align === 'end' ? 'right' : 'center';\n\n/**\n * Returns `start`, `end` or `(start + end) / 2` depending on `align`. Defaults to `center`\n * @private\n */\nexport const _alignStartEnd = (align: 'start' | 'end' | 'center', start: number, end: number) => align === 'start' ? start : align === 'end' ? end : (start + end) / 2;\n\n/**\n * Returns `left`, `right` or `(left + right) / 2` depending on `align`. Defaults to `left`\n * @private\n */\nexport const _textX = (align: 'left' | 'right' | 'center', left: number, right: number, rtl: boolean) => {\n  const check = rtl ? 'left' : 'right';\n  return align === check ? right : align === 'center' ? (left + right) / 2 : left;\n};\n\n/**\n * Return start and count of visible points.\n * @private\n */\nexport function _getStartAndCountOfVisiblePoints(meta: ChartMeta<'line' | 'scatter'>, points: PointElement[], animationsDisabled: boolean) {\n  const pointCount = points.length;\n\n  let start = 0;\n  let count = pointCount;\n\n  if (meta._sorted) {\n    const {iScale, _parsed} = meta;\n    const axis = iScale.axis;\n    const {min, max, minDefined, maxDefined} = iScale.getUserBounds();\n\n    if (minDefined) {\n      start = _limitValue(Math.min(\n        // @ts-expect-error Need to type _parsed\n        _lookupByKey(_parsed, axis, min).lo,\n        // @ts-expect-error Need to fix types on _lookupByKey\n        animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo),\n      0, pointCount - 1);\n    }\n    if (maxDefined) {\n      count = _limitValue(Math.max(\n        // @ts-expect-error Need to type _parsed\n        _lookupByKey(_parsed, iScale.axis, max, true).hi + 1,\n        // @ts-expect-error Need to fix types on _lookupByKey\n        animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max), true).hi + 1),\n      start, pointCount) - start;\n    } else {\n      count = pointCount - start;\n    }\n  }\n\n  return {start, count};\n}\n\n/**\n * Checks if the scale ranges have changed.\n * @param {object} meta - dataset meta.\n * @returns {boolean}\n * @private\n */\nexport 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\n\t\t|| _scaleRanges.xmax !== xScale.max\n\t\t|| _scaleRanges.ymin !== yScale.min\n\t\t|| _scaleRanges.ymax !== yScale.max;\n\n  Object.assign(_scaleRanges, newRanges);\n  return changed;\n}\n","import {PI, TAU, HALF_PI} from './helpers.math.js';\n\nconst atEdge = (t: number) => t === 0 || t === 1;\nconst elasticIn = (t: number, s: number, p: number) => -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));\nconst elasticOut = (t: number, s: number, p: number) => Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1;\n\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 */\nconst effects = {\n  linear: (t: number) => t,\n\n  easeInQuad: (t: number) => t * t,\n\n  easeOutQuad: (t: number) => -t * (t - 2),\n\n  easeInOutQuad: (t: number) => ((t /= 0.5) < 1)\n    ? 0.5 * t * t\n    : -0.5 * ((--t) * (t - 2) - 1),\n\n  easeInCubic: (t: number) => t * t * t,\n\n  easeOutCubic: (t: number) => (t -= 1) * t * t + 1,\n\n  easeInOutCubic: (t: number) => ((t /= 0.5) < 1)\n    ? 0.5 * t * t * t\n    : 0.5 * ((t -= 2) * t * t + 2),\n\n  easeInQuart: (t: number) => t * t * t * t,\n\n  easeOutQuart: (t: number) => -((t -= 1) * t * t * t - 1),\n\n  easeInOutQuart: (t: number) => ((t /= 0.5) < 1)\n    ? 0.5 * t * t * t * t\n    : -0.5 * ((t -= 2) * t * t * t - 2),\n\n  easeInQuint: (t: number) => t * t * t * t * t,\n\n  easeOutQuint: (t: number) => (t -= 1) * t * t * t * t + 1,\n\n  easeInOutQuint: (t: number) => ((t /= 0.5) < 1)\n    ? 0.5 * t * t * t * t * t\n    : 0.5 * ((t -= 2) * t * t * t * t + 2),\n\n  easeInSine: (t: number) => -Math.cos(t * HALF_PI) + 1,\n\n  easeOutSine: (t: number) => Math.sin(t * HALF_PI),\n\n  easeInOutSine: (t: number) => -0.5 * (Math.cos(PI * t) - 1),\n\n  easeInExpo: (t: number) => (t === 0) ? 0 : Math.pow(2, 10 * (t - 1)),\n\n  easeOutExpo: (t: number) => (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1,\n\n  easeInOutExpo: (t: number) => atEdge(t) ? t : t < 0.5\n    ? 0.5 * Math.pow(2, 10 * (t * 2 - 1))\n    : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2),\n\n  easeInCirc: (t: number) => (t >= 1) ? t : -(Math.sqrt(1 - t * t) - 1),\n\n  easeOutCirc: (t: number) => Math.sqrt(1 - (t -= 1) * t),\n\n  easeInOutCirc: (t: number) => ((t /= 0.5) < 1)\n    ? -0.5 * (Math.sqrt(1 - t * t) - 1)\n    : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1),\n\n  easeInElastic: (t: number) => atEdge(t) ? t : elasticIn(t, 0.075, 0.3),\n\n  easeOutElastic: (t: number) => atEdge(t) ? t : elasticOut(t, 0.075, 0.3),\n\n  easeInOutElastic(t: number) {\n    const s = 0.1125;\n    const p = 0.45;\n    return atEdge(t) ? t :\n      t < 0.5\n        ? 0.5 * elasticIn(t * 2, s, p)\n        : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p);\n  },\n\n  easeInBack(t: number) {\n    const s = 1.70158;\n    return t * t * ((s + 1) * t - s);\n  },\n\n  easeOutBack(t: number) {\n    const s = 1.70158;\n    return (t -= 1) * t * ((s + 1) * t + s) + 1;\n  },\n\n  easeInOutBack(t: number) {\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\n  easeInBounce: (t: number) => 1 - effects.easeOutBounce(1 - t),\n\n  easeOutBounce(t: number) {\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\n  easeInOutBounce: (t: number) => (t < 0.5)\n    ? effects.easeInBounce(t * 2) * 0.5\n    : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5,\n} as const;\n\nexport type EasingFunction = keyof typeof effects\n\nexport default effects;\n","import {Color} from '@kurkle/color';\n\nexport function isPatternOrGradient(value: unknown): value is CanvasPattern | CanvasGradient {\n  if (value && typeof value === 'object') {\n    const type = value.toString();\n    return type === '[object CanvasPattern]' || type === '[object CanvasGradient]';\n  }\n\n  return false;\n}\n\nexport function color(value: CanvasGradient): CanvasGradient;\nexport function color(value: CanvasPattern): CanvasPattern;\nexport function color(\n  value:\n  | string\n  | { r: number; g: number; b: number; a: number }\n  | [number, number, number]\n  | [number, number, number, number]\n): Color;\nexport function color(value) {\n  return isPatternOrGradient(value) ? value : new Color(value);\n}\n\nexport function getHoverColor(value: CanvasGradient): CanvasGradient;\nexport function getHoverColor(value: CanvasPattern): CanvasPattern;\nexport function getHoverColor(value: string): string;\nexport function getHoverColor(value) {\n  return isPatternOrGradient(value)\n    ? value\n    : new Color(value).saturate(0.5).darken(0.1).hexString();\n}\n","const numbers = ['x', 'y', 'borderWidth', 'radius', 'tension'];\nconst colors = ['color', 'borderColor', 'backgroundColor'];\n\nexport function 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\n  defaults.describe('animation', {\n    _fallback: false,\n    _indexable: false,\n    _scriptable: (name) => name !== 'onProgress' && name !== 'onComplete' && name !== 'fn',\n  });\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\n  defaults.describe('animations', {\n    _fallback: 'animation',\n  });\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 // show immediately\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 // for keeping the dataset visible all the way through the animation\n        },\n      }\n    }\n  });\n}\n","\nconst intlCache = new Map<string, Intl.NumberFormat>();\n\nfunction getNumberFormat(locale: string, options?: Intl.NumberFormatOptions) {\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}\n\nexport function formatNumber(num: number, locale: string, options?: Intl.NumberFormatOptions) {\n  return getNumberFormat(locale, options).format(num);\n}\n","import {isArray} from '../helpers/helpers.core.js';\nimport {formatNumber} from '../helpers/helpers.intl.js';\nimport {log10} from '../helpers/helpers.math.js';\n\n/**\n * Namespace to hold formatters for different types of ticks\n * @namespace Chart.Ticks.formatters\n */\nconst formatters = {\n  /**\n   * Formatter for value labels\n   * @method Chart.Ticks.formatters.values\n   * @param value the value to display\n   * @return {string|string[]} the label to display\n   */\n  values(value) {\n    return isArray(value) ? /** @type {string[]} */ (value) : '' + value;\n  },\n\n  /**\n   * Formatter for numeric ticks\n   * @method Chart.Ticks.formatters.numeric\n   * @param tickValue {number} the value to be formatted\n   * @param index {number} the position of the tickValue parameter in the ticks array\n   * @param ticks {object[]} the list of ticks being converted\n   * @return {string} string representation of the tickValue parameter\n   */\n  numeric(tickValue, index, ticks) {\n    if (tickValue === 0) {\n      return '0'; // never show decimal places for 0\n    }\n\n    const locale = this.chart.options.locale;\n    let notation;\n    let delta = tickValue; // This is used when there are less than 2 ticks as the tick interval.\n\n    if (ticks.length > 1) {\n      // all ticks are small or there huge numbers; use scientific notation\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\n      delta = calculateDelta(tickValue, ticks);\n    }\n\n    const logDelta = log10(Math.abs(delta));\n\n    // When datasets have values approaching Number.MAX_VALUE, the tick calculations might result in\n    // infinity and eventually NaN. Passing NaN for minimumFractionDigits or maximumFractionDigits\n    // will make the number formatter throw. So instead we check for isNaN and use a fallback value.\n    //\n    // toFixed has a max of 20 decimal places\n    const numDecimal = isNaN(logDelta) ? 1 : Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);\n\n    const options = {notation, minimumFractionDigits: numDecimal, maximumFractionDigits: numDecimal};\n    Object.assign(options, this.options.ticks.format);\n\n    return formatNumber(tickValue, locale, options);\n  },\n\n\n  /**\n   * Formatter for logarithmic ticks\n   * @method Chart.Ticks.formatters.logarithmic\n   * @param tickValue {number} the value to be formatted\n   * @param index {number} the position of the tickValue parameter in the ticks array\n   * @param ticks {object[]} the list of ticks being converted\n   * @return {string} string representation of the tickValue parameter\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 ([1, 2, 3, 5, 10, 15].includes(remain) || index > 0.8 * ticks.length) {\n      return formatters.numeric.call(this, tickValue, index, ticks);\n    }\n    return '';\n  }\n\n};\n\n\nfunction calculateDelta(tickValue, ticks) {\n  // Figure out how many digits to show\n  // The space between the first two ticks might be smaller than normal spacing\n  let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;\n\n  // If we have a number like 2.5 as the delta, figure out how many decimal places we need\n  if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {\n    // not an integer\n    delta = tickValue - Math.floor(tickValue);\n  }\n  return delta;\n}\n\n/**\n * Namespace to hold static tick generation functions\n * @namespace Chart.Ticks\n */\nexport default {formatters};\n","import {getHoverColor} from '../helpers/helpers.color.js';\nimport {isObject, merge, valueOrDefault} from '../helpers/helpers.core.js';\nimport {applyAnimationsDefaults} from './core.animations.defaults.js';\nimport {applyLayoutsDefaults} from './core.layouts.defaults.js';\nimport {applyScaleDefaults} from './core.scale.defaults.js';\n\nexport const overrides = Object.create(null);\nexport const descriptors = Object.create(null);\n\n/**\n * @param {object} node\n * @param {string} key\n * @return {object}\n */\nfunction getScope(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}\n\nfunction set(root, scope, values) {\n  if (typeof scope === 'string') {\n    return merge(getScope(root, scope), values);\n  }\n  return merge(getScope(root, ''), scope);\n}\n\n/**\n * Please use the module's default export which provides a singleton instance\n * Note: class is exported for typedoc\n */\nexport 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\n    this.describe(_descriptors);\n    this.apply(_appliers);\n  }\n\n  /**\n\t * @param {string|object} scope\n\t * @param {object} [values]\n\t */\n  set(scope, values) {\n    return set(this, scope, values);\n  }\n\n  /**\n\t * @param {string} scope\n\t */\n  get(scope) {\n    return getScope(this, scope);\n  }\n\n  /**\n\t * @param {string|object} scope\n\t * @param {object} [values]\n\t */\n  describe(scope, values) {\n    return set(descriptors, scope, values);\n  }\n\n  override(scope, values) {\n    return set(overrides, scope, values);\n  }\n\n  /**\n\t * Routes the named defaults to fallback to another scope/name.\n\t * This routing is useful when those target values, like defaults.color, are changed runtime.\n\t * If the values would be copied, the runtime change would not take effect. By routing, the\n\t * fallback is evaluated at each access, so its always up to date.\n\t *\n\t * Example:\n\t *\n\t * \tdefaults.route('elements.arc', 'backgroundColor', '', 'color')\n\t *   - reads the backgroundColor from defaults.color when undefined locally\n\t *\n\t * @param {string} scope Scope this route applies to.\n\t * @param {string} name Property name that should be routed to different namespace when not defined here.\n\t * @param {string} targetScope The namespace where those properties should be routed to.\n\t * Empty string ('') is the root of defaults.\n\t * @param {string} targetName The target name in the target scope the property should be routed to.\n\t */\n  route(scope, name, targetScope, targetName) {\n    const scopeObject = getScope(this, scope);\n    const targetScopeObject = getScope(this, targetScope);\n    const privateName = '_' + name;\n\n    Object.defineProperties(scopeObject, {\n      // A private property is defined to hold the actual value, when this property is set in its scope (set in the setter)\n      [privateName]: {\n        value: scopeObject[name],\n        writable: true\n      },\n      // The actual property is defined as getter/setter so we can do the routing when value is not locally set.\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\n  apply(appliers) {\n    appliers.forEach((apply) => apply(this));\n  }\n}\n\n// singleton instance\nexport default /* #__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}, [applyAnimationsDefaults, applyLayoutsDefaults, applyScaleDefaults]);\n","export function 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","import Ticks from './core.ticks.js';\n\nexport function applyScaleDefaults(defaults) {\n  defaults.set('scale', {\n    display: true,\n    offset: false,\n    reverse: false,\n    beginAtZero: false,\n\n    /**\n     * Scale boundary strategy (bypassed by min/max time options)\n     * - `data`: make sure data are fully visible, ticks outside are removed\n     * - `ticks`: make sure ticks are fully visible, data outside are truncated\n     * @see https://github.com/chartjs/Chart.js/pull/4556\n     * @since 3.0.0\n     */\n    bounds: 'ticks',\n\n    clip: true,\n\n    /**\n     * Addition grace added to max and reduced from min data value.\n     * @since 3.0.0\n     */\n    grace: 0,\n\n    // grid line settings\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\n    border: {\n      display: true,\n      dash: [],\n      dashOffset: 0.0,\n      width: 1\n    },\n\n    // scale title\n    title: {\n      // display property\n      display: false,\n\n      // actual label\n      text: '',\n\n      // top/bottom padding\n      padding: {\n        top: 4,\n        bottom: 4\n      }\n    },\n\n    // label settings\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      // We pass through arrays to be rendered as multiline labels, we convert Others to strings here.\n      callback: Ticks.formatters.values,\n      minor: {},\n      major: {},\n      align: 'center',\n      crossAlign: 'near',\n\n      showLabelBackdrop: false,\n      backdropColor: 'rgba(255, 255, 255, 0.75)',\n      backdropPadding: 2,\n    }\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\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\n  defaults.describe('scales', {\n    _fallback: 'scale',\n  });\n\n  defaults.describe('scale.ticks', {\n    _scriptable: (name) => name !== 'backdropPadding' && name !== 'callback',\n    _indexable: (name) => name !== 'backdropPadding',\n  });\n}\n","import type {\n  Chart,\n  Point,\n  FontSpec,\n  CanvasFontSpec,\n  PointStyle,\n  RenderTextOpts,\n  BackdropOptions\n} from '../types/index.js';\nimport type {\n  TRBL,\n  SplinePoint,\n  RoundedRect,\n  TRBLCorners\n} from '../types/geometric.js';\nimport {isArray, isNullOrUndef} from './helpers.core.js';\nimport {PI, TAU, HALF_PI, QUARTER_PI, TWO_THIRDS_PI, RAD_PER_DEG} from './helpers.math.js';\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 */\nexport function toFontString(font: FontSpec) {\n  if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {\n    return null;\n  }\n\n  return (font.style ? font.style + ' ' : '')\n\t\t+ (font.weight ? font.weight + ' ' : '')\n\t\t+ font.size + 'px '\n\t\t+ font.family;\n}\n\n/**\n * @private\n */\nexport function _measureText(\n  ctx: CanvasRenderingContext2D,\n  data: Record<string, number>,\n  gc: string[],\n  longest: number,\n  string: string\n) {\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\ntype Thing = string | undefined | null\ntype Things = (Thing | Thing[])[]\n\n/**\n * @private\n */\n// eslint-disable-next-line complexity\nexport function _longestText(\n  ctx: CanvasRenderingContext2D,\n  font: string,\n  arrayOfThings: Things,\n  cache?: {data?: Record<string, number>, garbageCollect?: string[], font?: string}\n) {\n  cache = cache || {};\n  let data = cache.data = cache.data || {};\n  let gc = cache.garbageCollect = cache.garbageCollect || [];\n\n  if (cache.font !== font) {\n    data = cache.data = {};\n    gc = cache.garbageCollect = [];\n    cache.font = font;\n  }\n\n  ctx.save();\n\n  ctx.font = font;\n  let longest = 0;\n  const ilen = arrayOfThings.length;\n  let i: number, j: number, jlen: number, thing: Thing | Thing[], nestedThing: Thing | Thing[];\n  for (i = 0; i < ilen; i++) {\n    thing = arrayOfThings[i];\n\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\n  ctx.restore();\n\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/**\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 */\nexport function _alignPixel(chart: Chart, pixel: number, width: number) {\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/**\n * Clears the entire canvas.\n */\nexport function clearCanvas(canvas?: HTMLCanvasElement, ctx?: CanvasRenderingContext2D) {\n  if (!ctx && !canvas) {\n    return;\n  }\n\n  ctx = ctx || canvas.getContext('2d');\n\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}\n\nexport interface DrawPointOptions {\n  pointStyle: PointStyle;\n  rotation?: number;\n  radius: number;\n  borderWidth: number;\n}\n\nexport function drawPoint(\n  ctx: CanvasRenderingContext2D,\n  options: DrawPointOptions,\n  x: number,\n  y: number\n) {\n  // eslint-disable-next-line @typescript-eslint/no-use-before-define\n  drawPointLegend(ctx, options, x, y, null);\n}\n\n// eslint-disable-next-line complexity\nexport function drawPointLegend(\n  ctx: CanvasRenderingContext2D,\n  options: DrawPointOptions,\n  x: number,\n  y: number,\n  w: number\n) {\n  let type: string, xOffset: number, yOffset: number, size: number, cornerRadius: number, width: number, xOffsetW: number, yOffsetW: number;\n  const style = options.pointStyle;\n  const rotation = options.rotation;\n  const radius = options.radius;\n  let rad = (rotation || 0) * RAD_PER_DEG;\n\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\n  if (isNaN(radius) || radius <= 0) {\n    return;\n  }\n\n  ctx.beginPath();\n\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 */\n    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 */\n    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\n  ctx.fill();\n  if (options.borderWidth > 0) {\n    ctx.stroke();\n  }\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 */\nexport function _isPointInArea(\n  point: Point,\n  area: TRBL,\n  margin?: number\n) {\n  margin = margin || 0.5; // margin - default is to match rounded decimals\n\n  return !area || (point && point.x > area.left - margin && point.x < area.right + margin &&\n\t\tpoint.y > area.top - margin && point.y < area.bottom + margin);\n}\n\nexport function clipArea(ctx: CanvasRenderingContext2D, area: TRBL) {\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}\n\nexport function unclipArea(ctx: CanvasRenderingContext2D) {\n  ctx.restore();\n}\n\n/**\n * @private\n */\nexport function _steppedLineTo(\n  ctx: CanvasRenderingContext2D,\n  previous: Point,\n  target: Point,\n  flip?: boolean,\n  mode?: string\n) {\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/**\n * @private\n */\nexport function _bezierCurveTo(\n  ctx: CanvasRenderingContext2D,\n  previous: SplinePoint,\n  target: SplinePoint,\n  flip?: boolean\n) {\n  if (!previous) {\n    return ctx.lineTo(target.x, target.y);\n  }\n  ctx.bezierCurveTo(\n    flip ? previous.cp1x : previous.cp2x,\n    flip ? previous.cp1y : previous.cp2y,\n    flip ? target.cp2x : target.cp1x,\n    flip ? target.cp2y : target.cp1y,\n    target.x,\n    target.y);\n}\n\nfunction setRenderOpts(ctx: CanvasRenderingContext2D, opts: RenderTextOpts) {\n  if (opts.translation) {\n    ctx.translate(opts.translation[0], opts.translation[1]);\n  }\n\n  if (!isNullOrUndef(opts.rotation)) {\n    ctx.rotate(opts.rotation);\n  }\n\n  if (opts.color) {\n    ctx.fillStyle = opts.color;\n  }\n\n  if (opts.textAlign) {\n    ctx.textAlign = opts.textAlign;\n  }\n\n  if (opts.textBaseline) {\n    ctx.textBaseline = opts.textBaseline;\n  }\n}\n\nfunction decorateText(\n  ctx: CanvasRenderingContext2D,\n  x: number,\n  y: number,\n  line: string,\n  opts: RenderTextOpts\n) {\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     */\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\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}\n\nfunction drawBackdrop(ctx: CanvasRenderingContext2D, opts: BackdropOptions) {\n  const oldColor = ctx.fillStyle;\n\n  ctx.fillStyle = opts.color as string;\n  ctx.fillRect(opts.left, opts.top, opts.width, opts.height);\n  ctx.fillStyle = oldColor;\n}\n\n/**\n * Render text onto the canvas\n */\nexport function renderText(\n  ctx: CanvasRenderingContext2D,\n  text: string | string[],\n  x: number,\n  y: number,\n  font: CanvasFontSpec,\n  opts: RenderTextOpts = {}\n) {\n  const lines = isArray(text) ? text : [text];\n  const stroke = opts.strokeWidth > 0 && opts.strokeColor !== '';\n  let i: number, line: string;\n\n  ctx.save();\n  ctx.font = font.string;\n  setRenderOpts(ctx, opts);\n\n  for (i = 0; i < lines.length; ++i) {\n    line = lines[i];\n\n    if (opts.backdrop) {\n      drawBackdrop(ctx, opts.backdrop);\n    }\n\n    if (stroke) {\n      if (opts.strokeColor) {\n        ctx.strokeStyle = opts.strokeColor;\n      }\n\n      if (!isNullOrUndef(opts.strokeWidth)) {\n        ctx.lineWidth = opts.strokeWidth;\n      }\n\n      ctx.strokeText(line, x, y, opts.maxWidth);\n    }\n\n    ctx.fillText(line, x, y, opts.maxWidth);\n    decorateText(ctx, x, y, line, opts);\n\n    y += Number(font.lineHeight);\n  }\n\n  ctx.restore();\n}\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 */\nexport function addRoundedRectPath(\n  ctx: CanvasRenderingContext2D,\n  rect: RoundedRect & { radius: TRBLCorners }\n) {\n  const {x, y, w, h, radius} = rect;\n\n  // top left arc\n  ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, 1.5 * PI, PI, true);\n\n  // line from top left to bottom left\n  ctx.lineTo(x, y + h - radius.bottomLeft);\n\n  // bottom left arc\n  ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);\n\n  // line from bottom left to bottom right\n  ctx.lineTo(x + w - radius.bottomRight, y + h);\n\n  // bottom right arc\n  ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);\n\n  // line from bottom right to top right\n  ctx.lineTo(x + w, y + radius.topRight);\n\n  // top right arc\n  ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true);\n\n  // line from top right to top left\n  ctx.lineTo(x + radius.topLeft, y);\n}\n","import defaults from '../core/core.defaults.js';\nimport {isArray, isObject, toDimension, valueOrDefault} from './helpers.core.js';\nimport {toFontString} from './helpers.canvas.js';\nimport type {ChartArea, FontSpec, Point} from '../types/index.js';\nimport type {TRBL, TRBLCorners} from '../types/geometric.js';\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/**\n * @alias Chart.helpers.options\n * @namespace\n */\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 */\nexport function toLineHeight(value: number | string, size: number): number {\n  const matches = ('' + value).match(LINE_HEIGHT);\n  if (!matches || matches[1] === 'normal') {\n    return size * 1.2;\n  }\n\n  value = +matches[2];\n\n  switch (matches[3]) {\n    case 'px':\n      return value;\n    case '%':\n      value /= 100;\n      break;\n    default:\n      break;\n  }\n\n  return size * value;\n}\n\nconst numberOrZero = (v: unknown) => +v || 0;\n\n/**\n * @param value\n * @param props\n */\nexport function _readValueToProps<K extends string>(value: number | Record<K, number>, props: K[]): Record<K, number>;\nexport function _readValueToProps<K extends string, T extends string>(value: number | Record<K & T, number>, props: Record<T, K>): Record<T, number>;\nexport function _readValueToProps(value: number | Record<string, number>, props: string[] | Record<string, string>) {\n  const ret = {};\n  const objProps = isObject(props);\n  const keys = objProps ? Object.keys(props) : props;\n  const read = isObject(value)\n    ? objProps\n      ? prop => valueOrDefault(value[prop], value[props[prop]])\n      : prop => value[prop]\n    : () => value;\n\n  for (const prop of keys) {\n    ret[prop] = numberOrZero(read(prop));\n  }\n  return ret;\n}\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 */\nexport function toTRBL(value: number | TRBL | Point) {\n  return _readValueToProps(value, {top: 'y', right: 'x', bottom: 'y', 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 */\nexport function toTRBLCorners(value: number | TRBLCorners) {\n  return _readValueToProps(value, ['topLeft', 'topRight', 'bottomLeft', '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 */\nexport function toPadding(value?: number | TRBL): ChartArea {\n  const obj = toTRBL(value) as ChartArea;\n\n  obj.width = obj.left + obj.right;\n  obj.height = obj.top + obj.bottom;\n\n  return obj;\n}\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 */\n\nexport function toFont(options: Partial<FontSpec>, fallback?: Partial<FontSpec>) {\n  options = options || {};\n  fallback = fallback || defaults.font as FontSpec;\n\n  let size = valueOrDefault(options.size, fallback.size);\n\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\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\n  font.string = toFontString(font);\n  return font;\n}\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 */\nexport function resolve(inputs: Array<unknown>, context?: object, index?: number, info?: { cacheable: boolean }) {\n  let cacheable = true;\n  let i: number, ilen: number, value: unknown;\n\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/**\n * @param minmax\n * @param grace\n * @param beginAtZero\n * @private\n */\nexport function _addGrace(minmax: { min: number; max: number; }, grace: number | string, beginAtZero: boolean) {\n  const {min, max} = minmax;\n  const change = toDimension(grace, (max - min) / 2);\n  const keepZero = (value: number, add: number) => beginAtZero && value === 0 ? 0 : value + add;\n  return {\n    min: keepZero(min, -Math.abs(change)),\n    max: keepZero(max, change)\n  };\n}\n\n/**\n * Create a context inheriting parentContext\n * @param parentContext\n * @param context\n * @returns\n */\nexport function createContext<T extends object>(parentContext: null, context: T): T;\nexport function createContext<T extends object, P extends T>(parentContext: P, context: T): P & T;\nexport function createContext(parentContext: object, context: object) {\n  return Object.assign(Object.create(parentContext), context);\n}\n","/* eslint-disable @typescript-eslint/no-use-before-define */\nimport type {AnyObject} from '../types/basic.js';\nimport type {ChartMeta} from '../types/index.js';\nimport type {\n  ResolverObjectKey,\n  ResolverCache,\n  ResolverProxy,\n  DescriptorDefaults,\n  Descriptor,\n  ContextCache,\n  ContextProxy\n} from './helpers.config.types.js';\nimport {isArray, isFunction, isObject, resolveObjectKey, _capitalize} from './helpers.core.js';\n\nexport * from './helpers.config.types.js';\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 */\nexport function _createResolver<\n  T extends AnyObject[] = AnyObject[],\n  R extends AnyObject[] = T\n>(\n  scopes: T,\n  prefixes = [''],\n  rootScopes?: R,\n  fallback?: ResolverObjectKey,\n  getTarget = () => scopes[0]\n) {\n  const finalRootScopes = rootScopes || scopes;\n  if (typeof fallback === 'undefined') {\n    fallback = _resolve('_fallback', scopes);\n  }\n  const cache: ResolverCache<T, R> = {\n    [Symbol.toStringTag]: 'Object',\n    _cacheable: true,\n    _scopes: scopes,\n    _rootScopes: finalRootScopes,\n    _fallback: fallback,\n    _getTarget: getTarget,\n    override: (scope: AnyObject) => _createResolver([scope, ...scopes], prefixes, finalRootScopes, fallback),\n  };\n  return new Proxy(cache, {\n    /**\n     * A trap for the delete operator.\n     */\n    deleteProperty(target, prop: string) {\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    /**\n     * A trap for getting property values.\n     */\n    get(target, prop: string) {\n      return _cached(target, prop,\n        () => _resolveWithPrefixes(prop, prefixes, scopes, target));\n    },\n\n    /**\n     * A trap for Object.getOwnPropertyDescriptor.\n     * Also used by Object.hasOwnProperty.\n     */\n    getOwnPropertyDescriptor(target, prop) {\n      return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);\n    },\n\n    /**\n     * A trap for Object.getPrototypeOf.\n     */\n    getPrototypeOf() {\n      return Reflect.getPrototypeOf(scopes[0]);\n    },\n\n    /**\n     * A trap for the in operator.\n     */\n    has(target, prop: string) {\n      return getKeysFromAllScopes(target).includes(prop);\n    },\n\n    /**\n     * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.\n     */\n    ownKeys(target) {\n      return getKeysFromAllScopes(target);\n    },\n\n    /**\n     * A trap for setting property values.\n     */\n    set(target, prop: string, 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  }) as ResolverProxy<T, R>;\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 */\nexport function _attachContext<\n  T extends AnyObject[] = AnyObject[],\n  R extends AnyObject[] = T\n>(\n  proxy: ResolverProxy<T, R>,\n  context: AnyObject,\n  subProxy?: ResolverProxy<T, R>,\n  descriptorDefaults?: DescriptorDefaults\n) {\n  const cache: ContextCache<T, R> = {\n    _cacheable: false,\n    _proxy: proxy,\n    _context: context,\n    _subProxy: subProxy,\n    _stack: new Set(),\n    _descriptors: _descriptors(proxy, descriptorDefaults),\n    setContext: (ctx: AnyObject) => _attachContext(proxy, ctx, subProxy, descriptorDefaults),\n    override: (scope: AnyObject) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)\n  };\n  return new Proxy(cache, {\n    /**\n     * A trap for the delete operator.\n     */\n    deleteProperty(target, prop) {\n      delete target[prop]; // remove from cache\n      delete proxy[prop]; // remove from proxy\n      return true;\n    },\n\n    /**\n     * A trap for getting property values.\n     */\n    get(target, prop: string, receiver) {\n      return _cached(target, prop,\n        () => _resolveWithContext(target, prop, receiver));\n    },\n\n    /**\n     * A trap for Object.getOwnPropertyDescriptor.\n     * Also used by Object.hasOwnProperty.\n     */\n    getOwnPropertyDescriptor(target, prop) {\n      return target._descriptors.allKeys\n        ? Reflect.has(proxy, prop) ? {enumerable: true, configurable: true} : undefined\n        : Reflect.getOwnPropertyDescriptor(proxy, prop);\n    },\n\n    /**\n     * A trap for Object.getPrototypeOf.\n     */\n    getPrototypeOf() {\n      return Reflect.getPrototypeOf(proxy);\n    },\n\n    /**\n     * A trap for the in operator.\n     */\n    has(target, prop) {\n      return Reflect.has(proxy, prop);\n    },\n\n    /**\n     * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.\n     */\n    ownKeys() {\n      return Reflect.ownKeys(proxy);\n    },\n\n    /**\n     * A trap for setting property values.\n     */\n    set(target, prop, value) {\n      proxy[prop] = value; // set to proxy\n      delete target[prop]; // remove from cache\n      return true;\n    }\n  }) as ContextProxy<T, R>;\n}\n\n/**\n * @private\n */\nexport function _descriptors(\n  proxy: ResolverCache,\n  defaults: DescriptorDefaults = {scriptable: true, indexable: true}\n): Descriptor {\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}\n\nconst readKey = (prefix: string, name: string) => prefix ? prefix + _capitalize(name) : name;\nconst needsSubResolver = (prop: string, value: unknown) => isObject(value) && prop !== 'adapters' &&\n  (Object.getPrototypeOf(value) === null || value.constructor === Object);\n\nfunction _cached(\n  target: AnyObject,\n  prop: string,\n  resolve: () => unknown\n) {\n  if (Object.prototype.hasOwnProperty.call(target, prop) || prop === 'constructor') {\n    return target[prop];\n  }\n\n  const value = resolve();\n  // cache the resolved value\n  target[prop] = value;\n  return value;\n}\n\nfunction _resolveWithContext(\n  target: ContextCache,\n  prop: string,\n  receiver: AnyObject\n) {\n  const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;\n  let value = _proxy[prop]; // resolve from proxy\n\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}\n\nfunction _resolveScriptable(\n  prop: string,\n  getValue: (ctx: AnyObject, sub: AnyObject) => unknown,\n  target: ContextCache,\n  receiver: AnyObject\n) {\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}\n\nfunction _resolveArray(\n  prop: string,\n  value: unknown[],\n  target: ContextCache,\n  isIndexable: (key: string) => boolean\n) {\n  const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;\n\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}\n\nfunction resolveFallback(\n  fallback: ResolverObjectKey | ((prop: ResolverObjectKey, value: unknown) => ResolverObjectKey),\n  prop: ResolverObjectKey,\n  value: unknown\n) {\n  return isFunction(fallback) ? fallback(prop, value) : fallback;\n}\n\nconst getScope = (key: ResolverObjectKey, parent: AnyObject) => key === true ? parent\n  : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;\n\nfunction addScopes(\n  set: Set<AnyObject>,\n  parentScopes: AnyObject[],\n  key: ResolverObjectKey,\n  parentFallback: ResolverObjectKey,\n  value: unknown\n) {\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}\n\nfunction createSubResolver(\n  parentScopes: AnyObject[],\n  resolver: ResolverCache,\n  prop: ResolverObjectKey,\n  value: unknown\n) {\n  const rootScopes = resolver._rootScopes;\n  const fallback = resolveFallback(resolver._fallback, prop, value);\n  const allScopes = [...parentScopes, ...rootScopes];\n  const set = new Set<AnyObject>();\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), [''], rootScopes, fallback,\n    () => subGetTarget(resolver, prop as string, value));\n}\n\nfunction addScopesFromKey(\n  set: Set<AnyObject>,\n  allScopes: AnyObject[],\n  key: ResolverObjectKey,\n  fallback: ResolverObjectKey,\n  item: unknown\n) {\n  while (key) {\n    key = addScopes(set, allScopes, key, fallback, item);\n  }\n  return key;\n}\n\nfunction subGetTarget(\n  resolver: ResolverCache,\n  prop: string,\n  value: unknown\n) {\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}\n\nfunction _resolveWithPrefixes(\n  prop: string,\n  prefixes: string[],\n  scopes: AnyObject[],\n  proxy: ResolverProxy\n) {\n  let value: unknown;\n  for (const prefix of prefixes) {\n    value = _resolve(readKey(prefix, prop), scopes);\n    if (typeof value !== 'undefined') {\n      return needsSubResolver(prop, value)\n        ? createSubResolver(scopes, proxy, prop, value)\n        : value;\n    }\n  }\n}\n\nfunction _resolve(key: string, scopes: AnyObject[]) {\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}\n\nfunction getKeysFromAllScopes(target: ResolverCache) {\n  let keys = target._keys;\n  if (!keys) {\n    keys = target._keys = resolveKeysFromAllScopes(target._scopes);\n  }\n  return keys;\n}\n\nfunction resolveKeysFromAllScopes(scopes: AnyObject[]) {\n  const set = new Set<string>();\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}\n\nexport function _parseObjectDataRadialScale(\n  meta: ChartMeta<'line' | 'scatter'>,\n  data: AnyObject[],\n  start: number,\n  count: number\n) {\n  const {iScale} = meta;\n  const {key = 'r'} = this._parsing;\n  const parsed = new Array<{r: unknown}>(count);\n  let i: number, ilen: number, index: number, item: AnyObject;\n\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","import {almostEquals, distanceBetweenPoints, sign} from './helpers.math.js';\nimport {_isPointInArea} from './helpers.canvas.js';\nimport type {ChartArea} from '../types/index.js';\nimport type {SplinePoint} from '../types/geometric.js';\n\nconst EPSILON = Number.EPSILON || 1e-14;\n\ntype OptionalSplinePoint = SplinePoint | false\nconst getPoint = (points: SplinePoint[], i: number): OptionalSplinePoint => i < points.length && !points[i].skip && points[i];\nconst getValueAxis = (indexAxis: 'x' | 'y') => indexAxis === 'x' ? 'y' : 'x';\n\nexport function splineCurve(\n  firstPoint: SplinePoint,\n  middlePoint: SplinePoint,\n  afterPoint: SplinePoint,\n  t: number\n): {\n    previous: SplinePoint\n    next: SplinePoint\n  } {\n  // Props to Rob Spencer at scaled innovation for his post on splining between points\n  // http://scaledinnovation.com/analytics/splines/aboutSplines.html\n\n  // This function must also respect \"skipped\" points\n\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\n  let s01 = d01 / (d01 + d12);\n  let s12 = d12 / (d01 + d12);\n\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\n  const fa = t * s01; // scaling factor for triangle Ta\n  const fb = t * s12;\n\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/**\n * Adjust tangents to ensure monotonic properties\n */\nfunction monotoneAdjust(points: SplinePoint[], deltaK: number[], mK: number[]) {\n  const pointsLen = points.length;\n\n  let alphaK: number, betaK: number, tauK: number, squaredMagnitude: number, pointCurrent: OptionalSplinePoint;\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\n    if (almostEquals(deltaK[i], 0, EPSILON)) {\n      mK[i] = mK[i + 1] = 0;\n      continue;\n    }\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\n    tauK = 3 / Math.sqrt(squaredMagnitude);\n    mK[i] = alphaK * tauK * deltaK[i];\n    mK[i + 1] = betaK * tauK * deltaK[i];\n  }\n}\n\nfunction monotoneCompute(points: SplinePoint[], mK: number[], indexAxis: 'x' | 'y' = 'x') {\n  const valueAxis = getValueAxis(indexAxis);\n  const pointsLen = points.length;\n  let delta: number, pointBefore: OptionalSplinePoint, pointCurrent: OptionalSplinePoint;\n  let pointAfter = getPoint(points, 0);\n\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\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/**\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 */\nexport function splineCurveMonotone(points: SplinePoint[], indexAxis: 'x' | 'y' = 'x') {\n  const valueAxis = getValueAxis(indexAxis);\n  const pointsLen = points.length;\n  const deltaK: number[] = Array(pointsLen).fill(0);\n  const mK: number[] = Array(pointsLen);\n\n  // Calculate slopes (deltaK) and initialize tangents (mK)\n  let i, pointBefore: OptionalSplinePoint, pointCurrent: OptionalSplinePoint;\n  let pointAfter = getPoint(points, 0);\n\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\n    if (pointAfter) {\n      const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis];\n\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]\n      : !pointAfter ? deltaK[i - 1]\n        : (sign(deltaK[i - 1]) !== sign(deltaK[i])) ? 0\n          : (deltaK[i - 1] + deltaK[i]) / 2;\n  }\n\n  monotoneAdjust(points, deltaK, mK);\n\n  monotoneCompute(points, mK, indexAxis);\n}\n\nfunction capControlPoint(pt: number, min: number, max: number) {\n  return Math.max(Math.min(pt, max), min);\n}\n\nfunction capBezierPoints(points: SplinePoint[], area: ChartArea) {\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/**\n * @private\n */\nexport function _updateBezierControlPoints(\n  points: SplinePoint[],\n  options,\n  area: ChartArea,\n  loop: boolean,\n  indexAxis: 'x' | 'y'\n) {\n  let i: number, ilen: number, point: SplinePoint, controlPoints: ReturnType<typeof splineCurve>;\n\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\n  if (options.cubicInterpolationMode === 'monotone') {\n    splineCurveMonotone(points, indexAxis);\n  } else {\n    let prev = loop ? points[points.length - 1] : points[0];\n    for (i = 0, ilen = points.length; i < ilen; ++i) {\n      point = points[i];\n      controlPoints = splineCurve(\n        prev,\n        point,\n        points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen],\n        options.tension\n      );\n      point.cp1x = controlPoints.previous.x;\n      point.cp1y = controlPoints.previous.y;\n      point.cp2x = controlPoints.next.x;\n      point.cp2y = controlPoints.next.y;\n      prev = point;\n    }\n  }\n\n  if (options.capBezierPoints) {\n    capBezierPoints(points, area);\n  }\n}\n","import type {ChartArea, Scale} from '../types/index.js';\nimport type Chart from '../core/core.controller.js';\nimport type {ChartEvent} from '../types.js';\nimport {INFINITY} from './helpers.math.js';\n\n/**\n * Note: typedefs are auto-exported, so use a made-up `dom` namespace where\n * necessary to avoid duplicates with `export * from './helpers`; see\n * https://github.com/microsoft/TypeScript/issues/46011\n * @typedef { import('../core/core.controller.js').default } dom.Chart\n * @typedef { import('../../types').ChartEvent } ChartEvent\n */\n\n/**\n * @private\n */\nexport function _isDomSupported(): boolean {\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * @private\n */\nexport function _getParentNode(domNode: HTMLCanvasElement): HTMLCanvasElement {\n  let parent = domNode.parentNode;\n  if (parent && parent.toString() === '[object ShadowRoot]') {\n    parent = (parent as ShadowRoot).host;\n  }\n  return parent as HTMLCanvasElement;\n}\n\n/**\n * convert max-width/max-height values that may be percentages into a number\n * @private\n */\n\nfunction parseMaxStyle(styleValue: string | number, node: HTMLElement, parentProperty: string) {\n  let valueInPixels: number;\n  if (typeof styleValue === 'string') {\n    valueInPixels = parseInt(styleValue, 10);\n\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\n  return valueInPixels;\n}\n\nconst getComputedStyle = (element: HTMLElement): CSSStyleDeclaration =>\n  element.ownerDocument.defaultView.getComputedStyle(element, null);\n\nexport function getStyle(el: HTMLElement, property: string): string {\n  return getComputedStyle(el).getPropertyValue(property);\n}\n\nconst positions = ['top', 'right', 'bottom', 'left'];\nfunction getPositionedStyle(styles: CSSStyleDeclaration, style: string, suffix?: string): ChartArea {\n  const result = {} as ChartArea;\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}\n\nconst useOffsetPos = (x: number, y: number, target: HTMLElement | EventTarget) =>\n  (x > 0 || y > 0) && (!target || !(target as HTMLElement).shadowRoot);\n\n/**\n * @param e\n * @param canvas\n * @returns Canvas position\n */\nfunction getCanvasPosition(\n  e: Event | TouchEvent | MouseEvent,\n  canvas: HTMLCanvasElement\n): {\n    x: number;\n    y: number;\n    box: boolean;\n  } {\n  const touches = (e as TouchEvent).touches;\n  const source = (touches && touches.length ? touches[0] : e) as MouseEvent;\n  const {offsetX, offsetY} = source as MouseEvent;\n  let box = false;\n  let x, y;\n  if (useOffsetPos(offsetX, offsetY, e.target)) {\n    x = offsetX;\n    y = offsetY;\n  } else {\n    const rect = canvas.getBoundingClientRect();\n    x = source.clientX - rect.left;\n    y = source.clientY - rect.top;\n    box = true;\n  }\n  return {x, y, box};\n}\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 */\n\nexport function getRelativePosition(\n  event: Event | ChartEvent | TouchEvent | MouseEvent,\n  chart: Chart\n): { x: number; y: number } {\n  if ('native' in event) {\n    return event;\n  }\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\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}\n\nfunction getContainerSize(canvas: HTMLCanvasElement, width: number, height: number): Partial<Scale> {\n  let maxWidth: number, maxHeight: number;\n\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}\n\nconst round1 = (v: number) => Math.round(v * 10) / 10;\n\n// eslint-disable-next-line complexity\nexport function getMaximumSize(\n  canvas: HTMLCanvasElement,\n  bbWidth?: number,\n  bbHeight?: number,\n  aspectRatio?: number\n): { width: number; height: number } {\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\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\n  const maintainHeight = bbWidth !== undefined || bbHeight !== undefined;\n\n  if (maintainHeight && aspectRatio && containerSize.height && height > containerSize.height) {\n    height = containerSize.height;\n    width = round1(Math.floor(height * aspectRatio));\n  }\n\n  return {width, 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 */\nexport function retinaScale(\n  chart: Chart,\n  forceRatio: number,\n  forceStyle?: boolean\n): boolean | void {\n  const pixelRatio = forceRatio || 1;\n  const deviceHeight = Math.floor(chart.height * pixelRatio);\n  const deviceWidth = Math.floor(chart.width * pixelRatio);\n\n  chart.height = Math.floor(chart.height);\n  chart.width = Math.floor(chart.width);\n\n  const canvas = chart.canvas;\n\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\n  if (chart.currentDevicePixelRatio !== pixelRatio\n      || canvas.height !== deviceHeight\n      || canvas.width !== deviceWidth) {\n    chart.currentDevicePixelRatio = pixelRatio;\n    canvas.height = deviceHeight;\n    canvas.width = deviceWidth;\n    chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);\n    return true;\n  }\n  return false;\n}\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 */\nexport const supportsEventListenerOptions = (function() {\n  let passiveSupported = false;\n  try {\n    const options = {\n      get passive() { // This function will be called when the browser attempts to access the passive property.\n        passiveSupported = true;\n        return false;\n      }\n    } as EventListenerOptions;\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/**\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 */\n\nexport function readUsedSize(\n  element: HTMLElement,\n  property: 'width' | 'height'\n): number | undefined {\n  const value = getStyle(element, property);\n  const matches = value && value.match(/^(\\d+)(\\.\\d+)?px$/);\n  return matches ? +matches[1] : undefined;\n}\n","import type {Point, SplinePoint} from '../types/geometric.js';\n\n/**\n * @private\n */\nexport function _pointInLine(p1: Point, p2: Point, t: number, mode?) { // eslint-disable-line @typescript-eslint/no-unused-vars\n  return {\n    x: p1.x + t * (p2.x - p1.x),\n    y: p1.y + t * (p2.y - p1.y)\n  };\n}\n\n/**\n * @private\n */\nexport function _steppedInterpolation(\n  p1: Point,\n  p2: Point,\n  t: number, mode: 'middle' | 'after' | unknown\n) {\n  return {\n    x: p1.x + t * (p2.x - p1.x),\n    y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y\n      : mode === 'after' ? t < 1 ? p1.y : p2.y\n        : t > 0 ? p2.y : p1.y\n  };\n}\n\n/**\n * @private\n */\nexport function _bezierInterpolation(p1: SplinePoint, p2: SplinePoint, t: number, mode?) { // eslint-disable-line @typescript-eslint/no-unused-vars\n  const cp1 = {x: p1.cp2x, y: p1.cp2y};\n  const cp2 = {x: p2.cp1x, y: p2.cp1y};\n  const a = _pointInLine(p1, cp1, t);\n  const b = _pointInLine(cp1, cp2, t);\n  const c = _pointInLine(cp2, p2, t);\n  const d = _pointInLine(a, b, t);\n  const e = _pointInLine(b, c, t);\n  return _pointInLine(d, e, t);\n}\n","export interface RTLAdapter {\n  x(x: number): number;\n  setWidth(w: number): void;\n  textAlign(align: 'center' | 'left' | 'right'): 'center' | 'left' | 'right';\n  xPlus(x: number, value: number): number;\n  leftForLtr(x: number, itemWidth: number): number;\n}\n\nconst getRightToLeftAdapter = function(rectX: number, width: number): RTLAdapter {\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};\n\nconst getLeftToRightAdapter = function(): RTLAdapter {\n  return {\n    x(x) {\n      return x;\n    },\n    setWidth(w) { // eslint-disable-line no-unused-vars\n    },\n    textAlign(align) {\n      return align;\n    },\n    xPlus(x, value) {\n      return x + value;\n    },\n    leftForLtr(x, _itemWidth) { // eslint-disable-line @typescript-eslint/no-unused-vars\n      return x;\n    },\n  };\n};\n\nexport function getRtlAdapter(rtl: boolean, rectX: number, width: number) {\n  return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();\n}\n\nexport function overrideTextDirection(ctx: CanvasRenderingContext2D, direction: 'ltr' | 'rtl') {\n  let style: CSSStyleDeclaration, original: [string, string];\n  if (direction === 'ltr' || direction === 'rtl') {\n    style = ctx.canvas.style;\n    original = [\n      style.getPropertyValue('direction'),\n      style.getPropertyPriority('direction'),\n    ];\n\n    style.setProperty('direction', direction, 'important');\n    (ctx as { prevTextDirection?: [string, string] }).prevTextDirection = original;\n  }\n}\n\nexport function restoreTextDirection(ctx: CanvasRenderingContext2D, original?: [string, string]) {\n  if (original !== undefined) {\n    delete (ctx as { prevTextDirection?: [string, string] }).prevTextDirection;\n    ctx.canvas.style.setProperty('direction', original[0], original[1]);\n  }\n}\n","import {_angleBetween, _angleDiff, _isBetween, _normalizeAngle} from './helpers.math.js';\nimport {createContext} from './helpers.options.js';\nimport {isPatternOrGradient} from './helpers.color.js';\n\n/**\n * @typedef { import('../elements/element.line.js').default } LineElement\n * @typedef { import('../elements/element.point.js').default } PointElement\n * @typedef {{start: number, end: number, loop: boolean, style?: any}} Segment\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}\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}\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  // eslint-disable-next-line prefer-const\n  let {start, end, loop} = segment;\n  let i, ilen;\n\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\n  if (end < start) {\n    end += count;\n  }\n  return {start, end, loop, style: segment.style};\n}\n\n/**\n * Returns the sub-segment(s) of a line segment that fall in the given bounds\n * @param {object} segment\n * @param {number} segment.start - start index of the segment, referring the points array\n * @param {number} segment.end - end index of the segment, referring the points array\n * @param {boolean} segment.loop - indicates that the segment is a loop\n * @param {object} [segment.style] - segment style\n * @param {PointElement[]} points - the points that this segment refers to\n * @param {object} [bounds]\n * @param {string} bounds.property - the property of a `PointElement` we are bounding. `x`, `y` or `angle`.\n * @param {number} bounds.start - start value of the property\n * @param {number} bounds.end - end value of the property\n * @private\n **/\nexport function _boundSegment(segment, points, bounds) {\n  if (!bounds) {\n    return [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\n  const result = [];\n  let inside = false;\n  let subStart = null;\n  let value, point, prevValue;\n\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\n  for (let i = start, prev = start; i <= end; ++i) {\n    point = points[i % count];\n\n    if (point.skip) {\n      continue;\n    }\n\n    value = normalize(point[property]);\n\n    if (value === prevValue) {\n      continue;\n    }\n\n    inside = between(value, startBound, endBound);\n\n    if (subStart === null && shouldStart()) {\n      subStart = compare(value, startBound) === 0 ? i : prev;\n    }\n\n    if (subStart !== null && shouldStop()) {\n      result.push(normalizeSegment({start: subStart, end: i, loop, count, style}));\n      subStart = null;\n    }\n    prev = i;\n    prevValue = value;\n  }\n\n  if (subStart !== null) {\n    result.push(normalizeSegment({start: subStart, end, loop, count, style}));\n  }\n\n  return result;\n}\n\n\n/**\n * Returns the segments of the line that are inside given bounds\n * @param {LineElement} line\n * @param {object} [bounds]\n * @param {string} bounds.property - the property we are bounding with. `x`, `y` or `angle`.\n * @param {number} bounds.start - start value of the `property`\n * @param {number} bounds.end - end value of the `property`\n * @private\n */\nexport function _boundSegments(line, bounds) {\n  const result = [];\n  const segments = line.segments;\n\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\n/**\n * Find start and end index of a line.\n */\nfunction findStartAndEnd(points, count, loop, spanGaps) {\n  let start = 0;\n  let end = count - 1;\n\n  if (loop && !spanGaps) {\n    // loop and not spanning gaps, first find a gap to start from\n    while (start < count && !points[start].skip) {\n      start++;\n    }\n  }\n\n  // find first non skipped point (after the first gap possibly)\n  while (start < count && points[start].skip) {\n    start++;\n  }\n\n  // if we looped to count, start needs to be 0\n  start %= count;\n\n  if (loop) {\n    // loop will go past count, if start > 0\n    end += start;\n  }\n\n  while (end > start && points[end % count].skip) {\n    end--;\n  }\n\n  // end could be more than count, normalize\n  end %= count;\n\n  return {start, end};\n}\n\n/**\n * Compute solid segments from Points, when spanGaps === false\n * @param {PointElement[]} points - the points\n * @param {number} start - start index\n * @param {number} max - max index (can go past count on a loop)\n * @param {boolean} loop - boolean indicating that this would be a loop if no gaps are found\n */\nfunction solidSegments(points, start, max, loop) {\n  const count = points.length;\n  const result = [];\n  let last = start;\n  let prev = points[start];\n  let end;\n\n  for (end = start + 1; end <= max; ++end) {\n    const cur = points[end % count];\n    if (cur.skip || cur.stop) {\n      if (!prev.skip) {\n        loop = false;\n        result.push({start: start % count, end: (end - 1) % count, loop});\n        // @ts-ignore\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\n  if (last !== null) {\n    result.push({start: start % count, end: last % count, loop});\n  }\n\n  return result;\n}\n\n/**\n * Compute the continuous segments that define the whole line\n * There can be skipped points within a segment, if spanGaps is true.\n * @param {LineElement} line\n * @param {object} [segmentOptions]\n * @return {Segment[]}\n * @private\n */\nexport function _computeSegments(line, segmentOptions) {\n  const points = line.points;\n  const spanGaps = line.options.spanGaps;\n  const count = points.length;\n\n  if (!count) {\n    return [];\n  }\n\n  const loop = !!line._loop;\n  const {start, end} = findStartAndEnd(points, count, loop, spanGaps);\n\n  if (spanGaps === true) {\n    return splitByStyles(line, [{start, end, loop}], points, segmentOptions);\n  }\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\n/**\n * @param {Segment[]} segments\n * @param {PointElement[]} points\n * @param {object} [segmentOptions]\n * @return {Segment[]}\n */\nfunction splitByStyles(line, segments, points, segmentOptions) {\n  if (!segmentOptions || !segmentOptions.setContext || !points) {\n    return segments;\n  }\n  return doSplitByStyles(line, segments, points, segmentOptions);\n}\n\n/**\n * @param {LineElement} line\n * @param {Segment[]} segments\n * @param {PointElement[]} points\n * @param {object} [segmentOptions]\n * @return {Segment[]}\n */\nfunction doSplitByStyles(line, segments, points, segmentOptions) {\n  const chartContext = line._chart.getContext();\n  const baseStyle = readStyle(line.options);\n  const {_datasetIndex: datasetIndex, options: {spanGaps}} = line;\n  const count = points.length;\n  const result = [];\n  let prevStyle = baseStyle;\n  let start = segments[0].start;\n  let i = start;\n\n  function addStyle(s, e, l, st) {\n    const dir = spanGaps ? -1 : 1;\n    if (s === e) {\n      return;\n    }\n    // Style can not start/end on a skipped point, adjust indices accordingly\n    s += count;\n    while (points[s % count].skip) {\n      s -= dir;\n    }\n    while (points[e % count].skip) {\n      e += dir;\n    }\n    if (s % count !== e % count) {\n      result.push({start: s % count, end: e % count, loop: l, style: st});\n      prevStyle = st;\n      start = e % count;\n    }\n  }\n\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\n  return result;\n}\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}\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","import {requestAnimFrame} from '../helpers/helpers.extras.js';\n\n/**\n * @typedef { import('./core.animation.js').default } Animation\n * @typedef { import('./core.controller.js').default } Chart\n */\n\n/**\n * Please use the module's default export which provides a singleton instance\n * Note: class is export for typedoc\n */\nexport class Animator {\n  constructor() {\n    this._request = null;\n    this._charts = new Map();\n    this._running = false;\n    this._lastDate = undefined;\n  }\n\n  /**\n\t * @private\n\t */\n  _notify(chart, anims, date, type) {\n    const callbacks = anims.listeners[type];\n    const numSteps = anims.duration;\n\n    callbacks.forEach(fn => fn({\n      chart,\n      initial: anims.initial,\n      numSteps,\n      currentStep: Math.min(date - anims.start, numSteps)\n    }));\n  }\n\n  /**\n\t * @private\n\t */\n  _refresh() {\n    if (this._request) {\n      return;\n    }\n    this._running = true;\n\n    this._request = requestAnimFrame.call(window, () => {\n      this._update();\n      this._request = null;\n\n      if (this._running) {\n        this._refresh();\n      }\n    });\n  }\n\n  /**\n\t * @private\n\t */\n  _update(date = Date.now()) {\n    let remaining = 0;\n\n    this._charts.forEach((anims, chart) => {\n      if (!anims.running || !anims.items.length) {\n        return;\n      }\n      const items = anims.items;\n      let i = items.length - 1;\n      let draw = false;\n      let item;\n\n      for (; i >= 0; --i) {\n        item = items[i];\n\n        if (item._active) {\n          if (item._total > anims.duration) {\n            // if the animation has been updated and its duration prolonged,\n            // update to total duration of current animations run (for progress event)\n            anims.duration = item._total;\n          }\n          item.tick(date);\n          draw = true;\n        } else {\n          // Remove the item by replacing it with last item and removing the last\n          // A lot faster than splice.\n          items[i] = items[items.length - 1];\n          items.pop();\n        }\n      }\n\n      if (draw) {\n        chart.draw();\n        this._notify(chart, anims, date, 'progress');\n      }\n\n      if (!items.length) {\n        anims.running = false;\n        this._notify(chart, anims, date, 'complete');\n        anims.initial = false;\n      }\n\n      remaining += items.length;\n    });\n\n    this._lastDate = date;\n\n    if (remaining === 0) {\n      this._running = false;\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _getAnims(chart) {\n    const charts = this._charts;\n    let anims = charts.get(chart);\n    if (!anims) {\n      anims = {\n        running: false,\n        initial: true,\n        items: [],\n        listeners: {\n          complete: [],\n          progress: []\n        }\n      };\n      charts.set(chart, anims);\n    }\n    return anims;\n  }\n\n  /**\n\t * @param {Chart} chart\n\t * @param {string} event - event name\n\t * @param {Function} cb - callback\n\t */\n  listen(chart, event, cb) {\n    this._getAnims(chart).listeners[event].push(cb);\n  }\n\n  /**\n\t * Add animations\n\t * @param {Chart} chart\n\t * @param {Animation[]} items - animations\n\t */\n  add(chart, items) {\n    if (!items || !items.length) {\n      return;\n    }\n    this._getAnims(chart).items.push(...items);\n  }\n\n  /**\n\t * Counts number of active animations for the chart\n\t * @param {Chart} chart\n\t */\n  has(chart) {\n    return this._getAnims(chart).items.length > 0;\n  }\n\n  /**\n\t * Start animating (all charts)\n\t * @param {Chart} chart\n\t */\n  start(chart) {\n    const anims = this._charts.get(chart);\n    if (!anims) {\n      return;\n    }\n    anims.running = true;\n    anims.start = Date.now();\n    anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);\n    this._refresh();\n  }\n\n  running(chart) {\n    if (!this._running) {\n      return false;\n    }\n    const anims = this._charts.get(chart);\n    if (!anims || !anims.running || !anims.items.length) {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n\t * Stop all animations for the chart\n\t * @param {Chart} chart\n\t */\n  stop(chart) {\n    const anims = this._charts.get(chart);\n    if (!anims || !anims.items.length) {\n      return;\n    }\n    const items = anims.items;\n    let i = items.length - 1;\n\n    for (; i >= 0; --i) {\n      items[i].cancel();\n    }\n    anims.items = [];\n    this._notify(chart, anims, Date.now(), 'complete');\n  }\n\n  /**\n\t * Remove chart from Animator\n\t * @param {Chart} chart\n\t */\n  remove(chart) {\n    return this._charts.delete(chart);\n  }\n}\n\n// singleton instance\nexport default /* #__PURE__ */ new Animator();\n","import effects from '../helpers/helpers.easing.js';\nimport {resolve} from '../helpers/helpers.options.js';\nimport {color as helpersColor} from '../helpers/helpers.color.js';\n\nconst transparent = 'transparent';\nconst interpolators = {\n  boolean(from, to, factor) {\n    return factor > 0.5 ? to : from;\n  },\n  /**\n   * @param {string} from\n   * @param {string} to\n   * @param {number} factor\n   */\n  color(from, to, factor) {\n    const c0 = helpersColor(from || transparent);\n    const c1 = c0.valid && helpersColor(to || transparent);\n    return c1 && c1.valid\n      ? c1.mix(c0, factor).hexString()\n      : to;\n  },\n  number(from, to, factor) {\n    return from + (to - from) * factor;\n  }\n};\n\nexport default class Animation {\n  constructor(cfg, target, prop, to) {\n    const currentValue = target[prop];\n\n    to = resolve([cfg.to, to, currentValue, cfg.from]);\n    const from = resolve([cfg.from, currentValue, to]);\n\n    this._active = true;\n    this._fn = cfg.fn || interpolators[cfg.type || typeof from];\n    this._easing = effects[cfg.easing] || effects.linear;\n    this._start = Math.floor(Date.now() + (cfg.delay || 0));\n    this._duration = this._total = Math.floor(cfg.duration);\n    this._loop = !!cfg.loop;\n    this._target = target;\n    this._prop = prop;\n    this._from = from;\n    this._to = to;\n    this._promises = undefined;\n  }\n\n  active() {\n    return this._active;\n  }\n\n  update(cfg, to, date) {\n    if (this._active) {\n      this._notify(false);\n\n      const currentValue = this._target[this._prop];\n      const elapsed = date - this._start;\n      const remain = this._duration - elapsed;\n      this._start = date;\n      this._duration = Math.floor(Math.max(remain, cfg.duration));\n      this._total += elapsed;\n      this._loop = !!cfg.loop;\n      this._to = resolve([cfg.to, to, currentValue, cfg.from]);\n      this._from = resolve([cfg.from, currentValue, to]);\n    }\n  }\n\n  cancel() {\n    if (this._active) {\n      // update current evaluated value, for smoother animations\n      this.tick(Date.now());\n      this._active = false;\n      this._notify(false);\n    }\n  }\n\n  tick(date) {\n    const elapsed = date - this._start;\n    const duration = this._duration;\n    const prop = this._prop;\n    const from = this._from;\n    const loop = this._loop;\n    const to = this._to;\n    let factor;\n\n    this._active = from !== to && (loop || (elapsed < duration));\n\n    if (!this._active) {\n      this._target[prop] = to;\n      this._notify(true);\n      return;\n    }\n\n    if (elapsed < 0) {\n      this._target[prop] = from;\n      return;\n    }\n\n    factor = (elapsed / duration) % 2;\n    factor = loop && factor > 1 ? 2 - factor : factor;\n    factor = this._easing(Math.min(1, Math.max(0, factor)));\n\n    this._target[prop] = this._fn(from, to, factor);\n  }\n\n  wait() {\n    const promises = this._promises || (this._promises = []);\n    return new Promise((res, rej) => {\n      promises.push({res, rej});\n    });\n  }\n\n  _notify(resolved) {\n    const method = resolved ? 'res' : 'rej';\n    const promises = this._promises || [];\n    for (let i = 0; i < promises.length; i++) {\n      promises[i][method]();\n    }\n  }\n}\n","import animator from './core.animator.js';\nimport Animation from './core.animation.js';\nimport defaults from './core.defaults.js';\nimport {isArray, isObject} from '../helpers/helpers.core.js';\n\nexport default class Animations {\n  constructor(chart, config) {\n    this._chart = chart;\n    this._properties = new Map();\n    this.configure(config);\n  }\n\n  configure(config) {\n    if (!isObject(config)) {\n      return;\n    }\n\n    const animationOptions = Object.keys(defaults.animation);\n    const animatedProps = this._properties;\n\n    Object.getOwnPropertyNames(config).forEach(key => {\n      const cfg = config[key];\n      if (!isObject(cfg)) {\n        return;\n      }\n      const resolved = {};\n      for (const option of animationOptions) {\n        resolved[option] = cfg[option];\n      }\n\n      (isArray(cfg.properties) && cfg.properties || [key]).forEach((prop) => {\n        if (prop === key || !animatedProps.has(prop)) {\n          animatedProps.set(prop, resolved);\n        }\n      });\n    });\n  }\n\n  /**\n\t * Utility to handle animation of `options`.\n\t * @private\n\t */\n  _animateOptions(target, values) {\n    const newOptions = values.options;\n    const options = resolveTargetOptions(target, newOptions);\n    if (!options) {\n      return [];\n    }\n\n    const animations = this._createAnimations(options, newOptions);\n    if (newOptions.$shared) {\n      // Going to shared options:\n      // After all animations are done, assign the shared options object to the element\n      // So any new updates to the shared options are observed\n      awaitAll(target.options.$animations, newOptions).then(() => {\n        target.options = newOptions;\n      }, () => {\n        // rejected, noop\n      });\n    }\n\n    return animations;\n  }\n\n  /**\n\t * @private\n\t */\n  _createAnimations(target, values) {\n    const animatedProps = this._properties;\n    const animations = [];\n    const running = target.$animations || (target.$animations = {});\n    const props = Object.keys(values);\n    const date = Date.now();\n    let i;\n\n    for (i = props.length - 1; i >= 0; --i) {\n      const prop = props[i];\n      if (prop.charAt(0) === '$') {\n        continue;\n      }\n\n      if (prop === 'options') {\n        animations.push(...this._animateOptions(target, values));\n        continue;\n      }\n      const value = values[prop];\n      let animation = running[prop];\n      const cfg = animatedProps.get(prop);\n\n      if (animation) {\n        if (cfg && animation.active()) {\n          // There is an existing active animation, let's update that\n          animation.update(cfg, value, date);\n          continue;\n        } else {\n          animation.cancel();\n        }\n      }\n      if (!cfg || !cfg.duration) {\n        // not animated, set directly to new value\n        target[prop] = value;\n        continue;\n      }\n\n      running[prop] = animation = new Animation(cfg, target, prop, value);\n      animations.push(animation);\n    }\n    return animations;\n  }\n\n\n  /**\n\t * Update `target` properties to new values, using configured animations\n\t * @param {object} target - object to update\n\t * @param {object} values - new target properties\n\t * @returns {boolean|undefined} - `true` if animations were started\n\t **/\n  update(target, values) {\n    if (this._properties.size === 0) {\n      // Nothing is animated, just apply the new values.\n      Object.assign(target, values);\n      return;\n    }\n\n    const animations = this._createAnimations(target, values);\n\n    if (animations.length) {\n      animator.add(this._chart, animations);\n      return true;\n    }\n  }\n}\n\nfunction awaitAll(animations, properties) {\n  const running = [];\n  const keys = Object.keys(properties);\n  for (let i = 0; i < keys.length; i++) {\n    const anim = animations[keys[i]];\n    if (anim && anim.active()) {\n      running.push(anim.wait());\n    }\n  }\n  // @ts-ignore\n  return Promise.all(running);\n}\n\nfunction resolveTargetOptions(target, newOptions) {\n  if (!newOptions) {\n    return;\n  }\n  let options = target.options;\n  if (!options) {\n    target.options = newOptions;\n    return;\n  }\n  if (options.$shared) {\n    // Going from shared options to distinct one:\n    // Create new options object containing the old shared values and start updating that.\n    target.options = options = Object.assign({}, options, {$shared: false, $animations: {}});\n  }\n  return options;\n}\n","import Animations from './core.animations.js';\nimport defaults from './core.defaults.js';\nimport {isArray, isFinite, isObject, valueOrDefault, resolveObjectKey, defined} from '../helpers/helpers.core.js';\nimport {listenArrayEvents, unlistenArrayEvents} from '../helpers/helpers.collection.js';\nimport {createContext, sign} from '../helpers/index.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef { import('./core.scale.js').default } Scale\n */\n\nfunction scaleClip(scale, allowedOverflow) {\n  const opts = scale && scale.options || {};\n  const reverse = opts.reverse;\n  const min = opts.min === undefined ? allowedOverflow : 0;\n  const max = opts.max === undefined ? allowedOverflow : 0;\n  return {\n    start: reverse ? max : min,\n    end: reverse ? min : max\n  };\n}\n\nfunction defaultClip(xScale, yScale, allowedOverflow) {\n  if (allowedOverflow === false) {\n    return false;\n  }\n  const x = scaleClip(xScale, allowedOverflow);\n  const y = scaleClip(yScale, allowedOverflow);\n\n  return {\n    top: y.end,\n    right: x.end,\n    bottom: y.start,\n    left: x.start\n  };\n}\n\nfunction toClip(value) {\n  let t, r, b, l;\n\n  if (isObject(value)) {\n    t = value.top;\n    r = value.right;\n    b = value.bottom;\n    l = value.left;\n  } else {\n    t = r = b = l = value;\n  }\n\n  return {\n    top: t,\n    right: r,\n    bottom: b,\n    left: l,\n    disabled: value === false\n  };\n}\n\nfunction getSortedDatasetIndices(chart, filterVisible) {\n  const keys = [];\n  const metasets = chart._getSortedDatasetMetas(filterVisible);\n  let i, ilen;\n\n  for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n    keys.push(metasets[i].index);\n  }\n  return keys;\n}\n\nfunction applyStack(stack, value, dsIndex, options = {}) {\n  const keys = stack.keys;\n  const singleMode = options.mode === 'single';\n  let i, ilen, datasetIndex, otherValue;\n\n  if (value === null) {\n    return;\n  }\n\n  for (i = 0, ilen = keys.length; i < ilen; ++i) {\n    datasetIndex = +keys[i];\n    if (datasetIndex === dsIndex) {\n      if (options.all) {\n        continue;\n      }\n      break;\n    }\n    otherValue = stack.values[datasetIndex];\n    if (isFinite(otherValue) && (singleMode || (value === 0 || sign(value) === sign(otherValue)))) {\n      value += otherValue;\n    }\n  }\n  return value;\n}\n\nfunction convertObjectDataToArray(data, meta) {\n  const {iScale, vScale} = meta;\n  const iAxisKey = iScale.axis === 'x' ? 'x' : 'y';\n  const vAxisKey = vScale.axis === 'x' ? 'x' : 'y';\n  const keys = Object.keys(data);\n  const adata = new Array(keys.length);\n  let i, ilen, key;\n  for (i = 0, ilen = keys.length; i < ilen; ++i) {\n    key = keys[i];\n    adata[i] = {\n      [iAxisKey]: key,\n      [vAxisKey]: data[key]\n    };\n  }\n  return adata;\n}\n\nfunction isStacked(scale, meta) {\n  const stacked = scale && scale.options.stacked;\n  return stacked || (stacked === undefined && meta.stack !== undefined);\n}\n\nfunction getStackKey(indexScale, valueScale, meta) {\n  return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;\n}\n\nfunction getUserBounds(scale) {\n  const {min, max, minDefined, maxDefined} = scale.getUserBounds();\n  return {\n    min: minDefined ? min : Number.NEGATIVE_INFINITY,\n    max: maxDefined ? max : Number.POSITIVE_INFINITY\n  };\n}\n\nfunction getOrCreateStack(stacks, stackKey, indexValue) {\n  const subStack = stacks[stackKey] || (stacks[stackKey] = {});\n  return subStack[indexValue] || (subStack[indexValue] = {});\n}\n\nfunction getLastIndexInStack(stack, vScale, positive, type) {\n  for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {\n    const value = stack[meta.index];\n    if ((positive && value > 0) || (!positive && value < 0)) {\n      return meta.index;\n    }\n  }\n\n  return null;\n}\n\nfunction updateStacks(controller, parsed) {\n  const {chart, _cachedMeta: meta} = controller;\n  const stacks = chart._stacks || (chart._stacks = {}); // map structure is {stackKey: {datasetIndex: value}}\n  const {iScale, vScale, index: datasetIndex} = meta;\n  const iAxis = iScale.axis;\n  const vAxis = vScale.axis;\n  const key = getStackKey(iScale, vScale, meta);\n  const ilen = parsed.length;\n  let stack;\n\n  for (let i = 0; i < ilen; ++i) {\n    const item = parsed[i];\n    const {[iAxis]: index, [vAxis]: value} = item;\n    const itemStacks = item._stacks || (item._stacks = {});\n    stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);\n    stack[datasetIndex] = value;\n\n    stack._top = getLastIndexInStack(stack, vScale, true, meta.type);\n    stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);\n\n    const visualValues = stack._visualValues || (stack._visualValues = {});\n    visualValues[datasetIndex] = value;\n  }\n}\n\nfunction getFirstScaleId(chart, axis) {\n  const scales = chart.scales;\n  return Object.keys(scales).filter(key => scales[key].axis === axis).shift();\n}\n\nfunction createDatasetContext(parent, index) {\n  return createContext(parent,\n    {\n      active: false,\n      dataset: undefined,\n      datasetIndex: index,\n      index,\n      mode: 'default',\n      type: 'dataset'\n    }\n  );\n}\n\nfunction createDataContext(parent, index, element) {\n  return createContext(parent, {\n    active: false,\n    dataIndex: index,\n    parsed: undefined,\n    raw: undefined,\n    element,\n    index,\n    mode: 'default',\n    type: 'data'\n  });\n}\n\nfunction clearStacks(meta, items) {\n  // Not using meta.index here, because it might be already updated if the dataset changed location\n  const datasetIndex = meta.controller.index;\n  const axis = meta.vScale && meta.vScale.axis;\n  if (!axis) {\n    return;\n  }\n\n  items = items || meta._parsed;\n  for (const parsed of items) {\n    const stacks = parsed._stacks;\n    if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) {\n      return;\n    }\n    delete stacks[axis][datasetIndex];\n    if (stacks[axis]._visualValues !== undefined && stacks[axis]._visualValues[datasetIndex] !== undefined) {\n      delete stacks[axis]._visualValues[datasetIndex];\n    }\n  }\n}\n\nconst isDirectUpdateMode = (mode) => mode === 'reset' || mode === 'none';\nconst cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);\nconst createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked\n  && {keys: getSortedDatasetIndices(chart, true), values: null};\n\nexport default class DatasetController {\n\n  /**\n   * @type {any}\n   */\n  static defaults = {};\n\n  /**\n   * Element type used to generate a meta dataset (e.g. Chart.element.LineElement).\n   */\n  static datasetElementType = null;\n\n  /**\n   * Element type used to generate a meta data (e.g. Chart.element.PointElement).\n   */\n  static dataElementType = null;\n\n  /**\n\t * @param {Chart} chart\n\t * @param {number} datasetIndex\n\t */\n  constructor(chart, datasetIndex) {\n    this.chart = chart;\n    this._ctx = chart.ctx;\n    this.index = datasetIndex;\n    this._cachedDataOpts = {};\n    this._cachedMeta = this.getMeta();\n    this._type = this._cachedMeta.type;\n    this.options = undefined;\n    /** @type {boolean | object} */\n    this._parsing = false;\n    this._data = undefined;\n    this._objectData = undefined;\n    this._sharedOptions = undefined;\n    this._drawStart = undefined;\n    this._drawCount = undefined;\n    this.enableOptionSharing = false;\n    this.supportsDecimation = false;\n    this.$context = undefined;\n    this._syncList = [];\n    this.datasetElementType = new.target.datasetElementType;\n    this.dataElementType = new.target.dataElementType;\n\n    this.initialize();\n  }\n\n  initialize() {\n    const meta = this._cachedMeta;\n    this.configure();\n    this.linkScales();\n    meta._stacked = isStacked(meta.vScale, meta);\n    this.addElements();\n\n    if (this.options.fill && !this.chart.isPluginEnabled('filler')) {\n      console.warn(\"Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options\");\n    }\n  }\n\n  updateIndex(datasetIndex) {\n    if (this.index !== datasetIndex) {\n      clearStacks(this._cachedMeta);\n    }\n    this.index = datasetIndex;\n  }\n\n  linkScales() {\n    const chart = this.chart;\n    const meta = this._cachedMeta;\n    const dataset = this.getDataset();\n\n    const chooseId = (axis, x, y, r) => axis === 'x' ? x : axis === 'r' ? r : y;\n\n    const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x'));\n    const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y'));\n    const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r'));\n    const indexAxis = meta.indexAxis;\n    const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);\n    const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);\n    meta.xScale = this.getScaleForId(xid);\n    meta.yScale = this.getScaleForId(yid);\n    meta.rScale = this.getScaleForId(rid);\n    meta.iScale = this.getScaleForId(iid);\n    meta.vScale = this.getScaleForId(vid);\n  }\n\n  getDataset() {\n    return this.chart.data.datasets[this.index];\n  }\n\n  getMeta() {\n    return this.chart.getDatasetMeta(this.index);\n  }\n\n  /**\n\t * @param {string} scaleID\n\t * @return {Scale}\n\t */\n  getScaleForId(scaleID) {\n    return this.chart.scales[scaleID];\n  }\n\n  /**\n\t * @private\n\t */\n  _getOtherScale(scale) {\n    const meta = this._cachedMeta;\n    return scale === meta.iScale\n      ? meta.vScale\n      : meta.iScale;\n  }\n\n  reset() {\n    this._update('reset');\n  }\n\n  /**\n\t * @private\n\t */\n  _destroy() {\n    const meta = this._cachedMeta;\n    if (this._data) {\n      unlistenArrayEvents(this._data, this);\n    }\n    if (meta._stacked) {\n      clearStacks(meta);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _dataCheck() {\n    const dataset = this.getDataset();\n    const data = dataset.data || (dataset.data = []);\n    const _data = this._data;\n\n    // In order to correctly handle data addition/deletion animation (and thus simulate\n    // real-time charts), we need to monitor these data modifications and synchronize\n    // the internal metadata accordingly.\n\n    if (isObject(data)) {\n      const meta = this._cachedMeta;\n      this._data = convertObjectDataToArray(data, meta);\n    } else if (_data !== data) {\n      if (_data) {\n        // This case happens when the user replaced the data array instance.\n        unlistenArrayEvents(_data, this);\n        // Discard old parsed data and stacks\n        const meta = this._cachedMeta;\n        clearStacks(meta);\n        meta._parsed = [];\n      }\n      if (data && Object.isExtensible(data)) {\n        listenArrayEvents(data, this);\n      }\n      this._syncList = [];\n      this._data = data;\n    }\n  }\n\n  addElements() {\n    const meta = this._cachedMeta;\n\n    this._dataCheck();\n\n    if (this.datasetElementType) {\n      meta.dataset = new this.datasetElementType();\n    }\n  }\n\n  buildOrUpdateElements(resetNewElements) {\n    const meta = this._cachedMeta;\n    const dataset = this.getDataset();\n    let stackChanged = false;\n\n    this._dataCheck();\n\n    // make sure cached _stacked status is current\n    const oldStacked = meta._stacked;\n    meta._stacked = isStacked(meta.vScale, meta);\n\n    // detect change in stack option\n    if (meta.stack !== dataset.stack) {\n      stackChanged = true;\n      // remove values from old stack\n      clearStacks(meta);\n      meta.stack = dataset.stack;\n    }\n\n    // Re-sync meta data in case the user replaced the data array or if we missed\n    // any updates and so make sure that we handle number of datapoints changing.\n    this._resyncElements(resetNewElements);\n\n    // if stack changed, update stack values for the whole dataset\n    if (stackChanged || oldStacked !== meta._stacked) {\n      updateStacks(this, meta._parsed);\n    }\n  }\n\n  /**\n\t * Merges user-supplied and default dataset-level options\n\t * @private\n\t */\n  configure() {\n    const config = this.chart.config;\n    const scopeKeys = config.datasetScopeKeys(this._type);\n    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);\n    this.options = config.createResolver(scopes, this.getContext());\n    this._parsing = this.options.parsing;\n    this._cachedDataOpts = {};\n  }\n\n  /**\n\t * @param {number} start\n\t * @param {number} count\n\t */\n  parse(start, count) {\n    const {_cachedMeta: meta, _data: data} = this;\n    const {iScale, _stacked} = meta;\n    const iAxis = iScale.axis;\n\n    let sorted = start === 0 && count === data.length ? true : meta._sorted;\n    let prev = start > 0 && meta._parsed[start - 1];\n    let i, cur, parsed;\n\n    if (this._parsing === false) {\n      meta._parsed = data;\n      meta._sorted = true;\n      parsed = data;\n    } else {\n      if (isArray(data[start])) {\n        parsed = this.parseArrayData(meta, data, start, count);\n      } else if (isObject(data[start])) {\n        parsed = this.parseObjectData(meta, data, start, count);\n      } else {\n        parsed = this.parsePrimitiveData(meta, data, start, count);\n      }\n\n      const isNotInOrderComparedToPrev = () => cur[iAxis] === null || (prev && cur[iAxis] < prev[iAxis]);\n      for (i = 0; i < count; ++i) {\n        meta._parsed[i + start] = cur = parsed[i];\n        if (sorted) {\n          if (isNotInOrderComparedToPrev()) {\n            sorted = false;\n          }\n          prev = cur;\n        }\n      }\n      meta._sorted = sorted;\n    }\n\n    if (_stacked) {\n      updateStacks(this, parsed);\n    }\n  }\n\n  /**\n\t * Parse array of primitive values\n\t * @param {object} meta - dataset meta\n\t * @param {array} data - data array. Example [1,3,4]\n\t * @param {number} start - start index\n\t * @param {number} count - number of items to parse\n\t * @returns {object} parsed item - item containing index and a parsed value\n\t * for each scale id.\n\t * Example: {xScale0: 0, yScale0: 1}\n\t * @protected\n\t */\n  parsePrimitiveData(meta, data, start, count) {\n    const {iScale, vScale} = meta;\n    const iAxis = iScale.axis;\n    const vAxis = vScale.axis;\n    const labels = iScale.getLabels();\n    const singleScale = iScale === vScale;\n    const parsed = new Array(count);\n    let i, ilen, index;\n\n    for (i = 0, ilen = count; i < ilen; ++i) {\n      index = i + start;\n      parsed[i] = {\n        [iAxis]: singleScale || iScale.parse(labels[index], index),\n        [vAxis]: vScale.parse(data[index], index)\n      };\n    }\n    return parsed;\n  }\n\n  /**\n\t * Parse array of arrays\n\t * @param {object} meta - dataset meta\n\t * @param {array} data - data array. Example [[1,2],[3,4]]\n\t * @param {number} start - start index\n\t * @param {number} count - number of items to parse\n\t * @returns {object} parsed item - item containing index and a parsed value\n\t * for each scale id.\n\t * Example: {x: 0, y: 1}\n\t * @protected\n\t */\n  parseArrayData(meta, data, start, count) {\n    const {xScale, yScale} = meta;\n    const parsed = new Array(count);\n    let i, ilen, index, item;\n\n    for (i = 0, ilen = count; i < ilen; ++i) {\n      index = i + start;\n      item = data[index];\n      parsed[i] = {\n        x: xScale.parse(item[0], index),\n        y: yScale.parse(item[1], index)\n      };\n    }\n    return parsed;\n  }\n\n  /**\n\t * Parse array of objects\n\t * @param {object} meta - dataset meta\n\t * @param {array} data - data array. Example [{x:1, y:5}, {x:2, y:10}]\n\t * @param {number} start - start index\n\t * @param {number} count - number of items to parse\n\t * @returns {object} parsed item - item containing index and a parsed value\n\t * for each scale id. _custom is optional\n\t * Example: {xScale0: 0, yScale0: 1, _custom: {r: 10, foo: 'bar'}}\n\t * @protected\n\t */\n  parseObjectData(meta, data, start, count) {\n    const {xScale, yScale} = meta;\n    const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n    const parsed = new Array(count);\n    let i, ilen, index, item;\n\n    for (i = 0, ilen = count; i < ilen; ++i) {\n      index = i + start;\n      item = data[index];\n      parsed[i] = {\n        x: xScale.parse(resolveObjectKey(item, xAxisKey), index),\n        y: yScale.parse(resolveObjectKey(item, yAxisKey), index)\n      };\n    }\n    return parsed;\n  }\n\n  /**\n\t * @protected\n\t */\n  getParsed(index) {\n    return this._cachedMeta._parsed[index];\n  }\n\n  /**\n\t * @protected\n\t */\n  getDataElement(index) {\n    return this._cachedMeta.data[index];\n  }\n\n  /**\n\t * @protected\n\t */\n  applyStack(scale, parsed, mode) {\n    const chart = this.chart;\n    const meta = this._cachedMeta;\n    const value = parsed[scale.axis];\n    const stack = {\n      keys: getSortedDatasetIndices(chart, true),\n      values: parsed._stacks[scale.axis]._visualValues\n    };\n    return applyStack(stack, value, meta.index, {mode});\n  }\n\n  /**\n\t * @protected\n\t */\n  updateRangeFromParsed(range, scale, parsed, stack) {\n    const parsedValue = parsed[scale.axis];\n    let value = parsedValue === null ? NaN : parsedValue;\n    const values = stack && parsed._stacks[scale.axis];\n    if (stack && values) {\n      stack.values = values;\n      value = applyStack(stack, parsedValue, this._cachedMeta.index);\n    }\n    range.min = Math.min(range.min, value);\n    range.max = Math.max(range.max, value);\n  }\n\n  /**\n\t * @protected\n\t */\n  getMinMax(scale, canStack) {\n    const meta = this._cachedMeta;\n    const _parsed = meta._parsed;\n    const sorted = meta._sorted && scale === meta.iScale;\n    const ilen = _parsed.length;\n    const otherScale = this._getOtherScale(scale);\n    const stack = createStack(canStack, meta, this.chart);\n    const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};\n    const {min: otherMin, max: otherMax} = getUserBounds(otherScale);\n    let i, parsed;\n\n    function _skip() {\n      parsed = _parsed[i];\n      const otherValue = parsed[otherScale.axis];\n      return !isFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;\n    }\n\n    for (i = 0; i < ilen; ++i) {\n      if (_skip()) {\n        continue;\n      }\n      this.updateRangeFromParsed(range, scale, parsed, stack);\n      if (sorted) {\n        // if the data is sorted, we don't need to check further from this end of array\n        break;\n      }\n    }\n    if (sorted) {\n      // in the sorted case, find first non-skipped value from other end of array\n      for (i = ilen - 1; i >= 0; --i) {\n        if (_skip()) {\n          continue;\n        }\n        this.updateRangeFromParsed(range, scale, parsed, stack);\n        break;\n      }\n    }\n    return range;\n  }\n\n  getAllParsedValues(scale) {\n    const parsed = this._cachedMeta._parsed;\n    const values = [];\n    let i, ilen, value;\n\n    for (i = 0, ilen = parsed.length; i < ilen; ++i) {\n      value = parsed[i][scale.axis];\n      if (isFinite(value)) {\n        values.push(value);\n      }\n    }\n    return values;\n  }\n\n  /**\n\t * @return {number|boolean}\n\t * @protected\n\t */\n  getMaxOverflow() {\n    return false;\n  }\n\n  /**\n\t * @protected\n\t */\n  getLabelAndValue(index) {\n    const meta = this._cachedMeta;\n    const iScale = meta.iScale;\n    const vScale = meta.vScale;\n    const parsed = this.getParsed(index);\n    return {\n      label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '',\n      value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : ''\n    };\n  }\n\n  /**\n\t * @private\n\t */\n  _update(mode) {\n    const meta = this._cachedMeta;\n    this.update(mode || 'default');\n    meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));\n  }\n\n  /**\n\t * @param {string} mode\n\t */\n  update(mode) {} // eslint-disable-line no-unused-vars\n\n  draw() {\n    const ctx = this._ctx;\n    const chart = this.chart;\n    const meta = this._cachedMeta;\n    const elements = meta.data || [];\n    const area = chart.chartArea;\n    const active = [];\n    const start = this._drawStart || 0;\n    const count = this._drawCount || (elements.length - start);\n    const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;\n    let i;\n\n    if (meta.dataset) {\n      meta.dataset.draw(ctx, area, start, count);\n    }\n\n    for (i = start; i < start + count; ++i) {\n      const element = elements[i];\n      if (element.hidden) {\n        continue;\n      }\n      if (element.active && drawActiveElementsOnTop) {\n        active.push(element);\n      } else {\n        element.draw(ctx, area);\n      }\n    }\n\n    for (i = 0; i < active.length; ++i) {\n      active[i].draw(ctx, area);\n    }\n  }\n\n  /**\n\t * Returns a set of predefined style properties that should be used to represent the dataset\n\t * or the data if the index is specified\n\t * @param {number} index - data index\n\t * @param {boolean} [active] - true if hover\n\t * @return {object} style object\n\t */\n  getStyle(index, active) {\n    const mode = active ? 'active' : 'default';\n    return index === undefined && this._cachedMeta.dataset\n      ? this.resolveDatasetElementOptions(mode)\n      : this.resolveDataElementOptions(index || 0, mode);\n  }\n\n  /**\n\t * @protected\n\t */\n  getContext(index, active, mode) {\n    const dataset = this.getDataset();\n    let context;\n    if (index >= 0 && index < this._cachedMeta.data.length) {\n      const element = this._cachedMeta.data[index];\n      context = element.$context ||\n        (element.$context = createDataContext(this.getContext(), index, element));\n      context.parsed = this.getParsed(index);\n      context.raw = dataset.data[index];\n      context.index = context.dataIndex = index;\n    } else {\n      context = this.$context ||\n        (this.$context = createDatasetContext(this.chart.getContext(), this.index));\n      context.dataset = dataset;\n      context.index = context.datasetIndex = this.index;\n    }\n\n    context.active = !!active;\n    context.mode = mode;\n    return context;\n  }\n\n  /**\n\t * @param {string} [mode]\n\t * @protected\n\t */\n  resolveDatasetElementOptions(mode) {\n    return this._resolveElementOptions(this.datasetElementType.id, mode);\n  }\n\n  /**\n\t * @param {number} index\n\t * @param {string} [mode]\n\t * @protected\n\t */\n  resolveDataElementOptions(index, mode) {\n    return this._resolveElementOptions(this.dataElementType.id, mode, index);\n  }\n\n  /**\n\t * @private\n\t */\n  _resolveElementOptions(elementType, mode = 'default', index) {\n    const active = mode === 'active';\n    const cache = this._cachedDataOpts;\n    const cacheKey = elementType + '-' + mode;\n    const cached = cache[cacheKey];\n    const sharing = this.enableOptionSharing && defined(index);\n    if (cached) {\n      return cloneIfNotShared(cached, sharing);\n    }\n    const config = this.chart.config;\n    const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);\n    const prefixes = active ? [`${elementType}Hover`, 'hover', elementType, ''] : [elementType, ''];\n    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n    const names = Object.keys(defaults.elements[elementType]);\n    // context is provided as a function, and is called only if needed,\n    // so we don't create a context for each element if not needed.\n    const context = () => this.getContext(index, active, mode);\n    const values = config.resolveNamedOptions(scopes, names, context, prefixes);\n\n    if (values.$shared) {\n      // `$shared` indicates this set of options can be shared between multiple elements.\n      // Sharing is used to reduce number of properties to change during animation.\n      values.$shared = sharing;\n\n      // We cache options by `mode`, which can be 'active' for example. This enables us\n      // to have the 'active' element options and 'default' options to switch between\n      // when interacting.\n      cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));\n    }\n\n    return values;\n  }\n\n\n  /**\n\t * @private\n\t */\n  _resolveAnimations(index, transition, active) {\n    const chart = this.chart;\n    const cache = this._cachedDataOpts;\n    const cacheKey = `animation-${transition}`;\n    const cached = cache[cacheKey];\n    if (cached) {\n      return cached;\n    }\n    let options;\n    if (chart.options.animation !== false) {\n      const config = this.chart.config;\n      const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);\n      const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n      options = config.createResolver(scopes, this.getContext(index, active, transition));\n    }\n    const animations = new Animations(chart, options && options.animations);\n    if (options && options._cacheable) {\n      cache[cacheKey] = Object.freeze(animations);\n    }\n    return animations;\n  }\n\n  /**\n\t * Utility for getting the options object shared between elements\n\t * @protected\n\t */\n  getSharedOptions(options) {\n    if (!options.$shared) {\n      return;\n    }\n    return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));\n  }\n\n  /**\n\t * Utility for determining if `options` should be included in the updated properties\n\t * @protected\n\t */\n  includeOptions(mode, sharedOptions) {\n    return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;\n  }\n\n  /**\n   * @todo v4, rename to getSharedOptions and remove excess functions\n   */\n  _getSharedOptions(start, mode) {\n    const firstOpts = this.resolveDataElementOptions(start, mode);\n    const previouslySharedOptions = this._sharedOptions;\n    const sharedOptions = this.getSharedOptions(firstOpts);\n    const includeOptions = this.includeOptions(mode, sharedOptions) || (sharedOptions !== previouslySharedOptions);\n    this.updateSharedOptions(sharedOptions, mode, firstOpts);\n    return {sharedOptions, includeOptions};\n  }\n\n  /**\n\t * Utility for updating an element with new properties, using animations when appropriate.\n\t * @protected\n\t */\n  updateElement(element, index, properties, mode) {\n    if (isDirectUpdateMode(mode)) {\n      Object.assign(element, properties);\n    } else {\n      this._resolveAnimations(index, mode).update(element, properties);\n    }\n  }\n\n  /**\n\t * Utility to animate the shared options, that are potentially affecting multiple elements.\n\t * @protected\n\t */\n  updateSharedOptions(sharedOptions, mode, newOptions) {\n    if (sharedOptions && !isDirectUpdateMode(mode)) {\n      this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _setStyle(element, index, mode, active) {\n    element.active = active;\n    const options = this.getStyle(index, active);\n    this._resolveAnimations(index, mode, active).update(element, {\n      // When going from active to inactive, we need to update to the shared options.\n      // This way the once hovered element will end up with the same original shared options instance, after animation.\n      options: (!active && this.getSharedOptions(options)) || options\n    });\n  }\n\n  removeHoverStyle(element, datasetIndex, index) {\n    this._setStyle(element, index, 'active', false);\n  }\n\n  setHoverStyle(element, datasetIndex, index) {\n    this._setStyle(element, index, 'active', true);\n  }\n\n  /**\n\t * @private\n\t */\n  _removeDatasetHoverStyle() {\n    const element = this._cachedMeta.dataset;\n\n    if (element) {\n      this._setStyle(element, undefined, 'active', false);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _setDatasetHoverStyle() {\n    const element = this._cachedMeta.dataset;\n\n    if (element) {\n      this._setStyle(element, undefined, 'active', true);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _resyncElements(resetNewElements) {\n    const data = this._data;\n    const elements = this._cachedMeta.data;\n\n    // Apply changes detected through array listeners\n    for (const [method, arg1, arg2] of this._syncList) {\n      this[method](arg1, arg2);\n    }\n    this._syncList = [];\n\n    const numMeta = elements.length;\n    const numData = data.length;\n    const count = Math.min(numData, numMeta);\n\n    if (count) {\n      // TODO: It is not optimal to always parse the old data\n      // This is done because we are not detecting direct assignments:\n      // chart.data.datasets[0].data[5] = 10;\n      // chart.data.datasets[0].data[5].y = 10;\n      this.parse(0, count);\n    }\n\n    if (numData > numMeta) {\n      this._insertElements(numMeta, numData - numMeta, resetNewElements);\n    } else if (numData < numMeta) {\n      this._removeElements(numData, numMeta - numData);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _insertElements(start, count, resetNewElements = true) {\n    const meta = this._cachedMeta;\n    const data = meta.data;\n    const end = start + count;\n    let i;\n\n    const move = (arr) => {\n      arr.length += count;\n      for (i = arr.length - 1; i >= end; i--) {\n        arr[i] = arr[i - count];\n      }\n    };\n    move(data);\n\n    for (i = start; i < end; ++i) {\n      data[i] = new this.dataElementType();\n    }\n\n    if (this._parsing) {\n      move(meta._parsed);\n    }\n    this.parse(start, count);\n\n    if (resetNewElements) {\n      this.updateElements(data, start, count, 'reset');\n    }\n  }\n\n  updateElements(element, start, count, mode) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * @private\n\t */\n  _removeElements(start, count) {\n    const meta = this._cachedMeta;\n    if (this._parsing) {\n      const removed = meta._parsed.splice(start, count);\n      if (meta._stacked) {\n        clearStacks(meta, removed);\n      }\n    }\n    meta.data.splice(start, count);\n  }\n\n  /**\n\t * @private\n   */\n  _sync(args) {\n    if (this._parsing) {\n      this._syncList.push(args);\n    } else {\n      const [method, arg1, arg2] = args;\n      this[method](arg1, arg2);\n    }\n    this.chart._dataChanges.push([this.index, ...args]);\n  }\n\n  _onDataPush() {\n    const count = arguments.length;\n    this._sync(['_insertElements', this.getDataset().data.length - count, count]);\n  }\n\n  _onDataPop() {\n    this._sync(['_removeElements', this._cachedMeta.data.length - 1, 1]);\n  }\n\n  _onDataShift() {\n    this._sync(['_removeElements', 0, 1]);\n  }\n\n  _onDataSplice(start, count) {\n    if (count) {\n      this._sync(['_removeElements', start, count]);\n    }\n    const newCount = arguments.length - 2;\n    if (newCount) {\n      this._sync(['_insertElements', start, newCount]);\n    }\n  }\n\n  _onDataUnshift() {\n    this._sync(['_insertElements', 0, arguments.length]);\n  }\n}\n","import DatasetController from '../core/core.datasetController.js';\nimport {\n  _arrayUnique, isArray, isNullOrUndef,\n  valueOrDefault, resolveObjectKey, sign, defined\n} from '../helpers/index.js';\n\nfunction getAllScaleValues(scale, type) {\n  if (!scale._cache.$bar) {\n    const visibleMetas = scale.getMatchingVisibleMetas(type);\n    let values = [];\n\n    for (let i = 0, ilen = visibleMetas.length; i < ilen; i++) {\n      values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale));\n    }\n    scale._cache.$bar = _arrayUnique(values.sort((a, b) => a - b));\n  }\n  return scale._cache.$bar;\n}\n\n/**\n * Computes the \"optimal\" sample size to maintain bars equally sized while preventing overlap.\n * @private\n */\nfunction computeMinSampleSize(meta) {\n  const scale = meta.iScale;\n  const values = getAllScaleValues(scale, meta.type);\n  let min = scale._length;\n  let i, ilen, curr, prev;\n  const updateMinAndPrev = () => {\n    if (curr === 32767 || curr === -32768) {\n      // Ignore truncated pixels\n      return;\n    }\n    if (defined(prev)) {\n      // curr - prev === 0 is ignored\n      min = Math.min(min, Math.abs(curr - prev) || min);\n    }\n    prev = curr;\n  };\n\n  for (i = 0, ilen = values.length; i < ilen; ++i) {\n    curr = scale.getPixelForValue(values[i]);\n    updateMinAndPrev();\n  }\n\n  prev = undefined;\n  for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) {\n    curr = scale.getPixelForTick(i);\n    updateMinAndPrev();\n  }\n\n  return min;\n}\n\n/**\n * Computes an \"ideal\" category based on the absolute bar thickness or, if undefined or null,\n * uses the smallest interval (see computeMinSampleSize) that prevents bar overlapping. This\n * mode currently always generates bars equally sized (until we introduce scriptable options?).\n * @private\n */\nfunction computeFitCategoryTraits(index, ruler, options, stackCount) {\n  const thickness = options.barThickness;\n  let size, ratio;\n\n  if (isNullOrUndef(thickness)) {\n    size = ruler.min * options.categoryPercentage;\n    ratio = options.barPercentage;\n  } else {\n    // When bar thickness is enforced, category and bar percentages are ignored.\n    // Note(SB): we could add support for relative bar thickness (e.g. barThickness: '50%')\n    // and deprecate barPercentage since this value is ignored when thickness is absolute.\n    size = thickness * stackCount;\n    ratio = 1;\n  }\n\n  return {\n    chunk: size / stackCount,\n    ratio,\n    start: ruler.pixels[index] - (size / 2)\n  };\n}\n\n/**\n * Computes an \"optimal\" category that globally arranges bars side by side (no gap when\n * percentage options are 1), based on the previous and following categories. This mode\n * generates bars with different widths when data are not evenly spaced.\n * @private\n */\nfunction computeFlexCategoryTraits(index, ruler, options, stackCount) {\n  const pixels = ruler.pixels;\n  const curr = pixels[index];\n  let prev = index > 0 ? pixels[index - 1] : null;\n  let next = index < pixels.length - 1 ? pixels[index + 1] : null;\n  const percent = options.categoryPercentage;\n\n  if (prev === null) {\n    // first data: its size is double based on the next point or,\n    // if it's also the last data, we use the scale size.\n    prev = curr - (next === null ? ruler.end - ruler.start : next - curr);\n  }\n\n  if (next === null) {\n    // last data: its size is also double based on the previous point.\n    next = curr + curr - prev;\n  }\n\n  const start = curr - (curr - Math.min(prev, next)) / 2 * percent;\n  const size = Math.abs(next - prev) / 2 * percent;\n\n  return {\n    chunk: size / stackCount,\n    ratio: options.barPercentage,\n    start\n  };\n}\n\nfunction parseFloatBar(entry, item, vScale, i) {\n  const startValue = vScale.parse(entry[0], i);\n  const endValue = vScale.parse(entry[1], i);\n  const min = Math.min(startValue, endValue);\n  const max = Math.max(startValue, endValue);\n  let barStart = min;\n  let barEnd = max;\n\n  if (Math.abs(min) > Math.abs(max)) {\n    barStart = max;\n    barEnd = min;\n  }\n\n  // Store `barEnd` (furthest away from origin) as parsed value,\n  // to make stacking straight forward\n  item[vScale.axis] = barEnd;\n\n  item._custom = {\n    barStart,\n    barEnd,\n    start: startValue,\n    end: endValue,\n    min,\n    max\n  };\n}\n\nfunction parseValue(entry, item, vScale, i) {\n  if (isArray(entry)) {\n    parseFloatBar(entry, item, vScale, i);\n  } else {\n    item[vScale.axis] = vScale.parse(entry, i);\n  }\n  return item;\n}\n\nfunction parseArrayOrPrimitive(meta, data, start, count) {\n  const iScale = meta.iScale;\n  const vScale = meta.vScale;\n  const labels = iScale.getLabels();\n  const singleScale = iScale === vScale;\n  const parsed = [];\n  let i, ilen, item, entry;\n\n  for (i = start, ilen = start + count; i < ilen; ++i) {\n    entry = data[i];\n    item = {};\n    item[iScale.axis] = singleScale || iScale.parse(labels[i], i);\n    parsed.push(parseValue(entry, item, vScale, i));\n  }\n  return parsed;\n}\n\nfunction isFloatBar(custom) {\n  return custom && custom.barStart !== undefined && custom.barEnd !== undefined;\n}\n\nfunction barSign(size, vScale, actualBase) {\n  if (size !== 0) {\n    return sign(size);\n  }\n  return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);\n}\n\nfunction borderProps(properties) {\n  let reverse, start, end, top, bottom;\n  if (properties.horizontal) {\n    reverse = properties.base > properties.x;\n    start = 'left';\n    end = 'right';\n  } else {\n    reverse = properties.base < properties.y;\n    start = 'bottom';\n    end = 'top';\n  }\n  if (reverse) {\n    top = 'end';\n    bottom = 'start';\n  } else {\n    top = 'start';\n    bottom = 'end';\n  }\n  return {start, end, reverse, top, bottom};\n}\n\nfunction setBorderSkipped(properties, options, stack, index) {\n  let edge = options.borderSkipped;\n  const res = {};\n\n  if (!edge) {\n    properties.borderSkipped = res;\n    return;\n  }\n\n  if (edge === true) {\n    properties.borderSkipped = {top: true, right: true, bottom: true, left: true};\n    return;\n  }\n\n  const {start, end, reverse, top, bottom} = borderProps(properties);\n\n  if (edge === 'middle' && stack) {\n    properties.enableBorderRadius = true;\n    if ((stack._top || 0) === index) {\n      edge = top;\n    } else if ((stack._bottom || 0) === index) {\n      edge = bottom;\n    } else {\n      res[parseEdge(bottom, start, end, reverse)] = true;\n      edge = top;\n    }\n  }\n\n  res[parseEdge(edge, start, end, reverse)] = true;\n  properties.borderSkipped = res;\n}\n\nfunction parseEdge(edge, a, b, reverse) {\n  if (reverse) {\n    edge = swap(edge, a, b);\n    edge = startEnd(edge, b, a);\n  } else {\n    edge = startEnd(edge, a, b);\n  }\n  return edge;\n}\n\nfunction swap(orig, v1, v2) {\n  return orig === v1 ? v2 : orig === v2 ? v1 : orig;\n}\n\nfunction startEnd(v, start, end) {\n  return v === 'start' ? start : v === 'end' ? end : v;\n}\n\nfunction setInflateAmount(properties, {inflateAmount}, ratio) {\n  properties.inflateAmount = inflateAmount === 'auto'\n    ? ratio === 1 ? 0.33 : 0\n    : inflateAmount;\n}\n\nexport default class BarController extends DatasetController {\n\n  static id = 'bar';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    datasetElementType: false,\n    dataElementType: 'bar',\n\n    categoryPercentage: 0.8,\n    barPercentage: 0.9,\n    grouped: true,\n\n    animations: {\n      numbers: {\n        type: 'number',\n        properties: ['x', 'y', 'base', 'width', 'height']\n      }\n    }\n  };\n\n  /**\n   * @type {any}\n   */\n  static overrides = {\n    scales: {\n      _index_: {\n        type: 'category',\n        offset: true,\n        grid: {\n          offset: true\n        }\n      },\n      _value_: {\n        type: 'linear',\n        beginAtZero: true,\n      }\n    }\n  };\n\n\n  /**\n\t * Overriding primitive data parsing since we support mixed primitive/array\n\t * data for float bars\n\t * @protected\n\t */\n  parsePrimitiveData(meta, data, start, count) {\n    return parseArrayOrPrimitive(meta, data, start, count);\n  }\n\n  /**\n\t * Overriding array data parsing since we support mixed primitive/array\n\t * data for float bars\n\t * @protected\n\t */\n  parseArrayData(meta, data, start, count) {\n    return parseArrayOrPrimitive(meta, data, start, count);\n  }\n\n  /**\n\t * Overriding object data parsing since we support mixed primitive/array\n\t * value-scale data for float bars\n\t * @protected\n\t */\n  parseObjectData(meta, data, start, count) {\n    const {iScale, vScale} = meta;\n    const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n    const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey;\n    const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey;\n    const parsed = [];\n    let i, ilen, item, obj;\n    for (i = start, ilen = start + count; i < ilen; ++i) {\n      obj = data[i];\n      item = {};\n      item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i);\n      parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i));\n    }\n    return parsed;\n  }\n\n  /**\n\t * @protected\n\t */\n  updateRangeFromParsed(range, scale, parsed, stack) {\n    super.updateRangeFromParsed(range, scale, parsed, stack);\n    const custom = parsed._custom;\n    if (custom && scale === this._cachedMeta.vScale) {\n      // float bar: only one end of the bar is considered by `super`\n      range.min = Math.min(range.min, custom.min);\n      range.max = Math.max(range.max, custom.max);\n    }\n  }\n\n  /**\n\t * @return {number|boolean}\n\t * @protected\n\t */\n  getMaxOverflow() {\n    return 0;\n  }\n\n  /**\n\t * @protected\n\t */\n  getLabelAndValue(index) {\n    const meta = this._cachedMeta;\n    const {iScale, vScale} = meta;\n    const parsed = this.getParsed(index);\n    const custom = parsed._custom;\n    const value = isFloatBar(custom)\n      ? '[' + custom.start + ', ' + custom.end + ']'\n      : '' + vScale.getLabelForValue(parsed[vScale.axis]);\n\n    return {\n      label: '' + iScale.getLabelForValue(parsed[iScale.axis]),\n      value\n    };\n  }\n\n  initialize() {\n    this.enableOptionSharing = true;\n\n    super.initialize();\n\n    const meta = this._cachedMeta;\n    meta.stack = this.getDataset().stack;\n  }\n\n  update(mode) {\n    const meta = this._cachedMeta;\n    this.updateElements(meta.data, 0, meta.data.length, mode);\n  }\n\n  updateElements(bars, start, count, mode) {\n    const reset = mode === 'reset';\n    const {index, _cachedMeta: {vScale}} = this;\n    const base = vScale.getBasePixel();\n    const horizontal = vScale.isHorizontal();\n    const ruler = this._getRuler();\n    const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode);\n\n    for (let i = start; i < start + count; i++) {\n      const parsed = this.getParsed(i);\n      const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {base, head: base} : this._calculateBarValuePixels(i);\n      const ipixels = this._calculateBarIndexPixels(i, ruler);\n      const stack = (parsed._stacks || {})[vScale.axis];\n\n      const properties = {\n        horizontal,\n        base: vpixels.base,\n        enableBorderRadius: !stack || isFloatBar(parsed._custom) || (index === stack._top || index === stack._bottom),\n        x: horizontal ? vpixels.head : ipixels.center,\n        y: horizontal ? ipixels.center : vpixels.head,\n        height: horizontal ? ipixels.size : Math.abs(vpixels.size),\n        width: horizontal ? Math.abs(vpixels.size) : ipixels.size\n      };\n\n      if (includeOptions) {\n        properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode);\n      }\n      const options = properties.options || bars[i].options;\n      setBorderSkipped(properties, options, stack, index);\n      setInflateAmount(properties, options, ruler.ratio);\n      this.updateElement(bars[i], i, properties, mode);\n    }\n  }\n\n  /**\n\t * Returns the stacks based on groups and bar visibility.\n\t * @param {number} [last] - The dataset index\n\t * @param {number} [dataIndex] - The data index of the ruler\n\t * @returns {string[]} The list of stack IDs\n\t * @private\n\t */\n  _getStacks(last, dataIndex) {\n    const {iScale} = this._cachedMeta;\n    const metasets = iScale.getMatchingVisibleMetas(this._type)\n      .filter(meta => meta.controller.options.grouped);\n    const stacked = iScale.options.stacked;\n    const stacks = [];\n\n    const skipNull = (meta) => {\n      const parsed = meta.controller.getParsed(dataIndex);\n      const val = parsed && parsed[meta.vScale.axis];\n\n      if (isNullOrUndef(val) || isNaN(val)) {\n        return true;\n      }\n    };\n\n    for (const meta of metasets) {\n      if (dataIndex !== undefined && skipNull(meta)) {\n        continue;\n      }\n\n      // stacked   | meta.stack\n      //           | found | not found | undefined\n      // false     |   x   |     x     |     x\n      // true      |       |     x     |\n      // undefined |       |     x     |     x\n      if (stacked === false || stacks.indexOf(meta.stack) === -1 ||\n\t\t\t\t(stacked === undefined && meta.stack === undefined)) {\n        stacks.push(meta.stack);\n      }\n      if (meta.index === last) {\n        break;\n      }\n    }\n\n    // No stacks? that means there is no visible data. Let's still initialize an `undefined`\n    // stack where possible invisible bars will be located.\n    // https://github.com/chartjs/Chart.js/issues/6368\n    if (!stacks.length) {\n      stacks.push(undefined);\n    }\n\n    return stacks;\n  }\n\n  /**\n\t * Returns the effective number of stacks based on groups and bar visibility.\n\t * @private\n\t */\n  _getStackCount(index) {\n    return this._getStacks(undefined, index).length;\n  }\n\n  /**\n\t * Returns the stack index for the given dataset based on groups and bar visibility.\n\t * @param {number} [datasetIndex] - The dataset index\n\t * @param {string} [name] - The stack name to find\n   * @param {number} [dataIndex]\n\t * @returns {number} The stack index\n\t * @private\n\t */\n  _getStackIndex(datasetIndex, name, dataIndex) {\n    const stacks = this._getStacks(datasetIndex, dataIndex);\n    const index = (name !== undefined)\n      ? stacks.indexOf(name)\n      : -1; // indexOf returns -1 if element is not present\n\n    return (index === -1)\n      ? stacks.length - 1\n      : index;\n  }\n\n  /**\n\t * @private\n\t */\n  _getRuler() {\n    const opts = this.options;\n    const meta = this._cachedMeta;\n    const iScale = meta.iScale;\n    const pixels = [];\n    let i, ilen;\n\n    for (i = 0, ilen = meta.data.length; i < ilen; ++i) {\n      pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i));\n    }\n\n    const barThickness = opts.barThickness;\n    const min = barThickness || computeMinSampleSize(meta);\n\n    return {\n      min,\n      pixels,\n      start: iScale._startPixel,\n      end: iScale._endPixel,\n      stackCount: this._getStackCount(),\n      scale: iScale,\n      grouped: opts.grouped,\n      // bar thickness ratio used for non-grouped bars\n      ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage\n    };\n  }\n\n  /**\n\t * Note: pixel values are not clamped to the scale area.\n\t * @private\n\t */\n  _calculateBarValuePixels(index) {\n    const {_cachedMeta: {vScale, _stacked, index: datasetIndex}, options: {base: baseValue, minBarLength}} = this;\n    const actualBase = baseValue || 0;\n    const parsed = this.getParsed(index);\n    const custom = parsed._custom;\n    const floating = isFloatBar(custom);\n    let value = parsed[vScale.axis];\n    let start = 0;\n    let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;\n    let head, size;\n\n    if (length !== value) {\n      start = length - value;\n      length = value;\n    }\n\n    if (floating) {\n      value = custom.barStart;\n      length = custom.barEnd - custom.barStart;\n      // bars crossing origin are not stacked\n      if (value !== 0 && sign(value) !== sign(custom.barEnd)) {\n        start = 0;\n      }\n      start += value;\n    }\n\n    const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;\n    let base = vScale.getPixelForValue(startValue);\n\n    if (this.chart.getDataVisibility(index)) {\n      head = vScale.getPixelForValue(start + length);\n    } else {\n      // When not visible, no height\n      head = base;\n    }\n\n    size = head - base;\n\n    if (Math.abs(size) < minBarLength) {\n      size = barSign(size, vScale, actualBase) * minBarLength;\n      if (value === actualBase) {\n        base -= size / 2;\n      }\n      const startPixel = vScale.getPixelForDecimal(0);\n      const endPixel = vScale.getPixelForDecimal(1);\n      const min = Math.min(startPixel, endPixel);\n      const max = Math.max(startPixel, endPixel);\n      base = Math.max(Math.min(base, max), min);\n      head = base + size;\n\n      if (_stacked && !floating) {\n        // visual data coordinates after applying minBarLength\n        parsed._stacks[vScale.axis]._visualValues[datasetIndex] = vScale.getValueForPixel(head) - vScale.getValueForPixel(base);\n      }\n    }\n\n    if (base === vScale.getPixelForValue(actualBase)) {\n      const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;\n      base += halfGrid;\n      size -= halfGrid;\n    }\n\n    return {\n      size,\n      base,\n      head,\n      center: head + size / 2\n    };\n  }\n\n  /**\n\t * @private\n\t */\n  _calculateBarIndexPixels(index, ruler) {\n    const scale = ruler.scale;\n    const options = this.options;\n    const skipNull = options.skipNull;\n    const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);\n    let center, size;\n    if (ruler.grouped) {\n      const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;\n      const range = options.barThickness === 'flex'\n        ? computeFlexCategoryTraits(index, ruler, options, stackCount)\n        : computeFitCategoryTraits(index, ruler, options, stackCount);\n\n      const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined);\n      center = range.start + (range.chunk * stackIndex) + (range.chunk / 2);\n      size = Math.min(maxBarThickness, range.chunk * range.ratio);\n    } else {\n      // For non-grouped bar charts, exact pixel values are used\n      center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);\n      size = Math.min(maxBarThickness, ruler.min * ruler.ratio);\n    }\n\n    return {\n      base: center - size / 2,\n      head: center + size / 2,\n      center,\n      size\n    };\n  }\n\n  draw() {\n    const meta = this._cachedMeta;\n    const vScale = meta.vScale;\n    const rects = meta.data;\n    const ilen = rects.length;\n    let i = 0;\n\n    for (; i < ilen; ++i) {\n      if (this.getParsed(i)[vScale.axis] !== null && !rects[i].hidden) {\n        rects[i].draw(this._ctx);\n      }\n    }\n  }\n\n}\n","import DatasetController from '../core/core.datasetController.js';\nimport {isObject, resolveObjectKey, toPercentage, toDimension, valueOrDefault} from '../helpers/helpers.core.js';\nimport {formatNumber} from '../helpers/helpers.intl.js';\nimport {toRadians, PI, TAU, HALF_PI, _angleBetween} from '../helpers/helpers.math.js';\n\n/**\n * @typedef { import('../core/core.controller.js').default } Chart\n */\n\nfunction getRatioAndOffset(rotation, circumference, cutout) {\n  let ratioX = 1;\n  let ratioY = 1;\n  let offsetX = 0;\n  let offsetY = 0;\n  // If the chart's circumference isn't a full circle, calculate size as a ratio of the width/height of the arc\n  if (circumference < TAU) {\n    const startAngle = rotation;\n    const endAngle = startAngle + circumference;\n    const startX = Math.cos(startAngle);\n    const startY = Math.sin(startAngle);\n    const endX = Math.cos(endAngle);\n    const endY = Math.sin(endAngle);\n    const calcMax = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a, a * cutout, b, b * cutout);\n    const calcMin = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a, a * cutout, b, b * cutout);\n    const maxX = calcMax(0, startX, endX);\n    const maxY = calcMax(HALF_PI, startY, endY);\n    const minX = calcMin(PI, startX, endX);\n    const minY = calcMin(PI + HALF_PI, startY, endY);\n    ratioX = (maxX - minX) / 2;\n    ratioY = (maxY - minY) / 2;\n    offsetX = -(maxX + minX) / 2;\n    offsetY = -(maxY + minY) / 2;\n  }\n  return {ratioX, ratioY, offsetX, offsetY};\n}\n\nexport default class DoughnutController extends DatasetController {\n\n  static id = 'doughnut';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    datasetElementType: false,\n    dataElementType: 'arc',\n    animation: {\n      // Boolean - Whether we animate the rotation of the Doughnut\n      animateRotate: true,\n      // Boolean - Whether we animate scaling the Doughnut from the centre\n      animateScale: false\n    },\n    animations: {\n      numbers: {\n        type: 'number',\n        properties: ['circumference', 'endAngle', 'innerRadius', 'outerRadius', 'startAngle', 'x', 'y', 'offset', 'borderWidth', 'spacing']\n      },\n    },\n    // The percentage of the chart that we cut out of the middle.\n    cutout: '50%',\n\n    // The rotation of the chart, where the first data arc begins.\n    rotation: 0,\n\n    // The total circumference of the chart.\n    circumference: 360,\n\n    // The outer radius of the chart\n    radius: '100%',\n\n    // Spacing between arcs\n    spacing: 0,\n\n    indexAxis: 'r',\n  };\n\n  static descriptors = {\n    _scriptable: (name) => name !== 'spacing',\n    _indexable: (name) => name !== 'spacing' && !name.startsWith('borderDash') && !name.startsWith('hoverBorderDash'),\n  };\n\n  /**\n   * @type {any}\n   */\n  static overrides = {\n    aspectRatio: 1,\n\n    // Need to override these to give a nice default\n    plugins: {\n      legend: {\n        labels: {\n          generateLabels(chart) {\n            const data = chart.data;\n            if (data.labels.length && data.datasets.length) {\n              const {labels: {pointStyle, color}} = chart.legend.options;\n\n              return data.labels.map((label, i) => {\n                const meta = chart.getDatasetMeta(0);\n                const style = meta.controller.getStyle(i);\n\n                return {\n                  text: label,\n                  fillStyle: style.backgroundColor,\n                  strokeStyle: style.borderColor,\n                  fontColor: color,\n                  lineWidth: style.borderWidth,\n                  pointStyle: pointStyle,\n                  hidden: !chart.getDataVisibility(i),\n\n                  // Extra data used for toggling the correct item\n                  index: i\n                };\n              });\n            }\n            return [];\n          }\n        },\n\n        onClick(e, legendItem, legend) {\n          legend.chart.toggleDataVisibility(legendItem.index);\n          legend.chart.update();\n        }\n      }\n    }\n  };\n\n  constructor(chart, datasetIndex) {\n    super(chart, datasetIndex);\n\n    this.enableOptionSharing = true;\n    this.innerRadius = undefined;\n    this.outerRadius = undefined;\n    this.offsetX = undefined;\n    this.offsetY = undefined;\n  }\n\n  linkScales() {}\n\n  /**\n\t * Override data parsing, since we are not using scales\n\t */\n  parse(start, count) {\n    const data = this.getDataset().data;\n    const meta = this._cachedMeta;\n\n    if (this._parsing === false) {\n      meta._parsed = data;\n    } else {\n      let getter = (i) => +data[i];\n\n      if (isObject(data[start])) {\n        const {key = 'value'} = this._parsing;\n        getter = (i) => +resolveObjectKey(data[i], key);\n      }\n\n      let i, ilen;\n      for (i = start, ilen = start + count; i < ilen; ++i) {\n        meta._parsed[i] = getter(i);\n      }\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _getRotation() {\n    return toRadians(this.options.rotation - 90);\n  }\n\n  /**\n\t * @private\n\t */\n  _getCircumference() {\n    return toRadians(this.options.circumference);\n  }\n\n  /**\n\t * Get the maximal rotation & circumference extents\n\t * across all visible datasets.\n\t */\n  _getRotationExtents() {\n    let min = TAU;\n    let max = -TAU;\n\n    for (let i = 0; i < this.chart.data.datasets.length; ++i) {\n      if (this.chart.isDatasetVisible(i) && this.chart.getDatasetMeta(i).type === this._type) {\n        const controller = this.chart.getDatasetMeta(i).controller;\n        const rotation = controller._getRotation();\n        const circumference = controller._getCircumference();\n\n        min = Math.min(min, rotation);\n        max = Math.max(max, rotation + circumference);\n      }\n    }\n\n    return {\n      rotation: min,\n      circumference: max - min,\n    };\n  }\n\n  /**\n\t * @param {string} mode\n\t */\n  update(mode) {\n    const chart = this.chart;\n    const {chartArea} = chart;\n    const meta = this._cachedMeta;\n    const arcs = meta.data;\n    const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing;\n    const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0);\n    const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1);\n    const chartWeight = this._getRingWeight(this.index);\n\n    // Compute the maximal rotation & circumference limits.\n    // If we only consider our dataset, this can cause problems when two datasets\n    // are both less than a circle with different rotations (starting angles)\n    const {circumference, rotation} = this._getRotationExtents();\n    const {ratioX, ratioY, offsetX, offsetY} = getRatioAndOffset(rotation, circumference, cutout);\n    const maxWidth = (chartArea.width - spacing) / ratioX;\n    const maxHeight = (chartArea.height - spacing) / ratioY;\n    const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);\n    const outerRadius = toDimension(this.options.radius, maxRadius);\n    const innerRadius = Math.max(outerRadius * cutout, 0);\n    const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal();\n    this.offsetX = offsetX * outerRadius;\n    this.offsetY = offsetY * outerRadius;\n\n    meta.total = this.calculateTotal();\n\n    this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index);\n    this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0);\n\n    this.updateElements(arcs, 0, arcs.length, mode);\n  }\n\n  /**\n   * @private\n   */\n  _circumference(i, reset) {\n    const opts = this.options;\n    const meta = this._cachedMeta;\n    const circumference = this._getCircumference();\n    if ((reset && opts.animation.animateRotate) || !this.chart.getDataVisibility(i) || meta._parsed[i] === null || meta.data[i].hidden) {\n      return 0;\n    }\n    return this.calculateCircumference(meta._parsed[i] * circumference / TAU);\n  }\n\n  updateElements(arcs, start, count, mode) {\n    const reset = mode === 'reset';\n    const chart = this.chart;\n    const chartArea = chart.chartArea;\n    const opts = chart.options;\n    const animationOpts = opts.animation;\n    const centerX = (chartArea.left + chartArea.right) / 2;\n    const centerY = (chartArea.top + chartArea.bottom) / 2;\n    const animateScale = reset && animationOpts.animateScale;\n    const innerRadius = animateScale ? 0 : this.innerRadius;\n    const outerRadius = animateScale ? 0 : this.outerRadius;\n    const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode);\n    let startAngle = this._getRotation();\n    let i;\n\n    for (i = 0; i < start; ++i) {\n      startAngle += this._circumference(i, reset);\n    }\n\n    for (i = start; i < start + count; ++i) {\n      const circumference = this._circumference(i, reset);\n      const arc = arcs[i];\n      const properties = {\n        x: centerX + this.offsetX,\n        y: centerY + this.offsetY,\n        startAngle,\n        endAngle: startAngle + circumference,\n        circumference,\n        outerRadius,\n        innerRadius\n      };\n      if (includeOptions) {\n        properties.options = sharedOptions || this.resolveDataElementOptions(i, arc.active ? 'active' : mode);\n      }\n      startAngle += circumference;\n\n      this.updateElement(arc, i, properties, mode);\n    }\n  }\n\n  calculateTotal() {\n    const meta = this._cachedMeta;\n    const metaData = meta.data;\n    let total = 0;\n    let i;\n\n    for (i = 0; i < metaData.length; i++) {\n      const value = meta._parsed[i];\n      if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i) && !metaData[i].hidden) {\n        total += Math.abs(value);\n      }\n    }\n\n    return total;\n  }\n\n  calculateCircumference(value) {\n    const total = this._cachedMeta.total;\n    if (total > 0 && !isNaN(value)) {\n      return TAU * (Math.abs(value) / total);\n    }\n    return 0;\n  }\n\n  getLabelAndValue(index) {\n    const meta = this._cachedMeta;\n    const chart = this.chart;\n    const labels = chart.data.labels || [];\n    const value = formatNumber(meta._parsed[index], chart.options.locale);\n\n    return {\n      label: labels[index] || '',\n      value,\n    };\n  }\n\n  getMaxBorderWidth(arcs) {\n    let max = 0;\n    const chart = this.chart;\n    let i, ilen, meta, controller, options;\n\n    if (!arcs) {\n      // Find the outmost visible dataset\n      for (i = 0, ilen = chart.data.datasets.length; i < ilen; ++i) {\n        if (chart.isDatasetVisible(i)) {\n          meta = chart.getDatasetMeta(i);\n          arcs = meta.data;\n          controller = meta.controller;\n          break;\n        }\n      }\n    }\n\n    if (!arcs) {\n      return 0;\n    }\n\n    for (i = 0, ilen = arcs.length; i < ilen; ++i) {\n      options = controller.resolveDataElementOptions(i);\n      if (options.borderAlign !== 'inner') {\n        max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0);\n      }\n    }\n    return max;\n  }\n\n  getMaxOffset(arcs) {\n    let max = 0;\n\n    for (let i = 0, ilen = arcs.length; i < ilen; ++i) {\n      const options = this.resolveDataElementOptions(i);\n      max = Math.max(max, options.offset || 0, options.hoverOffset || 0);\n    }\n    return max;\n  }\n\n  /**\n\t * Get radius length offset of the dataset in relation to the visible datasets weights. This allows determining the inner and outer radius correctly\n\t * @private\n\t */\n  _getRingWeightOffset(datasetIndex) {\n    let ringWeightOffset = 0;\n\n    for (let i = 0; i < datasetIndex; ++i) {\n      if (this.chart.isDatasetVisible(i)) {\n        ringWeightOffset += this._getRingWeight(i);\n      }\n    }\n\n    return ringWeightOffset;\n  }\n\n  /**\n\t * @private\n\t */\n  _getRingWeight(datasetIndex) {\n    return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);\n  }\n\n  /**\n\t * Returns the sum of all visible data set weights.\n\t * @private\n\t */\n  _getVisibleDatasetWeightTotal() {\n    return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;\n  }\n}\n","import DatasetController from '../core/core.datasetController.js';\nimport {toRadians, PI, formatNumber, _parseObjectDataRadialScale} from '../helpers/index.js';\n\nexport default class PolarAreaController extends DatasetController {\n\n  static id = 'polarArea';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    dataElementType: 'arc',\n    animation: {\n      animateRotate: true,\n      animateScale: true\n    },\n    animations: {\n      numbers: {\n        type: 'number',\n        properties: ['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius']\n      },\n    },\n    indexAxis: 'r',\n    startAngle: 0,\n  };\n\n  /**\n   * @type {any}\n   */\n  static overrides = {\n    aspectRatio: 1,\n\n    plugins: {\n      legend: {\n        labels: {\n          generateLabels(chart) {\n            const data = chart.data;\n            if (data.labels.length && data.datasets.length) {\n              const {labels: {pointStyle, color}} = chart.legend.options;\n\n              return data.labels.map((label, i) => {\n                const meta = chart.getDatasetMeta(0);\n                const style = meta.controller.getStyle(i);\n\n                return {\n                  text: label,\n                  fillStyle: style.backgroundColor,\n                  strokeStyle: style.borderColor,\n                  fontColor: color,\n                  lineWidth: style.borderWidth,\n                  pointStyle: pointStyle,\n                  hidden: !chart.getDataVisibility(i),\n\n                  // Extra data used for toggling the correct item\n                  index: i\n                };\n              });\n            }\n            return [];\n          }\n        },\n\n        onClick(e, legendItem, legend) {\n          legend.chart.toggleDataVisibility(legendItem.index);\n          legend.chart.update();\n        }\n      }\n    },\n\n    scales: {\n      r: {\n        type: 'radialLinear',\n        angleLines: {\n          display: false\n        },\n        beginAtZero: true,\n        grid: {\n          circular: true\n        },\n        pointLabels: {\n          display: false\n        },\n        startAngle: 0\n      }\n    }\n  };\n\n  constructor(chart, datasetIndex) {\n    super(chart, datasetIndex);\n\n    this.innerRadius = undefined;\n    this.outerRadius = undefined;\n  }\n\n  getLabelAndValue(index) {\n    const meta = this._cachedMeta;\n    const chart = this.chart;\n    const labels = chart.data.labels || [];\n    const value = formatNumber(meta._parsed[index].r, chart.options.locale);\n\n    return {\n      label: labels[index] || '',\n      value,\n    };\n  }\n\n  parseObjectData(meta, data, start, count) {\n    return _parseObjectDataRadialScale.bind(this)(meta, data, start, count);\n  }\n\n  update(mode) {\n    const arcs = this._cachedMeta.data;\n\n    this._updateRadius();\n    this.updateElements(arcs, 0, arcs.length, mode);\n  }\n\n  /**\n   * @protected\n   */\n  getMinMax() {\n    const meta = this._cachedMeta;\n    const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};\n\n    meta.data.forEach((element, index) => {\n      const parsed = this.getParsed(index).r;\n\n      if (!isNaN(parsed) && this.chart.getDataVisibility(index)) {\n        if (parsed < range.min) {\n          range.min = parsed;\n        }\n\n        if (parsed > range.max) {\n          range.max = parsed;\n        }\n      }\n    });\n\n    return range;\n  }\n\n  /**\n\t * @private\n\t */\n  _updateRadius() {\n    const chart = this.chart;\n    const chartArea = chart.chartArea;\n    const opts = chart.options;\n    const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);\n\n    const outerRadius = Math.max(minSize / 2, 0);\n    const innerRadius = Math.max(opts.cutoutPercentage ? (outerRadius / 100) * (opts.cutoutPercentage) : 1, 0);\n    const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount();\n\n    this.outerRadius = outerRadius - (radiusLength * this.index);\n    this.innerRadius = this.outerRadius - radiusLength;\n  }\n\n  updateElements(arcs, start, count, mode) {\n    const reset = mode === 'reset';\n    const chart = this.chart;\n    const opts = chart.options;\n    const animationOpts = opts.animation;\n    const scale = this._cachedMeta.rScale;\n    const centerX = scale.xCenter;\n    const centerY = scale.yCenter;\n    const datasetStartAngle = scale.getIndexAngle(0) - 0.5 * PI;\n    let angle = datasetStartAngle;\n    let i;\n\n    const defaultAngle = 360 / this.countVisibleElements();\n\n    for (i = 0; i < start; ++i) {\n      angle += this._computeAngle(i, mode, defaultAngle);\n    }\n    for (i = start; i < start + count; i++) {\n      const arc = arcs[i];\n      let startAngle = angle;\n      let endAngle = angle + this._computeAngle(i, mode, defaultAngle);\n      let outerRadius = chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(this.getParsed(i).r) : 0;\n      angle = endAngle;\n\n      if (reset) {\n        if (animationOpts.animateScale) {\n          outerRadius = 0;\n        }\n        if (animationOpts.animateRotate) {\n          startAngle = endAngle = datasetStartAngle;\n        }\n      }\n\n      const properties = {\n        x: centerX,\n        y: centerY,\n        innerRadius: 0,\n        outerRadius,\n        startAngle,\n        endAngle,\n        options: this.resolveDataElementOptions(i, arc.active ? 'active' : mode)\n      };\n\n      this.updateElement(arc, i, properties, mode);\n    }\n  }\n\n  countVisibleElements() {\n    const meta = this._cachedMeta;\n    let count = 0;\n\n    meta.data.forEach((element, index) => {\n      if (!isNaN(this.getParsed(index).r) && this.chart.getDataVisibility(index)) {\n        count++;\n      }\n    });\n\n    return count;\n  }\n\n  /**\n\t * @private\n\t */\n  _computeAngle(index, mode, defaultAngle) {\n    return this.chart.getDataVisibility(index)\n      ? toRadians(this.resolveDataElementOptions(index, mode).angle || defaultAngle)\n      : 0;\n  }\n}\n","import {_lookupByKey, _rlookupByKey} from '../helpers/helpers.collection.js';\nimport {getRelativePosition} from '../helpers/helpers.dom.js';\nimport {_angleBetween, getAngleFromPoint} from '../helpers/helpers.math.js';\nimport {_isPointInArea} from '../helpers/index.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef {{axis?: string, intersect?: boolean, includeInvisible?: boolean}} InteractionOptions\n * @typedef {{datasetIndex: number, index: number, element: import('./core.element.js').default}} InteractionItem\n * @typedef { import('../types/index.js').Point } Point\n */\n\n/**\n * Helper function to do binary search when possible\n * @param {object} metaset - the dataset meta\n * @param {string} axis - the axis mode. x|y|xy|r\n * @param {number} value - the value to find\n * @param {boolean} [intersect] - should the element intersect\n * @returns {{lo:number, hi:number}} indices to search data array between\n */\nfunction binarySearch(metaset, axis, value, intersect) {\n  const {controller, data, _sorted} = metaset;\n  const iScale = controller._cachedMeta.iScale;\n  if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) {\n    const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;\n    if (!intersect) {\n      return lookupMethod(data, axis, value);\n    } else if (controller._sharedOptions) {\n      // _sharedOptions indicates that each element has equal options -> equal proportions\n      // So we can do a ranged binary search based on the range of first element and\n      // be confident to get the full range of indices that can intersect with the value.\n      const el = data[0];\n      const range = typeof el.getRange === 'function' && el.getRange(axis);\n      if (range) {\n        const start = lookupMethod(data, axis, value - range);\n        const end = lookupMethod(data, axis, value + range);\n        return {lo: start.lo, hi: end.hi};\n      }\n    }\n  }\n  // Default to all elements, when binary search can not be used.\n  return {lo: 0, hi: data.length - 1};\n}\n\n/**\n * Helper function to select candidate elements for interaction\n * @param {Chart} chart - the chart\n * @param {string} axis - the axis mode. x|y|xy|r\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {function} handler - the callback to execute for each visible item\n * @param {boolean} [intersect] - consider intersecting items\n */\nfunction evaluateInteractionItems(chart, axis, position, handler, intersect) {\n  const metasets = chart.getSortedVisibleDatasetMetas();\n  const value = position[axis];\n  for (let i = 0, ilen = metasets.length; i < ilen; ++i) {\n    const {index, data} = metasets[i];\n    const {lo, hi} = binarySearch(metasets[i], axis, value, intersect);\n    for (let j = lo; j <= hi; ++j) {\n      const element = data[j];\n      if (!element.skip) {\n        handler(element, index, j);\n      }\n    }\n  }\n}\n\n/**\n * Get a distance metric function for two points based on the\n * axis mode setting\n * @param {string} axis - the axis mode. x|y|xy|r\n */\nfunction getDistanceMetricForAxis(axis) {\n  const useX = axis.indexOf('x') !== -1;\n  const useY = axis.indexOf('y') !== -1;\n\n  return function(pt1, pt2) {\n    const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;\n    const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;\n    return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));\n  };\n}\n\n/**\n * Helper function to get the items that intersect the event position\n * @param {Chart} chart - the chart\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axis mode. x|y|xy|r\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @param {boolean} [includeInvisible] - include invisible points that are outside of the chart area\n * @return {InteractionItem[]} the nearest items\n */\nfunction getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {\n  const items = [];\n\n  if (!includeInvisible && !chart.isPointInArea(position)) {\n    return items;\n  }\n\n  const evaluationFunc = function(element, datasetIndex, index) {\n    if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {\n      return;\n    }\n    if (element.inRange(position.x, position.y, useFinalPosition)) {\n      items.push({element, datasetIndex, index});\n    }\n  };\n\n  evaluateInteractionItems(chart, axis, position, evaluationFunc, true);\n  return items;\n}\n\n/**\n * Helper function to get the items nearest to the event position for a radial chart\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axes along which to measure distance\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @return {InteractionItem[]} the nearest items\n */\nfunction getNearestRadialItems(chart, position, axis, useFinalPosition) {\n  let items = [];\n\n  function evaluationFunc(element, datasetIndex, index) {\n    const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition);\n    const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y});\n\n    if (_angleBetween(angle, startAngle, endAngle)) {\n      items.push({element, datasetIndex, index});\n    }\n  }\n\n  evaluateInteractionItems(chart, axis, position, evaluationFunc);\n  return items;\n}\n\n/**\n * Helper function to get the items nearest to the event position for a cartesian chart\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axes along which to measure distance\n * @param {boolean} [intersect] - if true, only consider items that intersect the position\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @param {boolean} [includeInvisible] - include invisible points that are outside of the chart area\n * @return {InteractionItem[]} the nearest items\n */\nfunction getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n  let items = [];\n  const distanceMetric = getDistanceMetricForAxis(axis);\n  let minDistance = Number.POSITIVE_INFINITY;\n\n  function evaluationFunc(element, datasetIndex, index) {\n    const inRange = element.inRange(position.x, position.y, useFinalPosition);\n    if (intersect && !inRange) {\n      return;\n    }\n\n    const center = element.getCenterPoint(useFinalPosition);\n    const pointInArea = !!includeInvisible || chart.isPointInArea(center);\n    if (!pointInArea && !inRange) {\n      return;\n    }\n\n    const distance = distanceMetric(position, center);\n    if (distance < minDistance) {\n      items = [{element, datasetIndex, index}];\n      minDistance = distance;\n    } else if (distance === minDistance) {\n      // Can have multiple items at the same distance in which case we sort by size\n      items.push({element, datasetIndex, index});\n    }\n  }\n\n  evaluateInteractionItems(chart, axis, position, evaluationFunc);\n  return items;\n}\n\n/**\n * Helper function to get the items nearest to the event position considering all visible items in the chart\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axes along which to measure distance\n * @param {boolean} [intersect] - if true, only consider items that intersect the position\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @param {boolean} [includeInvisible] - include invisible points that are outside of the chart area\n * @return {InteractionItem[]} the nearest items\n */\nfunction getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n  if (!includeInvisible && !chart.isPointInArea(position)) {\n    return [];\n  }\n\n  return axis === 'r' && !intersect\n    ? getNearestRadialItems(chart, position, axis, useFinalPosition)\n    : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);\n}\n\n/**\n * Helper function to get the items matching along the given X or Y axis\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axis to match\n * @param {boolean} [intersect] - if true, only consider items that intersect the position\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @return {InteractionItem[]} the nearest items\n */\nfunction getAxisItems(chart, position, axis, intersect, useFinalPosition) {\n  const items = [];\n  const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange';\n  let intersectsItem = false;\n\n  evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => {\n    if (element[rangeMethod](position[axis], useFinalPosition)) {\n      items.push({element, datasetIndex, index});\n      intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);\n    }\n  });\n\n  // If we want to trigger on an intersect and we don't have any items\n  // that intersect the position, return nothing\n  if (intersect && !intersectsItem) {\n    return [];\n  }\n  return items;\n}\n\n/**\n * Contains interaction related functions\n * @namespace Chart.Interaction\n */\nexport default {\n  // Part of the public API to facilitate developers creating their own modes\n  evaluateInteractionItems,\n\n  // Helper function for different modes\n  modes: {\n    /**\n\t\t * Returns items at the same index. If the options.intersect parameter is true, we only return items if we intersect something\n\t\t * If the options.intersect mode is false, we find the nearest item and return the items at the same index as that item\n\t\t * @function Chart.Interaction.modes.index\n\t\t * @since v2.4.0\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    index(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      // Default axis for index mode is 'x' to match old behaviour\n      const axis = options.axis || 'x';\n      const includeInvisible = options.includeInvisible || false;\n      const items = options.intersect\n        ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible)\n        : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n      const elements = [];\n\n      if (!items.length) {\n        return [];\n      }\n\n      chart.getSortedVisibleDatasetMetas().forEach((meta) => {\n        const index = items[0].index;\n        const element = meta.data[index];\n\n        // don't count items that are skipped (null data)\n        if (element && !element.skip) {\n          elements.push({element, datasetIndex: meta.index, index});\n        }\n      });\n\n      return elements;\n    },\n\n    /**\n\t\t * Returns items in the same dataset. If the options.intersect parameter is true, we only return items if we intersect something\n\t\t * If the options.intersect is false, we find the nearest item and return the items in that dataset\n\t\t * @function Chart.Interaction.modes.dataset\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    dataset(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      const axis = options.axis || 'xy';\n      const includeInvisible = options.includeInvisible || false;\n      let items = options.intersect\n        ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) :\n        getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n\n      if (items.length > 0) {\n        const datasetIndex = items[0].datasetIndex;\n        const data = chart.getDatasetMeta(datasetIndex).data;\n        items = [];\n        for (let i = 0; i < data.length; ++i) {\n          items.push({element: data[i], datasetIndex, index: i});\n        }\n      }\n\n      return items;\n    },\n\n    /**\n\t\t * Point mode returns all elements that hit test based on the event position\n\t\t * of the event\n\t\t * @function Chart.Interaction.modes.intersect\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    point(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      const axis = options.axis || 'xy';\n      const includeInvisible = options.includeInvisible || false;\n      return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);\n    },\n\n    /**\n\t\t * nearest mode returns the element closest to the point\n\t\t * @function Chart.Interaction.modes.intersect\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    nearest(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      const axis = options.axis || 'xy';\n      const includeInvisible = options.includeInvisible || false;\n      return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);\n    },\n\n    /**\n\t\t * x mode returns the elements that hit-test at the current x coordinate\n\t\t * @function Chart.Interaction.modes.x\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    x(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      return getAxisItems(chart, position, 'x', options.intersect, useFinalPosition);\n    },\n\n    /**\n\t\t * y mode returns the elements that hit-test at the current y coordinate\n\t\t * @function Chart.Interaction.modes.y\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    y(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      return getAxisItems(chart, position, 'y', options.intersect, useFinalPosition);\n    }\n  }\n};\n","import {defined, each, isObject} from '../helpers/helpers.core.js';\nimport {toPadding} from '../helpers/helpers.options.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n */\n\nconst STATIC_POSITIONS = ['left', 'top', 'right', 'bottom'];\n\nfunction filterByPosition(array, position) {\n  return array.filter(v => v.pos === position);\n}\n\nfunction filterDynamicPositionByAxis(array, axis) {\n  return array.filter(v => STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis);\n}\n\nfunction sortByWeight(array, reverse) {\n  return array.sort((a, b) => {\n    const v0 = reverse ? b : a;\n    const v1 = reverse ? a : b;\n    return v0.weight === v1.weight ?\n      v0.index - v1.index :\n      v0.weight - v1.weight;\n  });\n}\n\nfunction wrapBoxes(boxes) {\n  const layoutBoxes = [];\n  let i, ilen, box, pos, stack, stackWeight;\n\n  for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) {\n    box = boxes[i];\n    ({position: pos, options: {stack, stackWeight = 1}} = box);\n    layoutBoxes.push({\n      index: i,\n      box,\n      pos,\n      horizontal: box.isHorizontal(),\n      weight: box.weight,\n      stack: stack && (pos + stack),\n      stackWeight\n    });\n  }\n  return layoutBoxes;\n}\n\nfunction buildStacks(layouts) {\n  const stacks = {};\n  for (const wrap of layouts) {\n    const {stack, pos, stackWeight} = wrap;\n    if (!stack || !STATIC_POSITIONS.includes(pos)) {\n      continue;\n    }\n    const _stack = stacks[stack] || (stacks[stack] = {count: 0, placed: 0, weight: 0, size: 0});\n    _stack.count++;\n    _stack.weight += stackWeight;\n  }\n  return stacks;\n}\n\n/**\n * store dimensions used instead of available chartArea in fitBoxes\n **/\nfunction setLayoutDims(layouts, params) {\n  const stacks = buildStacks(layouts);\n  const {vBoxMaxWidth, hBoxMaxHeight} = params;\n  let i, ilen, layout;\n  for (i = 0, ilen = layouts.length; i < ilen; ++i) {\n    layout = layouts[i];\n    const {fullSize} = layout.box;\n    const stack = stacks[layout.stack];\n    const factor = stack && layout.stackWeight / stack.weight;\n    if (layout.horizontal) {\n      layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;\n      layout.height = hBoxMaxHeight;\n    } else {\n      layout.width = vBoxMaxWidth;\n      layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;\n    }\n  }\n  return stacks;\n}\n\nfunction buildLayoutBoxes(boxes) {\n  const layoutBoxes = wrapBoxes(boxes);\n  const fullSize = sortByWeight(layoutBoxes.filter(wrap => wrap.box.fullSize), true);\n  const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true);\n  const right = sortByWeight(filterByPosition(layoutBoxes, 'right'));\n  const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true);\n  const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom'));\n  const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x');\n  const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y');\n\n  return {\n    fullSize,\n    leftAndTop: left.concat(top),\n    rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),\n    chartArea: filterByPosition(layoutBoxes, 'chartArea'),\n    vertical: left.concat(right).concat(centerVertical),\n    horizontal: top.concat(bottom).concat(centerHorizontal)\n  };\n}\n\nfunction getCombinedMax(maxPadding, chartArea, a, b) {\n  return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]);\n}\n\nfunction updateMaxPadding(maxPadding, boxPadding) {\n  maxPadding.top = Math.max(maxPadding.top, boxPadding.top);\n  maxPadding.left = Math.max(maxPadding.left, boxPadding.left);\n  maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);\n  maxPadding.right = Math.max(maxPadding.right, boxPadding.right);\n}\n\nfunction updateDims(chartArea, params, layout, stacks) {\n  const {pos, box} = layout;\n  const maxPadding = chartArea.maxPadding;\n\n  // dynamically placed boxes size is not considered\n  if (!isObject(pos)) {\n    if (layout.size) {\n      // this layout was already counted for, lets first reduce old size\n      chartArea[pos] -= layout.size;\n    }\n    const stack = stacks[layout.stack] || {size: 0, count: 1};\n    stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);\n    layout.size = stack.size / stack.count;\n    chartArea[pos] += layout.size;\n  }\n\n  if (box.getPadding) {\n    updateMaxPadding(maxPadding, box.getPadding());\n  }\n\n  const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right'));\n  const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom'));\n  const widthChanged = newWidth !== chartArea.w;\n  const heightChanged = newHeight !== chartArea.h;\n  chartArea.w = newWidth;\n  chartArea.h = newHeight;\n\n  // return booleans on the changes per direction\n  return layout.horizontal\n    ? {same: widthChanged, other: heightChanged}\n    : {same: heightChanged, other: widthChanged};\n}\n\nfunction handleMaxPadding(chartArea) {\n  const maxPadding = chartArea.maxPadding;\n\n  function updatePos(pos) {\n    const change = Math.max(maxPadding[pos] - chartArea[pos], 0);\n    chartArea[pos] += change;\n    return change;\n  }\n  chartArea.y += updatePos('top');\n  chartArea.x += updatePos('left');\n  updatePos('right');\n  updatePos('bottom');\n}\n\nfunction getMargins(horizontal, chartArea) {\n  const maxPadding = chartArea.maxPadding;\n\n  function marginForPositions(positions) {\n    const margin = {left: 0, top: 0, right: 0, bottom: 0};\n    positions.forEach((pos) => {\n      margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);\n    });\n    return margin;\n  }\n\n  return horizontal\n    ? marginForPositions(['left', 'right'])\n    : marginForPositions(['top', 'bottom']);\n}\n\nfunction fitBoxes(boxes, chartArea, params, stacks) {\n  const refitBoxes = [];\n  let i, ilen, layout, box, refit, changed;\n\n  for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) {\n    layout = boxes[i];\n    box = layout.box;\n\n    box.update(\n      layout.width || chartArea.w,\n      layout.height || chartArea.h,\n      getMargins(layout.horizontal, chartArea)\n    );\n    const {same, other} = updateDims(chartArea, params, layout, stacks);\n\n    // Dimensions changed and there were non full width boxes before this\n    // -> we have to refit those\n    refit |= same && refitBoxes.length;\n\n    // Chart area changed in the opposite direction\n    changed = changed || other;\n\n    if (!box.fullSize) { // fullSize boxes don't need to be re-fitted in any case\n      refitBoxes.push(layout);\n    }\n  }\n\n  return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;\n}\n\nfunction setBoxDims(box, left, top, width, height) {\n  box.top = top;\n  box.left = left;\n  box.right = left + width;\n  box.bottom = top + height;\n  box.width = width;\n  box.height = height;\n}\n\nfunction placeBoxes(boxes, chartArea, params, stacks) {\n  const userPadding = params.padding;\n  let {x, y} = chartArea;\n\n  for (const layout of boxes) {\n    const box = layout.box;\n    const stack = stacks[layout.stack] || {count: 1, placed: 0, weight: 1};\n    const weight = (layout.stackWeight / stack.weight) || 1;\n    if (layout.horizontal) {\n      const width = chartArea.w * weight;\n      const height = stack.size || box.height;\n      if (defined(stack.start)) {\n        y = stack.start;\n      }\n      if (box.fullSize) {\n        setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height);\n      } else {\n        setBoxDims(box, chartArea.left + stack.placed, y, width, height);\n      }\n      stack.start = y;\n      stack.placed += width;\n      y = box.bottom;\n    } else {\n      const height = chartArea.h * weight;\n      const width = stack.size || box.width;\n      if (defined(stack.start)) {\n        x = stack.start;\n      }\n      if (box.fullSize) {\n        setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);\n      } else {\n        setBoxDims(box, x, chartArea.top + stack.placed, width, height);\n      }\n      stack.start = x;\n      stack.placed += height;\n      x = box.right;\n    }\n  }\n\n  chartArea.x = x;\n  chartArea.y = y;\n}\n\n/**\n * @interface LayoutItem\n * @typedef {object} LayoutItem\n * @prop {string} position - The position of the item in the chart layout. Possible values are\n * 'left', 'top', 'right', 'bottom', and 'chartArea'\n * @prop {number} weight - The weight used to sort the item. Higher weights are further away from the chart area\n * @prop {boolean} fullSize - if true, and the item is horizontal, then push vertical boxes down\n * @prop {function} isHorizontal - returns true if the layout item is horizontal (ie. top or bottom)\n * @prop {function} update - Takes two parameters: width and height. Returns size of item\n * @prop {function} draw - Draws the element\n * @prop {function} [getPadding] -  Returns an object with padding on the edges\n * @prop {number} width - Width of item. Must be valid after update()\n * @prop {number} height - Height of item. Must be valid after update()\n * @prop {number} left - Left edge of the item. Set by layout system and cannot be used in update\n * @prop {number} top - Top edge of the item. Set by layout system and cannot be used in update\n * @prop {number} right - Right edge of the item. Set by layout system and cannot be used in update\n * @prop {number} bottom - Bottom edge of the item. Set by layout system and cannot be used in update\n */\n\n// The layout service is very self explanatory.  It's responsible for the layout within a chart.\n// Scales, Legends and Plugins all rely on the layout service and can easily register to be placed anywhere they need\n// It is this service's responsibility of carrying out that layout.\nexport default {\n\n  /**\n\t * Register a box to a chart.\n\t * A box is simply a reference to an object that requires layout. eg. Scales, Legend, Title.\n\t * @param {Chart} chart - the chart to use\n\t * @param {LayoutItem} item - the item to add to be laid out\n\t */\n  addBox(chart, item) {\n    if (!chart.boxes) {\n      chart.boxes = [];\n    }\n\n    // initialize item with default values\n    item.fullSize = item.fullSize || false;\n    item.position = item.position || 'top';\n    item.weight = item.weight || 0;\n    // @ts-ignore\n    item._layers = item._layers || function() {\n      return [{\n        z: 0,\n        draw(chartArea) {\n          item.draw(chartArea);\n        }\n      }];\n    };\n\n    chart.boxes.push(item);\n  },\n\n  /**\n\t * Remove a layoutItem from a chart\n\t * @param {Chart} chart - the chart to remove the box from\n\t * @param {LayoutItem} layoutItem - the item to remove from the layout\n\t */\n  removeBox(chart, layoutItem) {\n    const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;\n    if (index !== -1) {\n      chart.boxes.splice(index, 1);\n    }\n  },\n\n  /**\n\t * Sets (or updates) options on the given `item`.\n\t * @param {Chart} chart - the chart in which the item lives (or will be added to)\n\t * @param {LayoutItem} item - the item to configure with the given options\n\t * @param {object} options - the new item options.\n\t */\n  configure(chart, item, options) {\n    item.fullSize = options.fullSize;\n    item.position = options.position;\n    item.weight = options.weight;\n  },\n\n  /**\n\t * Fits boxes of the given chart into the given size by having each box measure itself\n\t * then running a fitting algorithm\n\t * @param {Chart} chart - the chart\n\t * @param {number} width - the width to fit into\n\t * @param {number} height - the height to fit into\n   * @param {number} minPadding - minimum padding required for each side of chart area\n\t */\n  update(chart, width, height, minPadding) {\n    if (!chart) {\n      return;\n    }\n\n    const padding = toPadding(chart.options.layout.padding);\n    const availableWidth = Math.max(width - padding.width, 0);\n    const availableHeight = Math.max(height - padding.height, 0);\n    const boxes = buildLayoutBoxes(chart.boxes);\n    const verticalBoxes = boxes.vertical;\n    const horizontalBoxes = boxes.horizontal;\n\n    // Before any changes are made, notify boxes that an update is about to being\n    // This is used to clear any cached data (e.g. scale limits)\n    each(chart.boxes, box => {\n      if (typeof box.beforeLayout === 'function') {\n        box.beforeLayout();\n      }\n    });\n\n    // Essentially we now have any number of boxes on each of the 4 sides.\n    // Our canvas looks like the following.\n    // The areas L1 and L2 are the left axes. R1 is the right axis, T1 is the top axis and\n    // B1 is the bottom axis\n    // There are also 4 quadrant-like locations (left to right instead of clockwise) reserved for chart overlays\n    // These locations are single-box locations only, when trying to register a chartArea location that is already taken,\n    // an error will be thrown.\n    //\n    // |----------------------------------------------------|\n    // |                  T1 (Full Width)                   |\n    // |----------------------------------------------------|\n    // |    |    |                 T2                  |    |\n    // |    |----|-------------------------------------|----|\n    // |    |    | C1 |                           | C2 |    |\n    // |    |    |----|                           |----|    |\n    // |    |    |                                     |    |\n    // | L1 | L2 |           ChartArea (C0)            | R1 |\n    // |    |    |                                     |    |\n    // |    |    |----|                           |----|    |\n    // |    |    | C3 |                           | C4 |    |\n    // |    |----|-------------------------------------|----|\n    // |    |    |                 B1                  |    |\n    // |----------------------------------------------------|\n    // |                  B2 (Full Width)                   |\n    // |----------------------------------------------------|\n    //\n\n    const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) =>\n      wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;\n\n    const params = Object.freeze({\n      outerWidth: width,\n      outerHeight: height,\n      padding,\n      availableWidth,\n      availableHeight,\n      vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,\n      hBoxMaxHeight: availableHeight / 2\n    });\n    const maxPadding = Object.assign({}, padding);\n    updateMaxPadding(maxPadding, toPadding(minPadding));\n    const chartArea = Object.assign({\n      maxPadding,\n      w: availableWidth,\n      h: availableHeight,\n      x: padding.left,\n      y: padding.top\n    }, padding);\n\n    const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);\n\n    // First fit the fullSize boxes, to reduce probability of re-fitting.\n    fitBoxes(boxes.fullSize, chartArea, params, stacks);\n\n    // Then fit vertical boxes\n    fitBoxes(verticalBoxes, chartArea, params, stacks);\n\n    // Then fit horizontal boxes\n    if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {\n      // if the area changed, re-fit vertical boxes\n      fitBoxes(verticalBoxes, chartArea, params, stacks);\n    }\n\n    handleMaxPadding(chartArea);\n\n    // Finally place the boxes to correct coordinates\n    placeBoxes(boxes.leftAndTop, chartArea, params, stacks);\n\n    // Move to opposite side of chart\n    chartArea.x += chartArea.w;\n    chartArea.y += chartArea.h;\n\n    placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);\n\n    chart.chartArea = {\n      left: chartArea.left,\n      top: chartArea.top,\n      right: chartArea.left + chartArea.w,\n      bottom: chartArea.top + chartArea.h,\n      height: chartArea.h,\n      width: chartArea.w,\n    };\n\n    // Finally update boxes in chartArea (radial scale for example)\n    each(boxes.chartArea, (layout) => {\n      const box = layout.box;\n      Object.assign(box, chart.chartArea);\n      box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0});\n    });\n  }\n};\n","\n/**\n * @typedef { import('../core/core.controller.js').default } Chart\n */\n\n/**\n * Abstract class that allows abstracting platform dependencies away from the chart.\n */\nexport default class BasePlatform {\n  /**\n\t * Called at chart construction time, returns a context2d instance implementing\n\t * the [W3C Canvas 2D Context API standard]{@link https://www.w3.org/TR/2dcontext/}.\n\t * @param {HTMLCanvasElement} canvas - The canvas from which to acquire context (platform specific)\n\t * @param {number} [aspectRatio] - The chart options\n\t */\n  acquireContext(canvas, aspectRatio) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * Called at chart destruction time, releases any resources associated to the context\n\t * previously returned by the acquireContext() method.\n\t * @param {CanvasRenderingContext2D} context - The context2d instance\n\t * @returns {boolean} true if the method succeeded, else false\n\t */\n  releaseContext(context) { // eslint-disable-line no-unused-vars\n    return false;\n  }\n\n  /**\n\t * Registers the specified listener on the given chart.\n\t * @param {Chart} chart - Chart from which to listen for event\n\t * @param {string} type - The ({@link ChartEvent}) type to listen for\n\t * @param {function} listener - Receives a notification (an object that implements\n\t * the {@link ChartEvent} interface) when an event of the specified type occurs.\n\t */\n  addEventListener(chart, type, listener) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * Removes the specified listener previously registered with addEventListener.\n\t * @param {Chart} chart - Chart from which to remove the listener\n\t * @param {string} type - The ({@link ChartEvent}) type to remove\n\t * @param {function} listener - The listener function to remove from the event target.\n\t */\n  removeEventListener(chart, type, listener) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * @returns {number} the current devicePixelRatio of the device this platform is connected to.\n\t */\n  getDevicePixelRatio() {\n    return 1;\n  }\n\n  /**\n\t * Returns the maximum size in pixels of given canvas element.\n\t * @param {HTMLCanvasElement} element\n\t * @param {number} [width] - content width of parent element\n\t * @param {number} [height] - content height of parent element\n\t * @param {number} [aspectRatio] - aspect ratio to maintain\n\t */\n  getMaximumSize(element, width, height, aspectRatio) {\n    width = Math.max(0, width || element.width);\n    height = height || element.height;\n    return {\n      width,\n      height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)\n    };\n  }\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t * @returns {boolean} true if the canvas is attached to the platform, false if not.\n\t */\n  isAttached(canvas) { // eslint-disable-line no-unused-vars\n    return true;\n  }\n\n  /**\n   * Updates config with platform specific requirements\n   * @param {import('../core/core.config.js').default} config\n   */\n  updateConfig(config) { // eslint-disable-line no-unused-vars\n    // no-op\n  }\n}\n","/**\n * Platform fallback implementation (minimal).\n * @see https://github.com/chartjs/Chart.js/pull/4591#issuecomment-319575939\n */\n\nimport BasePlatform from './platform.base.js';\n\n/**\n * Platform class for charts without access to the DOM or to many element properties\n * This platform is used by default for any chart passed an OffscreenCanvas.\n * @extends BasePlatform\n */\nexport default class BasicPlatform extends BasePlatform {\n  acquireContext(item) {\n    // To prevent canvas fingerprinting, some add-ons undefine the getContext\n    // method, for example: https://github.com/kkapsner/CanvasBlocker\n    // https://github.com/chartjs/Chart.js/issues/2807\n    return item && item.getContext && item.getContext('2d') || null;\n  }\n  updateConfig(config) {\n    config.options.animation = false;\n  }\n}\n","/**\n * Chart.Platform implementation for targeting a web browser\n */\n\nimport BasePlatform from './platform.base.js';\nimport {_getParentNode, getRelativePosition, supportsEventListenerOptions, readUsedSize, getMaximumSize} from '../helpers/helpers.dom.js';\nimport {throttled} from '../helpers/helpers.extras.js';\nimport {isNullOrUndef} from '../helpers/helpers.core.js';\n\n/**\n * @typedef { import('../core/core.controller.js').default } Chart\n */\n\nconst EXPANDO_KEY = '$chartjs';\n\n/**\n * DOM event types -> Chart.js event types.\n * Note: only events with different types are mapped.\n * @see https://developer.mozilla.org/en-US/docs/Web/Events\n */\nconst EVENT_TYPES = {\n  touchstart: 'mousedown',\n  touchmove: 'mousemove',\n  touchend: 'mouseup',\n  pointerenter: 'mouseenter',\n  pointerdown: 'mousedown',\n  pointermove: 'mousemove',\n  pointerup: 'mouseup',\n  pointerleave: 'mouseout',\n  pointerout: 'mouseout'\n};\n\nconst isNullOrEmpty = value => value === null || value === '';\n/**\n * Initializes the canvas style and render size without modifying the canvas display size,\n * since responsiveness is handled by the controller.resize() method. The config is used\n * to determine the aspect ratio to apply in case no explicit height has been specified.\n * @param {HTMLCanvasElement} canvas\n * @param {number} [aspectRatio]\n */\nfunction initCanvas(canvas, aspectRatio) {\n  const style = canvas.style;\n\n  // NOTE(SB) canvas.getAttribute('width') !== canvas.width: in the first case it\n  // returns null or '' if no explicit value has been set to the canvas attribute.\n  const renderHeight = canvas.getAttribute('height');\n  const renderWidth = canvas.getAttribute('width');\n\n  // Chart.js modifies some canvas values that we want to restore on destroy\n  canvas[EXPANDO_KEY] = {\n    initial: {\n      height: renderHeight,\n      width: renderWidth,\n      style: {\n        display: style.display,\n        height: style.height,\n        width: style.width\n      }\n    }\n  };\n\n  // Force canvas to display as block to avoid extra space caused by inline\n  // elements, which would interfere with the responsive resize process.\n  // https://github.com/chartjs/Chart.js/issues/2538\n  style.display = style.display || 'block';\n  // Include possible borders in the size\n  style.boxSizing = style.boxSizing || 'border-box';\n\n  if (isNullOrEmpty(renderWidth)) {\n    const displayWidth = readUsedSize(canvas, 'width');\n    if (displayWidth !== undefined) {\n      canvas.width = displayWidth;\n    }\n  }\n\n  if (isNullOrEmpty(renderHeight)) {\n    if (canvas.style.height === '') {\n      // If no explicit render height and style height, let's apply the aspect ratio,\n      // which one can be specified by the user but also by charts as default option\n      // (i.e. options.aspectRatio). If not specified, use canvas aspect ratio of 2.\n      canvas.height = canvas.width / (aspectRatio || 2);\n    } else {\n      const displayHeight = readUsedSize(canvas, 'height');\n      if (displayHeight !== undefined) {\n        canvas.height = displayHeight;\n      }\n    }\n  }\n\n  return canvas;\n}\n\n// Default passive to true as expected by Chrome for 'touchstart' and 'touchend' events.\n// https://github.com/chartjs/Chart.js/issues/4287\nconst eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false;\n\nfunction addListener(node, type, listener) {\n  if (node) {\n    node.addEventListener(type, listener, eventListenerOptions);\n  }\n}\n\nfunction removeListener(chart, type, listener) {\n  if (chart && chart.canvas) {\n    chart.canvas.removeEventListener(type, listener, eventListenerOptions);\n  }\n}\n\nfunction fromNativeEvent(event, chart) {\n  const type = EVENT_TYPES[event.type] || event.type;\n  const {x, y} = getRelativePosition(event, chart);\n  return {\n    type,\n    chart,\n    native: event,\n    x: x !== undefined ? x : null,\n    y: y !== undefined ? y : null,\n  };\n}\n\nfunction nodeListContains(nodeList, canvas) {\n  for (const node of nodeList) {\n    if (node === canvas || node.contains(canvas)) {\n      return true;\n    }\n  }\n}\n\nfunction createAttachObserver(chart, type, listener) {\n  const canvas = chart.canvas;\n  const observer = new MutationObserver(entries => {\n    let trigger = false;\n    for (const entry of entries) {\n      trigger = trigger || nodeListContains(entry.addedNodes, canvas);\n      trigger = trigger && !nodeListContains(entry.removedNodes, canvas);\n    }\n    if (trigger) {\n      listener();\n    }\n  });\n  observer.observe(document, {childList: true, subtree: true});\n  return observer;\n}\n\nfunction createDetachObserver(chart, type, listener) {\n  const canvas = chart.canvas;\n  const observer = new MutationObserver(entries => {\n    let trigger = false;\n    for (const entry of entries) {\n      trigger = trigger || nodeListContains(entry.removedNodes, canvas);\n      trigger = trigger && !nodeListContains(entry.addedNodes, canvas);\n    }\n    if (trigger) {\n      listener();\n    }\n  });\n  observer.observe(document, {childList: true, subtree: true});\n  return observer;\n}\n\nconst drpListeningCharts = new Map();\nlet oldDevicePixelRatio = 0;\n\nfunction onWindowResize() {\n  const dpr = window.devicePixelRatio;\n  if (dpr === oldDevicePixelRatio) {\n    return;\n  }\n  oldDevicePixelRatio = dpr;\n  drpListeningCharts.forEach((resize, chart) => {\n    if (chart.currentDevicePixelRatio !== dpr) {\n      resize();\n    }\n  });\n}\n\nfunction listenDevicePixelRatioChanges(chart, resize) {\n  if (!drpListeningCharts.size) {\n    window.addEventListener('resize', onWindowResize);\n  }\n  drpListeningCharts.set(chart, resize);\n}\n\nfunction unlistenDevicePixelRatioChanges(chart) {\n  drpListeningCharts.delete(chart);\n  if (!drpListeningCharts.size) {\n    window.removeEventListener('resize', onWindowResize);\n  }\n}\n\nfunction createResizeObserver(chart, type, listener) {\n  const canvas = chart.canvas;\n  const container = canvas && _getParentNode(canvas);\n  if (!container) {\n    return;\n  }\n  const resize = throttled((width, height) => {\n    const w = container.clientWidth;\n    listener(width, height);\n    if (w < container.clientWidth) {\n      // If the container size shrank during chart resize, let's assume\n      // scrollbar appeared. So we resize again with the scrollbar visible -\n      // effectively making chart smaller and the scrollbar hidden again.\n      // Because we are inside `throttled`, and currently `ticking`, scroll\n      // events are ignored during this whole 2 resize process.\n      // If we assumed wrong and something else happened, we are resizing\n      // twice in a frame (potential performance issue)\n      listener();\n    }\n  }, window);\n\n  // @ts-ignore until https://github.com/microsoft/TypeScript/issues/37861 implemented\n  const observer = new ResizeObserver(entries => {\n    const entry = entries[0];\n    const width = entry.contentRect.width;\n    const height = entry.contentRect.height;\n    // When its container's display is set to 'none' the callback will be called with a\n    // size of (0, 0), which will cause the chart to lose its original height, so skip\n    // resizing in such case.\n    if (width === 0 && height === 0) {\n      return;\n    }\n    resize(width, height);\n  });\n  observer.observe(container);\n  listenDevicePixelRatioChanges(chart, resize);\n\n  return observer;\n}\n\nfunction releaseObserver(chart, type, observer) {\n  if (observer) {\n    observer.disconnect();\n  }\n  if (type === 'resize') {\n    unlistenDevicePixelRatioChanges(chart);\n  }\n}\n\nfunction createProxyAndListen(chart, type, listener) {\n  const canvas = chart.canvas;\n  const proxy = throttled((event) => {\n    // This case can occur if the chart is destroyed while waiting\n    // for the throttled function to occur. We prevent crashes by checking\n    // for a destroyed chart\n    if (chart.ctx !== null) {\n      listener(fromNativeEvent(event, chart));\n    }\n  }, chart);\n\n  addListener(canvas, type, proxy);\n\n  return proxy;\n}\n\n/**\n * Platform class for charts that can access the DOM and global window/document properties\n * @extends BasePlatform\n */\nexport default class DomPlatform extends BasePlatform {\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t * @param {number} [aspectRatio]\n\t * @return {CanvasRenderingContext2D|null}\n\t */\n  acquireContext(canvas, aspectRatio) {\n    // To prevent canvas fingerprinting, some add-ons undefine the getContext\n    // method, for example: https://github.com/kkapsner/CanvasBlocker\n    // https://github.com/chartjs/Chart.js/issues/2807\n    const context = canvas && canvas.getContext && canvas.getContext('2d');\n\n    // `instanceof HTMLCanvasElement/CanvasRenderingContext2D` fails when the canvas is\n    // inside an iframe or when running in a protected environment. We could guess the\n    // types from their toString() value but let's keep things flexible and assume it's\n    // a sufficient condition if the canvas has a context2D which has canvas as `canvas`.\n    // https://github.com/chartjs/Chart.js/issues/3887\n    // https://github.com/chartjs/Chart.js/issues/4102\n    // https://github.com/chartjs/Chart.js/issues/4152\n    if (context && context.canvas === canvas) {\n      // Load platform resources on first chart creation, to make it possible to\n      // import the library before setting platform options.\n      initCanvas(canvas, aspectRatio);\n      return context;\n    }\n\n    return null;\n  }\n\n  /**\n\t * @param {CanvasRenderingContext2D} context\n\t */\n  releaseContext(context) {\n    const canvas = context.canvas;\n    if (!canvas[EXPANDO_KEY]) {\n      return false;\n    }\n\n    const initial = canvas[EXPANDO_KEY].initial;\n    ['height', 'width'].forEach((prop) => {\n      const value = initial[prop];\n      if (isNullOrUndef(value)) {\n        canvas.removeAttribute(prop);\n      } else {\n        canvas.setAttribute(prop, value);\n      }\n    });\n\n    const style = initial.style || {};\n    Object.keys(style).forEach((key) => {\n      canvas.style[key] = style[key];\n    });\n\n    // The canvas render size might have been changed (and thus the state stack discarded),\n    // we can't use save() and restore() to restore the initial state. So make sure that at\n    // least the canvas context is reset to the default state by setting the canvas width.\n    // https://www.w3.org/TR/2011/WD-html5-20110525/the-canvas-element.html\n    // eslint-disable-next-line no-self-assign\n    canvas.width = canvas.width;\n\n    delete canvas[EXPANDO_KEY];\n    return true;\n  }\n\n  /**\n\t *\n\t * @param {Chart} chart\n\t * @param {string} type\n\t * @param {function} listener\n\t */\n  addEventListener(chart, type, listener) {\n    // Can have only one listener per type, so make sure previous is removed\n    this.removeEventListener(chart, type);\n\n    const proxies = chart.$proxies || (chart.$proxies = {});\n    const handlers = {\n      attach: createAttachObserver,\n      detach: createDetachObserver,\n      resize: createResizeObserver\n    };\n    const handler = handlers[type] || createProxyAndListen;\n    proxies[type] = handler(chart, type, listener);\n  }\n\n\n  /**\n\t * @param {Chart} chart\n\t * @param {string} type\n\t */\n  removeEventListener(chart, type) {\n    const proxies = chart.$proxies || (chart.$proxies = {});\n    const proxy = proxies[type];\n\n    if (!proxy) {\n      return;\n    }\n\n    const handlers = {\n      attach: releaseObserver,\n      detach: releaseObserver,\n      resize: releaseObserver\n    };\n    const handler = handlers[type] || removeListener;\n    handler(chart, type, proxy);\n    proxies[type] = undefined;\n  }\n\n  getDevicePixelRatio() {\n    return window.devicePixelRatio;\n  }\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t * @param {number} [width] - content width of parent element\n\t * @param {number} [height] - content height of parent element\n\t * @param {number} [aspectRatio] - aspect ratio to maintain\n\t */\n  getMaximumSize(canvas, width, height, aspectRatio) {\n    return getMaximumSize(canvas, width, height, aspectRatio);\n  }\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t */\n  isAttached(canvas) {\n    const container = canvas && _getParentNode(canvas);\n    return !!(container && container.isConnected);\n  }\n}\n","import type {AnyObject} from '../types/basic.js';\nimport type {Point} from '../types/geometric.js';\nimport type {Animation} from '../types/animation.js';\nimport {isNumber} from '../helpers/helpers.math.js';\n\nexport default class Element<T = AnyObject, O = AnyObject> {\n\n  static defaults = {};\n  static defaultRoutes = undefined;\n\n  x: number;\n  y: number;\n  active = false;\n  options: O;\n  $animations: Record<keyof T, Animation>;\n\n  tooltipPosition(useFinalPosition: boolean): Point {\n    const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n    return {x, y} as Point;\n  }\n\n  hasValue() {\n    return isNumber(this.x) && isNumber(this.y);\n  }\n\n  /**\n   * Gets the current or final value of each prop. Can return extra properties (whole object).\n   * @param props - properties to get\n   * @param [final] - get the final value (animation target)\n   */\n  getProps<P extends (keyof T)[]>(props: P, final?: boolean): Pick<T, P[number]>;\n  getProps<P extends string>(props: P[], final?: boolean): Partial<Record<P, unknown>>;\n  getProps(props: string[], final?: boolean): Partial<Record<string, unknown>> {\n    const anims = this.$animations;\n    if (!final || !anims) {\n      // let's not create an object, if not needed\n      return this as Record<string, unknown>;\n    }\n    const ret: Record<string, unknown> = {};\n    props.forEach((prop) => {\n      ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop as string];\n    });\n    return ret;\n  }\n}\n","import {isNullOrUndef, valueOrDefault} from '../helpers/helpers.core.js';\nimport {_factorize} from '../helpers/helpers.math.js';\n\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef {{value:number | string, label?:string, major?:boolean, $context?:any}} Tick\n */\n\n/**\n * Returns a subset of ticks to be plotted to avoid overlapping labels.\n * @param {import('./core.scale.js').default} scale\n * @param {Tick[]} ticks\n * @return {Tick[]}\n * @private\n */\nexport function autoSkip(scale, ticks) {\n  const tickOpts = scale.options.ticks;\n  const determinedMaxTicks = determineMaxTicks(scale);\n  const ticksLimit = Math.min(tickOpts.maxTicksLimit || determinedMaxTicks, determinedMaxTicks);\n  const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];\n  const numMajorIndices = majorIndices.length;\n  const first = majorIndices[0];\n  const last = majorIndices[numMajorIndices - 1];\n  const newTicks = [];\n\n  // If there are too many major ticks to display them all\n  if (numMajorIndices > ticksLimit) {\n    skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);\n    return newTicks;\n  }\n\n  const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);\n\n  if (numMajorIndices > 0) {\n    let i, ilen;\n    const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;\n    skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);\n    for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) {\n      skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);\n    }\n    skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);\n    return newTicks;\n  }\n  skip(ticks, newTicks, spacing);\n  return newTicks;\n}\n\nfunction determineMaxTicks(scale) {\n  const offset = scale.options.offset;\n  const tickLength = scale._tickSize();\n  const maxScale = scale._length / tickLength + (offset ? 0 : 1);\n  const maxChart = scale._maxLength / tickLength;\n  return Math.floor(Math.min(maxScale, maxChart));\n}\n\n/**\n * @param {number[]} majorIndices\n * @param {Tick[]} ticks\n * @param {number} ticksLimit\n */\nfunction calculateSpacing(majorIndices, ticks, ticksLimit) {\n  const evenMajorSpacing = getEvenSpacing(majorIndices);\n  const spacing = ticks.length / ticksLimit;\n\n  // If the major ticks are evenly spaced apart, place the minor ticks\n  // so that they divide the major ticks into even chunks\n  if (!evenMajorSpacing) {\n    return Math.max(spacing, 1);\n  }\n\n  const factors = _factorize(evenMajorSpacing);\n  for (let i = 0, ilen = factors.length - 1; i < ilen; i++) {\n    const factor = factors[i];\n    if (factor > spacing) {\n      return factor;\n    }\n  }\n  return Math.max(spacing, 1);\n}\n\n/**\n * @param {Tick[]} ticks\n */\nfunction getMajorIndices(ticks) {\n  const result = [];\n  let i, ilen;\n  for (i = 0, ilen = ticks.length; i < ilen; i++) {\n    if (ticks[i].major) {\n      result.push(i);\n    }\n  }\n  return result;\n}\n\n/**\n * @param {Tick[]} ticks\n * @param {Tick[]} newTicks\n * @param {number[]} majorIndices\n * @param {number} spacing\n */\nfunction skipMajors(ticks, newTicks, majorIndices, spacing) {\n  let count = 0;\n  let next = majorIndices[0];\n  let i;\n\n  spacing = Math.ceil(spacing);\n  for (i = 0; i < ticks.length; i++) {\n    if (i === next) {\n      newTicks.push(ticks[i]);\n      count++;\n      next = majorIndices[count * spacing];\n    }\n  }\n}\n\n/**\n * @param {Tick[]} ticks\n * @param {Tick[]} newTicks\n * @param {number} spacing\n * @param {number} [majorStart]\n * @param {number} [majorEnd]\n */\nfunction skip(ticks, newTicks, spacing, majorStart, majorEnd) {\n  const start = valueOrDefault(majorStart, 0);\n  const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);\n  let count = 0;\n  let length, i, next;\n\n  spacing = Math.ceil(spacing);\n  if (majorEnd) {\n    length = majorEnd - majorStart;\n    spacing = length / Math.floor(length / spacing);\n  }\n\n  next = start;\n\n  while (next < 0) {\n    count++;\n    next = Math.round(start + count * spacing);\n  }\n\n  for (i = Math.max(start, 0); i < end; i++) {\n    if (i === next) {\n      newTicks.push(ticks[i]);\n      count++;\n      next = Math.round(start + count * spacing);\n    }\n  }\n}\n\n\n/**\n * @param {number[]} arr\n */\nfunction getEvenSpacing(arr) {\n  const len = arr.length;\n  let i, diff;\n\n  if (len < 2) {\n    return false;\n  }\n\n  for (diff = arr[0], i = 1; i < len; ++i) {\n    if (arr[i] - arr[i - 1] !== diff) {\n      return false;\n    }\n  }\n  return diff;\n}\n","import Element from './core.element.js';\nimport {_alignPixel, _measureText, renderText, clipArea, unclipArea} from '../helpers/helpers.canvas.js';\nimport {callback as call, each, finiteOrDefault, isArray, isFinite, isNullOrUndef, isObject, valueOrDefault} from '../helpers/helpers.core.js';\nimport {toDegrees, toRadians, _int16Range, _limitValue, HALF_PI} from '../helpers/helpers.math.js';\nimport {_alignStartEnd, _toLeftRightCenter} from '../helpers/helpers.extras.js';\nimport {createContext, toFont, toPadding, _addGrace} from '../helpers/helpers.options.js';\nimport {autoSkip} from './core.scale.autoskip.js';\n\nconst reverseAlign = (align) => align === 'left' ? 'right' : align === 'right' ? 'left' : align;\nconst offsetFromEdge = (scale, edge, offset) => edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset;\nconst getTicksLimit = (ticksLength, maxTicksLimit) => Math.min(maxTicksLimit || ticksLength, ticksLength);\n\n/**\n * @typedef { import('../types/index.js').Chart } Chart\n * @typedef {{value:number | string, label?:string, major?:boolean, $context?:any}} Tick\n */\n\n/**\n * Returns a new array containing numItems from arr\n * @param {any[]} arr\n * @param {number} numItems\n */\nfunction sample(arr, numItems) {\n  const result = [];\n  const increment = arr.length / numItems;\n  const len = arr.length;\n  let i = 0;\n\n  for (; i < len; i += increment) {\n    result.push(arr[Math.floor(i)]);\n  }\n  return result;\n}\n\n/**\n * @param {Scale} scale\n * @param {number} index\n * @param {boolean} offsetGridLines\n */\nfunction getPixelForGridLine(scale, index, offsetGridLines) {\n  const length = scale.ticks.length;\n  const validIndex = Math.min(index, length - 1);\n  const start = scale._startPixel;\n  const end = scale._endPixel;\n  const epsilon = 1e-6; // 1e-6 is margin in pixels for accumulated error.\n  let lineValue = scale.getPixelForTick(validIndex);\n  let offset;\n\n  if (offsetGridLines) {\n    if (length === 1) {\n      offset = Math.max(lineValue - start, end - lineValue);\n    } else if (index === 0) {\n      offset = (scale.getPixelForTick(1) - lineValue) / 2;\n    } else {\n      offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2;\n    }\n    lineValue += validIndex < index ? offset : -offset;\n\n    // Return undefined if the pixel is out of the range\n    if (lineValue < start - epsilon || lineValue > end + epsilon) {\n      return;\n    }\n  }\n  return lineValue;\n}\n\n/**\n * @param {object} caches\n * @param {number} length\n */\nfunction garbageCollect(caches, length) {\n  each(caches, (cache) => {\n    const gc = cache.gc;\n    const gcLen = gc.length / 2;\n    let i;\n    if (gcLen > length) {\n      for (i = 0; i < gcLen; ++i) {\n        delete cache.data[gc[i]];\n      }\n      gc.splice(0, gcLen);\n    }\n  });\n}\n\n/**\n * @param {object} options\n */\nfunction getTickMarkLength(options) {\n  return options.drawTicks ? options.tickLength : 0;\n}\n\n/**\n * @param {object} options\n */\nfunction getTitleHeight(options, fallback) {\n  if (!options.display) {\n    return 0;\n  }\n\n  const font = toFont(options.font, fallback);\n  const padding = toPadding(options.padding);\n  const lines = isArray(options.text) ? options.text.length : 1;\n\n  return (lines * font.lineHeight) + padding.height;\n}\n\nfunction createScaleContext(parent, scale) {\n  return createContext(parent, {\n    scale,\n    type: 'scale'\n  });\n}\n\nfunction createTickContext(parent, index, tick) {\n  return createContext(parent, {\n    tick,\n    index,\n    type: 'tick'\n  });\n}\n\nfunction titleAlign(align, position, reverse) {\n  /** @type {CanvasTextAlign} */\n  let ret = _toLeftRightCenter(align);\n  if ((reverse && position !== 'right') || (!reverse && position === 'right')) {\n    ret = reverseAlign(ret);\n  }\n  return ret;\n}\n\nfunction titleArgs(scale, offset, position, align) {\n  const {top, left, bottom, right, chart} = scale;\n  const {chartArea, scales} = chart;\n  let rotation = 0;\n  let maxWidth, titleX, titleY;\n  const height = bottom - top;\n  const width = right - left;\n\n  if (scale.isHorizontal()) {\n    titleX = _alignStartEnd(align, left, right);\n\n    if (isObject(position)) {\n      const positionAxisID = Object.keys(position)[0];\n      const value = position[positionAxisID];\n      titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;\n    } else if (position === 'center') {\n      titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;\n    } else {\n      titleY = offsetFromEdge(scale, position, offset);\n    }\n    maxWidth = right - left;\n  } else {\n    if (isObject(position)) {\n      const positionAxisID = Object.keys(position)[0];\n      const value = position[positionAxisID];\n      titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;\n    } else if (position === 'center') {\n      titleX = (chartArea.left + chartArea.right) / 2 - width + offset;\n    } else {\n      titleX = offsetFromEdge(scale, position, offset);\n    }\n    titleY = _alignStartEnd(align, bottom, top);\n    rotation = position === 'left' ? -HALF_PI : HALF_PI;\n  }\n  return {titleX, titleY, maxWidth, rotation};\n}\n\nexport default class Scale extends Element {\n\n  // eslint-disable-next-line max-statements\n  constructor(cfg) {\n    super();\n\n    /** @type {string} */\n    this.id = cfg.id;\n    /** @type {string} */\n    this.type = cfg.type;\n    /** @type {any} */\n    this.options = undefined;\n    /** @type {CanvasRenderingContext2D} */\n    this.ctx = cfg.ctx;\n    /** @type {Chart} */\n    this.chart = cfg.chart;\n\n    // implements box\n    /** @type {number} */\n    this.top = undefined;\n    /** @type {number} */\n    this.bottom = undefined;\n    /** @type {number} */\n    this.left = undefined;\n    /** @type {number} */\n    this.right = undefined;\n    /** @type {number} */\n    this.width = undefined;\n    /** @type {number} */\n    this.height = undefined;\n    this._margins = {\n      left: 0,\n      right: 0,\n      top: 0,\n      bottom: 0\n    };\n    /** @type {number} */\n    this.maxWidth = undefined;\n    /** @type {number} */\n    this.maxHeight = undefined;\n    /** @type {number} */\n    this.paddingTop = undefined;\n    /** @type {number} */\n    this.paddingBottom = undefined;\n    /** @type {number} */\n    this.paddingLeft = undefined;\n    /** @type {number} */\n    this.paddingRight = undefined;\n\n    // scale-specific properties\n    /** @type {string=} */\n    this.axis = undefined;\n    /** @type {number=} */\n    this.labelRotation = undefined;\n    this.min = undefined;\n    this.max = undefined;\n    this._range = undefined;\n    /** @type {Tick[]} */\n    this.ticks = [];\n    /** @type {object[]|null} */\n    this._gridLineItems = null;\n    /** @type {object[]|null} */\n    this._labelItems = null;\n    /** @type {object|null} */\n    this._labelSizes = null;\n    this._length = 0;\n    this._maxLength = 0;\n    this._longestTextCache = {};\n    /** @type {number} */\n    this._startPixel = undefined;\n    /** @type {number} */\n    this._endPixel = undefined;\n    this._reversePixels = false;\n    this._userMax = undefined;\n    this._userMin = undefined;\n    this._suggestedMax = undefined;\n    this._suggestedMin = undefined;\n    this._ticksLength = 0;\n    this._borderValue = 0;\n    this._cache = {};\n    this._dataLimitsCached = false;\n    this.$context = undefined;\n  }\n\n  /**\n\t * @param {any} options\n\t * @since 3.0\n\t */\n  init(options) {\n    this.options = options.setContext(this.getContext());\n\n    this.axis = options.axis;\n\n    // parse min/max value, so we can properly determine min/max for other scales\n    this._userMin = this.parse(options.min);\n    this._userMax = this.parse(options.max);\n    this._suggestedMin = this.parse(options.suggestedMin);\n    this._suggestedMax = this.parse(options.suggestedMax);\n  }\n\n  /**\n\t * Parse a supported input value to internal representation.\n\t * @param {*} raw\n\t * @param {number} [index]\n\t * @since 3.0\n\t */\n  parse(raw, index) { // eslint-disable-line no-unused-vars\n    return raw;\n  }\n\n  /**\n\t * @return {{min: number, max: number, minDefined: boolean, maxDefined: boolean}}\n\t * @protected\n\t * @since 3.0\n\t */\n  getUserBounds() {\n    let {_userMin, _userMax, _suggestedMin, _suggestedMax} = this;\n    _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);\n    _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);\n    _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);\n    _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);\n    return {\n      min: finiteOrDefault(_userMin, _suggestedMin),\n      max: finiteOrDefault(_userMax, _suggestedMax),\n      minDefined: isFinite(_userMin),\n      maxDefined: isFinite(_userMax)\n    };\n  }\n\n  /**\n\t * @param {boolean} canStack\n\t * @return {{min: number, max: number}}\n\t * @protected\n\t * @since 3.0\n\t */\n  getMinMax(canStack) {\n    // eslint-disable-next-line prefer-const\n    let {min, max, minDefined, maxDefined} = this.getUserBounds();\n    let range;\n\n    if (minDefined && maxDefined) {\n      return {min, max};\n    }\n\n    const metas = this.getMatchingVisibleMetas();\n    for (let i = 0, ilen = metas.length; i < ilen; ++i) {\n      range = metas[i].controller.getMinMax(this, canStack);\n      if (!minDefined) {\n        min = Math.min(min, range.min);\n      }\n      if (!maxDefined) {\n        max = Math.max(max, range.max);\n      }\n    }\n\n    // Make sure min <= max when only min or max is defined by user and the data is outside that range\n    min = maxDefined && min > max ? max : min;\n    max = minDefined && min > max ? min : max;\n\n    return {\n      min: finiteOrDefault(min, finiteOrDefault(max, min)),\n      max: finiteOrDefault(max, finiteOrDefault(min, max))\n    };\n  }\n\n  /**\n\t * Get the padding needed for the scale\n\t * @return {{top: number, left: number, bottom: number, right: number}} the necessary padding\n\t * @private\n\t */\n  getPadding() {\n    return {\n      left: this.paddingLeft || 0,\n      top: this.paddingTop || 0,\n      right: this.paddingRight || 0,\n      bottom: this.paddingBottom || 0\n    };\n  }\n\n  /**\n\t * Returns the scale tick objects\n\t * @return {Tick[]}\n\t * @since 2.7\n\t */\n  getTicks() {\n    return this.ticks;\n  }\n\n  /**\n\t * @return {string[]}\n\t */\n  getLabels() {\n    const data = this.chart.data;\n    return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];\n  }\n\n  /**\n   * @return {import('../types.js').LabelItem[]}\n   */\n  getLabelItems(chartArea = this.chart.chartArea) {\n    const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));\n    return items;\n  }\n\n  // When a new layout is created, reset the data limits cache\n  beforeLayout() {\n    this._cache = {};\n    this._dataLimitsCached = false;\n  }\n\n  // These methods are ordered by lifecycle. Utilities then follow.\n  // Any function defined here is inherited by all scale types.\n  // Any function can be extended by the scale type\n\n  beforeUpdate() {\n    call(this.options.beforeUpdate, [this]);\n  }\n\n  /**\n\t * @param {number} maxWidth - the max width in pixels\n\t * @param {number} maxHeight - the max height in pixels\n\t * @param {{top: number, left: number, bottom: number, right: number}} margins - the space between the edge of the other scales and edge of the chart\n\t *   This space comes from two sources:\n\t *     - padding - space that's required to show the labels at the edges of the scale\n\t *     - thickness of scales or legends in another orientation\n\t */\n  update(maxWidth, maxHeight, margins) {\n    const {beginAtZero, grace, ticks: tickOpts} = this.options;\n    const sampleSize = tickOpts.sampleSize;\n\n    // Update Lifecycle - Probably don't want to ever extend or overwrite this function ;)\n    this.beforeUpdate();\n\n    // Absorb the master measurements\n    this.maxWidth = maxWidth;\n    this.maxHeight = maxHeight;\n    this._margins = margins = Object.assign({\n      left: 0,\n      right: 0,\n      top: 0,\n      bottom: 0\n    }, margins);\n\n    this.ticks = null;\n    this._labelSizes = null;\n    this._gridLineItems = null;\n    this._labelItems = null;\n\n    // Dimensions\n    this.beforeSetDimensions();\n    this.setDimensions();\n    this.afterSetDimensions();\n\n    this._maxLength = this.isHorizontal()\n      ? this.width + margins.left + margins.right\n      : this.height + margins.top + margins.bottom;\n\n    // Data min/max\n    if (!this._dataLimitsCached) {\n      this.beforeDataLimits();\n      this.determineDataLimits();\n      this.afterDataLimits();\n      this._range = _addGrace(this, grace, beginAtZero);\n      this._dataLimitsCached = true;\n    }\n\n    this.beforeBuildTicks();\n\n    this.ticks = this.buildTicks() || [];\n\n    // Allow modification of ticks in callback.\n    this.afterBuildTicks();\n\n    // Compute tick rotation and fit using a sampled subset of labels\n    // We generally don't need to compute the size of every single label for determining scale size\n    const samplingEnabled = sampleSize < this.ticks.length;\n    this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);\n\n    // configure is called twice, once here, once from core.controller.updateLayout.\n    // Here we haven't been positioned yet, but dimensions are correct.\n    // Variables set in configure are needed for calculateLabelRotation, and\n    // it's ok that coordinates are not correct there, only dimensions matter.\n    this.configure();\n\n    // Tick Rotation\n    this.beforeCalculateLabelRotation();\n    this.calculateLabelRotation(); // Preconditions: number of ticks and sizes of largest labels must be calculated beforehand\n    this.afterCalculateLabelRotation();\n\n    // Auto-skip\n    if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) {\n      this.ticks = autoSkip(this, this.ticks);\n      this._labelSizes = null;\n      this.afterAutoSkip();\n    }\n\n    if (samplingEnabled) {\n      // Generate labels using all non-skipped ticks\n      this._convertTicksToLabels(this.ticks);\n    }\n\n    this.beforeFit();\n    this.fit(); // Preconditions: label rotation and label sizes must be calculated beforehand\n    this.afterFit();\n\n    // IMPORTANT: after this point, we consider that `this.ticks` will NEVER change!\n\n    this.afterUpdate();\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    let reversePixels = this.options.reverse;\n    let startPixel, endPixel;\n\n    if (this.isHorizontal()) {\n      startPixel = this.left;\n      endPixel = this.right;\n    } else {\n      startPixel = this.top;\n      endPixel = this.bottom;\n      // by default vertical scales are from bottom to top, so pixels are reversed\n      reversePixels = !reversePixels;\n    }\n    this._startPixel = startPixel;\n    this._endPixel = endPixel;\n    this._reversePixels = reversePixels;\n    this._length = endPixel - startPixel;\n    this._alignToPixels = this.options.alignToPixels;\n  }\n\n  afterUpdate() {\n    call(this.options.afterUpdate, [this]);\n  }\n\n  //\n\n  beforeSetDimensions() {\n    call(this.options.beforeSetDimensions, [this]);\n  }\n  setDimensions() {\n    // Set the unconstrained dimension before label rotation\n    if (this.isHorizontal()) {\n      // Reset position before calculating rotation\n      this.width = this.maxWidth;\n      this.left = 0;\n      this.right = this.width;\n    } else {\n      this.height = this.maxHeight;\n\n      // Reset position before calculating rotation\n      this.top = 0;\n      this.bottom = this.height;\n    }\n\n    // Reset padding\n    this.paddingLeft = 0;\n    this.paddingTop = 0;\n    this.paddingRight = 0;\n    this.paddingBottom = 0;\n  }\n  afterSetDimensions() {\n    call(this.options.afterSetDimensions, [this]);\n  }\n\n  _callHooks(name) {\n    this.chart.notifyPlugins(name, this.getContext());\n    call(this.options[name], [this]);\n  }\n\n  // Data limits\n  beforeDataLimits() {\n    this._callHooks('beforeDataLimits');\n  }\n  determineDataLimits() {}\n  afterDataLimits() {\n    this._callHooks('afterDataLimits');\n  }\n\n  //\n  beforeBuildTicks() {\n    this._callHooks('beforeBuildTicks');\n  }\n  /**\n\t * @return {object[]} the ticks\n\t */\n  buildTicks() {\n    return [];\n  }\n  afterBuildTicks() {\n    this._callHooks('afterBuildTicks');\n  }\n\n  beforeTickToLabelConversion() {\n    call(this.options.beforeTickToLabelConversion, [this]);\n  }\n  /**\n\t * Convert ticks to label strings\n\t * @param {Tick[]} ticks\n\t */\n  generateTickLabels(ticks) {\n    const tickOpts = this.options.ticks;\n    let i, ilen, tick;\n    for (i = 0, ilen = ticks.length; i < ilen; i++) {\n      tick = ticks[i];\n      tick.label = call(tickOpts.callback, [tick.value, i, ticks], this);\n    }\n  }\n  afterTickToLabelConversion() {\n    call(this.options.afterTickToLabelConversion, [this]);\n  }\n\n  //\n\n  beforeCalculateLabelRotation() {\n    call(this.options.beforeCalculateLabelRotation, [this]);\n  }\n  calculateLabelRotation() {\n    const options = this.options;\n    const tickOpts = options.ticks;\n    const numTicks = getTicksLimit(this.ticks.length, options.ticks.maxTicksLimit);\n    const minRotation = tickOpts.minRotation || 0;\n    const maxRotation = tickOpts.maxRotation;\n    let labelRotation = minRotation;\n    let tickWidth, maxHeight, maxLabelDiagonal;\n\n    if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {\n      this.labelRotation = minRotation;\n      return;\n    }\n\n    const labelSizes = this._getLabelSizes();\n    const maxLabelWidth = labelSizes.widest.width;\n    const maxLabelHeight = labelSizes.highest.height;\n\n    // Estimate the width of each grid based on the canvas width, the maximum\n    // label width and the number of tick intervals\n    const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);\n    tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);\n\n    // Allow 3 pixels x2 padding either side for label readability\n    if (maxLabelWidth + 6 > tickWidth) {\n      tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));\n      maxHeight = this.maxHeight - getTickMarkLength(options.grid)\n\t\t\t\t- tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);\n      maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);\n      labelRotation = toDegrees(Math.min(\n        Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)),\n        Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))\n      ));\n      labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));\n    }\n\n    this.labelRotation = labelRotation;\n  }\n  afterCalculateLabelRotation() {\n    call(this.options.afterCalculateLabelRotation, [this]);\n  }\n  afterAutoSkip() {}\n\n  //\n\n  beforeFit() {\n    call(this.options.beforeFit, [this]);\n  }\n  fit() {\n    // Reset\n    const minSize = {\n      width: 0,\n      height: 0\n    };\n\n    const {chart, options: {ticks: tickOpts, title: titleOpts, grid: gridOpts}} = this;\n    const display = this._isVisible();\n    const isHorizontal = this.isHorizontal();\n\n    if (display) {\n      const titleHeight = getTitleHeight(titleOpts, chart.options.font);\n      if (isHorizontal) {\n        minSize.width = this.maxWidth;\n        minSize.height = getTickMarkLength(gridOpts) + titleHeight;\n      } else {\n        minSize.height = this.maxHeight; // fill all the height\n        minSize.width = getTickMarkLength(gridOpts) + titleHeight;\n      }\n\n      // Don't bother fitting the ticks if we are not showing the labels\n      if (tickOpts.display && this.ticks.length) {\n        const {first, last, widest, highest} = this._getLabelSizes();\n        const tickPadding = tickOpts.padding * 2;\n        const angleRadians = toRadians(this.labelRotation);\n        const cos = Math.cos(angleRadians);\n        const sin = Math.sin(angleRadians);\n\n        if (isHorizontal) {\n        // A horizontal axis is more constrained by the height.\n          const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;\n          minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);\n        } else {\n        // A vertical axis is more constrained by the width. Labels are the\n        // dominant factor here, so get that length first and account for padding\n          const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;\n\n          minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);\n        }\n        this._calculatePadding(first, last, sin, cos);\n      }\n    }\n\n    this._handleMargins();\n\n    if (isHorizontal) {\n      this.width = this._length = chart.width - this._margins.left - this._margins.right;\n      this.height = minSize.height;\n    } else {\n      this.width = minSize.width;\n      this.height = this._length = chart.height - this._margins.top - this._margins.bottom;\n    }\n  }\n\n  _calculatePadding(first, last, sin, cos) {\n    const {ticks: {align, padding}, position} = this.options;\n    const isRotated = this.labelRotation !== 0;\n    const labelsBelowTicks = position !== 'top' && this.axis === 'x';\n\n    if (this.isHorizontal()) {\n      const offsetLeft = this.getPixelForTick(0) - this.left;\n      const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);\n      let paddingLeft = 0;\n      let paddingRight = 0;\n\n      // Ensure that our ticks are always inside the canvas. When rotated, ticks are right aligned\n      // which means that the right padding is dominated by the font height\n      if (isRotated) {\n        if (labelsBelowTicks) {\n          paddingLeft = cos * first.width;\n          paddingRight = sin * last.height;\n        } else {\n          paddingLeft = sin * first.height;\n          paddingRight = cos * last.width;\n        }\n      } else if (align === 'start') {\n        paddingRight = last.width;\n      } else if (align === 'end') {\n        paddingLeft = first.width;\n      } else if (align !== 'inner') {\n        paddingLeft = first.width / 2;\n        paddingRight = last.width / 2;\n      }\n\n      // Adjust padding taking into account changes in offsets\n      this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);\n      this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);\n    } else {\n      let paddingTop = last.height / 2;\n      let paddingBottom = first.height / 2;\n\n      if (align === 'start') {\n        paddingTop = 0;\n        paddingBottom = first.height;\n      } else if (align === 'end') {\n        paddingTop = last.height;\n        paddingBottom = 0;\n      }\n\n      this.paddingTop = paddingTop + padding;\n      this.paddingBottom = paddingBottom + padding;\n    }\n  }\n\n  /**\n\t * Handle margins and padding interactions\n\t * @private\n\t */\n  _handleMargins() {\n    if (this._margins) {\n      this._margins.left = Math.max(this.paddingLeft, this._margins.left);\n      this._margins.top = Math.max(this.paddingTop, this._margins.top);\n      this._margins.right = Math.max(this.paddingRight, this._margins.right);\n      this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);\n    }\n  }\n\n  afterFit() {\n    call(this.options.afterFit, [this]);\n  }\n\n  // Shared Methods\n  /**\n\t * @return {boolean}\n\t */\n  isHorizontal() {\n    const {axis, position} = this.options;\n    return position === 'top' || position === 'bottom' || axis === 'x';\n  }\n  /**\n\t * @return {boolean}\n\t */\n  isFullSize() {\n    return this.options.fullSize;\n  }\n\n  /**\n\t * @param {Tick[]} ticks\n\t * @private\n\t */\n  _convertTicksToLabels(ticks) {\n    this.beforeTickToLabelConversion();\n\n    this.generateTickLabels(ticks);\n\n    // Ticks should be skipped when callback returns null or undef, so lets remove those.\n    let i, ilen;\n    for (i = 0, ilen = ticks.length; i < ilen; i++) {\n      if (isNullOrUndef(ticks[i].label)) {\n        ticks.splice(i, 1);\n        ilen--;\n        i--;\n      }\n    }\n\n    this.afterTickToLabelConversion();\n  }\n\n  /**\n\t * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}\n\t * @private\n\t */\n  _getLabelSizes() {\n    let labelSizes = this._labelSizes;\n\n    if (!labelSizes) {\n      const sampleSize = this.options.ticks.sampleSize;\n      let ticks = this.ticks;\n      if (sampleSize < ticks.length) {\n        ticks = sample(ticks, sampleSize);\n      }\n\n      this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length, this.options.ticks.maxTicksLimit);\n    }\n\n    return labelSizes;\n  }\n\n  /**\n\t * Returns {width, height, offset} objects for the first, last, widest, highest tick\n\t * labels where offset indicates the anchor point offset from the top in pixels.\n\t * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}\n\t * @private\n\t */\n  _computeLabelSizes(ticks, length, maxTicksLimit) {\n    const {ctx, _longestTextCache: caches} = this;\n    const widths = [];\n    const heights = [];\n    const increment = Math.floor(length / getTicksLimit(length, maxTicksLimit));\n    let widestLabelSize = 0;\n    let highestLabelSize = 0;\n    let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;\n\n    for (i = 0; i < length; i += increment) {\n      label = ticks[i].label;\n      tickFont = this._resolveTickFontOptions(i);\n      ctx.font = fontString = tickFont.string;\n      cache = caches[fontString] = caches[fontString] || {data: {}, gc: []};\n      lineHeight = tickFont.lineHeight;\n      width = height = 0;\n      // Undefined labels and arrays should not be measured\n      if (!isNullOrUndef(label) && !isArray(label)) {\n        width = _measureText(ctx, cache.data, cache.gc, width, label);\n        height = lineHeight;\n      } else if (isArray(label)) {\n        // if it is an array let's measure each element\n        for (j = 0, jlen = label.length; j < jlen; ++j) {\n          nestedLabel = /** @type {string} */ (label[j]);\n          // Undefined labels and arrays should not be measured\n          if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {\n            width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);\n            height += lineHeight;\n          }\n        }\n      }\n      widths.push(width);\n      heights.push(height);\n      widestLabelSize = Math.max(width, widestLabelSize);\n      highestLabelSize = Math.max(height, highestLabelSize);\n    }\n    garbageCollect(caches, length);\n\n    const widest = widths.indexOf(widestLabelSize);\n    const highest = heights.indexOf(highestLabelSize);\n\n    const valueAt = (idx) => ({width: widths[idx] || 0, height: heights[idx] || 0});\n\n    return {\n      first: valueAt(0),\n      last: valueAt(length - 1),\n      widest: valueAt(widest),\n      highest: valueAt(highest),\n      widths,\n      heights,\n    };\n  }\n\n  /**\n\t * Used to get the label to display in the tooltip for the given value\n\t * @param {*} value\n\t * @return {string}\n\t */\n  getLabelForValue(value) {\n    return value;\n  }\n\n  /**\n\t * Returns the location of the given data point. Value can either be an index or a numerical value\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {*} value\n\t * @param {number} [index]\n\t * @return {number}\n\t */\n  getPixelForValue(value, index) { // eslint-disable-line no-unused-vars\n    return NaN;\n  }\n\n  /**\n\t * Used to get the data value from a given pixel. This is the inverse of getPixelForValue\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {number} pixel\n\t * @return {*}\n\t */\n  getValueForPixel(pixel) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * Returns the location of the tick at the given index\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {number} index\n\t * @return {number}\n\t */\n  getPixelForTick(index) {\n    const ticks = this.ticks;\n    if (index < 0 || index > ticks.length - 1) {\n      return null;\n    }\n    return this.getPixelForValue(ticks[index].value);\n  }\n\n  /**\n\t * Utility for getting the pixel location of a percentage of scale\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {number} decimal\n\t * @return {number}\n\t */\n  getPixelForDecimal(decimal) {\n    if (this._reversePixels) {\n      decimal = 1 - decimal;\n    }\n\n    const pixel = this._startPixel + decimal * this._length;\n    return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);\n  }\n\n  /**\n\t * @param {number} pixel\n\t * @return {number}\n\t */\n  getDecimalForPixel(pixel) {\n    const decimal = (pixel - this._startPixel) / this._length;\n    return this._reversePixels ? 1 - decimal : decimal;\n  }\n\n  /**\n\t * Returns the pixel for the minimum chart value\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @return {number}\n\t */\n  getBasePixel() {\n    return this.getPixelForValue(this.getBaseValue());\n  }\n\n  /**\n\t * @return {number}\n\t */\n  getBaseValue() {\n    const {min, max} = this;\n\n    return min < 0 && max < 0 ? max :\n      min > 0 && max > 0 ? min :\n      0;\n  }\n\n  /**\n\t * @protected\n\t */\n  getContext(index) {\n    const ticks = this.ticks || [];\n\n    if (index >= 0 && index < ticks.length) {\n      const tick = ticks[index];\n      return tick.$context ||\n\t\t\t\t(tick.$context = createTickContext(this.getContext(), index, tick));\n    }\n    return this.$context ||\n\t\t\t(this.$context = createScaleContext(this.chart.getContext(), this));\n  }\n\n  /**\n\t * @return {number}\n\t * @private\n\t */\n  _tickSize() {\n    const optionTicks = this.options.ticks;\n\n    // Calculate space needed by label in axis direction.\n    const rot = toRadians(this.labelRotation);\n    const cos = Math.abs(Math.cos(rot));\n    const sin = Math.abs(Math.sin(rot));\n\n    const labelSizes = this._getLabelSizes();\n    const padding = optionTicks.autoSkipPadding || 0;\n    const w = labelSizes ? labelSizes.widest.width + padding : 0;\n    const h = labelSizes ? labelSizes.highest.height + padding : 0;\n\n    // Calculate space needed for 1 tick in axis direction.\n    return this.isHorizontal()\n      ? h * cos > w * sin ? w / cos : h / sin\n      : h * sin < w * cos ? h / cos : w / sin;\n  }\n\n  /**\n\t * @return {boolean}\n\t * @private\n\t */\n  _isVisible() {\n    const display = this.options.display;\n\n    if (display !== 'auto') {\n      return !!display;\n    }\n\n    return this.getMatchingVisibleMetas().length > 0;\n  }\n\n  /**\n\t * @private\n\t */\n  _computeGridLineItems(chartArea) {\n    const axis = this.axis;\n    const chart = this.chart;\n    const options = this.options;\n    const {grid, position, border} = options;\n    const offset = grid.offset;\n    const isHorizontal = this.isHorizontal();\n    const ticks = this.ticks;\n    const ticksLength = ticks.length + (offset ? 1 : 0);\n    const tl = getTickMarkLength(grid);\n    const items = [];\n\n    const borderOpts = border.setContext(this.getContext());\n    const axisWidth = borderOpts.display ? borderOpts.width : 0;\n    const axisHalfWidth = axisWidth / 2;\n    const alignBorderValue = function(pixel) {\n      return _alignPixel(chart, pixel, axisWidth);\n    };\n    let borderValue, i, lineValue, alignedLineValue;\n    let tx1, ty1, tx2, ty2, x1, y1, x2, y2;\n\n    if (position === 'top') {\n      borderValue = alignBorderValue(this.bottom);\n      ty1 = this.bottom - tl;\n      ty2 = borderValue - axisHalfWidth;\n      y1 = alignBorderValue(chartArea.top) + axisHalfWidth;\n      y2 = chartArea.bottom;\n    } else if (position === 'bottom') {\n      borderValue = alignBorderValue(this.top);\n      y1 = chartArea.top;\n      y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;\n      ty1 = borderValue + axisHalfWidth;\n      ty2 = this.top + tl;\n    } else if (position === 'left') {\n      borderValue = alignBorderValue(this.right);\n      tx1 = this.right - tl;\n      tx2 = borderValue - axisHalfWidth;\n      x1 = alignBorderValue(chartArea.left) + axisHalfWidth;\n      x2 = chartArea.right;\n    } else if (position === 'right') {\n      borderValue = alignBorderValue(this.left);\n      x1 = chartArea.left;\n      x2 = alignBorderValue(chartArea.right) - axisHalfWidth;\n      tx1 = borderValue + axisHalfWidth;\n      tx2 = this.left + tl;\n    } else if (axis === 'x') {\n      if (position === 'center') {\n        borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n      }\n\n      y1 = chartArea.top;\n      y2 = chartArea.bottom;\n      ty1 = borderValue + axisHalfWidth;\n      ty2 = ty1 + tl;\n    } else if (axis === 'y') {\n      if (position === 'center') {\n        borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n      }\n\n      tx1 = borderValue - axisHalfWidth;\n      tx2 = tx1 - tl;\n      x1 = chartArea.left;\n      x2 = chartArea.right;\n    }\n\n    const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);\n    const step = Math.max(1, Math.ceil(ticksLength / limit));\n    for (i = 0; i < ticksLength; i += step) {\n      const context = this.getContext(i);\n      const optsAtIndex = grid.setContext(context);\n      const optsAtIndexBorder = border.setContext(context);\n\n      const lineWidth = optsAtIndex.lineWidth;\n      const lineColor = optsAtIndex.color;\n      const borderDash = optsAtIndexBorder.dash || [];\n      const borderDashOffset = optsAtIndexBorder.dashOffset;\n\n      const tickWidth = optsAtIndex.tickWidth;\n      const tickColor = optsAtIndex.tickColor;\n      const tickBorderDash = optsAtIndex.tickBorderDash || [];\n      const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;\n\n      lineValue = getPixelForGridLine(this, i, offset);\n\n      // Skip if the pixel is out of the range\n      if (lineValue === undefined) {\n        continue;\n      }\n\n      alignedLineValue = _alignPixel(chart, lineValue, lineWidth);\n\n      if (isHorizontal) {\n        tx1 = tx2 = x1 = x2 = alignedLineValue;\n      } else {\n        ty1 = ty2 = y1 = y2 = alignedLineValue;\n      }\n\n      items.push({\n        tx1,\n        ty1,\n        tx2,\n        ty2,\n        x1,\n        y1,\n        x2,\n        y2,\n        width: lineWidth,\n        color: lineColor,\n        borderDash,\n        borderDashOffset,\n        tickWidth,\n        tickColor,\n        tickBorderDash,\n        tickBorderDashOffset,\n      });\n    }\n\n    this._ticksLength = ticksLength;\n    this._borderValue = borderValue;\n\n    return items;\n  }\n\n  /**\n\t * @private\n\t */\n  _computeLabelItems(chartArea) {\n    const axis = this.axis;\n    const options = this.options;\n    const {position, ticks: optionTicks} = options;\n    const isHorizontal = this.isHorizontal();\n    const ticks = this.ticks;\n    const {align, crossAlign, padding, mirror} = optionTicks;\n    const tl = getTickMarkLength(options.grid);\n    const tickAndPadding = tl + padding;\n    const hTickAndPadding = mirror ? -padding : tickAndPadding;\n    const rotation = -toRadians(this.labelRotation);\n    const items = [];\n    let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;\n    let textBaseline = 'middle';\n\n    if (position === 'top') {\n      y = this.bottom - hTickAndPadding;\n      textAlign = this._getXAxisLabelAlignment();\n    } else if (position === 'bottom') {\n      y = this.top + hTickAndPadding;\n      textAlign = this._getXAxisLabelAlignment();\n    } else if (position === 'left') {\n      const ret = this._getYAxisLabelAlignment(tl);\n      textAlign = ret.textAlign;\n      x = ret.x;\n    } else if (position === 'right') {\n      const ret = this._getYAxisLabelAlignment(tl);\n      textAlign = ret.textAlign;\n      x = ret.x;\n    } else if (axis === 'x') {\n      if (position === 'center') {\n        y = ((chartArea.top + chartArea.bottom) / 2) + tickAndPadding;\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;\n      }\n      textAlign = this._getXAxisLabelAlignment();\n    } else if (axis === 'y') {\n      if (position === 'center') {\n        x = ((chartArea.left + chartArea.right) / 2) - tickAndPadding;\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        x = this.chart.scales[positionAxisID].getPixelForValue(value);\n      }\n      textAlign = this._getYAxisLabelAlignment(tl).textAlign;\n    }\n\n    if (axis === 'y') {\n      if (align === 'start') {\n        textBaseline = 'top';\n      } else if (align === 'end') {\n        textBaseline = 'bottom';\n      }\n    }\n\n    const labelSizes = this._getLabelSizes();\n    for (i = 0, ilen = ticks.length; i < ilen; ++i) {\n      tick = ticks[i];\n      label = tick.label;\n\n      const optsAtIndex = optionTicks.setContext(this.getContext(i));\n      pixel = this.getPixelForTick(i) + optionTicks.labelOffset;\n      font = this._resolveTickFontOptions(i);\n      lineHeight = font.lineHeight;\n      lineCount = isArray(label) ? label.length : 1;\n      const halfCount = lineCount / 2;\n      const color = optsAtIndex.color;\n      const strokeColor = optsAtIndex.textStrokeColor;\n      const strokeWidth = optsAtIndex.textStrokeWidth;\n      let tickTextAlign = textAlign;\n\n      if (isHorizontal) {\n        x = pixel;\n\n        if (textAlign === 'inner') {\n          if (i === ilen - 1) {\n            tickTextAlign = !this.options.reverse ? 'right' : 'left';\n          } else if (i === 0) {\n            tickTextAlign = !this.options.reverse ? 'left' : 'right';\n          } else {\n            tickTextAlign = 'center';\n          }\n        }\n\n        if (position === 'top') {\n          if (crossAlign === 'near' || rotation !== 0) {\n            textOffset = -lineCount * lineHeight + lineHeight / 2;\n          } else if (crossAlign === 'center') {\n            textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;\n          } else {\n            textOffset = -labelSizes.highest.height + lineHeight / 2;\n          }\n        } else {\n          // eslint-disable-next-line no-lonely-if\n          if (crossAlign === 'near' || rotation !== 0) {\n            textOffset = lineHeight / 2;\n          } else if (crossAlign === 'center') {\n            textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;\n          } else {\n            textOffset = labelSizes.highest.height - lineCount * lineHeight;\n          }\n        }\n        if (mirror) {\n          textOffset *= -1;\n        }\n        if (rotation !== 0 && !optsAtIndex.showLabelBackdrop) {\n          x += (lineHeight / 2) * Math.sin(rotation);\n        }\n      } else {\n        y = pixel;\n        textOffset = (1 - lineCount) * lineHeight / 2;\n      }\n\n      let backdrop;\n\n      if (optsAtIndex.showLabelBackdrop) {\n        const labelPadding = toPadding(optsAtIndex.backdropPadding);\n        const height = labelSizes.heights[i];\n        const width = labelSizes.widths[i];\n\n        let top = textOffset - labelPadding.top;\n        let left = 0 - labelPadding.left;\n\n        switch (textBaseline) {\n        case 'middle':\n          top -= height / 2;\n          break;\n        case 'bottom':\n          top -= height;\n          break;\n        default:\n          break;\n        }\n\n        switch (textAlign) {\n        case 'center':\n          left -= width / 2;\n          break;\n        case 'right':\n          left -= width;\n          break;\n        case 'inner':\n          if (i === ilen - 1) {\n            left -= width;\n          } else if (i > 0) {\n            left -= width / 2;\n          }\n          break;\n        default:\n          break;\n        }\n\n        backdrop = {\n          left,\n          top,\n          width: width + labelPadding.width,\n          height: height + labelPadding.height,\n\n          color: optsAtIndex.backdropColor,\n        };\n      }\n\n      items.push({\n        label,\n        font,\n        textOffset,\n        options: {\n          rotation,\n          color,\n          strokeColor,\n          strokeWidth,\n          textAlign: tickTextAlign,\n          textBaseline,\n          translation: [x, y],\n          backdrop,\n        }\n      });\n    }\n\n    return items;\n  }\n\n  _getXAxisLabelAlignment() {\n    const {position, ticks} = this.options;\n    const rotation = -toRadians(this.labelRotation);\n\n    if (rotation) {\n      return position === 'top' ? 'left' : 'right';\n    }\n\n    let align = 'center';\n\n    if (ticks.align === 'start') {\n      align = 'left';\n    } else if (ticks.align === 'end') {\n      align = 'right';\n    } else if (ticks.align === 'inner') {\n      align = 'inner';\n    }\n\n    return align;\n  }\n\n  _getYAxisLabelAlignment(tl) {\n    const {position, ticks: {crossAlign, mirror, padding}} = this.options;\n    const labelSizes = this._getLabelSizes();\n    const tickAndPadding = tl + padding;\n    const widest = labelSizes.widest.width;\n\n    let textAlign;\n    let x;\n\n    if (position === 'left') {\n      if (mirror) {\n        x = this.right + padding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'left';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x += (widest / 2);\n        } else {\n          textAlign = 'right';\n          x += widest;\n        }\n      } else {\n        x = this.right - tickAndPadding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'right';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x -= (widest / 2);\n        } else {\n          textAlign = 'left';\n          x = this.left;\n        }\n      }\n    } else if (position === 'right') {\n      if (mirror) {\n        x = this.left + padding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'right';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x -= (widest / 2);\n        } else {\n          textAlign = 'left';\n          x -= widest;\n        }\n      } else {\n        x = this.left + tickAndPadding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'left';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x += widest / 2;\n        } else {\n          textAlign = 'right';\n          x = this.right;\n        }\n      }\n    } else {\n      textAlign = 'right';\n    }\n\n    return {textAlign, x};\n  }\n\n  /**\n\t * @private\n\t */\n  _computeLabelArea() {\n    if (this.options.ticks.mirror) {\n      return;\n    }\n\n    const chart = this.chart;\n    const position = this.options.position;\n\n    if (position === 'left' || position === 'right') {\n      return {top: 0, left: this.left, bottom: chart.height, right: this.right};\n    } if (position === 'top' || position === 'bottom') {\n      return {top: this.top, left: 0, bottom: this.bottom, right: chart.width};\n    }\n  }\n\n  /**\n   * @protected\n   */\n  drawBackground() {\n    const {ctx, options: {backgroundColor}, left, top, width, height} = this;\n    if (backgroundColor) {\n      ctx.save();\n      ctx.fillStyle = backgroundColor;\n      ctx.fillRect(left, top, width, height);\n      ctx.restore();\n    }\n  }\n\n  getLineWidthForValue(value) {\n    const grid = this.options.grid;\n    if (!this._isVisible() || !grid.display) {\n      return 0;\n    }\n    const ticks = this.ticks;\n    const index = ticks.findIndex(t => t.value === value);\n    if (index >= 0) {\n      const opts = grid.setContext(this.getContext(index));\n      return opts.lineWidth;\n    }\n    return 0;\n  }\n\n  /**\n\t * @protected\n\t */\n  drawGrid(chartArea) {\n    const grid = this.options.grid;\n    const ctx = this.ctx;\n    const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));\n    let i, ilen;\n\n    const drawLine = (p1, p2, style) => {\n      if (!style.width || !style.color) {\n        return;\n      }\n      ctx.save();\n      ctx.lineWidth = style.width;\n      ctx.strokeStyle = style.color;\n      ctx.setLineDash(style.borderDash || []);\n      ctx.lineDashOffset = style.borderDashOffset;\n\n      ctx.beginPath();\n      ctx.moveTo(p1.x, p1.y);\n      ctx.lineTo(p2.x, p2.y);\n      ctx.stroke();\n      ctx.restore();\n    };\n\n    if (grid.display) {\n      for (i = 0, ilen = items.length; i < ilen; ++i) {\n        const item = items[i];\n\n        if (grid.drawOnChartArea) {\n          drawLine(\n            {x: item.x1, y: item.y1},\n            {x: item.x2, y: item.y2},\n            item\n          );\n        }\n\n        if (grid.drawTicks) {\n          drawLine(\n            {x: item.tx1, y: item.ty1},\n            {x: item.tx2, y: item.ty2},\n            {\n              color: item.tickColor,\n              width: item.tickWidth,\n              borderDash: item.tickBorderDash,\n              borderDashOffset: item.tickBorderDashOffset\n            }\n          );\n        }\n      }\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawBorder() {\n    const {chart, ctx, options: {border, grid}} = this;\n    const borderOpts = border.setContext(this.getContext());\n    const axisWidth = border.display ? borderOpts.width : 0;\n    if (!axisWidth) {\n      return;\n    }\n    const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;\n    const borderValue = this._borderValue;\n    let x1, x2, y1, y2;\n\n    if (this.isHorizontal()) {\n      x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;\n      x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;\n      y1 = y2 = borderValue;\n    } else {\n      y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;\n      y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;\n      x1 = x2 = borderValue;\n    }\n    ctx.save();\n    ctx.lineWidth = borderOpts.width;\n    ctx.strokeStyle = borderOpts.color;\n\n    ctx.beginPath();\n    ctx.moveTo(x1, y1);\n    ctx.lineTo(x2, y2);\n    ctx.stroke();\n\n    ctx.restore();\n  }\n\n  /**\n\t * @protected\n\t */\n  drawLabels(chartArea) {\n    const optionTicks = this.options.ticks;\n\n    if (!optionTicks.display) {\n      return;\n    }\n\n    const ctx = this.ctx;\n\n    const area = this._computeLabelArea();\n    if (area) {\n      clipArea(ctx, area);\n    }\n\n    const items = this.getLabelItems(chartArea);\n    for (const item of items) {\n      const renderTextOptions = item.options;\n      const tickFont = item.font;\n      const label = item.label;\n      const y = item.textOffset;\n      renderText(ctx, label, 0, y, tickFont, renderTextOptions);\n    }\n\n    if (area) {\n      unclipArea(ctx);\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawTitle() {\n    const {ctx, options: {position, title, reverse}} = this;\n\n    if (!title.display) {\n      return;\n    }\n\n    const font = toFont(title.font);\n    const padding = toPadding(title.padding);\n    const align = title.align;\n    let offset = font.lineHeight / 2;\n\n    if (position === 'bottom' || position === 'center' || isObject(position)) {\n      offset += padding.bottom;\n      if (isArray(title.text)) {\n        offset += font.lineHeight * (title.text.length - 1);\n      }\n    } else {\n      offset += padding.top;\n    }\n\n    const {titleX, titleY, maxWidth, rotation} = titleArgs(this, offset, position, align);\n\n    renderText(ctx, title.text, 0, 0, font, {\n      color: title.color,\n      maxWidth,\n      rotation,\n      textAlign: titleAlign(align, position, reverse),\n      textBaseline: 'middle',\n      translation: [titleX, titleY],\n    });\n  }\n\n  draw(chartArea) {\n    if (!this._isVisible()) {\n      return;\n    }\n\n    this.drawBackground();\n    this.drawGrid(chartArea);\n    this.drawBorder();\n    this.drawTitle();\n    this.drawLabels(chartArea);\n  }\n\n  /**\n\t * @return {object[]}\n\t * @private\n\t */\n  _layers() {\n    const opts = this.options;\n    const tz = opts.ticks && opts.ticks.z || 0;\n    const gz = valueOrDefault(opts.grid && opts.grid.z, -1);\n    const bz = valueOrDefault(opts.border && opts.border.z, 0);\n\n    if (!this._isVisible() || this.draw !== Scale.prototype.draw) {\n      // backward compatibility: draw has been overridden by custom scale\n      return [{\n        z: tz,\n        draw: (chartArea) => {\n          this.draw(chartArea);\n        }\n      }];\n    }\n\n    return [{\n      z: gz,\n      draw: (chartArea) => {\n        this.drawBackground();\n        this.drawGrid(chartArea);\n        this.drawTitle();\n      }\n    }, {\n      z: bz,\n      draw: () => {\n        this.drawBorder();\n      }\n    }, {\n      z: tz,\n      draw: (chartArea) => {\n        this.drawLabels(chartArea);\n      }\n    }];\n  }\n\n  /**\n\t * Returns visible dataset metas that are attached to this scale\n\t * @param {string} [type] - if specified, also filter by dataset type\n\t * @return {object[]}\n\t */\n  getMatchingVisibleMetas(type) {\n    const metas = this.chart.getSortedVisibleDatasetMetas();\n    const axisID = this.axis + 'AxisID';\n    const result = [];\n    let i, ilen;\n\n    for (i = 0, ilen = metas.length; i < ilen; ++i) {\n      const meta = metas[i];\n      if (meta[axisID] === this.id && (!type || meta.type === type)) {\n        result.push(meta);\n      }\n    }\n    return result;\n  }\n\n  /**\n\t * @param {number} index\n\t * @return {object}\n\t * @protected\n \t */\n  _resolveTickFontOptions(index) {\n    const opts = this.options.ticks.setContext(this.getContext(index));\n    return toFont(opts.font);\n  }\n\n  /**\n   * @protected\n   */\n  _maxDigits() {\n    const fontSize = this._resolveTickFontOptions(0).lineHeight;\n    return (this.isHorizontal() ? this.width : this.height) / fontSize;\n  }\n}\n","import {merge} from '../helpers/index.js';\nimport defaults, {overrides} from './core.defaults.js';\n\n/**\n * @typedef {{id: string, defaults: any, overrides?: any, defaultRoutes: any}} IChartComponent\n */\n\nexport default class TypedRegistry {\n  constructor(type, scope, override) {\n    this.type = type;\n    this.scope = scope;\n    this.override = override;\n    this.items = Object.create(null);\n  }\n\n  isForType(type) {\n    return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);\n  }\n\n  /**\n\t * @param {IChartComponent} item\n\t * @returns {string} The scope where items defaults were registered to.\n\t */\n  register(item) {\n    const proto = Object.getPrototypeOf(item);\n    let parentScope;\n\n    if (isIChartComponent(proto)) {\n      // Make sure the parent is registered and note the scope where its defaults are.\n      parentScope = this.register(proto);\n    }\n\n    const items = this.items;\n    const id = item.id;\n    const scope = this.scope + '.' + id;\n\n    if (!id) {\n      throw new Error('class does not have id: ' + item);\n    }\n\n    if (id in items) {\n      // already registered\n      return scope;\n    }\n\n    items[id] = item;\n    registerDefaults(item, scope, parentScope);\n    if (this.override) {\n      defaults.override(item.id, item.overrides);\n    }\n\n    return scope;\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {object?}\n\t */\n  get(id) {\n    return this.items[id];\n  }\n\n  /**\n\t * @param {IChartComponent} item\n\t */\n  unregister(item) {\n    const items = this.items;\n    const id = item.id;\n    const scope = this.scope;\n\n    if (id in items) {\n      delete items[id];\n    }\n\n    if (scope && id in defaults[scope]) {\n      delete defaults[scope][id];\n      if (this.override) {\n        delete overrides[id];\n      }\n    }\n  }\n}\n\nfunction registerDefaults(item, scope, parentScope) {\n  // Inherit the parent's defaults and keep existing defaults\n  const itemDefaults = merge(Object.create(null), [\n    parentScope ? defaults.get(parentScope) : {},\n    defaults.get(scope),\n    item.defaults\n  ]);\n\n  defaults.set(scope, itemDefaults);\n\n  if (item.defaultRoutes) {\n    routeDefaults(scope, item.defaultRoutes);\n  }\n\n  if (item.descriptors) {\n    defaults.describe(scope, item.descriptors);\n  }\n}\n\nfunction routeDefaults(scope, routes) {\n  Object.keys(routes).forEach(property => {\n    const propertyParts = property.split('.');\n    const sourceName = propertyParts.pop();\n    const sourceScope = [scope].concat(propertyParts).join('.');\n    const parts = routes[property].split('.');\n    const targetName = parts.pop();\n    const targetScope = parts.join('.');\n    defaults.route(sourceScope, sourceName, targetScope, targetName);\n  });\n}\n\nfunction isIChartComponent(proto) {\n  return 'id' in proto && 'defaults' in proto;\n}\n","import DatasetController from './core.datasetController.js';\nimport Element from './core.element.js';\nimport Scale from './core.scale.js';\nimport TypedRegistry from './core.typedRegistry.js';\nimport {each, callback as call, _capitalize} from '../helpers/helpers.core.js';\n\n/**\n * Please use the module's default export which provides a singleton instance\n * Note: class is exported for typedoc\n */\nexport class Registry {\n  constructor() {\n    this.controllers = new TypedRegistry(DatasetController, 'datasets', true);\n    this.elements = new TypedRegistry(Element, 'elements');\n    this.plugins = new TypedRegistry(Object, 'plugins');\n    this.scales = new TypedRegistry(Scale, 'scales');\n    // Order is important, Scale has Element in prototype chain,\n    // so Scales must be before Elements. Plugins are a fallback, so not listed here.\n    this._typedRegistries = [this.controllers, this.scales, this.elements];\n  }\n\n  /**\n\t * @param  {...any} args\n\t */\n  add(...args) {\n    this._each('register', args);\n  }\n\n  remove(...args) {\n    this._each('unregister', args);\n  }\n\n  /**\n\t * @param  {...typeof DatasetController} args\n\t */\n  addControllers(...args) {\n    this._each('register', args, this.controllers);\n  }\n\n  /**\n\t * @param  {...typeof Element} args\n\t */\n  addElements(...args) {\n    this._each('register', args, this.elements);\n  }\n\n  /**\n\t * @param  {...any} args\n\t */\n  addPlugins(...args) {\n    this._each('register', args, this.plugins);\n  }\n\n  /**\n\t * @param  {...typeof Scale} args\n\t */\n  addScales(...args) {\n    this._each('register', args, this.scales);\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {typeof DatasetController}\n\t */\n  getController(id) {\n    return this._get(id, this.controllers, 'controller');\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {typeof Element}\n\t */\n  getElement(id) {\n    return this._get(id, this.elements, 'element');\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {object}\n\t */\n  getPlugin(id) {\n    return this._get(id, this.plugins, 'plugin');\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {typeof Scale}\n\t */\n  getScale(id) {\n    return this._get(id, this.scales, 'scale');\n  }\n\n  /**\n\t * @param  {...typeof DatasetController} args\n\t */\n  removeControllers(...args) {\n    this._each('unregister', args, this.controllers);\n  }\n\n  /**\n\t * @param  {...typeof Element} args\n\t */\n  removeElements(...args) {\n    this._each('unregister', args, this.elements);\n  }\n\n  /**\n\t * @param  {...any} args\n\t */\n  removePlugins(...args) {\n    this._each('unregister', args, this.plugins);\n  }\n\n  /**\n\t * @param  {...typeof Scale} args\n\t */\n  removeScales(...args) {\n    this._each('unregister', args, this.scales);\n  }\n\n  /**\n\t * @private\n\t */\n  _each(method, args, typedRegistry) {\n    [...args].forEach(arg => {\n      const reg = typedRegistry || this._getRegistryForType(arg);\n      if (typedRegistry || reg.isForType(arg) || (reg === this.plugins && arg.id)) {\n        this._exec(method, reg, arg);\n      } else {\n        // Handle loopable args\n        // Use case:\n        //  import * as plugins from './plugins.js';\n        //  Chart.register(plugins);\n        each(arg, item => {\n          // If there are mixed types in the loopable, make sure those are\n          // registered in correct registry\n          // Use case: (treemap exporting controller, elements etc)\n          //  import * as treemap from 'chartjs-chart-treemap.js';\n          //  Chart.register(treemap);\n\n          const itemReg = typedRegistry || this._getRegistryForType(item);\n          this._exec(method, itemReg, item);\n        });\n      }\n    });\n  }\n\n  /**\n\t * @private\n\t */\n  _exec(method, registry, component) {\n    const camelMethod = _capitalize(method);\n    call(component['before' + camelMethod], [], component); // beforeRegister / beforeUnregister\n    registry[method](component);\n    call(component['after' + camelMethod], [], component); // afterRegister / afterUnregister\n  }\n\n  /**\n\t * @private\n\t */\n  _getRegistryForType(type) {\n    for (let i = 0; i < this._typedRegistries.length; i++) {\n      const reg = this._typedRegistries[i];\n      if (reg.isForType(type)) {\n        return reg;\n      }\n    }\n    // plugins is the fallback registry\n    return this.plugins;\n  }\n\n  /**\n\t * @private\n\t */\n  _get(id, typedRegistry, type) {\n    const item = typedRegistry.get(id);\n    if (item === undefined) {\n      throw new Error('\"' + id + '\" is not a registered ' + type + '.');\n    }\n    return item;\n  }\n\n}\n\n// singleton instance\nexport default /* #__PURE__ */ new Registry();\n","import registry from './core.registry.js';\nimport {callback as callCallback, isNullOrUndef, valueOrDefault} from '../helpers/helpers.core.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef { import('../plugins/plugin.tooltip.js').default } Tooltip\n */\n\n/**\n * @callback filterCallback\n * @param {{plugin: object, options: object}} value\n * @param {number} [index]\n * @param {array} [array]\n * @param {object} [thisArg]\n * @return {boolean}\n */\n\n\nexport default class PluginService {\n  constructor() {\n    this._init = [];\n  }\n\n  /**\n\t * Calls enabled plugins for `chart` on the specified hook and with the given args.\n\t * This method immediately returns as soon as a plugin explicitly returns false. The\n\t * returned value can be used, for instance, to interrupt the current action.\n\t * @param {Chart} chart - The chart instance for which plugins should be called.\n\t * @param {string} hook - The name of the plugin method to call (e.g. 'beforeUpdate').\n\t * @param {object} [args] - Extra arguments to apply to the hook call.\n   * @param {filterCallback} [filter] - Filtering function for limiting which plugins are notified\n\t * @returns {boolean} false if any of the plugins return false, else returns true.\n\t */\n  notify(chart, hook, args, filter) {\n    if (hook === 'beforeInit') {\n      this._init = this._createDescriptors(chart, true);\n      this._notify(this._init, chart, 'install');\n    }\n\n    const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);\n    const result = this._notify(descriptors, chart, hook, args);\n\n    if (hook === 'afterDestroy') {\n      this._notify(descriptors, chart, 'stop');\n      this._notify(this._init, chart, 'uninstall');\n    }\n    return result;\n  }\n\n  /**\n\t * @private\n\t */\n  _notify(descriptors, chart, hook, args) {\n    args = args || {};\n    for (const descriptor of descriptors) {\n      const plugin = descriptor.plugin;\n      const method = plugin[hook];\n      const params = [chart, args, descriptor.options];\n      if (callCallback(method, params, plugin) === false && args.cancelable) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  invalidate() {\n    // When plugins are registered, there is the possibility of a double\n    // invalidate situation. In this case, we only want to invalidate once.\n    // If we invalidate multiple times, the `_oldCache` is lost and all of the\n    // plugins are restarted without being correctly stopped.\n    // See https://github.com/chartjs/Chart.js/issues/8147\n    if (!isNullOrUndef(this._cache)) {\n      this._oldCache = this._cache;\n      this._cache = undefined;\n    }\n  }\n\n  /**\n\t * @param {Chart} chart\n\t * @private\n\t */\n  _descriptors(chart) {\n    if (this._cache) {\n      return this._cache;\n    }\n\n    const descriptors = this._cache = this._createDescriptors(chart);\n\n    this._notifyStateChanges(chart);\n\n    return descriptors;\n  }\n\n  _createDescriptors(chart, all) {\n    const config = chart && chart.config;\n    const options = valueOrDefault(config.options && config.options.plugins, {});\n    const plugins = allPlugins(config);\n    // options === false => all plugins are disabled\n    return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);\n  }\n\n  /**\n\t * @param {Chart} chart\n\t * @private\n\t */\n  _notifyStateChanges(chart) {\n    const previousDescriptors = this._oldCache || [];\n    const descriptors = this._cache;\n    const diff = (a, b) => a.filter(x => !b.some(y => x.plugin.id === y.plugin.id));\n    this._notify(diff(previousDescriptors, descriptors), chart, 'stop');\n    this._notify(diff(descriptors, previousDescriptors), chart, 'start');\n  }\n}\n\n/**\n * @param {import('./core.config.js').default} config\n */\nfunction allPlugins(config) {\n  const localIds = {};\n  const plugins = [];\n  const keys = Object.keys(registry.plugins.items);\n  for (let i = 0; i < keys.length; i++) {\n    plugins.push(registry.getPlugin(keys[i]));\n  }\n\n  const local = config.plugins || [];\n  for (let i = 0; i < local.length; i++) {\n    const plugin = local[i];\n\n    if (plugins.indexOf(plugin) === -1) {\n      plugins.push(plugin);\n      localIds[plugin.id] = true;\n    }\n  }\n\n  return {plugins, localIds};\n}\n\nfunction getOpts(options, all) {\n  if (!all && options === false) {\n    return null;\n  }\n  if (options === true) {\n    return {};\n  }\n  return options;\n}\n\nfunction createDescriptors(chart, {plugins, localIds}, options, all) {\n  const result = [];\n  const context = chart.getContext();\n\n  for (const plugin of plugins) {\n    const id = plugin.id;\n    const opts = getOpts(options[id], all);\n    if (opts === null) {\n      continue;\n    }\n    result.push({\n      plugin,\n      options: pluginOpts(chart.config, {plugin, local: localIds[id]}, opts, context)\n    });\n  }\n\n  return result;\n}\n\nfunction pluginOpts(config, {plugin, local}, opts, context) {\n  const keys = config.pluginScopeKeys(plugin);\n  const scopes = config.getOptionScopes(opts, keys);\n  if (local && plugin.defaults) {\n    // make sure plugin defaults are in scopes for local (not registered) plugins\n    scopes.push(plugin.defaults);\n  }\n  return config.createResolver(scopes, context, [''], {\n    // These are just defaults that plugins can override\n    scriptable: false,\n    indexable: false,\n    allKeys: true\n  });\n}\n","import defaults, {overrides, descriptors} from './core.defaults.js';\nimport {mergeIf, resolveObjectKey, isArray, isFunction, valueOrDefault, isObject} from '../helpers/helpers.core.js';\nimport {_attachContext, _createResolver, _descriptors} from '../helpers/helpers.config.js';\n\nexport function getIndexAxis(type, options) {\n  const datasetDefaults = defaults.datasets[type] || {};\n  const datasetOptions = (options.datasets || {})[type] || {};\n  return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x';\n}\n\nfunction getAxisFromDefaultScaleID(id, indexAxis) {\n  let axis = id;\n  if (id === '_index_') {\n    axis = indexAxis;\n  } else if (id === '_value_') {\n    axis = indexAxis === 'x' ? 'y' : 'x';\n  }\n  return axis;\n}\n\nfunction getDefaultScaleIDFromAxis(axis, indexAxis) {\n  return axis === indexAxis ? '_index_' : '_value_';\n}\n\nfunction idMatchesAxis(id) {\n  if (id === 'x' || id === 'y' || id === 'r') {\n    return id;\n  }\n}\n\nfunction axisFromPosition(position) {\n  if (position === 'top' || position === 'bottom') {\n    return 'x';\n  }\n  if (position === 'left' || position === 'right') {\n    return 'y';\n  }\n}\n\nexport function determineAxis(id, ...scaleOptions) {\n  if (idMatchesAxis(id)) {\n    return id;\n  }\n  for (const opts of scaleOptions) {\n    const axis = opts.axis\n      || axisFromPosition(opts.position)\n      || id.length > 1 && idMatchesAxis(id[0].toLowerCase());\n    if (axis) {\n      return axis;\n    }\n  }\n  throw new Error(`Cannot determine type of '${id}' axis. Please provide 'axis' or 'position' option.`);\n}\n\nfunction getAxisFromDataset(id, axis, dataset) {\n  if (dataset[axis + 'AxisID'] === id) {\n    return {axis};\n  }\n}\n\nfunction retrieveAxisFromDatasets(id, config) {\n  if (config.data && config.data.datasets) {\n    const boundDs = config.data.datasets.filter((d) => d.xAxisID === id || d.yAxisID === id);\n    if (boundDs.length) {\n      return getAxisFromDataset(id, 'x', boundDs[0]) || getAxisFromDataset(id, 'y', boundDs[0]);\n    }\n  }\n  return {};\n}\n\nfunction mergeScaleConfig(config, options) {\n  const chartDefaults = overrides[config.type] || {scales: {}};\n  const configScales = options.scales || {};\n  const chartIndexAxis = getIndexAxis(config.type, options);\n  const scales = Object.create(null);\n\n  // First figure out first scale id's per axis.\n  Object.keys(configScales).forEach(id => {\n    const scaleConf = configScales[id];\n    if (!isObject(scaleConf)) {\n      return console.error(`Invalid scale configuration for scale: ${id}`);\n    }\n    if (scaleConf._proxy) {\n      return console.warn(`Ignoring resolver passed as options for scale: ${id}`);\n    }\n    const axis = determineAxis(id, scaleConf, retrieveAxisFromDatasets(id, config), defaults.scales[scaleConf.type]);\n    const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);\n    const defaultScaleOptions = chartDefaults.scales || {};\n    scales[id] = mergeIf(Object.create(null), [{axis}, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]);\n  });\n\n  // Then merge dataset defaults to scale configs\n  config.data.datasets.forEach(dataset => {\n    const type = dataset.type || config.type;\n    const indexAxis = dataset.indexAxis || getIndexAxis(type, options);\n    const datasetDefaults = overrides[type] || {};\n    const defaultScaleOptions = datasetDefaults.scales || {};\n    Object.keys(defaultScaleOptions).forEach(defaultID => {\n      const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);\n      const id = dataset[axis + 'AxisID'] || axis;\n      scales[id] = scales[id] || Object.create(null);\n      mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]);\n    });\n  });\n\n  // apply scale defaults, if not overridden by dataset defaults\n  Object.keys(scales).forEach(key => {\n    const scale = scales[key];\n    mergeIf(scale, [defaults.scales[scale.type], defaults.scale]);\n  });\n\n  return scales;\n}\n\nfunction initOptions(config) {\n  const options = config.options || (config.options = {});\n\n  options.plugins = valueOrDefault(options.plugins, {});\n  options.scales = mergeScaleConfig(config, options);\n}\n\nfunction initData(data) {\n  data = data || {};\n  data.datasets = data.datasets || [];\n  data.labels = data.labels || [];\n  return data;\n}\n\nfunction initConfig(config) {\n  config = config || {};\n  config.data = initData(config.data);\n\n  initOptions(config);\n\n  return config;\n}\n\nconst keyCache = new Map();\nconst keysCached = new Set();\n\nfunction cachedKeys(cacheKey, generate) {\n  let keys = keyCache.get(cacheKey);\n  if (!keys) {\n    keys = generate();\n    keyCache.set(cacheKey, keys);\n    keysCached.add(keys);\n  }\n  return keys;\n}\n\nconst addIfFound = (set, obj, key) => {\n  const opts = resolveObjectKey(obj, key);\n  if (opts !== undefined) {\n    set.add(opts);\n  }\n};\n\nexport default class Config {\n  constructor(config) {\n    this._config = initConfig(config);\n    this._scopeCache = new Map();\n    this._resolverCache = new Map();\n  }\n\n  get platform() {\n    return this._config.platform;\n  }\n\n  get type() {\n    return this._config.type;\n  }\n\n  set type(type) {\n    this._config.type = type;\n  }\n\n  get data() {\n    return this._config.data;\n  }\n\n  set data(data) {\n    this._config.data = initData(data);\n  }\n\n  get options() {\n    return this._config.options;\n  }\n\n  set options(options) {\n    this._config.options = options;\n  }\n\n  get plugins() {\n    return this._config.plugins;\n  }\n\n  update() {\n    const config = this._config;\n    this.clearCache();\n    initOptions(config);\n  }\n\n  clearCache() {\n    this._scopeCache.clear();\n    this._resolverCache.clear();\n  }\n\n  /**\n   * Returns the option scope keys for resolving dataset options.\n   * These keys do not include the dataset itself, because it is not under options.\n   * @param {string} datasetType\n   * @return {string[][]}\n   */\n  datasetScopeKeys(datasetType) {\n    return cachedKeys(datasetType,\n      () => [[\n        `datasets.${datasetType}`,\n        ''\n      ]]);\n  }\n\n  /**\n   * Returns the option scope keys for resolving dataset animation options.\n   * These keys do not include the dataset itself, because it is not under options.\n   * @param {string} datasetType\n   * @param {string} transition\n   * @return {string[][]}\n   */\n  datasetAnimationScopeKeys(datasetType, transition) {\n    return cachedKeys(`${datasetType}.transition.${transition}`,\n      () => [\n        [\n          `datasets.${datasetType}.transitions.${transition}`,\n          `transitions.${transition}`,\n        ],\n        // The following are used for looking up the `animations` and `animation` keys\n        [\n          `datasets.${datasetType}`,\n          ''\n        ]\n      ]);\n  }\n\n  /**\n   * Returns the options scope keys for resolving element options that belong\n   * to an dataset. These keys do not include the dataset itself, because it\n   * is not under options.\n   * @param {string} datasetType\n   * @param {string} elementType\n   * @return {string[][]}\n   */\n  datasetElementScopeKeys(datasetType, elementType) {\n    return cachedKeys(`${datasetType}-${elementType}`,\n      () => [[\n        `datasets.${datasetType}.elements.${elementType}`,\n        `datasets.${datasetType}`,\n        `elements.${elementType}`,\n        ''\n      ]]);\n  }\n\n  /**\n   * Returns the options scope keys for resolving plugin options.\n   * @param {{id: string, additionalOptionScopes?: string[]}} plugin\n   * @return {string[][]}\n   */\n  pluginScopeKeys(plugin) {\n    const id = plugin.id;\n    const type = this.type;\n    return cachedKeys(`${type}-plugin-${id}`,\n      () => [[\n        `plugins.${id}`,\n        ...plugin.additionalOptionScopes || [],\n      ]]);\n  }\n\n  /**\n   * @private\n   */\n  _cachedScopes(mainScope, resetCache) {\n    const _scopeCache = this._scopeCache;\n    let cache = _scopeCache.get(mainScope);\n    if (!cache || resetCache) {\n      cache = new Map();\n      _scopeCache.set(mainScope, cache);\n    }\n    return cache;\n  }\n\n  /**\n   * Resolves the objects from options and defaults for option value resolution.\n   * @param {object} mainScope - The main scope object for options\n   * @param {string[][]} keyLists - The arrays of keys in resolution order\n   * @param {boolean} [resetCache] - reset the cache for this mainScope\n   */\n  getOptionScopes(mainScope, keyLists, resetCache) {\n    const {options, type} = this;\n    const cache = this._cachedScopes(mainScope, resetCache);\n    const cached = cache.get(keyLists);\n    if (cached) {\n      return cached;\n    }\n\n    const scopes = new Set();\n\n    keyLists.forEach(keys => {\n      if (mainScope) {\n        scopes.add(mainScope);\n        keys.forEach(key => addIfFound(scopes, mainScope, key));\n      }\n      keys.forEach(key => addIfFound(scopes, options, key));\n      keys.forEach(key => addIfFound(scopes, overrides[type] || {}, key));\n      keys.forEach(key => addIfFound(scopes, defaults, key));\n      keys.forEach(key => addIfFound(scopes, descriptors, key));\n    });\n\n    const array = Array.from(scopes);\n    if (array.length === 0) {\n      array.push(Object.create(null));\n    }\n    if (keysCached.has(keyLists)) {\n      cache.set(keyLists, array);\n    }\n    return array;\n  }\n\n  /**\n   * Returns the option scopes for resolving chart options\n   * @return {object[]}\n   */\n  chartOptionScopes() {\n    const {options, type} = this;\n\n    return [\n      options,\n      overrides[type] || {},\n      defaults.datasets[type] || {}, // https://github.com/chartjs/Chart.js/issues/8531\n      {type},\n      defaults,\n      descriptors\n    ];\n  }\n\n  /**\n   * @param {object[]} scopes\n   * @param {string[]} names\n   * @param {function|object} context\n   * @param {string[]} [prefixes]\n   * @return {object}\n   */\n  resolveNamedOptions(scopes, names, context, prefixes = ['']) {\n    const result = {$shared: true};\n    const {resolver, subPrefixes} = getResolver(this._resolverCache, scopes, prefixes);\n    let options = resolver;\n    if (needContext(resolver, names)) {\n      result.$shared = false;\n      context = isFunction(context) ? context() : context;\n      // subResolver is passed to scriptable options. It should not resolve to hover options.\n      const subResolver = this.createResolver(scopes, context, subPrefixes);\n      options = _attachContext(resolver, context, subResolver);\n    }\n\n    for (const prop of names) {\n      result[prop] = options[prop];\n    }\n    return result;\n  }\n\n  /**\n   * @param {object[]} scopes\n   * @param {object} [context]\n   * @param {string[]} [prefixes]\n   * @param {{scriptable: boolean, indexable: boolean, allKeys?: boolean}} [descriptorDefaults]\n   */\n  createResolver(scopes, context, prefixes = [''], descriptorDefaults) {\n    const {resolver} = getResolver(this._resolverCache, scopes, prefixes);\n    return isObject(context)\n      ? _attachContext(resolver, context, undefined, descriptorDefaults)\n      : resolver;\n  }\n}\n\nfunction getResolver(resolverCache, scopes, prefixes) {\n  let cache = resolverCache.get(scopes);\n  if (!cache) {\n    cache = new Map();\n    resolverCache.set(scopes, cache);\n  }\n  const cacheKey = prefixes.join();\n  let cached = cache.get(cacheKey);\n  if (!cached) {\n    const resolver = _createResolver(scopes, prefixes);\n    cached = {\n      resolver,\n      subPrefixes: prefixes.filter(p => !p.toLowerCase().includes('hover'))\n    };\n    cache.set(cacheKey, cached);\n  }\n  return cached;\n}\n\nconst hasFunction = value => isObject(value)\n  && Object.getOwnPropertyNames(value).some((key) => isFunction(value[key]));\n\nfunction needContext(proxy, names) {\n  const {isScriptable, isIndexable} = _descriptors(proxy);\n\n  for (const prop of names) {\n    const scriptable = isScriptable(prop);\n    const indexable = isIndexable(prop);\n    const value = (indexable || scriptable) && proxy[prop];\n    if ((scriptable && (isFunction(value) || hasFunction(value)))\n      || (indexable && isArray(value))) {\n      return true;\n    }\n  }\n  return false;\n}\n","import animator from './core.animator.js';\nimport defaults, {overrides} from './core.defaults.js';\nimport Interaction from './core.interaction.js';\nimport layouts from './core.layouts.js';\nimport {_detectPlatform} from '../platform/index.js';\nimport PluginService from './core.plugins.js';\nimport registry from './core.registry.js';\nimport Config, {determineAxis, getIndexAxis} from './core.config.js';\nimport {retinaScale, _isDomSupported} from '../helpers/helpers.dom.js';\nimport {each, callback as callCallback, uid, valueOrDefault, _elementsEqual, isNullOrUndef, setsEqual, defined, isFunction, _isClickEvent} from '../helpers/helpers.core.js';\nimport {clearCanvas, clipArea, createContext, unclipArea, _isPointInArea} from '../helpers/index.js';\n// @ts-ignore\nimport {version} from '../../package.json';\nimport {debounce} from '../helpers/helpers.extras.js';\n\n/**\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef { import('../types/index.js').Point } Point\n */\n\nconst KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea'];\nfunction positionIsHorizontal(position, axis) {\n  return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x');\n}\n\nfunction compare2Level(l1, l2) {\n  return function(a, b) {\n    return a[l1] === b[l1]\n      ? a[l2] - b[l2]\n      : a[l1] - b[l1];\n  };\n}\n\nfunction onAnimationsComplete(context) {\n  const chart = context.chart;\n  const animationOptions = chart.options.animation;\n\n  chart.notifyPlugins('afterRender');\n  callCallback(animationOptions && animationOptions.onComplete, [context], chart);\n}\n\nfunction onAnimationProgress(context) {\n  const chart = context.chart;\n  const animationOptions = chart.options.animation;\n  callCallback(animationOptions && animationOptions.onProgress, [context], chart);\n}\n\n/**\n * Chart.js can take a string id of a canvas element, a 2d context, or a canvas element itself.\n * Attempt to unwrap the item passed into the chart constructor so that it is a canvas element (if possible).\n */\nfunction getCanvas(item) {\n  if (_isDomSupported() && typeof item === 'string') {\n    item = document.getElementById(item);\n  } else if (item && item.length) {\n    // Support for array based queries (such as jQuery)\n    item = item[0];\n  }\n\n  if (item && item.canvas) {\n    // Support for any object associated to a canvas (including a context2d)\n    item = item.canvas;\n  }\n  return item;\n}\n\nconst instances = {};\nconst getChart = (key) => {\n  const canvas = getCanvas(key);\n  return Object.values(instances).filter((c) => c.canvas === canvas).pop();\n};\n\nfunction moveNumericKeys(obj, start, move) {\n  const keys = Object.keys(obj);\n  for (const key of keys) {\n    const intKey = +key;\n    if (intKey >= start) {\n      const value = obj[key];\n      delete obj[key];\n      if (move > 0 || intKey > start) {\n        obj[intKey + move] = value;\n      }\n    }\n  }\n}\n\n/**\n * @param {ChartEvent} e\n * @param {ChartEvent|null} lastEvent\n * @param {boolean} inChartArea\n * @param {boolean} isClick\n * @returns {ChartEvent|null}\n */\nfunction determineLastEvent(e, lastEvent, inChartArea, isClick) {\n  if (!inChartArea || e.type === 'mouseout') {\n    return null;\n  }\n  if (isClick) {\n    return lastEvent;\n  }\n  return e;\n}\n\nfunction getSizeForArea(scale, chartArea, field) {\n  return scale.options.clip ? scale[field] : chartArea[field];\n}\n\nfunction getDatasetArea(meta, chartArea) {\n  const {xScale, yScale} = meta;\n  if (xScale && yScale) {\n    return {\n      left: getSizeForArea(xScale, chartArea, 'left'),\n      right: getSizeForArea(xScale, chartArea, 'right'),\n      top: getSizeForArea(yScale, chartArea, 'top'),\n      bottom: getSizeForArea(yScale, chartArea, 'bottom')\n    };\n  }\n  return chartArea;\n}\n\nclass Chart {\n\n  static defaults = defaults;\n  static instances = instances;\n  static overrides = overrides;\n  static registry = registry;\n  static version = version;\n  static getChart = getChart;\n\n  static register(...items) {\n    registry.add(...items);\n    invalidatePlugins();\n  }\n\n  static unregister(...items) {\n    registry.remove(...items);\n    invalidatePlugins();\n  }\n\n  // eslint-disable-next-line max-statements\n  constructor(item, userConfig) {\n    const config = this.config = new Config(userConfig);\n    const initialCanvas = getCanvas(item);\n    const existingChart = getChart(initialCanvas);\n    if (existingChart) {\n      throw new Error(\n        'Canvas is already in use. Chart with ID \\'' + existingChart.id + '\\'' +\n\t\t\t\t' must be destroyed before the canvas with ID \\'' + existingChart.canvas.id + '\\' can be reused.'\n      );\n    }\n\n    const options = config.createResolver(config.chartOptionScopes(), this.getContext());\n\n    this.platform = new (config.platform || _detectPlatform(initialCanvas))();\n    this.platform.updateConfig(config);\n\n    const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);\n    const canvas = context && context.canvas;\n    const height = canvas && canvas.height;\n    const width = canvas && canvas.width;\n\n    this.id = uid();\n    this.ctx = context;\n    this.canvas = canvas;\n    this.width = width;\n    this.height = height;\n    this._options = options;\n    // Store the previously used aspect ratio to determine if a resize\n    // is needed during updates. Do this after _options is set since\n    // aspectRatio uses a getter\n    this._aspectRatio = this.aspectRatio;\n    this._layers = [];\n    this._metasets = [];\n    this._stacks = undefined;\n    this.boxes = [];\n    this.currentDevicePixelRatio = undefined;\n    this.chartArea = undefined;\n    this._active = [];\n    this._lastEvent = undefined;\n    this._listeners = {};\n    /** @type {?{attach?: function, detach?: function, resize?: function}} */\n    this._responsiveListeners = undefined;\n    this._sortedMetasets = [];\n    this.scales = {};\n    this._plugins = new PluginService();\n    this.$proxies = {};\n    this._hiddenIndices = {};\n    this.attached = false;\n    this._animationsDisabled = undefined;\n    this.$context = undefined;\n    this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0);\n    this._dataChanges = [];\n\n    // Add the chart instance to the global namespace\n    instances[this.id] = this;\n\n    if (!context || !canvas) {\n      // The given item is not a compatible context2d element, let's return before finalizing\n      // the chart initialization but after setting basic chart / controller properties that\n      // can help to figure out that the chart is not valid (e.g chart.canvas !== null);\n      // https://github.com/chartjs/Chart.js/issues/2807\n      console.error(\"Failed to create chart: can't acquire context from the given item\");\n      return;\n    }\n\n    animator.listen(this, 'complete', onAnimationsComplete);\n    animator.listen(this, 'progress', onAnimationProgress);\n\n    this._initialize();\n    if (this.attached) {\n      this.update();\n    }\n  }\n\n  get aspectRatio() {\n    const {options: {aspectRatio, maintainAspectRatio}, width, height, _aspectRatio} = this;\n    if (!isNullOrUndef(aspectRatio)) {\n      // If aspectRatio is defined in options, use that.\n      return aspectRatio;\n    }\n\n    if (maintainAspectRatio && _aspectRatio) {\n      // If maintainAspectRatio is truthly and we had previously determined _aspectRatio, use that\n      return _aspectRatio;\n    }\n\n    // Calculate\n    return height ? width / height : null;\n  }\n\n  get data() {\n    return this.config.data;\n  }\n\n  set data(data) {\n    this.config.data = data;\n  }\n\n  get options() {\n    return this._options;\n  }\n\n  set options(options) {\n    this.config.options = options;\n  }\n\n  get registry() {\n    return registry;\n  }\n\n  /**\n\t * @private\n\t */\n  _initialize() {\n    // Before init plugin notification\n    this.notifyPlugins('beforeInit');\n\n    if (this.options.responsive) {\n      this.resize();\n    } else {\n      retinaScale(this, this.options.devicePixelRatio);\n    }\n\n    this.bindEvents();\n\n    // After init plugin notification\n    this.notifyPlugins('afterInit');\n\n    return this;\n  }\n\n  clear() {\n    clearCanvas(this.canvas, this.ctx);\n    return this;\n  }\n\n  stop() {\n    animator.stop(this);\n    return this;\n  }\n\n  /**\n\t * Resize the chart to its container or to explicit dimensions.\n\t * @param {number} [width]\n\t * @param {number} [height]\n\t */\n  resize(width, height) {\n    if (!animator.running(this)) {\n      this._resize(width, height);\n    } else {\n      this._resizeBeforeDraw = {width, height};\n    }\n  }\n\n  _resize(width, height) {\n    const options = this.options;\n    const canvas = this.canvas;\n    const aspectRatio = options.maintainAspectRatio && this.aspectRatio;\n    const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);\n    const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();\n    const mode = this.width ? 'resize' : 'attach';\n\n    this.width = newSize.width;\n    this.height = newSize.height;\n    this._aspectRatio = this.aspectRatio;\n    if (!retinaScale(this, newRatio, true)) {\n      return;\n    }\n\n    this.notifyPlugins('resize', {size: newSize});\n\n    callCallback(options.onResize, [this, newSize], this);\n\n    if (this.attached) {\n      if (this._doResize(mode)) {\n        // The resize update is delayed, only draw without updating.\n        this.render();\n      }\n    }\n  }\n\n  ensureScalesHaveIDs() {\n    const options = this.options;\n    const scalesOptions = options.scales || {};\n\n    each(scalesOptions, (axisOptions, axisID) => {\n      axisOptions.id = axisID;\n    });\n  }\n\n  /**\n\t * Builds a map of scale ID to scale object for future lookup.\n\t */\n  buildOrUpdateScales() {\n    const options = this.options;\n    const scaleOpts = options.scales;\n    const scales = this.scales;\n    const updated = Object.keys(scales).reduce((obj, id) => {\n      obj[id] = false;\n      return obj;\n    }, {});\n    let items = [];\n\n    if (scaleOpts) {\n      items = items.concat(\n        Object.keys(scaleOpts).map((id) => {\n          const scaleOptions = scaleOpts[id];\n          const axis = determineAxis(id, scaleOptions);\n          const isRadial = axis === 'r';\n          const isHorizontal = axis === 'x';\n          return {\n            options: scaleOptions,\n            dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left',\n            dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear'\n          };\n        })\n      );\n    }\n\n    each(items, (item) => {\n      const scaleOptions = item.options;\n      const id = scaleOptions.id;\n      const axis = determineAxis(id, scaleOptions);\n      const scaleType = valueOrDefault(scaleOptions.type, item.dtype);\n\n      if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {\n        scaleOptions.position = item.dposition;\n      }\n\n      updated[id] = true;\n      let scale = null;\n      if (id in scales && scales[id].type === scaleType) {\n        scale = scales[id];\n      } else {\n        const scaleClass = registry.getScale(scaleType);\n        scale = new scaleClass({\n          id,\n          type: scaleType,\n          ctx: this.ctx,\n          chart: this\n        });\n        scales[scale.id] = scale;\n      }\n\n      scale.init(scaleOptions, options);\n    });\n    // clear up discarded scales\n    each(updated, (hasUpdated, id) => {\n      if (!hasUpdated) {\n        delete scales[id];\n      }\n    });\n\n    each(scales, (scale) => {\n      layouts.configure(this, scale, scale.options);\n      layouts.addBox(this, scale);\n    });\n  }\n\n  /**\n\t * @private\n\t */\n  _updateMetasets() {\n    const metasets = this._metasets;\n    const numData = this.data.datasets.length;\n    const numMeta = metasets.length;\n\n    metasets.sort((a, b) => a.index - b.index);\n    if (numMeta > numData) {\n      for (let i = numData; i < numMeta; ++i) {\n        this._destroyDatasetMeta(i);\n      }\n      metasets.splice(numData, numMeta - numData);\n    }\n    this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index'));\n  }\n\n  /**\n\t * @private\n\t */\n  _removeUnreferencedMetasets() {\n    const {_metasets: metasets, data: {datasets}} = this;\n    if (metasets.length > datasets.length) {\n      delete this._stacks;\n    }\n    metasets.forEach((meta, index) => {\n      if (datasets.filter(x => x === meta._dataset).length === 0) {\n        this._destroyDatasetMeta(index);\n      }\n    });\n  }\n\n  buildOrUpdateControllers() {\n    const newControllers = [];\n    const datasets = this.data.datasets;\n    let i, ilen;\n\n    this._removeUnreferencedMetasets();\n\n    for (i = 0, ilen = datasets.length; i < ilen; i++) {\n      const dataset = datasets[i];\n      let meta = this.getDatasetMeta(i);\n      const type = dataset.type || this.config.type;\n\n      if (meta.type && meta.type !== type) {\n        this._destroyDatasetMeta(i);\n        meta = this.getDatasetMeta(i);\n      }\n      meta.type = type;\n      meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);\n      meta.order = dataset.order || 0;\n      meta.index = i;\n      meta.label = '' + dataset.label;\n      meta.visible = this.isDatasetVisible(i);\n\n      if (meta.controller) {\n        meta.controller.updateIndex(i);\n        meta.controller.linkScales();\n      } else {\n        const ControllerClass = registry.getController(type);\n        const {datasetElementType, dataElementType} = defaults.datasets[type];\n        Object.assign(ControllerClass, {\n          dataElementType: registry.getElement(dataElementType),\n          datasetElementType: datasetElementType && registry.getElement(datasetElementType)\n        });\n        meta.controller = new ControllerClass(this, i);\n        newControllers.push(meta.controller);\n      }\n    }\n\n    this._updateMetasets();\n    return newControllers;\n  }\n\n  /**\n\t * Reset the elements of all datasets\n\t * @private\n\t */\n  _resetElements() {\n    each(this.data.datasets, (dataset, datasetIndex) => {\n      this.getDatasetMeta(datasetIndex).controller.reset();\n    }, this);\n  }\n\n  /**\n\t* Resets the chart back to its state before the initial animation\n\t*/\n  reset() {\n    this._resetElements();\n    this.notifyPlugins('reset');\n  }\n\n  update(mode) {\n    const config = this.config;\n\n    config.update();\n    const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());\n    const animsDisabled = this._animationsDisabled = !options.animation;\n\n    this._updateScales();\n    this._checkEventBindings();\n    this._updateHiddenIndices();\n\n    // plugins options references might have change, let's invalidate the cache\n    // https://github.com/chartjs/Chart.js/issues/5111#issuecomment-355934167\n    this._plugins.invalidate();\n\n    if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) {\n      return;\n    }\n\n    // Make sure dataset controllers are updated and new controllers are reset\n    const newControllers = this.buildOrUpdateControllers();\n\n    this.notifyPlugins('beforeElementsUpdate');\n\n    // Make sure all dataset controllers have correct meta data counts\n    let minPadding = 0;\n    for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) {\n      const {controller} = this.getDatasetMeta(i);\n      const reset = !animsDisabled && newControllers.indexOf(controller) === -1;\n      // New controllers will be reset after the layout pass, so we only want to modify\n      // elements added to new datasets\n      controller.buildOrUpdateElements(reset);\n      minPadding = Math.max(+controller.getMaxOverflow(), minPadding);\n    }\n    minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;\n    this._updateLayout(minPadding);\n\n    // Only reset the controllers if we have animations\n    if (!animsDisabled) {\n      // Can only reset the new controllers after the scales have been updated\n      // Reset is done to get the starting point for the initial animation\n      each(newControllers, (controller) => {\n        controller.reset();\n      });\n    }\n\n    this._updateDatasets(mode);\n\n    // Do this before render so that any plugins that need final scale updates can use it\n    this.notifyPlugins('afterUpdate', {mode});\n\n    this._layers.sort(compare2Level('z', '_idx'));\n\n    // Replay last event from before update, or set hover styles on active elements\n    const {_active, _lastEvent} = this;\n    if (_lastEvent) {\n      this._eventHandler(_lastEvent, true);\n    } else if (_active.length) {\n      this._updateHoverStyles(_active, _active, true);\n    }\n\n    this.render();\n  }\n\n  /**\n   * @private\n   */\n  _updateScales() {\n    each(this.scales, (scale) => {\n      layouts.removeBox(this, scale);\n    });\n\n    this.ensureScalesHaveIDs();\n    this.buildOrUpdateScales();\n  }\n\n  /**\n   * @private\n   */\n  _checkEventBindings() {\n    const options = this.options;\n    const existingEvents = new Set(Object.keys(this._listeners));\n    const newEvents = new Set(options.events);\n\n    if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {\n      // The configured events have changed. Rebind.\n      this.unbindEvents();\n      this.bindEvents();\n    }\n  }\n\n  /**\n   * @private\n   */\n  _updateHiddenIndices() {\n    const {_hiddenIndices} = this;\n    const changes = this._getUniformDataChanges() || [];\n    for (const {method, start, count} of changes) {\n      const move = method === '_removeElements' ? -count : count;\n      moveNumericKeys(_hiddenIndices, start, move);\n    }\n  }\n\n  /**\n   * @private\n   */\n  _getUniformDataChanges() {\n    const _dataChanges = this._dataChanges;\n    if (!_dataChanges || !_dataChanges.length) {\n      return;\n    }\n\n    this._dataChanges = [];\n    const datasetCount = this.data.datasets.length;\n    const makeSet = (idx) => new Set(\n      _dataChanges\n        .filter(c => c[0] === idx)\n        .map((c, i) => i + ',' + c.splice(1).join(','))\n    );\n\n    const changeSet = makeSet(0);\n    for (let i = 1; i < datasetCount; i++) {\n      if (!setsEqual(changeSet, makeSet(i))) {\n        return;\n      }\n    }\n    return Array.from(changeSet)\n      .map(c => c.split(','))\n      .map(a => ({method: a[1], start: +a[2], count: +a[3]}));\n  }\n\n  /**\n\t * Updates the chart layout unless a plugin returns `false` to the `beforeLayout`\n\t * hook, in which case, plugins will not be called on `afterLayout`.\n\t * @private\n\t */\n  _updateLayout(minPadding) {\n    if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) {\n      return;\n    }\n\n    layouts.update(this, this.width, this.height, minPadding);\n\n    const area = this.chartArea;\n    const noArea = area.width <= 0 || area.height <= 0;\n\n    this._layers = [];\n    each(this.boxes, (box) => {\n      if (noArea && box.position === 'chartArea') {\n        // Skip drawing and configuring chartArea boxes when chartArea is zero or negative\n        return;\n      }\n\n      // configure is called twice, once in core.scale.update and once here.\n      // Here the boxes are fully updated and at their final positions.\n      if (box.configure) {\n        box.configure();\n      }\n      this._layers.push(...box._layers());\n    }, this);\n\n    this._layers.forEach((item, index) => {\n      item._idx = index;\n    });\n\n    this.notifyPlugins('afterLayout');\n  }\n\n  /**\n\t * Updates all datasets unless a plugin returns `false` to the `beforeDatasetsUpdate`\n\t * hook, in which case, plugins will not be called on `afterDatasetsUpdate`.\n\t * @private\n\t */\n  _updateDatasets(mode) {\n    if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) {\n      return;\n    }\n\n    for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n      this.getDatasetMeta(i).controller.configure();\n    }\n\n    for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n      this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode);\n    }\n\n    this.notifyPlugins('afterDatasetsUpdate', {mode});\n  }\n\n  /**\n\t * Updates dataset at index unless a plugin returns `false` to the `beforeDatasetUpdate`\n\t * hook, in which case, plugins will not be called on `afterDatasetUpdate`.\n\t * @private\n\t */\n  _updateDataset(index, mode) {\n    const meta = this.getDatasetMeta(index);\n    const args = {meta, index, mode, cancelable: true};\n\n    if (this.notifyPlugins('beforeDatasetUpdate', args) === false) {\n      return;\n    }\n\n    meta.controller._update(mode);\n\n    args.cancelable = false;\n    this.notifyPlugins('afterDatasetUpdate', args);\n  }\n\n  render() {\n    if (this.notifyPlugins('beforeRender', {cancelable: true}) === false) {\n      return;\n    }\n\n    if (animator.has(this)) {\n      if (this.attached && !animator.running(this)) {\n        animator.start(this);\n      }\n    } else {\n      this.draw();\n      onAnimationsComplete({chart: this});\n    }\n  }\n\n  draw() {\n    let i;\n    if (this._resizeBeforeDraw) {\n      const {width, height} = this._resizeBeforeDraw;\n      this._resize(width, height);\n      this._resizeBeforeDraw = null;\n    }\n    this.clear();\n\n    if (this.width <= 0 || this.height <= 0) {\n      return;\n    }\n\n    if (this.notifyPlugins('beforeDraw', {cancelable: true}) === false) {\n      return;\n    }\n\n    // Because of plugin hooks (before/afterDatasetsDraw), datasets can't\n    // currently be part of layers. Instead, we draw\n    // layers <= 0 before(default, backward compat), and the rest after\n    const layers = this._layers;\n    for (i = 0; i < layers.length && layers[i].z <= 0; ++i) {\n      layers[i].draw(this.chartArea);\n    }\n\n    this._drawDatasets();\n\n    // Rest of layers\n    for (; i < layers.length; ++i) {\n      layers[i].draw(this.chartArea);\n    }\n\n    this.notifyPlugins('afterDraw');\n  }\n\n  /**\n\t * @private\n\t */\n  _getSortedDatasetMetas(filterVisible) {\n    const metasets = this._sortedMetasets;\n    const result = [];\n    let i, ilen;\n\n    for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n      const meta = metasets[i];\n      if (!filterVisible || meta.visible) {\n        result.push(meta);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n\t * Gets the visible dataset metas in drawing order\n\t * @return {object[]}\n\t */\n  getSortedVisibleDatasetMetas() {\n    return this._getSortedDatasetMetas(true);\n  }\n\n  /**\n\t * Draws all datasets unless a plugin returns `false` to the `beforeDatasetsDraw`\n\t * hook, in which case, plugins will not be called on `afterDatasetsDraw`.\n\t * @private\n\t */\n  _drawDatasets() {\n    if (this.notifyPlugins('beforeDatasetsDraw', {cancelable: true}) === false) {\n      return;\n    }\n\n    const metasets = this.getSortedVisibleDatasetMetas();\n    for (let i = metasets.length - 1; i >= 0; --i) {\n      this._drawDataset(metasets[i]);\n    }\n\n    this.notifyPlugins('afterDatasetsDraw');\n  }\n\n  /**\n\t * Draws dataset at index unless a plugin returns `false` to the `beforeDatasetDraw`\n\t * hook, in which case, plugins will not be called on `afterDatasetDraw`.\n\t * @private\n\t */\n  _drawDataset(meta) {\n    const ctx = this.ctx;\n    const clip = meta._clip;\n    const useClip = !clip.disabled;\n    const area = getDatasetArea(meta, this.chartArea);\n    const args = {\n      meta,\n      index: meta.index,\n      cancelable: true\n    };\n\n    if (this.notifyPlugins('beforeDatasetDraw', args) === false) {\n      return;\n    }\n\n    if (useClip) {\n      clipArea(ctx, {\n        left: clip.left === false ? 0 : area.left - clip.left,\n        right: clip.right === false ? this.width : area.right + clip.right,\n        top: clip.top === false ? 0 : area.top - clip.top,\n        bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom\n      });\n    }\n\n    meta.controller.draw();\n\n    if (useClip) {\n      unclipArea(ctx);\n    }\n\n    args.cancelable = false;\n    this.notifyPlugins('afterDatasetDraw', args);\n  }\n\n  /**\n   * Checks whether the given point is in the chart area.\n   * @param {Point} point - in relative coordinates (see, e.g., getRelativePosition)\n   * @returns {boolean}\n   */\n  isPointInArea(point) {\n    return _isPointInArea(point, this.chartArea, this._minPadding);\n  }\n\n  getElementsAtEventForMode(e, mode, options, useFinalPosition) {\n    const method = Interaction.modes[mode];\n    if (typeof method === 'function') {\n      return method(this, e, options, useFinalPosition);\n    }\n\n    return [];\n  }\n\n  getDatasetMeta(datasetIndex) {\n    const dataset = this.data.datasets[datasetIndex];\n    const metasets = this._metasets;\n    let meta = metasets.filter(x => x && x._dataset === dataset).pop();\n\n    if (!meta) {\n      meta = {\n        type: null,\n        data: [],\n        dataset: null,\n        controller: null,\n        hidden: null,\t\t\t// See isDatasetVisible() comment\n        xAxisID: null,\n        yAxisID: null,\n        order: dataset && dataset.order || 0,\n        index: datasetIndex,\n        _dataset: dataset,\n        _parsed: [],\n        _sorted: false\n      };\n      metasets.push(meta);\n    }\n\n    return meta;\n  }\n\n  getContext() {\n    return this.$context || (this.$context = createContext(null, {chart: this, type: 'chart'}));\n  }\n\n  getVisibleDatasetCount() {\n    return this.getSortedVisibleDatasetMetas().length;\n  }\n\n  isDatasetVisible(datasetIndex) {\n    const dataset = this.data.datasets[datasetIndex];\n    if (!dataset) {\n      return false;\n    }\n\n    const meta = this.getDatasetMeta(datasetIndex);\n\n    // meta.hidden is a per chart dataset hidden flag override with 3 states: if true or false,\n    // the dataset.hidden value is ignored, else if null, the dataset hidden state is returned.\n    return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden;\n  }\n\n  setDatasetVisibility(datasetIndex, visible) {\n    const meta = this.getDatasetMeta(datasetIndex);\n    meta.hidden = !visible;\n  }\n\n  toggleDataVisibility(index) {\n    this._hiddenIndices[index] = !this._hiddenIndices[index];\n  }\n\n  getDataVisibility(index) {\n    return !this._hiddenIndices[index];\n  }\n\n  /**\n\t * @private\n\t */\n  _updateVisibility(datasetIndex, dataIndex, visible) {\n    const mode = visible ? 'show' : 'hide';\n    const meta = this.getDatasetMeta(datasetIndex);\n    const anims = meta.controller._resolveAnimations(undefined, mode);\n\n    if (defined(dataIndex)) {\n      meta.data[dataIndex].hidden = !visible;\n      this.update();\n    } else {\n      this.setDatasetVisibility(datasetIndex, visible);\n      // Animate visible state, so hide animation can be seen. This could be handled better if update / updateDataset returned a Promise.\n      anims.update(meta, {visible});\n      this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : undefined);\n    }\n  }\n\n  hide(datasetIndex, dataIndex) {\n    this._updateVisibility(datasetIndex, dataIndex, false);\n  }\n\n  show(datasetIndex, dataIndex) {\n    this._updateVisibility(datasetIndex, dataIndex, true);\n  }\n\n  /**\n\t * @private\n\t */\n  _destroyDatasetMeta(datasetIndex) {\n    const meta = this._metasets[datasetIndex];\n    if (meta && meta.controller) {\n      meta.controller._destroy();\n    }\n    delete this._metasets[datasetIndex];\n  }\n\n  _stop() {\n    let i, ilen;\n    this.stop();\n    animator.remove(this);\n\n    for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n      this._destroyDatasetMeta(i);\n    }\n  }\n\n  destroy() {\n    this.notifyPlugins('beforeDestroy');\n    const {canvas, ctx} = this;\n\n    this._stop();\n    this.config.clearCache();\n\n    if (canvas) {\n      this.unbindEvents();\n      clearCanvas(canvas, ctx);\n      this.platform.releaseContext(ctx);\n      this.canvas = null;\n      this.ctx = null;\n    }\n\n    delete instances[this.id];\n\n    this.notifyPlugins('afterDestroy');\n  }\n\n  toBase64Image(...args) {\n    return this.canvas.toDataURL(...args);\n  }\n\n  /**\n\t * @private\n\t */\n  bindEvents() {\n    this.bindUserEvents();\n    if (this.options.responsive) {\n      this.bindResponsiveEvents();\n    } else {\n      this.attached = true;\n    }\n  }\n\n  /**\n   * @private\n   */\n  bindUserEvents() {\n    const listeners = this._listeners;\n    const platform = this.platform;\n\n    const _add = (type, listener) => {\n      platform.addEventListener(this, type, listener);\n      listeners[type] = listener;\n    };\n\n    const listener = (e, x, y) => {\n      e.offsetX = x;\n      e.offsetY = y;\n      this._eventHandler(e);\n    };\n\n    each(this.options.events, (type) => _add(type, listener));\n  }\n\n  /**\n   * @private\n   */\n  bindResponsiveEvents() {\n    if (!this._responsiveListeners) {\n      this._responsiveListeners = {};\n    }\n    const listeners = this._responsiveListeners;\n    const platform = this.platform;\n\n    const _add = (type, listener) => {\n      platform.addEventListener(this, type, listener);\n      listeners[type] = listener;\n    };\n    const _remove = (type, listener) => {\n      if (listeners[type]) {\n        platform.removeEventListener(this, type, listener);\n        delete listeners[type];\n      }\n    };\n\n    const listener = (width, height) => {\n      if (this.canvas) {\n        this.resize(width, height);\n      }\n    };\n\n    let detached; // eslint-disable-line prefer-const\n    const attached = () => {\n      _remove('attach', attached);\n\n      this.attached = true;\n      this.resize();\n\n      _add('resize', listener);\n      _add('detach', detached);\n    };\n\n    detached = () => {\n      this.attached = false;\n\n      _remove('resize', listener);\n\n      // Stop animating and remove metasets, so when re-attached, the animations start from beginning.\n      this._stop();\n      this._resize(0, 0);\n\n      _add('attach', attached);\n    };\n\n    if (platform.isAttached(this.canvas)) {\n      attached();\n    } else {\n      detached();\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  unbindEvents() {\n    each(this._listeners, (listener, type) => {\n      this.platform.removeEventListener(this, type, listener);\n    });\n    this._listeners = {};\n\n    each(this._responsiveListeners, (listener, type) => {\n      this.platform.removeEventListener(this, type, listener);\n    });\n    this._responsiveListeners = undefined;\n  }\n\n  updateHoverStyle(items, mode, enabled) {\n    const prefix = enabled ? 'set' : 'remove';\n    let meta, item, i, ilen;\n\n    if (mode === 'dataset') {\n      meta = this.getDatasetMeta(items[0].datasetIndex);\n      meta.controller['_' + prefix + 'DatasetHoverStyle']();\n    }\n\n    for (i = 0, ilen = items.length; i < ilen; ++i) {\n      item = items[i];\n      const controller = item && this.getDatasetMeta(item.datasetIndex).controller;\n      if (controller) {\n        controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index);\n      }\n    }\n  }\n\n  /**\n\t * Get active (hovered) elements\n\t * @returns array\n\t */\n  getActiveElements() {\n    return this._active || [];\n  }\n\n  /**\n\t * Set active (hovered) elements\n\t * @param {array} activeElements New active data points\n\t */\n  setActiveElements(activeElements) {\n    const lastActive = this._active || [];\n    const active = activeElements.map(({datasetIndex, index}) => {\n      const meta = this.getDatasetMeta(datasetIndex);\n      if (!meta) {\n        throw new Error('No dataset found at index ' + datasetIndex);\n      }\n\n      return {\n        datasetIndex,\n        element: meta.data[index],\n        index,\n      };\n    });\n    const changed = !_elementsEqual(active, lastActive);\n\n    if (changed) {\n      this._active = active;\n      // Make sure we don't use the previous mouse event to override the active elements in update.\n      this._lastEvent = null;\n      this._updateHoverStyles(active, lastActive);\n    }\n  }\n\n  /**\n\t * Calls enabled plugins on the specified hook and with the given args.\n\t * This method immediately returns as soon as a plugin explicitly returns false. The\n\t * returned value can be used, for instance, to interrupt the current action.\n\t * @param {string} hook - The name of the plugin method to call (e.g. 'beforeUpdate').\n\t * @param {Object} [args] - Extra arguments to apply to the hook call.\n   * @param {import('./core.plugins.js').filterCallback} [filter] - Filtering function for limiting which plugins are notified\n\t * @returns {boolean} false if any of the plugins return false, else returns true.\n\t */\n  notifyPlugins(hook, args, filter) {\n    return this._plugins.notify(this, hook, args, filter);\n  }\n\n  /**\n   * Check if a plugin with the specific ID is registered and enabled\n   * @param {string} pluginId - The ID of the plugin of which to check if it is enabled\n   * @returns {boolean}\n   */\n  isPluginEnabled(pluginId) {\n    return this._plugins._cache.filter(p => p.plugin.id === pluginId).length === 1;\n  }\n\n  /**\n\t * @private\n\t */\n  _updateHoverStyles(active, lastActive, replay) {\n    const hoverOptions = this.options.hover;\n    const diff = (a, b) => a.filter(x => !b.some(y => x.datasetIndex === y.datasetIndex && x.index === y.index));\n    const deactivated = diff(lastActive, active);\n    const activated = replay ? active : diff(active, lastActive);\n\n    if (deactivated.length) {\n      this.updateHoverStyle(deactivated, hoverOptions.mode, false);\n    }\n\n    if (activated.length && hoverOptions.mode) {\n      this.updateHoverStyle(activated, hoverOptions.mode, true);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _eventHandler(e, replay) {\n    const args = {\n      event: e,\n      replay,\n      cancelable: true,\n      inChartArea: this.isPointInArea(e)\n    };\n    const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type);\n\n    if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) {\n      return;\n    }\n\n    const changed = this._handleEvent(e, replay, args.inChartArea);\n\n    args.cancelable = false;\n    this.notifyPlugins('afterEvent', args, eventFilter);\n\n    if (changed || args.changed) {\n      this.render();\n    }\n\n    return this;\n  }\n\n  /**\n\t * Handle an event\n\t * @param {ChartEvent} e the event to handle\n\t * @param {boolean} [replay] - true if the event was replayed by `update`\n   * @param {boolean} [inChartArea] - true if the event is inside chartArea\n\t * @return {boolean} true if the chart needs to re-render\n\t * @private\n\t */\n  _handleEvent(e, replay, inChartArea) {\n    const {_active: lastActive = [], options} = this;\n\n    // If the event is replayed from `update`, we should evaluate with the final positions.\n    //\n    // The `replay`:\n    // It's the last event (excluding click) that has occurred before `update`.\n    // So mouse has not moved. It's also over the chart, because there is a `replay`.\n    //\n    // The why:\n    // If animations are active, the elements haven't moved yet compared to state before update.\n    // But if they will, we are activating the elements that would be active, if this check\n    // was done after the animations have completed. => \"final positions\".\n    // If there is no animations, the \"final\" and \"current\" positions are equal.\n    // This is done so we do not have to evaluate the active elements each animation frame\n    // - it would be expensive.\n    const useFinalPosition = replay;\n    const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);\n    const isClick = _isClickEvent(e);\n    const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);\n\n    if (inChartArea) {\n      // Set _lastEvent to null while we are processing the event handlers.\n      // This prevents recursion if the handler calls chart.update()\n      this._lastEvent = null;\n\n      // Invoke onHover hook\n      callCallback(options.onHover, [e, active, this], this);\n\n      if (isClick) {\n        callCallback(options.onClick, [e, active, this], this);\n      }\n    }\n\n    const changed = !_elementsEqual(active, lastActive);\n    if (changed || replay) {\n      this._active = active;\n      this._updateHoverStyles(active, lastActive, replay);\n    }\n\n    this._lastEvent = lastEvent;\n\n    return changed;\n  }\n\n  /**\n   * @param {ChartEvent} e - The event\n   * @param {import('../types/index.js').ActiveElement[]} lastActive - Previously active elements\n   * @param {boolean} inChartArea - Is the envent inside chartArea\n   * @param {boolean} useFinalPosition - Should the evaluation be done with current or final (after animation) element positions\n   * @returns {import('../types/index.js').ActiveElement[]} - The active elements\n   * @pravate\n   */\n  _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {\n    if (e.type === 'mouseout') {\n      return [];\n    }\n\n    if (!inChartArea) {\n      // Let user control the active elements outside chartArea. Eg. using Legend.\n      return lastActive;\n    }\n\n    const hoverOptions = this.options.hover;\n    return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);\n  }\n}\n\n// @ts-ignore\nfunction invalidatePlugins() {\n  return each(Chart.instances, (chart) => chart._plugins.invalidate());\n}\n\nexport default Chart;\n","import {_isDomSupported} from '../helpers/index.js';\nimport BasePlatform from './platform.base.js';\nimport BasicPlatform from './platform.basic.js';\nimport DomPlatform from './platform.dom.js';\n\nexport function _detectPlatform(canvas) {\n  if (!_isDomSupported() || (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)) {\n    return BasicPlatform;\n  }\n  return DomPlatform;\n}\n\nexport {BasePlatform, BasicPlatform, DomPlatform};\n","import Element from '../core/core.element.js';\nimport {_angleBetween, getAngleFromPoint, TAU, HALF_PI, valueOrDefault} from '../helpers/index.js';\nimport {PI, _isBetween, _limitValue} from '../helpers/helpers.math.js';\nimport {_readValueToProps} from '../helpers/helpers.options.js';\nimport type {ArcOptions, Point} from '../types/index.js';\n\n\nfunction clipArc(ctx: CanvasRenderingContext2D, element: ArcElement, endAngle: number) {\n  const {startAngle, pixelMargin, x, y, outerRadius, innerRadius} = element;\n  let angleMargin = pixelMargin / outerRadius;\n\n  // Draw an inner border by clipping the arc and drawing a double-width border\n  // Enlarge the clipping arc by 0.33 pixels to eliminate glitches between borders\n  ctx.beginPath();\n  ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin);\n  if (innerRadius > pixelMargin) {\n    angleMargin = pixelMargin / innerRadius;\n    ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true);\n  } else {\n    ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI);\n  }\n  ctx.closePath();\n  ctx.clip();\n}\n\nfunction toRadiusCorners(value) {\n  return _readValueToProps(value, ['outerStart', 'outerEnd', 'innerStart', 'innerEnd']);\n}\n\n/**\n * Parse border radius from the provided options\n */\nfunction parseBorderRadius(arc: ArcElement, innerRadius: number, outerRadius: number, angleDelta: number) {\n  const o = toRadiusCorners(arc.options.borderRadius);\n  const halfThickness = (outerRadius - innerRadius) / 2;\n  const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2);\n\n  // Outer limits are complicated. We want to compute the available angular distance at\n  // a radius of outerRadius - borderRadius because for small angular distances, this term limits.\n  // We compute at r = outerRadius - borderRadius because this circle defines the center of the border corners.\n  //\n  // If the borderRadius is large, that value can become negative.\n  // This causes the outer borders to lose their radius entirely, which is rather unexpected. To solve that, if borderRadius > outerRadius\n  // we know that the thickness term will dominate and compute the limits at that point\n  const computeOuterLimit = (val) => {\n    const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2;\n    return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit));\n  };\n\n  return {\n    outerStart: computeOuterLimit(o.outerStart),\n    outerEnd: computeOuterLimit(o.outerEnd),\n    innerStart: _limitValue(o.innerStart, 0, innerLimit),\n    innerEnd: _limitValue(o.innerEnd, 0, innerLimit),\n  };\n}\n\n/**\n * Convert (r, 𝜃) to (x, y)\n */\nfunction rThetaToXY(r: number, theta: number, x: number, y: number) {\n  return {\n    x: x + r * Math.cos(theta),\n    y: y + r * Math.sin(theta),\n  };\n}\n\n\n/**\n * Path the arc, respecting border radius by separating into left and right halves.\n *\n *   Start      End\n *\n *    1--->a--->2    Outer\n *   /           \\\n *   8           3\n *   |           |\n *   |           |\n *   7           4\n *   \\           /\n *    6<---b<---5    Inner\n */\nfunction pathArc(\n  ctx: CanvasRenderingContext2D,\n  element: ArcElement,\n  offset: number,\n  spacing: number,\n  end: number,\n  circular: boolean,\n) {\n  const {x, y, startAngle: start, pixelMargin, innerRadius: innerR} = element;\n\n  const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0);\n  const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0;\n\n  let spacingOffset = 0;\n  const alpha = end - start;\n\n  if (spacing) {\n    // When spacing is present, it is the same for all items\n    // So we adjust the start and end angle of the arc such that\n    // the distance is the same as it would be without the spacing\n    const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0;\n    const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0;\n    const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2;\n    const adjustedAngle = avNogSpacingRadius !== 0 ? (alpha * avNogSpacingRadius) / (avNogSpacingRadius + spacing) : alpha;\n    spacingOffset = (alpha - adjustedAngle) / 2;\n  }\n\n  const beta = Math.max(0.001, alpha * outerRadius - offset / PI) / outerRadius;\n  const angleOffset = (alpha - beta) / 2;\n  const startAngle = start + angleOffset + spacingOffset;\n  const endAngle = end - angleOffset - spacingOffset;\n  const {outerStart, outerEnd, innerStart, innerEnd} = parseBorderRadius(element, innerRadius, outerRadius, endAngle - startAngle);\n\n  const outerStartAdjustedRadius = outerRadius - outerStart;\n  const outerEndAdjustedRadius = outerRadius - outerEnd;\n  const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius;\n  const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius;\n\n  const innerStartAdjustedRadius = innerRadius + innerStart;\n  const innerEndAdjustedRadius = innerRadius + innerEnd;\n  const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius;\n  const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius;\n\n  ctx.beginPath();\n\n  if (circular) {\n    // The first arc segments from point 1 to point a to point 2\n    const outerMidAdjustedAngle = (outerStartAdjustedAngle + outerEndAdjustedAngle) / 2;\n    ctx.arc(x, y, outerRadius, outerStartAdjustedAngle, outerMidAdjustedAngle);\n    ctx.arc(x, y, outerRadius, outerMidAdjustedAngle, outerEndAdjustedAngle);\n\n    // The corner segment from point 2 to point 3\n    if (outerEnd > 0) {\n      const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x, y);\n      ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI);\n    }\n\n    // The line from point 3 to point 4\n    const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x, y);\n    ctx.lineTo(p4.x, p4.y);\n\n    // The corner segment from point 4 to point 5\n    if (innerEnd > 0) {\n      const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x, y);\n      ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI);\n    }\n\n    // The inner arc from point 5 to point b to point 6\n    const innerMidAdjustedAngle = ((endAngle - (innerEnd / innerRadius)) + (startAngle + (innerStart / innerRadius))) / 2;\n    ctx.arc(x, y, innerRadius, endAngle - (innerEnd / innerRadius), innerMidAdjustedAngle, true);\n    ctx.arc(x, y, innerRadius, innerMidAdjustedAngle, startAngle + (innerStart / innerRadius), true);\n\n    // The corner segment from point 6 to point 7\n    if (innerStart > 0) {\n      const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x, y);\n      ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI);\n    }\n\n    // The line from point 7 to point 8\n    const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x, y);\n    ctx.lineTo(p8.x, p8.y);\n\n    // The corner segment from point 8 to point 1\n    if (outerStart > 0) {\n      const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x, y);\n      ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle);\n    }\n  } else {\n    ctx.moveTo(x, y);\n\n    const outerStartX = Math.cos(outerStartAdjustedAngle) * outerRadius + x;\n    const outerStartY = Math.sin(outerStartAdjustedAngle) * outerRadius + y;\n    ctx.lineTo(outerStartX, outerStartY);\n\n    const outerEndX = Math.cos(outerEndAdjustedAngle) * outerRadius + x;\n    const outerEndY = Math.sin(outerEndAdjustedAngle) * outerRadius + y;\n    ctx.lineTo(outerEndX, outerEndY);\n  }\n\n  ctx.closePath();\n}\n\nfunction drawArc(\n  ctx: CanvasRenderingContext2D,\n  element: ArcElement,\n  offset: number,\n  spacing: number,\n  circular: boolean,\n) {\n  const {fullCircles, startAngle, circumference} = element;\n  let endAngle = element.endAngle;\n  if (fullCircles) {\n    pathArc(ctx, element, offset, spacing, endAngle, circular);\n    for (let i = 0; i < fullCircles; ++i) {\n      ctx.fill();\n    }\n    if (!isNaN(circumference)) {\n      endAngle = startAngle + (circumference % TAU || TAU);\n    }\n  }\n  pathArc(ctx, element, offset, spacing, endAngle, circular);\n  ctx.fill();\n  return endAngle;\n}\n\nfunction drawBorder(\n  ctx: CanvasRenderingContext2D,\n  element: ArcElement,\n  offset: number,\n  spacing: number,\n  circular: boolean,\n) {\n  const {fullCircles, startAngle, circumference, options} = element;\n  const {borderWidth, borderJoinStyle, borderDash, borderDashOffset} = options;\n  const inner = options.borderAlign === 'inner';\n\n  if (!borderWidth) {\n    return;\n  }\n\n  ctx.setLineDash(borderDash || []);\n  ctx.lineDashOffset = borderDashOffset;\n\n  if (inner) {\n    ctx.lineWidth = borderWidth * 2;\n    ctx.lineJoin = borderJoinStyle || 'round';\n  } else {\n    ctx.lineWidth = borderWidth;\n    ctx.lineJoin = borderJoinStyle || 'bevel';\n  }\n\n  let endAngle = element.endAngle;\n  if (fullCircles) {\n    pathArc(ctx, element, offset, spacing, endAngle, circular);\n    for (let i = 0; i < fullCircles; ++i) {\n      ctx.stroke();\n    }\n    if (!isNaN(circumference)) {\n      endAngle = startAngle + (circumference % TAU || TAU);\n    }\n  }\n\n  if (inner) {\n    clipArc(ctx, element, endAngle);\n  }\n\n  if (!fullCircles) {\n    pathArc(ctx, element, offset, spacing, endAngle, circular);\n    ctx.stroke();\n  }\n}\n\nexport interface ArcProps extends Point {\n  startAngle: number;\n  endAngle: number;\n  innerRadius: number;\n  outerRadius: number;\n  circumference: number;\n}\n\nexport default class ArcElement extends Element<ArcProps, ArcOptions> {\n\n  static id = 'arc';\n\n  static defaults = {\n    borderAlign: 'center',\n    borderColor: '#fff',\n    borderDash: [],\n    borderDashOffset: 0,\n    borderJoinStyle: undefined,\n    borderRadius: 0,\n    borderWidth: 2,\n    offset: 0,\n    spacing: 0,\n    angle: undefined,\n    circular: true,\n  };\n\n  static defaultRoutes = {\n    backgroundColor: 'backgroundColor'\n  };\n\n  static descriptors = {\n    _scriptable: true,\n    _indexable: (name) => name !== 'borderDash'\n  };\n\n  circumference: number;\n  endAngle: number;\n  fullCircles: number;\n  innerRadius: number;\n  outerRadius: number;\n  pixelMargin: number;\n  startAngle: number;\n\n  constructor(cfg) {\n    super();\n\n    this.options = undefined;\n    this.circumference = undefined;\n    this.startAngle = undefined;\n    this.endAngle = undefined;\n    this.innerRadius = undefined;\n    this.outerRadius = undefined;\n    this.pixelMargin = 0;\n    this.fullCircles = 0;\n\n    if (cfg) {\n      Object.assign(this, cfg);\n    }\n  }\n\n  inRange(chartX: number, chartY: number, useFinalPosition: boolean) {\n    const point = this.getProps(['x', 'y'], useFinalPosition);\n    const {angle, distance} = getAngleFromPoint(point, {x: chartX, y: chartY});\n    const {startAngle, endAngle, innerRadius, outerRadius, circumference} = this.getProps([\n      'startAngle',\n      'endAngle',\n      'innerRadius',\n      'outerRadius',\n      'circumference'\n    ], useFinalPosition);\n    const rAdjust = (this.options.spacing + this.options.borderWidth) / 2;\n    const _circumference = valueOrDefault(circumference, endAngle - startAngle);\n    const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle);\n    const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);\n\n    return (betweenAngles && withinRadius);\n  }\n\n  getCenterPoint(useFinalPosition: boolean) {\n    const {x, y, startAngle, endAngle, innerRadius, outerRadius} = this.getProps([\n      'x',\n      'y',\n      'startAngle',\n      'endAngle',\n      'innerRadius',\n      'outerRadius'\n    ], useFinalPosition);\n    const {offset, spacing} = this.options;\n    const halfAngle = (startAngle + endAngle) / 2;\n    const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2;\n    return {\n      x: x + Math.cos(halfAngle) * halfRadius,\n      y: y + Math.sin(halfAngle) * halfRadius\n    };\n  }\n\n  tooltipPosition(useFinalPosition: boolean) {\n    return this.getCenterPoint(useFinalPosition);\n  }\n\n  draw(ctx: CanvasRenderingContext2D) {\n    const {options, circumference} = this;\n    const offset = (options.offset || 0) / 4;\n    const spacing = (options.spacing || 0) / 2;\n    const circular = options.circular;\n    this.pixelMargin = (options.borderAlign === 'inner') ? 0.33 : 0;\n    this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0;\n\n    if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) {\n      return;\n    }\n\n    ctx.save();\n\n    const halfAngle = (this.startAngle + this.endAngle) / 2;\n    ctx.translate(Math.cos(halfAngle) * offset, Math.sin(halfAngle) * offset);\n    const fix = 1 - Math.sin(Math.min(PI, circumference || 0));\n    const radiusOffset = offset * fix;\n\n    ctx.fillStyle = options.backgroundColor;\n    ctx.strokeStyle = options.borderColor;\n\n    drawArc(ctx, this, radiusOffset, spacing, circular);\n    drawBorder(ctx, this, radiusOffset, spacing, circular);\n\n    ctx.restore();\n  }\n}\n","import Element from '../core/core.element.js';\nimport {_bezierInterpolation, _pointInLine, _steppedInterpolation} from '../helpers/helpers.interpolation.js';\nimport {_computeSegments, _boundSegments} from '../helpers/helpers.segment.js';\nimport {_steppedLineTo, _bezierCurveTo} from '../helpers/helpers.canvas.js';\nimport {_updateBezierControlPoints} from '../helpers/helpers.curve.js';\nimport {valueOrDefault} from '../helpers/index.js';\n\n/**\n * @typedef { import('./element.point.js').default } PointElement\n */\n\nfunction setStyle(ctx, options, style = options) {\n  ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle);\n  ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash));\n  ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset);\n  ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle);\n  ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth);\n  ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor);\n}\n\nfunction lineTo(ctx, previous, target) {\n  ctx.lineTo(target.x, target.y);\n}\n\n/**\n * @returns {any}\n */\nfunction getLineMethod(options) {\n  if (options.stepped) {\n    return _steppedLineTo;\n  }\n\n  if (options.tension || options.cubicInterpolationMode === 'monotone') {\n    return _bezierCurveTo;\n  }\n\n  return lineTo;\n}\n\nfunction pathVars(points, segment, params = {}) {\n  const count = points.length;\n  const {start: paramsStart = 0, end: paramsEnd = count - 1} = params;\n  const {start: segmentStart, end: segmentEnd} = segment;\n  const start = Math.max(paramsStart, segmentStart);\n  const end = Math.min(paramsEnd, segmentEnd);\n  const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd;\n\n  return {\n    count,\n    start,\n    loop: segment.loop,\n    ilen: end < start && !outside ? count + end - start : end - start\n  };\n}\n\n/**\n * Create path from points, grouping by truncated x-coordinate\n * Points need to be in order by x-coordinate for this to work efficiently\n * @param {CanvasRenderingContext2D|Path2D} ctx - Context\n * @param {LineElement} line\n * @param {object} segment\n * @param {number} segment.start - start index of the segment, referring the points array\n * @param {number} segment.end - end index of the segment, referring the points array\n * @param {boolean} segment.loop - indicates that the segment is a loop\n * @param {object} params\n * @param {boolean} params.move - move to starting point (vs line to it)\n * @param {boolean} params.reverse - path the segment from end to start\n * @param {number} params.start - limit segment to points starting from `start` index\n * @param {number} params.end - limit segment to points ending at `start` + `count` index\n */\nfunction pathSegment(ctx, line, segment, params) {\n  const {points, options} = line;\n  const {count, start, loop, ilen} = pathVars(points, segment, params);\n  const lineMethod = getLineMethod(options);\n  // eslint-disable-next-line prefer-const\n  let {move = true, reverse} = params || {};\n  let i, point, prev;\n\n  for (i = 0; i <= ilen; ++i) {\n    point = points[(start + (reverse ? ilen - i : i)) % count];\n\n    if (point.skip) {\n      // If there is a skipped point inside a segment, spanGaps must be true\n      continue;\n    } else if (move) {\n      ctx.moveTo(point.x, point.y);\n      move = false;\n    } else {\n      lineMethod(ctx, prev, point, reverse, options.stepped);\n    }\n\n    prev = point;\n  }\n\n  if (loop) {\n    point = points[(start + (reverse ? ilen : 0)) % count];\n    lineMethod(ctx, prev, point, reverse, options.stepped);\n  }\n\n  return !!loop;\n}\n\n/**\n * Create path from points, grouping by truncated x-coordinate\n * Points need to be in order by x-coordinate for this to work efficiently\n * @param {CanvasRenderingContext2D|Path2D} ctx - Context\n * @param {LineElement} line\n * @param {object} segment\n * @param {number} segment.start - start index of the segment, referring the points array\n * @param {number} segment.end - end index of the segment, referring the points array\n * @param {boolean} segment.loop - indicates that the segment is a loop\n * @param {object} params\n * @param {boolean} params.move - move to starting point (vs line to it)\n * @param {boolean} params.reverse - path the segment from end to start\n * @param {number} params.start - limit segment to points starting from `start` index\n * @param {number} params.end - limit segment to points ending at `start` + `count` index\n */\nfunction fastPathSegment(ctx, line, segment, params) {\n  const points = line.points;\n  const {count, start, ilen} = pathVars(points, segment, params);\n  const {move = true, reverse} = params || {};\n  let avgX = 0;\n  let countX = 0;\n  let i, point, prevX, minY, maxY, lastY;\n\n  const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count;\n  const drawX = () => {\n    if (minY !== maxY) {\n      // Draw line to maxY and minY, using the average x-coordinate\n      ctx.lineTo(avgX, maxY);\n      ctx.lineTo(avgX, minY);\n      // Line to y-value of last point in group. So the line continues\n      // from correct position. Not using move, to have solid path.\n      ctx.lineTo(avgX, lastY);\n    }\n  };\n\n  if (move) {\n    point = points[pointIndex(0)];\n    ctx.moveTo(point.x, point.y);\n  }\n\n  for (i = 0; i <= ilen; ++i) {\n    point = points[pointIndex(i)];\n\n    if (point.skip) {\n      // If there is a skipped point inside a segment, spanGaps must be true\n      continue;\n    }\n\n    const x = point.x;\n    const y = point.y;\n    const truncX = x | 0; // truncated x-coordinate\n\n    if (truncX === prevX) {\n      // Determine `minY` / `maxY` and `avgX` while we stay within same x-position\n      if (y < minY) {\n        minY = y;\n      } else if (y > maxY) {\n        maxY = y;\n      }\n      // For first point in group, countX is `0`, so average will be `x` / 1.\n      avgX = (countX * avgX + x) / ++countX;\n    } else {\n      drawX();\n      // Draw line to next x-position, using the first (or only)\n      // y-value in that group\n      ctx.lineTo(x, y);\n\n      prevX = truncX;\n      countX = 0;\n      minY = maxY = y;\n    }\n    // Keep track of the last y-value in group\n    lastY = y;\n  }\n  drawX();\n}\n\n/**\n * @param {LineElement} line - the line\n * @returns {function}\n * @private\n */\nfunction _getSegmentMethod(line) {\n  const opts = line.options;\n  const borderDash = opts.borderDash && opts.borderDash.length;\n  const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash;\n  return useFastPath ? fastPathSegment : pathSegment;\n}\n\n/**\n * @private\n */\nfunction _getInterpolationMethod(options) {\n  if (options.stepped) {\n    return _steppedInterpolation;\n  }\n\n  if (options.tension || options.cubicInterpolationMode === 'monotone') {\n    return _bezierInterpolation;\n  }\n\n  return _pointInLine;\n}\n\nfunction strokePathWithCache(ctx, line, start, count) {\n  let path = line._path;\n  if (!path) {\n    path = line._path = new Path2D();\n    if (line.path(path, start, count)) {\n      path.closePath();\n    }\n  }\n  setStyle(ctx, line.options);\n  ctx.stroke(path);\n}\n\nfunction strokePathDirect(ctx, line, start, count) {\n  const {segments, options} = line;\n  const segmentMethod = _getSegmentMethod(line);\n\n  for (const segment of segments) {\n    setStyle(ctx, options, segment.style);\n    ctx.beginPath();\n    if (segmentMethod(ctx, line, segment, {start, end: start + count - 1})) {\n      ctx.closePath();\n    }\n    ctx.stroke();\n  }\n}\n\nconst usePath2D = typeof Path2D === 'function';\n\nfunction draw(ctx, line, start, count) {\n  if (usePath2D && !line.options.segment) {\n    strokePathWithCache(ctx, line, start, count);\n  } else {\n    strokePathDirect(ctx, line, start, count);\n  }\n}\n\nexport default class LineElement extends Element {\n\n  static id = 'line';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    borderCapStyle: 'butt',\n    borderDash: [],\n    borderDashOffset: 0,\n    borderJoinStyle: 'miter',\n    borderWidth: 3,\n    capBezierPoints: true,\n    cubicInterpolationMode: 'default',\n    fill: false,\n    spanGaps: false,\n    stepped: false,\n    tension: 0,\n  };\n\n  /**\n   * @type {any}\n   */\n  static defaultRoutes = {\n    backgroundColor: 'backgroundColor',\n    borderColor: 'borderColor'\n  };\n\n\n  static descriptors = {\n    _scriptable: true,\n    _indexable: (name) => name !== 'borderDash' && name !== 'fill',\n  };\n\n\n  constructor(cfg) {\n    super();\n\n    this.animated = true;\n    this.options = undefined;\n    this._chart = undefined;\n    this._loop = undefined;\n    this._fullLoop = undefined;\n    this._path = undefined;\n    this._points = undefined;\n    this._segments = undefined;\n    this._decimated = false;\n    this._pointsUpdated = false;\n    this._datasetIndex = undefined;\n\n    if (cfg) {\n      Object.assign(this, cfg);\n    }\n  }\n\n  updateControlPoints(chartArea, indexAxis) {\n    const options = this.options;\n    if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) {\n      const loop = options.spanGaps ? this._loop : this._fullLoop;\n      _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis);\n      this._pointsUpdated = true;\n    }\n  }\n\n  set points(points) {\n    this._points = points;\n    delete this._segments;\n    delete this._path;\n    this._pointsUpdated = false;\n  }\n\n  get points() {\n    return this._points;\n  }\n\n  get segments() {\n    return this._segments || (this._segments = _computeSegments(this, this.options.segment));\n  }\n\n  /**\n\t * First non-skipped point on this line\n\t * @returns {PointElement|undefined}\n\t */\n  first() {\n    const segments = this.segments;\n    const points = this.points;\n    return segments.length && points[segments[0].start];\n  }\n\n  /**\n\t * Last non-skipped point on this line\n\t * @returns {PointElement|undefined}\n\t */\n  last() {\n    const segments = this.segments;\n    const points = this.points;\n    const count = segments.length;\n    return count && points[segments[count - 1].end];\n  }\n\n  /**\n\t * Interpolate a point in this line at the same value on `property` as\n\t * the reference `point` provided\n\t * @param {PointElement} point - the reference point\n\t * @param {string} property - the property to match on\n\t * @returns {PointElement|undefined}\n\t */\n  interpolate(point, property) {\n    const options = this.options;\n    const value = point[property];\n    const points = this.points;\n    const segments = _boundSegments(this, {property, start: value, end: value});\n\n    if (!segments.length) {\n      return;\n    }\n\n    const result = [];\n    const _interpolate = _getInterpolationMethod(options);\n    let i, ilen;\n    for (i = 0, ilen = segments.length; i < ilen; ++i) {\n      const {start, end} = segments[i];\n      const p1 = points[start];\n      const p2 = points[end];\n      if (p1 === p2) {\n        result.push(p1);\n        continue;\n      }\n      const t = Math.abs((value - p1[property]) / (p2[property] - p1[property]));\n      const interpolated = _interpolate(p1, p2, t, options.stepped);\n      interpolated[property] = point[property];\n      result.push(interpolated);\n    }\n    return result.length === 1 ? result[0] : result;\n  }\n\n  /**\n\t * Append a segment of this line to current path.\n\t * @param {CanvasRenderingContext2D} ctx\n\t * @param {object} segment\n\t * @param {number} segment.start - start index of the segment, referring the points array\n \t * @param {number} segment.end - end index of the segment, referring the points array\n \t * @param {boolean} segment.loop - indicates that the segment is a loop\n\t * @param {object} params\n\t * @param {boolean} params.move - move to starting point (vs line to it)\n\t * @param {boolean} params.reverse - path the segment from end to start\n\t * @param {number} params.start - limit segment to points starting from `start` index\n\t * @param {number} params.end - limit segment to points ending at `start` + `count` index\n\t * @returns {undefined|boolean} - true if the segment is a full loop (path should be closed)\n\t */\n  pathSegment(ctx, segment, params) {\n    const segmentMethod = _getSegmentMethod(this);\n    return segmentMethod(ctx, this, segment, params);\n  }\n\n  /**\n\t * Append all segments of this line to current path.\n\t * @param {CanvasRenderingContext2D|Path2D} ctx\n\t * @param {number} [start]\n\t * @param {number} [count]\n\t * @returns {undefined|boolean} - true if line is a full loop (path should be closed)\n\t */\n  path(ctx, start, count) {\n    const segments = this.segments;\n    const segmentMethod = _getSegmentMethod(this);\n    let loop = this._loop;\n\n    start = start || 0;\n    count = count || (this.points.length - start);\n\n    for (const segment of segments) {\n      loop &= segmentMethod(ctx, this, segment, {start, end: start + count - 1});\n    }\n    return !!loop;\n  }\n\n  /**\n\t * Draw\n\t * @param {CanvasRenderingContext2D} ctx\n\t * @param {object} chartArea\n\t * @param {number} [start]\n\t * @param {number} [count]\n\t */\n  draw(ctx, chartArea, start, count) {\n    const options = this.options || {};\n    const points = this.points || [];\n\n    if (points.length && options.borderWidth) {\n      ctx.save();\n\n      draw(ctx, this, start, count);\n\n      ctx.restore();\n    }\n\n    if (this.animated) {\n      // When line is animated, the control points and path are not cached.\n      this._pointsUpdated = false;\n      this._path = undefined;\n    }\n  }\n}\n","import Element from '../core/core.element.js';\nimport {drawPoint, _isPointInArea} from '../helpers/helpers.canvas.js';\nimport type {\n  CartesianParsedData,\n  ChartArea,\n  Point,\n  PointHoverOptions,\n  PointOptions,\n} from '../types/index.js';\n\nfunction inRange(el: PointElement, pos: number, axis: 'x' | 'y', useFinalPosition?: boolean) {\n  const options = el.options;\n  const {[axis]: value} = el.getProps([axis], useFinalPosition);\n\n  return (Math.abs(pos - value) < options.radius + options.hitRadius);\n}\n\nexport type PointProps = Point\n\nexport default class PointElement extends Element<PointProps, PointOptions & PointHoverOptions> {\n\n  static id = 'point';\n\n  parsed: CartesianParsedData;\n  skip?: boolean;\n  stop?: boolean;\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    borderWidth: 1,\n    hitRadius: 1,\n    hoverBorderWidth: 1,\n    hoverRadius: 4,\n    pointStyle: 'circle',\n    radius: 3,\n    rotation: 0\n  };\n\n  /**\n   * @type {any}\n   */\n  static defaultRoutes = {\n    backgroundColor: 'backgroundColor',\n    borderColor: 'borderColor'\n  };\n\n  constructor(cfg) {\n    super();\n\n    this.options = undefined;\n    this.parsed = undefined;\n    this.skip = undefined;\n    this.stop = undefined;\n\n    if (cfg) {\n      Object.assign(this, cfg);\n    }\n  }\n\n  inRange(mouseX: number, mouseY: number, useFinalPosition?: boolean) {\n    const options = this.options;\n    const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n    return ((Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2)) < Math.pow(options.hitRadius + options.radius, 2));\n  }\n\n  inXRange(mouseX: number, useFinalPosition?: boolean) {\n    return inRange(this, mouseX, 'x', useFinalPosition);\n  }\n\n  inYRange(mouseY: number, useFinalPosition?: boolean) {\n    return inRange(this, mouseY, 'y', useFinalPosition);\n  }\n\n  getCenterPoint(useFinalPosition?: boolean) {\n    const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n    return {x, y};\n  }\n\n  size(options?: Partial<PointOptions & PointHoverOptions>) {\n    options = options || this.options || {};\n    let radius = options.radius || 0;\n    radius = Math.max(radius, radius && options.hoverRadius || 0);\n    const borderWidth = radius && options.borderWidth || 0;\n    return (radius + borderWidth) * 2;\n  }\n\n  draw(ctx: CanvasRenderingContext2D, area: ChartArea) {\n    const options = this.options;\n\n    if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) {\n      return;\n    }\n\n    ctx.strokeStyle = options.borderColor;\n    ctx.lineWidth = options.borderWidth;\n    ctx.fillStyle = options.backgroundColor;\n    drawPoint(ctx, options, this.x, this.y);\n  }\n\n  getRange() {\n    const options = this.options || {};\n    // @ts-expect-error Fallbacks should never be hit in practice\n    return options.radius + options.hitRadius;\n  }\n}\n","import Element from '../core/core.element.js';\nimport {isObject, _isBetween, _limitValue} from '../helpers/index.js';\nimport {addRoundedRectPath} from '../helpers/helpers.canvas.js';\nimport {toTRBL, toTRBLCorners} from '../helpers/helpers.options.js';\n\n/** @typedef {{ x: number, y: number, base: number, horizontal: boolean, width: number, height: number }} BarProps */\n\n/**\n * Helper function to get the bounds of the bar regardless of the orientation\n * @param {BarElement} bar the bar\n * @param {boolean} [useFinalPosition]\n * @return {object} bounds of the bar\n * @private\n */\nfunction getBarBounds(bar, useFinalPosition) {\n  const {x, y, base, width, height} = /** @type {BarProps} */ (bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition));\n\n  let left, right, top, bottom, half;\n\n  if (bar.horizontal) {\n    half = height / 2;\n    left = Math.min(x, base);\n    right = Math.max(x, base);\n    top = y - half;\n    bottom = y + half;\n  } else {\n    half = width / 2;\n    left = x - half;\n    right = x + half;\n    top = Math.min(y, base);\n    bottom = Math.max(y, base);\n  }\n\n  return {left, top, right, bottom};\n}\n\nfunction skipOrLimit(skip, value, min, max) {\n  return skip ? 0 : _limitValue(value, min, max);\n}\n\nfunction parseBorderWidth(bar, maxW, maxH) {\n  const value = bar.options.borderWidth;\n  const skip = bar.borderSkipped;\n  const o = toTRBL(value);\n\n  return {\n    t: skipOrLimit(skip.top, o.top, 0, maxH),\n    r: skipOrLimit(skip.right, o.right, 0, maxW),\n    b: skipOrLimit(skip.bottom, o.bottom, 0, maxH),\n    l: skipOrLimit(skip.left, o.left, 0, maxW)\n  };\n}\n\nfunction parseBorderRadius(bar, maxW, maxH) {\n  const {enableBorderRadius} = bar.getProps(['enableBorderRadius']);\n  const value = bar.options.borderRadius;\n  const o = toTRBLCorners(value);\n  const maxR = Math.min(maxW, maxH);\n  const skip = bar.borderSkipped;\n\n  // If the value is an object, assume the user knows what they are doing\n  // and apply as directed.\n  const enableBorder = enableBorderRadius || isObject(value);\n\n  return {\n    topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR),\n    topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR),\n    bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR),\n    bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR)\n  };\n}\n\nfunction boundingRects(bar) {\n  const bounds = getBarBounds(bar);\n  const width = bounds.right - bounds.left;\n  const height = bounds.bottom - bounds.top;\n  const border = parseBorderWidth(bar, width / 2, height / 2);\n  const radius = parseBorderRadius(bar, width / 2, height / 2);\n\n  return {\n    outer: {\n      x: bounds.left,\n      y: bounds.top,\n      w: width,\n      h: height,\n      radius\n    },\n    inner: {\n      x: bounds.left + border.l,\n      y: bounds.top + border.t,\n      w: width - border.l - border.r,\n      h: height - border.t - border.b,\n      radius: {\n        topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),\n        topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),\n        bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),\n        bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)),\n      }\n    }\n  };\n}\n\nfunction inRange(bar, x, y, useFinalPosition) {\n  const skipX = x === null;\n  const skipY = y === null;\n  const skipBoth = skipX && skipY;\n  const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);\n\n  return bounds\n\t\t&& (skipX || _isBetween(x, bounds.left, bounds.right))\n\t\t&& (skipY || _isBetween(y, bounds.top, bounds.bottom));\n}\n\nfunction hasRadius(radius) {\n  return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;\n}\n\n/**\n * Add a path of a rectangle to the current sub-path\n * @param {CanvasRenderingContext2D} ctx Context\n * @param {*} rect Bounding rect\n */\nfunction addNormalRectPath(ctx, rect) {\n  ctx.rect(rect.x, rect.y, rect.w, rect.h);\n}\n\nfunction inflateRect(rect, amount, refRect = {}) {\n  const x = rect.x !== refRect.x ? -amount : 0;\n  const y = rect.y !== refRect.y ? -amount : 0;\n  const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x;\n  const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y;\n  return {\n    x: rect.x + x,\n    y: rect.y + y,\n    w: rect.w + w,\n    h: rect.h + h,\n    radius: rect.radius\n  };\n}\n\nexport default class BarElement extends Element {\n\n  static id = 'bar';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    borderSkipped: 'start',\n    borderWidth: 0,\n    borderRadius: 0,\n    inflateAmount: 'auto',\n    pointStyle: undefined\n  };\n\n  /**\n   * @type {any}\n   */\n  static defaultRoutes = {\n    backgroundColor: 'backgroundColor',\n    borderColor: 'borderColor'\n  };\n\n  constructor(cfg) {\n    super();\n\n    this.options = undefined;\n    this.horizontal = undefined;\n    this.base = undefined;\n    this.width = undefined;\n    this.height = undefined;\n    this.inflateAmount = undefined;\n\n    if (cfg) {\n      Object.assign(this, cfg);\n    }\n  }\n\n  draw(ctx) {\n    const {inflateAmount, options: {borderColor, backgroundColor}} = this;\n    const {inner, outer} = boundingRects(this);\n    const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;\n\n    ctx.save();\n\n    if (outer.w !== inner.w || outer.h !== inner.h) {\n      ctx.beginPath();\n      addRectPath(ctx, inflateRect(outer, inflateAmount, inner));\n      ctx.clip();\n      addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));\n      ctx.fillStyle = borderColor;\n      ctx.fill('evenodd');\n    }\n\n    ctx.beginPath();\n    addRectPath(ctx, inflateRect(inner, inflateAmount));\n    ctx.fillStyle = backgroundColor;\n    ctx.fill();\n\n    ctx.restore();\n  }\n\n  inRange(mouseX, mouseY, useFinalPosition) {\n    return inRange(this, mouseX, mouseY, useFinalPosition);\n  }\n\n  inXRange(mouseX, useFinalPosition) {\n    return inRange(this, mouseX, null, useFinalPosition);\n  }\n\n  inYRange(mouseY, useFinalPosition) {\n    return inRange(this, null, mouseY, useFinalPosition);\n  }\n\n  getCenterPoint(useFinalPosition) {\n    const {x, y, base, horizontal} = /** @type {BarProps} */ (this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition));\n    return {\n      x: horizontal ? (x + base) / 2 : x,\n      y: horizontal ? y : (y + base) / 2\n    };\n  }\n\n  getRange(axis) {\n    return axis === 'x' ? this.width / 2 : this.height / 2;\n  }\n}\n","import {DoughnutController, PolarAreaController} from '../index.js';\nimport type {Chart, ChartDataset} from '../types.js';\n\nexport interface ColorsPluginOptions {\n  enabled?: boolean;\n  forceOverride?: boolean;\n}\n\ninterface ColorsDescriptor {\n  backgroundColor?: unknown;\n  borderColor?: unknown;\n}\n\nconst BORDER_COLORS = [\n  'rgb(54, 162, 235)', // blue\n  'rgb(255, 99, 132)', // red\n  'rgb(255, 159, 64)', // orange\n  'rgb(255, 205, 86)', // yellow\n  'rgb(75, 192, 192)', // green\n  'rgb(153, 102, 255)', // purple\n  'rgb(201, 203, 207)' // grey\n];\n\n// Border colors with 50% transparency\nconst BACKGROUND_COLORS = /* #__PURE__ */ BORDER_COLORS.map(color => color.replace('rgb(', 'rgba(').replace(')', ', 0.5)'));\n\nfunction getBorderColor(i: number) {\n  return BORDER_COLORS[i % BORDER_COLORS.length];\n}\n\nfunction getBackgroundColor(i: number) {\n  return BACKGROUND_COLORS[i % BACKGROUND_COLORS.length];\n}\n\nfunction colorizeDefaultDataset(dataset: ChartDataset, i: number) {\n  dataset.borderColor = getBorderColor(i);\n  dataset.backgroundColor = getBackgroundColor(i);\n\n  return ++i;\n}\n\nfunction colorizeDoughnutDataset(dataset: ChartDataset, i: number) {\n  dataset.backgroundColor = dataset.data.map(() => getBorderColor(i++));\n\n  return i;\n}\n\nfunction colorizePolarAreaDataset(dataset: ChartDataset, i: number) {\n  dataset.backgroundColor = dataset.data.map(() => getBackgroundColor(i++));\n\n  return i;\n}\n\nfunction getColorizer(chart: Chart) {\n  let i = 0;\n\n  return (dataset: ChartDataset, datasetIndex: number) => {\n    const controller = chart.getDatasetMeta(datasetIndex).controller;\n\n    if (controller instanceof DoughnutController) {\n      i = colorizeDoughnutDataset(dataset, i);\n    } else if (controller instanceof PolarAreaController) {\n      i = colorizePolarAreaDataset(dataset, i);\n    } else if (controller) {\n      i = colorizeDefaultDataset(dataset, i);\n    }\n  };\n}\n\nfunction containsColorsDefinitions(\n  descriptors: ColorsDescriptor[] | Record<string, ColorsDescriptor>\n) {\n  let k: number | string;\n\n  for (k in descriptors) {\n    if (descriptors[k].borderColor || descriptors[k].backgroundColor) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction containsColorsDefinition(\n  descriptor: ColorsDescriptor\n) {\n  return descriptor && (descriptor.borderColor || descriptor.backgroundColor);\n}\n\nexport default {\n  id: 'colors',\n\n  defaults: {\n    enabled: true,\n    forceOverride: false\n  } as ColorsPluginOptions,\n\n  beforeLayout(chart: Chart, _args, options: ColorsPluginOptions) {\n    if (!options.enabled) {\n      return;\n    }\n\n    const {\n      data: {datasets},\n      options: chartOptions\n    } = chart.config;\n    const {elements} = chartOptions;\n\n    if (!options.forceOverride && (containsColorsDefinitions(datasets) || containsColorsDefinition(chartOptions) || (elements && containsColorsDefinitions(elements)))) {\n      return;\n    }\n\n    const colorizer = getColorizer(chart);\n\n    datasets.forEach(colorizer);\n  }\n};\n","import Element from '../core/core.element.js';\nimport layouts from '../core/core.layouts.js';\nimport {PI, isArray, toPadding, toFont} from '../helpers/index.js';\nimport {_toLeftRightCenter, _alignStartEnd} from '../helpers/helpers.extras.js';\nimport {renderText} from '../helpers/helpers.canvas.js';\n\nexport class Title extends Element {\n  /**\n\t * @param {{ ctx: any; options: any; chart: any; }} config\n\t */\n  constructor(config) {\n    super();\n\n    this.chart = config.chart;\n    this.options = config.options;\n    this.ctx = config.ctx;\n    this._padding = undefined;\n    this.top = undefined;\n    this.bottom = undefined;\n    this.left = undefined;\n    this.right = undefined;\n    this.width = undefined;\n    this.height = undefined;\n    this.position = undefined;\n    this.weight = undefined;\n    this.fullSize = undefined;\n  }\n\n  update(maxWidth, maxHeight) {\n    const opts = this.options;\n\n    this.left = 0;\n    this.top = 0;\n\n    if (!opts.display) {\n      this.width = this.height = this.right = this.bottom = 0;\n      return;\n    }\n\n    this.width = this.right = maxWidth;\n    this.height = this.bottom = maxHeight;\n\n    const lineCount = isArray(opts.text) ? opts.text.length : 1;\n    this._padding = toPadding(opts.padding);\n    const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;\n\n    if (this.isHorizontal()) {\n      this.height = textSize;\n    } else {\n      this.width = textSize;\n    }\n  }\n\n  isHorizontal() {\n    const pos = this.options.position;\n    return pos === 'top' || pos === 'bottom';\n  }\n\n  _drawArgs(offset) {\n    const {top, left, bottom, right, options} = this;\n    const align = options.align;\n    let rotation = 0;\n    let maxWidth, titleX, titleY;\n\n    if (this.isHorizontal()) {\n      titleX = _alignStartEnd(align, left, right);\n      titleY = top + offset;\n      maxWidth = right - left;\n    } else {\n      if (options.position === 'left') {\n        titleX = left + offset;\n        titleY = _alignStartEnd(align, bottom, top);\n        rotation = PI * -0.5;\n      } else {\n        titleX = right - offset;\n        titleY = _alignStartEnd(align, top, bottom);\n        rotation = PI * 0.5;\n      }\n      maxWidth = bottom - top;\n    }\n    return {titleX, titleY, maxWidth, rotation};\n  }\n\n  draw() {\n    const ctx = this.ctx;\n    const opts = this.options;\n\n    if (!opts.display) {\n      return;\n    }\n\n    const fontOpts = toFont(opts.font);\n    const lineHeight = fontOpts.lineHeight;\n    const offset = lineHeight / 2 + this._padding.top;\n    const {titleX, titleY, maxWidth, rotation} = this._drawArgs(offset);\n\n    renderText(ctx, opts.text, 0, 0, fontOpts, {\n      color: opts.color,\n      maxWidth,\n      rotation,\n      textAlign: _toLeftRightCenter(opts.align),\n      textBaseline: 'middle',\n      translation: [titleX, titleY],\n    });\n  }\n}\n\nfunction createTitle(chart, titleOpts) {\n  const title = new Title({\n    ctx: chart.ctx,\n    options: titleOpts,\n    chart\n  });\n\n  layouts.configure(chart, title, titleOpts);\n  layouts.addBox(chart, title);\n  chart.titleBlock = title;\n}\n\nexport default {\n  id: 'title',\n\n  /**\n\t * For tests\n\t * @private\n\t */\n  _element: Title,\n\n  start(chart, _args, options) {\n    createTitle(chart, options);\n  },\n\n  stop(chart) {\n    const titleBlock = chart.titleBlock;\n    layouts.removeBox(chart, titleBlock);\n    delete chart.titleBlock;\n  },\n\n  beforeUpdate(chart, _args, options) {\n    const title = chart.titleBlock;\n    layouts.configure(chart, title, options);\n    title.options = options;\n  },\n\n  defaults: {\n    align: 'center',\n    display: false,\n    font: {\n      weight: 'bold',\n    },\n    fullSize: true,\n    padding: 10,\n    position: 'top',\n    text: '',\n    weight: 2000         // by default greater than legend (1000) to be above\n  },\n\n  defaultRoutes: {\n    color: 'color'\n  },\n\n  descriptors: {\n    _scriptable: true,\n    _indexable: false,\n  },\n};\n","import {Title} from './plugin.title.js';\nimport layouts from '../core/core.layouts.js';\n\nconst map = new WeakMap();\n\nexport default {\n  id: 'subtitle',\n\n  start(chart, _args, options) {\n    const title = new Title({\n      ctx: chart.ctx,\n      options,\n      chart\n    });\n\n    layouts.configure(chart, title, options);\n    layouts.addBox(chart, title);\n    map.set(chart, title);\n  },\n\n  stop(chart) {\n    layouts.removeBox(chart, map.get(chart));\n    map.delete(chart);\n  },\n\n  beforeUpdate(chart, _args, options) {\n    const title = map.get(chart);\n    layouts.configure(chart, title, options);\n    title.options = options;\n  },\n\n  defaults: {\n    align: 'center',\n    display: false,\n    font: {\n      weight: 'normal',\n    },\n    fullSize: true,\n    padding: 0,\n    position: 'top',\n    text: '',\n    weight: 1500         // by default greater than legend (1000) and smaller than title (2000)\n  },\n\n  defaultRoutes: {\n    color: 'color'\n  },\n\n  descriptors: {\n    _scriptable: true,\n    _indexable: false,\n  },\n};\n","import Animations from '../core/core.animations.js';\nimport Element from '../core/core.element.js';\nimport {addRoundedRectPath} from '../helpers/helpers.canvas.js';\nimport {each, noop, isNullOrUndef, isArray, _elementsEqual, isObject} from '../helpers/helpers.core.js';\nimport {toFont, toPadding, toTRBLCorners} from '../helpers/helpers.options.js';\nimport {getRtlAdapter, overrideTextDirection, restoreTextDirection} from '../helpers/helpers.rtl.js';\nimport {distanceBetweenPoints, _limitValue} from '../helpers/helpers.math.js';\nimport {createContext, drawPoint} from '../helpers/index.js';\n\n/**\n * @typedef { import('../platform/platform.base.js').Chart } Chart\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef { import('../types/index.js').ActiveElement } ActiveElement\n * @typedef { import('../core/core.interaction.js').InteractionItem } InteractionItem\n */\n\nconst positioners = {\n  /**\n\t * Average mode places the tooltip at the average position of the elements shown\n\t */\n  average(items) {\n    if (!items.length) {\n      return false;\n    }\n\n    let i, len;\n    let xSet = new Set();\n    let y = 0;\n    let count = 0;\n\n    for (i = 0, len = items.length; i < len; ++i) {\n      const el = items[i].element;\n      if (el && el.hasValue()) {\n        const pos = el.tooltipPosition();\n        xSet.add(pos.x);\n        y += pos.y;\n        ++count;\n      }\n    }\n\n    const xAverage = [...xSet].reduce((a, b) => a + b) / xSet.size;\n\n    return {\n      x: xAverage,\n      y: y / count\n    };\n  },\n\n  /**\n\t * Gets the tooltip position nearest of the item nearest to the event position\n\t */\n  nearest(items, eventPosition) {\n    if (!items.length) {\n      return false;\n    }\n\n    let x = eventPosition.x;\n    let y = eventPosition.y;\n    let minDistance = Number.POSITIVE_INFINITY;\n    let i, len, nearestElement;\n\n    for (i = 0, len = items.length; i < len; ++i) {\n      const el = items[i].element;\n      if (el && el.hasValue()) {\n        const center = el.getCenterPoint();\n        const d = distanceBetweenPoints(eventPosition, center);\n\n        if (d < minDistance) {\n          minDistance = d;\n          nearestElement = el;\n        }\n      }\n    }\n\n    if (nearestElement) {\n      const tp = nearestElement.tooltipPosition();\n      x = tp.x;\n      y = tp.y;\n    }\n\n    return {\n      x,\n      y\n    };\n  }\n};\n\n// Helper to push or concat based on if the 2nd parameter is an array or not\nfunction pushOrConcat(base, toPush) {\n  if (toPush) {\n    if (isArray(toPush)) {\n      // base = base.concat(toPush);\n      Array.prototype.push.apply(base, toPush);\n    } else {\n      base.push(toPush);\n    }\n  }\n\n  return base;\n}\n\n/**\n * Returns array of strings split by newline\n * @param {*} str - The value to split by newline.\n * @returns {string|string[]} value if newline present - Returned from String split() method\n * @function\n */\nfunction splitNewlines(str) {\n  if ((typeof str === 'string' || str instanceof String) && str.indexOf('\\n') > -1) {\n    return str.split('\\n');\n  }\n  return str;\n}\n\n\n/**\n * Private helper to create a tooltip item model\n * @param {Chart} chart\n * @param {ActiveElement} item - {element, index, datasetIndex} to create the tooltip item for\n * @return new tooltip item\n */\nfunction createTooltipItem(chart, item) {\n  const {element, datasetIndex, index} = item;\n  const controller = chart.getDatasetMeta(datasetIndex).controller;\n  const {label, value} = controller.getLabelAndValue(index);\n\n  return {\n    chart,\n    label,\n    parsed: controller.getParsed(index),\n    raw: chart.data.datasets[datasetIndex].data[index],\n    formattedValue: value,\n    dataset: controller.getDataset(),\n    dataIndex: index,\n    datasetIndex,\n    element\n  };\n}\n\n/**\n * Get the size of the tooltip\n */\nfunction getTooltipSize(tooltip, options) {\n  const ctx = tooltip.chart.ctx;\n  const {body, footer, title} = tooltip;\n  const {boxWidth, boxHeight} = options;\n  const bodyFont = toFont(options.bodyFont);\n  const titleFont = toFont(options.titleFont);\n  const footerFont = toFont(options.footerFont);\n  const titleLineCount = title.length;\n  const footerLineCount = footer.length;\n  const bodyLineItemCount = body.length;\n\n  const padding = toPadding(options.padding);\n  let height = padding.height;\n  let width = 0;\n\n  // Count of all lines in the body\n  let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);\n  combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;\n\n  if (titleLineCount) {\n    height += titleLineCount * titleFont.lineHeight\n\t\t\t+ (titleLineCount - 1) * options.titleSpacing\n\t\t\t+ options.titleMarginBottom;\n  }\n  if (combinedBodyLength) {\n    // Body lines may include some extra height depending on boxHeight\n    const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;\n    height += bodyLineItemCount * bodyLineHeight\n\t\t\t+ (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight\n\t\t\t+ (combinedBodyLength - 1) * options.bodySpacing;\n  }\n  if (footerLineCount) {\n    height += options.footerMarginTop\n\t\t\t+ footerLineCount * footerFont.lineHeight\n\t\t\t+ (footerLineCount - 1) * options.footerSpacing;\n  }\n\n  // Title width\n  let widthPadding = 0;\n  const maxLineWidth = function(line) {\n    width = Math.max(width, ctx.measureText(line).width + widthPadding);\n  };\n\n  ctx.save();\n\n  ctx.font = titleFont.string;\n  each(tooltip.title, maxLineWidth);\n\n  // Body width\n  ctx.font = bodyFont.string;\n  each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);\n\n  // Body lines may include some extra width due to the color box\n  widthPadding = options.displayColors ? (boxWidth + 2 + options.boxPadding) : 0;\n  each(body, (bodyItem) => {\n    each(bodyItem.before, maxLineWidth);\n    each(bodyItem.lines, maxLineWidth);\n    each(bodyItem.after, maxLineWidth);\n  });\n\n  // Reset back to 0\n  widthPadding = 0;\n\n  // Footer width\n  ctx.font = footerFont.string;\n  each(tooltip.footer, maxLineWidth);\n\n  ctx.restore();\n\n  // Add padding\n  width += padding.width;\n\n  return {width, height};\n}\n\nfunction determineYAlign(chart, size) {\n  const {y, height} = size;\n\n  if (y < height / 2) {\n    return 'top';\n  } else if (y > (chart.height - height / 2)) {\n    return 'bottom';\n  }\n  return 'center';\n}\n\nfunction doesNotFitWithAlign(xAlign, chart, options, size) {\n  const {x, width} = size;\n  const caret = options.caretSize + options.caretPadding;\n  if (xAlign === 'left' && x + width + caret > chart.width) {\n    return true;\n  }\n\n  if (xAlign === 'right' && x - width - caret < 0) {\n    return true;\n  }\n}\n\nfunction determineXAlign(chart, options, size, yAlign) {\n  const {x, width} = size;\n  const {width: chartWidth, chartArea: {left, right}} = chart;\n  let xAlign = 'center';\n\n  if (yAlign === 'center') {\n    xAlign = x <= (left + right) / 2 ? 'left' : 'right';\n  } else if (x <= width / 2) {\n    xAlign = 'left';\n  } else if (x >= chartWidth - width / 2) {\n    xAlign = 'right';\n  }\n\n  if (doesNotFitWithAlign(xAlign, chart, options, size)) {\n    xAlign = 'center';\n  }\n\n  return xAlign;\n}\n\n/**\n * Helper to get the alignment of a tooltip given the size\n */\nfunction determineAlignment(chart, options, size) {\n  const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);\n\n  return {\n    xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),\n    yAlign\n  };\n}\n\nfunction alignX(size, xAlign) {\n  let {x, width} = size;\n  if (xAlign === 'right') {\n    x -= width;\n  } else if (xAlign === 'center') {\n    x -= (width / 2);\n  }\n  return x;\n}\n\nfunction alignY(size, yAlign, paddingAndSize) {\n  // eslint-disable-next-line prefer-const\n  let {y, height} = size;\n  if (yAlign === 'top') {\n    y += paddingAndSize;\n  } else if (yAlign === 'bottom') {\n    y -= height + paddingAndSize;\n  } else {\n    y -= (height / 2);\n  }\n  return y;\n}\n\n/**\n * Helper to get the location a tooltip needs to be placed at given the initial position (via the vm) and the size and alignment\n */\nfunction getBackgroundPoint(options, size, alignment, chart) {\n  const {caretSize, caretPadding, cornerRadius} = options;\n  const {xAlign, yAlign} = alignment;\n  const paddingAndSize = caretSize + caretPadding;\n  const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n\n  let x = alignX(size, xAlign);\n  const y = alignY(size, yAlign, paddingAndSize);\n\n  if (yAlign === 'center') {\n    if (xAlign === 'left') {\n      x += paddingAndSize;\n    } else if (xAlign === 'right') {\n      x -= paddingAndSize;\n    }\n  } else if (xAlign === 'left') {\n    x -= Math.max(topLeft, bottomLeft) + caretSize;\n  } else if (xAlign === 'right') {\n    x += Math.max(topRight, bottomRight) + caretSize;\n  }\n\n  return {\n    x: _limitValue(x, 0, chart.width - size.width),\n    y: _limitValue(y, 0, chart.height - size.height)\n  };\n}\n\nfunction getAlignedX(tooltip, align, options) {\n  const padding = toPadding(options.padding);\n\n  return align === 'center'\n    ? tooltip.x + tooltip.width / 2\n    : align === 'right'\n      ? tooltip.x + tooltip.width - padding.right\n      : tooltip.x + padding.left;\n}\n\n/**\n * Helper to build before and after body lines\n */\nfunction getBeforeAfterBodyLines(callback) {\n  return pushOrConcat([], splitNewlines(callback));\n}\n\nfunction createTooltipContext(parent, tooltip, tooltipItems) {\n  return createContext(parent, {\n    tooltip,\n    tooltipItems,\n    type: 'tooltip'\n  });\n}\n\nfunction overrideCallbacks(callbacks, context) {\n  const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;\n  return override ? callbacks.override(override) : callbacks;\n}\n\nconst defaultCallbacks = {\n  // Args are: (tooltipItems, data)\n  beforeTitle: noop,\n  title(tooltipItems) {\n    if (tooltipItems.length > 0) {\n      const item = tooltipItems[0];\n      const labels = item.chart.data.labels;\n      const labelCount = labels ? labels.length : 0;\n\n      if (this && this.options && this.options.mode === 'dataset') {\n        return item.dataset.label || '';\n      } else if (item.label) {\n        return item.label;\n      } else if (labelCount > 0 && item.dataIndex < labelCount) {\n        return labels[item.dataIndex];\n      }\n    }\n\n    return '';\n  },\n  afterTitle: noop,\n\n  // Args are: (tooltipItems, data)\n  beforeBody: noop,\n\n  // Args are: (tooltipItem, data)\n  beforeLabel: noop,\n  label(tooltipItem) {\n    if (this && this.options && this.options.mode === 'dataset') {\n      return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue;\n    }\n\n    let label = tooltipItem.dataset.label || '';\n\n    if (label) {\n      label += ': ';\n    }\n    const value = tooltipItem.formattedValue;\n    if (!isNullOrUndef(value)) {\n      label += value;\n    }\n    return label;\n  },\n  labelColor(tooltipItem) {\n    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n    const options = meta.controller.getStyle(tooltipItem.dataIndex);\n    return {\n      borderColor: options.borderColor,\n      backgroundColor: options.backgroundColor,\n      borderWidth: options.borderWidth,\n      borderDash: options.borderDash,\n      borderDashOffset: options.borderDashOffset,\n      borderRadius: 0,\n    };\n  },\n  labelTextColor() {\n    return this.options.bodyColor;\n  },\n  labelPointStyle(tooltipItem) {\n    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n    const options = meta.controller.getStyle(tooltipItem.dataIndex);\n    return {\n      pointStyle: options.pointStyle,\n      rotation: options.rotation,\n    };\n  },\n  afterLabel: noop,\n\n  // Args are: (tooltipItems, data)\n  afterBody: noop,\n\n  // Args are: (tooltipItems, data)\n  beforeFooter: noop,\n  footer: noop,\n  afterFooter: noop\n};\n\n/**\n * Invoke callback from object with context and arguments.\n * If callback returns `undefined`, then will be invoked default callback.\n * @param {Record<keyof typeof defaultCallbacks, Function>} callbacks\n * @param {keyof typeof defaultCallbacks} name\n * @param {*} ctx\n * @param {*} arg\n * @returns {any}\n */\nfunction invokeCallbackWithFallback(callbacks, name, ctx, arg) {\n  const result = callbacks[name].call(ctx, arg);\n\n  if (typeof result === 'undefined') {\n    return defaultCallbacks[name].call(ctx, arg);\n  }\n\n  return result;\n}\n\nexport class Tooltip extends Element {\n\n  /**\n   * @namespace Chart.Tooltip.positioners\n   */\n  static positioners = positioners;\n\n  constructor(config) {\n    super();\n\n    this.opacity = 0;\n    this._active = [];\n    this._eventPosition = undefined;\n    this._size = undefined;\n    this._cachedAnimations = undefined;\n    this._tooltipItems = [];\n    this.$animations = undefined;\n    this.$context = undefined;\n    this.chart = config.chart;\n    this.options = config.options;\n    this.dataPoints = undefined;\n    this.title = undefined;\n    this.beforeBody = undefined;\n    this.body = undefined;\n    this.afterBody = undefined;\n    this.footer = undefined;\n    this.xAlign = undefined;\n    this.yAlign = undefined;\n    this.x = undefined;\n    this.y = undefined;\n    this.height = undefined;\n    this.width = undefined;\n    this.caretX = undefined;\n    this.caretY = undefined;\n    // TODO: V4, make this private, rename to `_labelStyles`, and combine with `labelPointStyles`\n    // and `labelTextColors` to create a single variable\n    this.labelColors = undefined;\n    this.labelPointStyles = undefined;\n    this.labelTextColors = undefined;\n  }\n\n  initialize(options) {\n    this.options = options;\n    this._cachedAnimations = undefined;\n    this.$context = undefined;\n  }\n\n  /**\n\t * @private\n\t */\n  _resolveAnimations() {\n    const cached = this._cachedAnimations;\n\n    if (cached) {\n      return cached;\n    }\n\n    const chart = this.chart;\n    const options = this.options.setContext(this.getContext());\n    const opts = options.enabled && chart.options.animation && options.animations;\n    const animations = new Animations(this.chart, opts);\n    if (opts._cacheable) {\n      this._cachedAnimations = Object.freeze(animations);\n    }\n\n    return animations;\n  }\n\n  /**\n\t * @protected\n\t */\n  getContext() {\n    return this.$context ||\n\t\t\t(this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));\n  }\n\n  getTitle(context, options) {\n    const {callbacks} = options;\n\n    const beforeTitle = invokeCallbackWithFallback(callbacks, 'beforeTitle', this, context);\n    const title = invokeCallbackWithFallback(callbacks, 'title', this, context);\n    const afterTitle = invokeCallbackWithFallback(callbacks, 'afterTitle', this, context);\n\n    let lines = [];\n    lines = pushOrConcat(lines, splitNewlines(beforeTitle));\n    lines = pushOrConcat(lines, splitNewlines(title));\n    lines = pushOrConcat(lines, splitNewlines(afterTitle));\n\n    return lines;\n  }\n\n  getBeforeBody(tooltipItems, options) {\n    return getBeforeAfterBodyLines(\n      invokeCallbackWithFallback(options.callbacks, 'beforeBody', this, tooltipItems)\n    );\n  }\n\n  getBody(tooltipItems, options) {\n    const {callbacks} = options;\n    const bodyItems = [];\n\n    each(tooltipItems, (context) => {\n      const bodyItem = {\n        before: [],\n        lines: [],\n        after: []\n      };\n      const scoped = overrideCallbacks(callbacks, context);\n      pushOrConcat(bodyItem.before, splitNewlines(invokeCallbackWithFallback(scoped, 'beforeLabel', this, context)));\n      pushOrConcat(bodyItem.lines, invokeCallbackWithFallback(scoped, 'label', this, context));\n      pushOrConcat(bodyItem.after, splitNewlines(invokeCallbackWithFallback(scoped, 'afterLabel', this, context)));\n\n      bodyItems.push(bodyItem);\n    });\n\n    return bodyItems;\n  }\n\n  getAfterBody(tooltipItems, options) {\n    return getBeforeAfterBodyLines(\n      invokeCallbackWithFallback(options.callbacks, 'afterBody', this, tooltipItems)\n    );\n  }\n\n  // Get the footer and beforeFooter and afterFooter lines\n  getFooter(tooltipItems, options) {\n    const {callbacks} = options;\n\n    const beforeFooter = invokeCallbackWithFallback(callbacks, 'beforeFooter', this, tooltipItems);\n    const footer = invokeCallbackWithFallback(callbacks, 'footer', this, tooltipItems);\n    const afterFooter = invokeCallbackWithFallback(callbacks, 'afterFooter', this, tooltipItems);\n\n    let lines = [];\n    lines = pushOrConcat(lines, splitNewlines(beforeFooter));\n    lines = pushOrConcat(lines, splitNewlines(footer));\n    lines = pushOrConcat(lines, splitNewlines(afterFooter));\n\n    return lines;\n  }\n\n  /**\n\t * @private\n\t */\n  _createItems(options) {\n    const active = this._active;\n    const data = this.chart.data;\n    const labelColors = [];\n    const labelPointStyles = [];\n    const labelTextColors = [];\n    let tooltipItems = [];\n    let i, len;\n\n    for (i = 0, len = active.length; i < len; ++i) {\n      tooltipItems.push(createTooltipItem(this.chart, active[i]));\n    }\n\n    // If the user provided a filter function, use it to modify the tooltip items\n    if (options.filter) {\n      tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));\n    }\n\n    // If the user provided a sorting function, use it to modify the tooltip items\n    if (options.itemSort) {\n      tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data));\n    }\n\n    // Determine colors for boxes\n    each(tooltipItems, (context) => {\n      const scoped = overrideCallbacks(options.callbacks, context);\n      labelColors.push(invokeCallbackWithFallback(scoped, 'labelColor', this, context));\n      labelPointStyles.push(invokeCallbackWithFallback(scoped, 'labelPointStyle', this, context));\n      labelTextColors.push(invokeCallbackWithFallback(scoped, 'labelTextColor', this, context));\n    });\n\n    this.labelColors = labelColors;\n    this.labelPointStyles = labelPointStyles;\n    this.labelTextColors = labelTextColors;\n    this.dataPoints = tooltipItems;\n    return tooltipItems;\n  }\n\n  update(changed, replay) {\n    const options = this.options.setContext(this.getContext());\n    const active = this._active;\n    let properties;\n    let tooltipItems = [];\n\n    if (!active.length) {\n      if (this.opacity !== 0) {\n        properties = {\n          opacity: 0\n        };\n      }\n    } else {\n      const position = positioners[options.position].call(this, active, this._eventPosition);\n      tooltipItems = this._createItems(options);\n\n      this.title = this.getTitle(tooltipItems, options);\n      this.beforeBody = this.getBeforeBody(tooltipItems, options);\n      this.body = this.getBody(tooltipItems, options);\n      this.afterBody = this.getAfterBody(tooltipItems, options);\n      this.footer = this.getFooter(tooltipItems, options);\n\n      const size = this._size = getTooltipSize(this, options);\n      const positionAndSize = Object.assign({}, position, size);\n      const alignment = determineAlignment(this.chart, options, positionAndSize);\n      const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);\n\n      this.xAlign = alignment.xAlign;\n      this.yAlign = alignment.yAlign;\n\n      properties = {\n        opacity: 1,\n        x: backgroundPoint.x,\n        y: backgroundPoint.y,\n        width: size.width,\n        height: size.height,\n        caretX: position.x,\n        caretY: position.y\n      };\n    }\n\n    this._tooltipItems = tooltipItems;\n    this.$context = undefined;\n\n    if (properties) {\n      this._resolveAnimations().update(this, properties);\n    }\n\n    if (changed && options.external) {\n      options.external.call(this, {chart: this.chart, tooltip: this, replay});\n    }\n  }\n\n  drawCaret(tooltipPoint, ctx, size, options) {\n    const caretPosition = this.getCaretPosition(tooltipPoint, size, options);\n\n    ctx.lineTo(caretPosition.x1, caretPosition.y1);\n    ctx.lineTo(caretPosition.x2, caretPosition.y2);\n    ctx.lineTo(caretPosition.x3, caretPosition.y3);\n  }\n\n  getCaretPosition(tooltipPoint, size, options) {\n    const {xAlign, yAlign} = this;\n    const {caretSize, cornerRadius} = options;\n    const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n    const {x: ptX, y: ptY} = tooltipPoint;\n    const {width, height} = size;\n    let x1, x2, x3, y1, y2, y3;\n\n    if (yAlign === 'center') {\n      y2 = ptY + (height / 2);\n\n      if (xAlign === 'left') {\n        x1 = ptX;\n        x2 = x1 - caretSize;\n\n        // Left draws bottom -> top, this y1 is on the bottom\n        y1 = y2 + caretSize;\n        y3 = y2 - caretSize;\n      } else {\n        x1 = ptX + width;\n        x2 = x1 + caretSize;\n\n        // Right draws top -> bottom, thus y1 is on the top\n        y1 = y2 - caretSize;\n        y3 = y2 + caretSize;\n      }\n\n      x3 = x1;\n    } else {\n      if (xAlign === 'left') {\n        x2 = ptX + Math.max(topLeft, bottomLeft) + (caretSize);\n      } else if (xAlign === 'right') {\n        x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;\n      } else {\n        x2 = this.caretX;\n      }\n\n      if (yAlign === 'top') {\n        y1 = ptY;\n        y2 = y1 - caretSize;\n\n        // Top draws left -> right, thus x1 is on the left\n        x1 = x2 - caretSize;\n        x3 = x2 + caretSize;\n      } else {\n        y1 = ptY + height;\n        y2 = y1 + caretSize;\n\n        // Bottom draws right -> left, thus x1 is on the right\n        x1 = x2 + caretSize;\n        x3 = x2 - caretSize;\n      }\n      y3 = y1;\n    }\n    return {x1, x2, x3, y1, y2, y3};\n  }\n\n  drawTitle(pt, ctx, options) {\n    const title = this.title;\n    const length = title.length;\n    let titleFont, titleSpacing, i;\n\n    if (length) {\n      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n\n      pt.x = getAlignedX(this, options.titleAlign, options);\n\n      ctx.textAlign = rtlHelper.textAlign(options.titleAlign);\n      ctx.textBaseline = 'middle';\n\n      titleFont = toFont(options.titleFont);\n      titleSpacing = options.titleSpacing;\n\n      ctx.fillStyle = options.titleColor;\n      ctx.font = titleFont.string;\n\n      for (i = 0; i < length; ++i) {\n        ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2);\n        pt.y += titleFont.lineHeight + titleSpacing; // Line Height and spacing\n\n        if (i + 1 === length) {\n          pt.y += options.titleMarginBottom - titleSpacing; // If Last, add margin, remove spacing\n        }\n      }\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _drawColorBox(ctx, pt, i, rtlHelper, options) {\n    const labelColor = this.labelColors[i];\n    const labelPointStyle = this.labelPointStyles[i];\n    const {boxHeight, boxWidth} = options;\n    const bodyFont = toFont(options.bodyFont);\n    const colorX = getAlignedX(this, 'left', options);\n    const rtlColorX = rtlHelper.x(colorX);\n    const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;\n    const colorY = pt.y + yOffSet;\n\n    if (options.usePointStyle) {\n      const drawOptions = {\n        radius: Math.min(boxWidth, boxHeight) / 2, // fit the circle in the box\n        pointStyle: labelPointStyle.pointStyle,\n        rotation: labelPointStyle.rotation,\n        borderWidth: 1\n      };\n      // Recalculate x and y for drawPoint() because its expecting\n      // x and y to be center of figure (instead of top left)\n      const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;\n      const centerY = colorY + boxHeight / 2;\n\n      // Fill the point with white so that colours merge nicely if the opacity is < 1\n      ctx.strokeStyle = options.multiKeyBackground;\n      ctx.fillStyle = options.multiKeyBackground;\n      drawPoint(ctx, drawOptions, centerX, centerY);\n\n      // Draw the point\n      ctx.strokeStyle = labelColor.borderColor;\n      ctx.fillStyle = labelColor.backgroundColor;\n      drawPoint(ctx, drawOptions, centerX, centerY);\n    } else {\n      // Border\n      ctx.lineWidth = isObject(labelColor.borderWidth) ? Math.max(...Object.values(labelColor.borderWidth)) : (labelColor.borderWidth || 1); // TODO, v4 remove fallback\n      ctx.strokeStyle = labelColor.borderColor;\n      ctx.setLineDash(labelColor.borderDash || []);\n      ctx.lineDashOffset = labelColor.borderDashOffset || 0;\n\n      // Fill a white rect so that colours merge nicely if the opacity is < 1\n      const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth);\n      const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - 2);\n      const borderRadius = toTRBLCorners(labelColor.borderRadius);\n\n      if (Object.values(borderRadius).some(v => v !== 0)) {\n        ctx.beginPath();\n        ctx.fillStyle = options.multiKeyBackground;\n        addRoundedRectPath(ctx, {\n          x: outerX,\n          y: colorY,\n          w: boxWidth,\n          h: boxHeight,\n          radius: borderRadius,\n        });\n        ctx.fill();\n        ctx.stroke();\n\n        // Inner square\n        ctx.fillStyle = labelColor.backgroundColor;\n        ctx.beginPath();\n        addRoundedRectPath(ctx, {\n          x: innerX,\n          y: colorY + 1,\n          w: boxWidth - 2,\n          h: boxHeight - 2,\n          radius: borderRadius,\n        });\n        ctx.fill();\n      } else {\n        // Normal rect\n        ctx.fillStyle = options.multiKeyBackground;\n        ctx.fillRect(outerX, colorY, boxWidth, boxHeight);\n        ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);\n        // Inner square\n        ctx.fillStyle = labelColor.backgroundColor;\n        ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);\n      }\n    }\n\n    // restore fillStyle\n    ctx.fillStyle = this.labelTextColors[i];\n  }\n\n  drawBody(pt, ctx, options) {\n    const {body} = this;\n    const {bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding} = options;\n    const bodyFont = toFont(options.bodyFont);\n    let bodyLineHeight = bodyFont.lineHeight;\n    let xLinePadding = 0;\n\n    const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n\n    const fillLineOfText = function(line) {\n      ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);\n      pt.y += bodyLineHeight + bodySpacing;\n    };\n\n    const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);\n    let bodyItem, textColor, lines, i, j, ilen, jlen;\n\n    ctx.textAlign = bodyAlign;\n    ctx.textBaseline = 'middle';\n    ctx.font = bodyFont.string;\n\n    pt.x = getAlignedX(this, bodyAlignForCalculation, options);\n\n    // Before body lines\n    ctx.fillStyle = options.bodyColor;\n    each(this.beforeBody, fillLineOfText);\n\n    xLinePadding = displayColors && bodyAlignForCalculation !== 'right'\n      ? bodyAlign === 'center' ? (boxWidth / 2 + boxPadding) : (boxWidth + 2 + boxPadding)\n      : 0;\n\n    // Draw body lines now\n    for (i = 0, ilen = body.length; i < ilen; ++i) {\n      bodyItem = body[i];\n      textColor = this.labelTextColors[i];\n\n      ctx.fillStyle = textColor;\n      each(bodyItem.before, fillLineOfText);\n\n      lines = bodyItem.lines;\n      // Draw Legend-like boxes if needed\n      if (displayColors && lines.length) {\n        this._drawColorBox(ctx, pt, i, rtlHelper, options);\n        bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);\n      }\n\n      for (j = 0, jlen = lines.length; j < jlen; ++j) {\n        fillLineOfText(lines[j]);\n        // Reset for any lines that don't include colorbox\n        bodyLineHeight = bodyFont.lineHeight;\n      }\n\n      each(bodyItem.after, fillLineOfText);\n    }\n\n    // Reset back to 0 for after body\n    xLinePadding = 0;\n    bodyLineHeight = bodyFont.lineHeight;\n\n    // After body lines\n    each(this.afterBody, fillLineOfText);\n    pt.y -= bodySpacing; // Remove last body spacing\n  }\n\n  drawFooter(pt, ctx, options) {\n    const footer = this.footer;\n    const length = footer.length;\n    let footerFont, i;\n\n    if (length) {\n      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n\n      pt.x = getAlignedX(this, options.footerAlign, options);\n      pt.y += options.footerMarginTop;\n\n      ctx.textAlign = rtlHelper.textAlign(options.footerAlign);\n      ctx.textBaseline = 'middle';\n\n      footerFont = toFont(options.footerFont);\n\n      ctx.fillStyle = options.footerColor;\n      ctx.font = footerFont.string;\n\n      for (i = 0; i < length; ++i) {\n        ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2);\n        pt.y += footerFont.lineHeight + options.footerSpacing;\n      }\n    }\n  }\n\n  drawBackground(pt, ctx, tooltipSize, options) {\n    const {xAlign, yAlign} = this;\n    const {x, y} = pt;\n    const {width, height} = tooltipSize;\n    const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(options.cornerRadius);\n\n    ctx.fillStyle = options.backgroundColor;\n    ctx.strokeStyle = options.borderColor;\n    ctx.lineWidth = options.borderWidth;\n\n    ctx.beginPath();\n    ctx.moveTo(x + topLeft, y);\n    if (yAlign === 'top') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x + width - topRight, y);\n    ctx.quadraticCurveTo(x + width, y, x + width, y + topRight);\n    if (yAlign === 'center' && xAlign === 'right') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x + width, y + height - bottomRight);\n    ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height);\n    if (yAlign === 'bottom') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x + bottomLeft, y + height);\n    ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft);\n    if (yAlign === 'center' && xAlign === 'left') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x, y + topLeft);\n    ctx.quadraticCurveTo(x, y, x + topLeft, y);\n    ctx.closePath();\n\n    ctx.fill();\n\n    if (options.borderWidth > 0) {\n      ctx.stroke();\n    }\n  }\n\n  /**\n\t * Update x/y animation targets when _active elements are animating too\n\t * @private\n\t */\n  _updateAnimationTarget(options) {\n    const chart = this.chart;\n    const anims = this.$animations;\n    const animX = anims && anims.x;\n    const animY = anims && anims.y;\n    if (animX || animY) {\n      const position = positioners[options.position].call(this, this._active, this._eventPosition);\n      if (!position) {\n        return;\n      }\n      const size = this._size = getTooltipSize(this, options);\n      const positionAndSize = Object.assign({}, position, this._size);\n      const alignment = determineAlignment(chart, options, positionAndSize);\n      const point = getBackgroundPoint(options, positionAndSize, alignment, chart);\n      if (animX._to !== point.x || animY._to !== point.y) {\n        this.xAlign = alignment.xAlign;\n        this.yAlign = alignment.yAlign;\n        this.width = size.width;\n        this.height = size.height;\n        this.caretX = position.x;\n        this.caretY = position.y;\n        this._resolveAnimations().update(this, point);\n      }\n    }\n  }\n\n  /**\n   * Determine if the tooltip will draw anything\n   * @returns {boolean} True if the tooltip will render\n   */\n  _willRender() {\n    return !!this.opacity;\n  }\n\n  draw(ctx) {\n    const options = this.options.setContext(this.getContext());\n    let opacity = this.opacity;\n\n    if (!opacity) {\n      return;\n    }\n\n    this._updateAnimationTarget(options);\n\n    const tooltipSize = {\n      width: this.width,\n      height: this.height\n    };\n    const pt = {\n      x: this.x,\n      y: this.y\n    };\n\n    // IE11/Edge does not like very small opacities, so snap to 0\n    opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;\n\n    const padding = toPadding(options.padding);\n\n    // Truthy/falsey value for empty tooltip\n    const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;\n\n    if (options.enabled && hasTooltipContent) {\n      ctx.save();\n      ctx.globalAlpha = opacity;\n\n      // Draw Background\n      this.drawBackground(pt, ctx, tooltipSize, options);\n\n      overrideTextDirection(ctx, options.textDirection);\n\n      pt.y += padding.top;\n\n      // Titles\n      this.drawTitle(pt, ctx, options);\n\n      // Body\n      this.drawBody(pt, ctx, options);\n\n      // Footer\n      this.drawFooter(pt, ctx, options);\n\n      restoreTextDirection(ctx, options.textDirection);\n\n      ctx.restore();\n    }\n  }\n\n  /**\n\t * Get active elements in the tooltip\n\t * @returns {Array} Array of elements that are active in the tooltip\n\t */\n  getActiveElements() {\n    return this._active || [];\n  }\n\n  /**\n\t * Set active elements in the tooltip\n\t * @param {array} activeElements Array of active datasetIndex/index pairs.\n\t * @param {object} eventPosition Synthetic event position used in positioning\n\t */\n  setActiveElements(activeElements, eventPosition) {\n    const lastActive = this._active;\n    const active = activeElements.map(({datasetIndex, index}) => {\n      const meta = this.chart.getDatasetMeta(datasetIndex);\n\n      if (!meta) {\n        throw new Error('Cannot find a dataset at index ' + datasetIndex);\n      }\n\n      return {\n        datasetIndex,\n        element: meta.data[index],\n        index,\n      };\n    });\n    const changed = !_elementsEqual(lastActive, active);\n    const positionChanged = this._positionChanged(active, eventPosition);\n\n    if (changed || positionChanged) {\n      this._active = active;\n      this._eventPosition = eventPosition;\n      this._ignoreReplayEvents = true;\n      this.update(true);\n    }\n  }\n\n  /**\n\t * Handle an event\n\t * @param {ChartEvent} e - The event to handle\n\t * @param {boolean} [replay] - This is a replayed event (from update)\n\t * @param {boolean} [inChartArea] - The event is inside chartArea\n\t * @returns {boolean} true if the tooltip changed\n\t */\n  handleEvent(e, replay, inChartArea = true) {\n    if (replay && this._ignoreReplayEvents) {\n      return false;\n    }\n    this._ignoreReplayEvents = false;\n\n    const options = this.options;\n    const lastActive = this._active || [];\n    const active = this._getActiveElements(e, lastActive, replay, inChartArea);\n\n    // When there are multiple items shown, but the tooltip position is nearest mode\n    // an update may need to be made because our position may have changed even though\n    // the items are the same as before.\n    const positionChanged = this._positionChanged(active, e);\n\n    // Remember Last Actives\n    const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;\n\n    // Only handle target event on tooltip change\n    if (changed) {\n      this._active = active;\n\n      if (options.enabled || options.external) {\n        this._eventPosition = {\n          x: e.x,\n          y: e.y\n        };\n\n        this.update(true, replay);\n      }\n    }\n\n    return changed;\n  }\n\n  /**\n\t * Helper for determining the active elements for event\n\t * @param {ChartEvent} e - The event to handle\n\t * @param {InteractionItem[]} lastActive - Previously active elements\n\t * @param {boolean} [replay] - This is a replayed event (from update)\n\t * @param {boolean} [inChartArea] - The event is inside chartArea\n\t * @returns {InteractionItem[]} - Active elements\n\t * @private\n\t */\n  _getActiveElements(e, lastActive, replay, inChartArea) {\n    const options = this.options;\n\n    if (e.type === 'mouseout') {\n      return [];\n    }\n\n    if (!inChartArea) {\n      // Let user control the active elements outside chartArea. Eg. using Legend.\n      // But make sure that active elements are still valid.\n      return lastActive.filter(i =>\n        this.chart.data.datasets[i.datasetIndex] &&\n        this.chart.getDatasetMeta(i.datasetIndex).controller.getParsed(i.index) !== undefined\n      );\n    }\n\n    // Find Active Elements for tooltips\n    const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);\n\n    if (options.reverse) {\n      active.reverse();\n    }\n\n    return active;\n  }\n\n  /**\n\t * Determine if the active elements + event combination changes the\n\t * tooltip position\n\t * @param {array} active - Active elements\n\t * @param {ChartEvent} e - Event that triggered the position change\n\t * @returns {boolean} True if the position has changed\n\t */\n  _positionChanged(active, e) {\n    const {caretX, caretY, options} = this;\n    const position = positioners[options.position].call(this, active, e);\n    return position !== false && (caretX !== position.x || caretY !== position.y);\n  }\n}\n\nexport default {\n  id: 'tooltip',\n  _element: Tooltip,\n  positioners,\n\n  afterInit(chart, _args, options) {\n    if (options) {\n      chart.tooltip = new Tooltip({chart, options});\n    }\n  },\n\n  beforeUpdate(chart, _args, options) {\n    if (chart.tooltip) {\n      chart.tooltip.initialize(options);\n    }\n  },\n\n  reset(chart, _args, options) {\n    if (chart.tooltip) {\n      chart.tooltip.initialize(options);\n    }\n  },\n\n  afterDraw(chart) {\n    const tooltip = chart.tooltip;\n\n    if (tooltip && tooltip._willRender()) {\n      const args = {\n        tooltip\n      };\n\n      if (chart.notifyPlugins('beforeTooltipDraw', {...args, cancelable: true}) === false) {\n        return;\n      }\n\n      tooltip.draw(chart.ctx);\n\n      chart.notifyPlugins('afterTooltipDraw', args);\n    }\n  },\n\n  afterEvent(chart, args) {\n    if (chart.tooltip) {\n      // If the event is replayed from `update`, we should evaluate with the final positions.\n      const useFinalPosition = args.replay;\n      if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {\n        // notify chart about the change, so it will render\n        args.changed = true;\n      }\n    }\n  },\n\n  defaults: {\n    enabled: true,\n    external: null,\n    position: 'average',\n    backgroundColor: 'rgba(0,0,0,0.8)',\n    titleColor: '#fff',\n    titleFont: {\n      weight: 'bold',\n    },\n    titleSpacing: 2,\n    titleMarginBottom: 6,\n    titleAlign: 'left',\n    bodyColor: '#fff',\n    bodySpacing: 2,\n    bodyFont: {\n    },\n    bodyAlign: 'left',\n    footerColor: '#fff',\n    footerSpacing: 2,\n    footerMarginTop: 6,\n    footerFont: {\n      weight: 'bold',\n    },\n    footerAlign: 'left',\n    padding: 6,\n    caretPadding: 2,\n    caretSize: 5,\n    cornerRadius: 6,\n    boxHeight: (ctx, opts) => opts.bodyFont.size,\n    boxWidth: (ctx, opts) => opts.bodyFont.size,\n    multiKeyBackground: '#fff',\n    displayColors: true,\n    boxPadding: 0,\n    borderColor: 'rgba(0,0,0,0)',\n    borderWidth: 0,\n    animation: {\n      duration: 400,\n      easing: 'easeOutQuart',\n    },\n    animations: {\n      numbers: {\n        type: 'number',\n        properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'],\n      },\n      opacity: {\n        easing: 'linear',\n        duration: 200\n      }\n    },\n    callbacks: defaultCallbacks\n  },\n\n  defaultRoutes: {\n    bodyFont: 'font',\n    footerFont: 'font',\n    titleFont: 'font'\n  },\n\n  descriptors: {\n    _scriptable: (name) => name !== 'filter' && name !== 'itemSort' && name !== 'external',\n    _indexable: false,\n    callbacks: {\n      _scriptable: false,\n      _indexable: false,\n    },\n    animation: {\n      _fallback: false\n    },\n    animations: {\n      _fallback: 'animation'\n    }\n  },\n\n  // Resolve additionally from `interaction` options and defaults.\n  additionalOptionScopes: ['interaction']\n};\n","import Scale from '../core/core.scale.js';\nimport {isNullOrUndef, valueOrDefault, _limitValue} from '../helpers/index.js';\n\nconst addIfString = (labels, raw, index, addedLabels) => {\n  if (typeof raw === 'string') {\n    index = labels.push(raw) - 1;\n    addedLabels.unshift({index, label: raw});\n  } else if (isNaN(raw)) {\n    index = null;\n  }\n  return index;\n};\n\nfunction findOrAddLabel(labels, raw, index, addedLabels) {\n  const first = labels.indexOf(raw);\n  if (first === -1) {\n    return addIfString(labels, raw, index, addedLabels);\n  }\n  const last = labels.lastIndexOf(raw);\n  return first !== last ? index : first;\n}\n\nconst validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max);\n\nfunction _getLabelForValue(value) {\n  const labels = this.getLabels();\n\n  if (value >= 0 && value < labels.length) {\n    return labels[value];\n  }\n  return value;\n}\n\nexport default class CategoryScale extends Scale {\n\n  static id = 'category';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    ticks: {\n      callback: _getLabelForValue\n    }\n  };\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this._startValue = undefined;\n    this._valueRange = 0;\n    this._addedLabels = [];\n  }\n\n  init(scaleOptions) {\n    const added = this._addedLabels;\n    if (added.length) {\n      const labels = this.getLabels();\n      for (const {index, label} of added) {\n        if (labels[index] === label) {\n          labels.splice(index, 1);\n        }\n      }\n      this._addedLabels = [];\n    }\n    super.init(scaleOptions);\n  }\n\n  parse(raw, index) {\n    if (isNullOrUndef(raw)) {\n      return null;\n    }\n    const labels = this.getLabels();\n    index = isFinite(index) && labels[index] === raw ? index\n      : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);\n    return validIndex(index, labels.length - 1);\n  }\n\n  determineDataLimits() {\n    const {minDefined, maxDefined} = this.getUserBounds();\n    let {min, max} = this.getMinMax(true);\n\n    if (this.options.bounds === 'ticks') {\n      if (!minDefined) {\n        min = 0;\n      }\n      if (!maxDefined) {\n        max = this.getLabels().length - 1;\n      }\n    }\n\n    this.min = min;\n    this.max = max;\n  }\n\n  buildTicks() {\n    const min = this.min;\n    const max = this.max;\n    const offset = this.options.offset;\n    const ticks = [];\n    let labels = this.getLabels();\n\n    // If we are viewing some subset of labels, slice the original array\n    labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1);\n\n    this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);\n    this._startValue = this.min - (offset ? 0.5 : 0);\n\n    for (let value = min; value <= max; value++) {\n      ticks.push({value});\n    }\n    return ticks;\n  }\n\n  getLabelForValue(value) {\n    return _getLabelForValue.call(this, value);\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    super.configure();\n\n    if (!this.isHorizontal()) {\n      // For backward compatibility, vertical category scale reverse is inverted.\n      this._reversePixels = !this._reversePixels;\n    }\n  }\n\n  // Used to get data value locations. Value can either be an index or a numerical value\n  getPixelForValue(value) {\n    if (typeof value !== 'number') {\n      value = this.parse(value);\n    }\n\n    return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n  }\n\n  // Must override base implementation because it calls getPixelForValue\n  // and category scale can have duplicate values\n  getPixelForTick(index) {\n    const ticks = this.ticks;\n    if (index < 0 || index > ticks.length - 1) {\n      return null;\n    }\n    return this.getPixelForValue(ticks[index].value);\n  }\n\n  getValueForPixel(pixel) {\n    return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);\n  }\n\n  getBasePixel() {\n    return this.bottom;\n  }\n}\n","import {isNullOrUndef} from '../helpers/helpers.core.js';\nimport {almostEquals, almostWhole, niceNum, _decimalPlaces, _setMinAndMaxByKey, sign, toRadians} from '../helpers/helpers.math.js';\nimport Scale from '../core/core.scale.js';\nimport {formatNumber} from '../helpers/helpers.intl.js';\n\n/**\n * Generate a set of linear ticks for an axis\n * 1. If generationOptions.min, generationOptions.max, and generationOptions.step are defined:\n *    if (max - min) / step is an integer, ticks are generated as [min, min + step, ..., max]\n *    Note that the generationOptions.maxCount setting is respected in this scenario\n *\n * 2. If generationOptions.min, generationOptions.max, and generationOptions.count is defined\n *    spacing = (max - min) / count\n *    Ticks are generated as [min, min + spacing, ..., max]\n *\n * 3. If generationOptions.count is defined\n *    spacing = (niceMax - niceMin) / count\n *\n * 4. Compute optimal spacing of ticks using niceNum algorithm\n *\n * @param generationOptions the options used to generate the ticks\n * @param dataRange the range of the data\n * @returns {object[]} array of tick objects\n */\nfunction generateTicks(generationOptions, dataRange) {\n  const ticks = [];\n  // To get a \"nice\" value for the tick spacing, we will use the appropriately named\n  // \"nice number\" algorithm. See https://stackoverflow.com/questions/8506881/nice-label-algorithm-for-charts-with-minimum-ticks\n  // for details.\n\n  const MIN_SPACING = 1e-14;\n  const {bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds} = generationOptions;\n  const unit = step || 1;\n  const maxSpaces = maxTicks - 1;\n  const {min: rmin, max: rmax} = dataRange;\n  const minDefined = !isNullOrUndef(min);\n  const maxDefined = !isNullOrUndef(max);\n  const countDefined = !isNullOrUndef(count);\n  const minSpacing = (rmax - rmin) / (maxDigits + 1);\n  let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;\n  let factor, niceMin, niceMax, numSpaces;\n\n  // Beyond MIN_SPACING floating point numbers being to lose precision\n  // such that we can't do the math necessary to generate ticks\n  if (spacing < MIN_SPACING && !minDefined && !maxDefined) {\n    return [{value: rmin}, {value: rmax}];\n  }\n\n  numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);\n  if (numSpaces > maxSpaces) {\n    // If the calculated num of spaces exceeds maxNumSpaces, recalculate it\n    spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;\n  }\n\n  if (!isNullOrUndef(precision)) {\n    // If the user specified a precision, round to that number of decimal places\n    factor = Math.pow(10, precision);\n    spacing = Math.ceil(spacing * factor) / factor;\n  }\n\n  if (bounds === 'ticks') {\n    niceMin = Math.floor(rmin / spacing) * spacing;\n    niceMax = Math.ceil(rmax / spacing) * spacing;\n  } else {\n    niceMin = rmin;\n    niceMax = rmax;\n  }\n\n  if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) {\n    // Case 1: If min, max and stepSize are set and they make an evenly spaced scale use it.\n    // spacing = step;\n    // numSpaces = (max - min) / spacing;\n    // Note that we round here to handle the case where almostWhole translated an FP error\n    numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));\n    spacing = (max - min) / numSpaces;\n    niceMin = min;\n    niceMax = max;\n  } else if (countDefined) {\n    // Cases 2 & 3, we have a count specified. Handle optional user defined edges to the range.\n    // Sometimes these are no-ops, but it makes the code a lot clearer\n    // and when a user defined range is specified, we want the correct ticks\n    niceMin = minDefined ? min : niceMin;\n    niceMax = maxDefined ? max : niceMax;\n    numSpaces = count - 1;\n    spacing = (niceMax - niceMin) / numSpaces;\n  } else {\n    // Case 4\n    numSpaces = (niceMax - niceMin) / spacing;\n\n    // If very close to our rounded value, use it.\n    if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {\n      numSpaces = Math.round(numSpaces);\n    } else {\n      numSpaces = Math.ceil(numSpaces);\n    }\n  }\n\n  // The spacing will have changed in cases 1, 2, and 3 so the factor cannot be computed\n  // until this point\n  const decimalPlaces = Math.max(\n    _decimalPlaces(spacing),\n    _decimalPlaces(niceMin)\n  );\n  factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);\n  niceMin = Math.round(niceMin * factor) / factor;\n  niceMax = Math.round(niceMax * factor) / factor;\n\n  let j = 0;\n  if (minDefined) {\n    if (includeBounds && niceMin !== min) {\n      ticks.push({value: min});\n\n      if (niceMin < min) {\n        j++; // Skip niceMin\n      }\n      // If the next nice tick is close to min, skip it\n      if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {\n        j++;\n      }\n    } else if (niceMin < min) {\n      j++;\n    }\n  }\n\n  for (; j < numSpaces; ++j) {\n    const tickValue = Math.round((niceMin + j * spacing) * factor) / factor;\n    if (maxDefined && tickValue > max) {\n      break;\n    }\n    ticks.push({value: tickValue});\n  }\n\n  if (maxDefined && includeBounds && niceMax !== max) {\n    // If the previous tick is too close to max, replace it with max, else add max\n    if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {\n      ticks[ticks.length - 1].value = max;\n    } else {\n      ticks.push({value: max});\n    }\n  } else if (!maxDefined || niceMax === max) {\n    ticks.push({value: niceMax});\n  }\n\n  return ticks;\n}\n\nfunction relativeLabelSize(value, minSpacing, {horizontal, minRotation}) {\n  const rad = toRadians(minRotation);\n  const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001;\n  const length = 0.75 * minSpacing * ('' + value).length;\n  return Math.min(minSpacing / ratio, length);\n}\n\nexport default class LinearScaleBase extends Scale {\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this.start = undefined;\n    /** @type {number} */\n    this.end = undefined;\n    /** @type {number} */\n    this._startValue = undefined;\n    /** @type {number} */\n    this._endValue = undefined;\n    this._valueRange = 0;\n  }\n\n  parse(raw, index) { // eslint-disable-line no-unused-vars\n    if (isNullOrUndef(raw)) {\n      return null;\n    }\n    if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) {\n      return null;\n    }\n\n    return +raw;\n  }\n\n  handleTickRangeOptions() {\n    const {beginAtZero} = this.options;\n    const {minDefined, maxDefined} = this.getUserBounds();\n    let {min, max} = this;\n\n    const setMin = v => (min = minDefined ? min : v);\n    const setMax = v => (max = maxDefined ? max : v);\n\n    if (beginAtZero) {\n      const minSign = sign(min);\n      const maxSign = sign(max);\n\n      if (minSign < 0 && maxSign < 0) {\n        setMax(0);\n      } else if (minSign > 0 && maxSign > 0) {\n        setMin(0);\n      }\n    }\n\n    if (min === max) {\n      let offset = max === 0 ? 1 : Math.abs(max * 0.05);\n\n      setMax(max + offset);\n\n      if (!beginAtZero) {\n        setMin(min - offset);\n      }\n    }\n    this.min = min;\n    this.max = max;\n  }\n\n  getTickLimit() {\n    const tickOpts = this.options.ticks;\n    // eslint-disable-next-line prefer-const\n    let {maxTicksLimit, stepSize} = tickOpts;\n    let maxTicks;\n\n    if (stepSize) {\n      maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;\n      if (maxTicks > 1000) {\n        console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);\n        maxTicks = 1000;\n      }\n    } else {\n      maxTicks = this.computeTickLimit();\n      maxTicksLimit = maxTicksLimit || 11;\n    }\n\n    if (maxTicksLimit) {\n      maxTicks = Math.min(maxTicksLimit, maxTicks);\n    }\n\n    return maxTicks;\n  }\n\n  /**\n\t * @protected\n\t */\n  computeTickLimit() {\n    return Number.POSITIVE_INFINITY;\n  }\n\n  buildTicks() {\n    const opts = this.options;\n    const tickOpts = opts.ticks;\n\n    // Figure out what the max number of ticks we can support it is based on the size of\n    // the axis area. For now, we say that the minimum tick spacing in pixels must be 40\n    // We also limit the maximum number of ticks to 11 which gives a nice 10 squares on\n    // the graph. Make sure we always have at least 2 ticks\n    let maxTicks = this.getTickLimit();\n    maxTicks = Math.max(2, maxTicks);\n\n    const numericGeneratorOptions = {\n      maxTicks,\n      bounds: opts.bounds,\n      min: opts.min,\n      max: opts.max,\n      precision: tickOpts.precision,\n      step: tickOpts.stepSize,\n      count: tickOpts.count,\n      maxDigits: this._maxDigits(),\n      horizontal: this.isHorizontal(),\n      minRotation: tickOpts.minRotation || 0,\n      includeBounds: tickOpts.includeBounds !== false\n    };\n    const dataRange = this._range || this;\n    const ticks = generateTicks(numericGeneratorOptions, dataRange);\n\n    // At this point, we need to update our max and min given the tick values,\n    // since we probably have expanded the range of the scale\n    if (opts.bounds === 'ticks') {\n      _setMinAndMaxByKey(ticks, this, 'value');\n    }\n\n    if (opts.reverse) {\n      ticks.reverse();\n\n      this.start = this.max;\n      this.end = this.min;\n    } else {\n      this.start = this.min;\n      this.end = this.max;\n    }\n\n    return ticks;\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    const ticks = this.ticks;\n    let start = this.min;\n    let end = this.max;\n\n    super.configure();\n\n    if (this.options.offset && ticks.length) {\n      const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;\n      start -= offset;\n      end += offset;\n    }\n    this._startValue = start;\n    this._endValue = end;\n    this._valueRange = end - start;\n  }\n\n  getLabelForValue(value) {\n    return formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n  }\n}\n","import {isFinite} from '../helpers/helpers.core.js';\nimport LinearScaleBase from './scale.linearbase.js';\nimport Ticks from '../core/core.ticks.js';\nimport {toRadians} from '../helpers/index.js';\n\nexport default class LinearScale extends LinearScaleBase {\n\n  static id = 'linear';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    ticks: {\n      callback: Ticks.formatters.numeric\n    }\n  };\n\n\n  determineDataLimits() {\n    const {min, max} = this.getMinMax(true);\n\n    this.min = isFinite(min) ? min : 0;\n    this.max = isFinite(max) ? max : 1;\n\n    // Common base implementation to handle min, max, beginAtZero\n    this.handleTickRangeOptions();\n  }\n\n  /**\n\t * Returns the maximum number of ticks based on the scale dimension\n\t * @protected\n \t */\n  computeTickLimit() {\n    const horizontal = this.isHorizontal();\n    const length = horizontal ? this.width : this.height;\n    const minRotation = toRadians(this.options.ticks.minRotation);\n    const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001;\n    const tickFont = this._resolveTickFontOptions(0);\n    return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));\n  }\n\n  // Utils\n  getPixelForValue(value) {\n    return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n  }\n\n  getValueForPixel(pixel) {\n    return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;\n  }\n}\n","import {finiteOrDefault, isFinite} from '../helpers/helpers.core.js';\nimport {formatNumber} from '../helpers/helpers.intl.js';\nimport {_setMinAndMaxByKey, log10} from '../helpers/helpers.math.js';\nimport Scale from '../core/core.scale.js';\nimport LinearScaleBase from './scale.linearbase.js';\nimport Ticks from '../core/core.ticks.js';\n\nconst log10Floor = v => Math.floor(log10(v));\nconst changeExponent = (v, m) => Math.pow(10, log10Floor(v) + m);\n\nfunction isMajor(tickVal) {\n  const remain = tickVal / (Math.pow(10, log10Floor(tickVal)));\n  return remain === 1;\n}\n\nfunction steps(min, max, rangeExp) {\n  const rangeStep = Math.pow(10, rangeExp);\n  const start = Math.floor(min / rangeStep);\n  const end = Math.ceil(max / rangeStep);\n  return end - start;\n}\n\nfunction startExp(min, max) {\n  const range = max - min;\n  let rangeExp = log10Floor(range);\n  while (steps(min, max, rangeExp) > 10) {\n    rangeExp++;\n  }\n  while (steps(min, max, rangeExp) < 10) {\n    rangeExp--;\n  }\n  return Math.min(rangeExp, log10Floor(min));\n}\n\n\n/**\n * Generate a set of logarithmic ticks\n * @param generationOptions the options used to generate the ticks\n * @param dataRange the range of the data\n * @returns {object[]} array of tick objects\n */\nfunction generateTicks(generationOptions, {min, max}) {\n  min = finiteOrDefault(generationOptions.min, min);\n  const ticks = [];\n  const minExp = log10Floor(min);\n  let exp = startExp(min, max);\n  let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;\n  const stepSize = Math.pow(10, exp);\n  const base = minExp > exp ? Math.pow(10, minExp) : 0;\n  const start = Math.round((min - base) * precision) / precision;\n  const offset = Math.floor((min - base) / stepSize / 10) * stepSize * 10;\n  let significand = Math.floor((start - offset) / Math.pow(10, exp));\n  let value = finiteOrDefault(generationOptions.min, Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision);\n  while (value < max) {\n    ticks.push({value, major: isMajor(value), significand});\n    if (significand >= 10) {\n      significand = significand < 15 ? 15 : 20;\n    } else {\n      significand++;\n    }\n    if (significand >= 20) {\n      exp++;\n      significand = 2;\n      precision = exp >= 0 ? 1 : precision;\n    }\n    value = Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision;\n  }\n  const lastTick = finiteOrDefault(generationOptions.max, value);\n  ticks.push({value: lastTick, major: isMajor(lastTick), significand});\n\n  return ticks;\n}\n\nexport default class LogarithmicScale extends Scale {\n\n  static id = 'logarithmic';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    ticks: {\n      callback: Ticks.formatters.logarithmic,\n      major: {\n        enabled: true\n      }\n    }\n  };\n\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this.start = undefined;\n    /** @type {number} */\n    this.end = undefined;\n    /** @type {number} */\n    this._startValue = undefined;\n    this._valueRange = 0;\n  }\n\n  parse(raw, index) {\n    const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]);\n    if (value === 0) {\n      this._zero = true;\n      return undefined;\n    }\n    return isFinite(value) && value > 0 ? value : null;\n  }\n\n  determineDataLimits() {\n    const {min, max} = this.getMinMax(true);\n\n    this.min = isFinite(min) ? Math.max(0, min) : null;\n    this.max = isFinite(max) ? Math.max(0, max) : null;\n\n    if (this.options.beginAtZero) {\n      this._zero = true;\n    }\n\n    // if data has `0` in it or `beginAtZero` is true, min (non zero) value is at bottom\n    // of scale, and it does not equal suggestedMin, lower the min bound by one exp.\n    if (this._zero && this.min !== this._suggestedMin && !isFinite(this._userMin)) {\n      this.min = min === changeExponent(this.min, 0) ? changeExponent(this.min, -1) : changeExponent(this.min, 0);\n    }\n\n    this.handleTickRangeOptions();\n  }\n\n  handleTickRangeOptions() {\n    const {minDefined, maxDefined} = this.getUserBounds();\n    let min = this.min;\n    let max = this.max;\n\n    const setMin = v => (min = minDefined ? min : v);\n    const setMax = v => (max = maxDefined ? max : v);\n\n    if (min === max) {\n      if (min <= 0) { // includes null\n        setMin(1);\n        setMax(10);\n      } else {\n        setMin(changeExponent(min, -1));\n        setMax(changeExponent(max, +1));\n      }\n    }\n    if (min <= 0) {\n      setMin(changeExponent(max, -1));\n    }\n    if (max <= 0) {\n\n      setMax(changeExponent(min, +1));\n    }\n\n    this.min = min;\n    this.max = max;\n  }\n\n  buildTicks() {\n    const opts = this.options;\n\n    const generationOptions = {\n      min: this._userMin,\n      max: this._userMax\n    };\n    const ticks = generateTicks(generationOptions, this);\n\n    // At this point, we need to update our max and min given the tick values,\n    // since we probably have expanded the range of the scale\n    if (opts.bounds === 'ticks') {\n      _setMinAndMaxByKey(ticks, this, 'value');\n    }\n\n    if (opts.reverse) {\n      ticks.reverse();\n\n      this.start = this.max;\n      this.end = this.min;\n    } else {\n      this.start = this.min;\n      this.end = this.max;\n    }\n\n    return ticks;\n  }\n\n  /**\n\t * @param {number} value\n\t * @return {string}\n\t */\n  getLabelForValue(value) {\n    return value === undefined\n      ? '0'\n      : formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    const start = this.min;\n\n    super.configure();\n\n    this._startValue = log10(start);\n    this._valueRange = log10(this.max) - log10(start);\n  }\n\n  getPixelForValue(value) {\n    if (value === undefined || value === 0) {\n      value = this.min;\n    }\n    if (value === null || isNaN(value)) {\n      return NaN;\n    }\n    return this.getPixelForDecimal(value === this.min\n      ? 0\n      : (log10(value) - this._startValue) / this._valueRange);\n  }\n\n  getValueForPixel(pixel) {\n    const decimal = this.getDecimalForPixel(pixel);\n    return Math.pow(10, this._startValue + decimal * this._valueRange);\n  }\n}\n","import defaults from '../core/core.defaults.js';\nimport {_longestText, addRoundedRectPath, renderText, _isPointInArea} from '../helpers/helpers.canvas.js';\nimport {HALF_PI, TAU, toDegrees, toRadians, _normalizeAngle, PI} from '../helpers/helpers.math.js';\nimport LinearScaleBase from './scale.linearbase.js';\nimport Ticks from '../core/core.ticks.js';\nimport {valueOrDefault, isArray, isFinite, callback as callCallback, isNullOrUndef} from '../helpers/helpers.core.js';\nimport {createContext, toFont, toPadding, toTRBLCorners} from '../helpers/helpers.options.js';\n\nfunction getTickBackdropHeight(opts) {\n  const tickOpts = opts.ticks;\n\n  if (tickOpts.display && opts.display) {\n    const padding = toPadding(tickOpts.backdropPadding);\n    return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height;\n  }\n  return 0;\n}\n\nfunction measureLabelSize(ctx, font, label) {\n  label = isArray(label) ? label : [label];\n  return {\n    w: _longestText(ctx, font.string, label),\n    h: label.length * font.lineHeight\n  };\n}\n\nfunction determineLimits(angle, pos, size, min, max) {\n  if (angle === min || angle === max) {\n    return {\n      start: pos - (size / 2),\n      end: pos + (size / 2)\n    };\n  } else if (angle < min || angle > max) {\n    return {\n      start: pos - size,\n      end: pos\n    };\n  }\n\n  return {\n    start: pos,\n    end: pos + size\n  };\n}\n\n/**\n * Helper function to fit a radial linear scale with point labels\n */\nfunction fitWithPointLabels(scale) {\n\n  // Right, this is really confusing and there is a lot of maths going on here\n  // The gist of the problem is here: https://gist.github.com/nnnick/696cc9c55f4b0beb8fe9\n  //\n  // Reaction: https://dl.dropboxusercontent.com/u/34601363/toomuchscience.gif\n  //\n  // Solution:\n  //\n  // We assume the radius of the polygon is half the size of the canvas at first\n  // at each index we check if the text overlaps.\n  //\n  // Where it does, we store that angle and that index.\n  //\n  // After finding the largest index and angle we calculate how much we need to remove\n  // from the shape radius to move the point inwards by that x.\n  //\n  // We average the left and right distances to get the maximum shape radius that can fit in the box\n  // along with labels.\n  //\n  // Once we have that, we can find the centre point for the chart, by taking the x text protrusion\n  // on each side, removing that from the size, halving it and adding the left x protrusion width.\n  //\n  // This will mean we have a shape fitted to the canvas, as large as it can be with the labels\n  // and position it in the most space efficient manner\n  //\n  // https://dl.dropboxusercontent.com/u/34601363/yeahscience.gif\n\n  // Get maximum radius of the polygon. Either half the height (minus the text width) or half the width.\n  // Use this to calculate the offset + change. - Make sure L/R protrusion is at least 0 to stop issues with centre points\n  const orig = {\n    l: scale.left + scale._padding.left,\n    r: scale.right - scale._padding.right,\n    t: scale.top + scale._padding.top,\n    b: scale.bottom - scale._padding.bottom\n  };\n  const limits = Object.assign({}, orig);\n  const labelSizes = [];\n  const padding = [];\n  const valueCount = scale._pointLabels.length;\n  const pointLabelOpts = scale.options.pointLabels;\n  const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;\n\n  for (let i = 0; i < valueCount; i++) {\n    const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i));\n    padding[i] = opts.padding;\n    const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle);\n    const plFont = toFont(opts.font);\n    const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]);\n    labelSizes[i] = textSize;\n\n    const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle);\n    const angle = Math.round(toDegrees(angleRadians));\n    const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);\n    const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);\n    updateLimits(limits, orig, angleRadians, hLimits, vLimits);\n  }\n\n  scale.setCenterPoint(\n    orig.l - limits.l,\n    limits.r - orig.r,\n    orig.t - limits.t,\n    limits.b - orig.b\n  );\n\n  // Now that text size is determined, compute the full positions\n  scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);\n}\n\nfunction updateLimits(limits, orig, angle, hLimits, vLimits) {\n  const sin = Math.abs(Math.sin(angle));\n  const cos = Math.abs(Math.cos(angle));\n  let x = 0;\n  let y = 0;\n  if (hLimits.start < orig.l) {\n    x = (orig.l - hLimits.start) / sin;\n    limits.l = Math.min(limits.l, orig.l - x);\n  } else if (hLimits.end > orig.r) {\n    x = (hLimits.end - orig.r) / sin;\n    limits.r = Math.max(limits.r, orig.r + x);\n  }\n  if (vLimits.start < orig.t) {\n    y = (orig.t - vLimits.start) / cos;\n    limits.t = Math.min(limits.t, orig.t - y);\n  } else if (vLimits.end > orig.b) {\n    y = (vLimits.end - orig.b) / cos;\n    limits.b = Math.max(limits.b, orig.b + y);\n  }\n}\n\nfunction createPointLabelItem(scale, index, itemOpts) {\n  const outerDistance = scale.drawingArea;\n  const {extra, additionalAngle, padding, size} = itemOpts;\n  const pointLabelPosition = scale.getPointPosition(index, outerDistance + extra + padding, additionalAngle);\n  const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));\n  const y = yForAngle(pointLabelPosition.y, size.h, angle);\n  const textAlign = getTextAlignForAngle(angle);\n  const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);\n  return {\n    // if to draw or overlapped\n    visible: true,\n\n    // Text position\n    x: pointLabelPosition.x,\n    y,\n\n    // Text rendering data\n    textAlign,\n\n    // Bounding box\n    left,\n    top: y,\n    right: left + size.w,\n    bottom: y + size.h\n  };\n}\n\nfunction isNotOverlapped(item, area) {\n  if (!area) {\n    return true;\n  }\n  const {left, top, right, bottom} = item;\n  const apexesInArea = _isPointInArea({x: left, y: top}, area) || _isPointInArea({x: left, y: bottom}, area) ||\n    _isPointInArea({x: right, y: top}, area) || _isPointInArea({x: right, y: bottom}, area);\n  return !apexesInArea;\n}\n\nfunction buildPointLabelItems(scale, labelSizes, padding) {\n  const items = [];\n  const valueCount = scale._pointLabels.length;\n  const opts = scale.options;\n  const {centerPointLabels, display} = opts.pointLabels;\n  const itemOpts = {\n    extra: getTickBackdropHeight(opts) / 2,\n    additionalAngle: centerPointLabels ? PI / valueCount : 0\n  };\n  let area;\n\n  for (let i = 0; i < valueCount; i++) {\n    itemOpts.padding = padding[i];\n    itemOpts.size = labelSizes[i];\n\n    const item = createPointLabelItem(scale, i, itemOpts);\n    items.push(item);\n    if (display === 'auto') {\n      item.visible = isNotOverlapped(item, area);\n      if (item.visible) {\n        area = item;\n      }\n    }\n  }\n  return items;\n}\n\nfunction getTextAlignForAngle(angle) {\n  if (angle === 0 || angle === 180) {\n    return 'center';\n  } else if (angle < 180) {\n    return 'left';\n  }\n\n  return 'right';\n}\n\nfunction leftForTextAlign(x, w, align) {\n  if (align === 'right') {\n    x -= w;\n  } else if (align === 'center') {\n    x -= (w / 2);\n  }\n  return x;\n}\n\nfunction yForAngle(y, h, angle) {\n  if (angle === 90 || angle === 270) {\n    y -= (h / 2);\n  } else if (angle > 270 || angle < 90) {\n    y -= h;\n  }\n  return y;\n}\n\nfunction drawPointLabelBox(ctx, opts, item) {\n  const {left, top, right, bottom} = item;\n  const {backdropColor} = opts;\n\n  if (!isNullOrUndef(backdropColor)) {\n    const borderRadius = toTRBLCorners(opts.borderRadius);\n    const padding = toPadding(opts.backdropPadding);\n    ctx.fillStyle = backdropColor;\n\n    const backdropLeft = left - padding.left;\n    const backdropTop = top - padding.top;\n    const backdropWidth = right - left + padding.width;\n    const backdropHeight = bottom - top + padding.height;\n\n    if (Object.values(borderRadius).some(v => v !== 0)) {\n      ctx.beginPath();\n      addRoundedRectPath(ctx, {\n        x: backdropLeft,\n        y: backdropTop,\n        w: backdropWidth,\n        h: backdropHeight,\n        radius: borderRadius,\n      });\n      ctx.fill();\n    } else {\n      ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight);\n    }\n  }\n}\n\nfunction drawPointLabels(scale, labelCount) {\n  const {ctx, options: {pointLabels}} = scale;\n\n  for (let i = labelCount - 1; i >= 0; i--) {\n    const item = scale._pointLabelItems[i];\n    if (!item.visible) {\n      // overlapping\n      continue;\n    }\n    const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i));\n    drawPointLabelBox(ctx, optsAtIndex, item);\n    const plFont = toFont(optsAtIndex.font);\n    const {x, y, textAlign} = item;\n\n    renderText(\n      ctx,\n      scale._pointLabels[i],\n      x,\n      y + (plFont.lineHeight / 2),\n      plFont,\n      {\n        color: optsAtIndex.color,\n        textAlign: textAlign,\n        textBaseline: 'middle'\n      }\n    );\n  }\n}\n\nfunction pathRadiusLine(scale, radius, circular, labelCount) {\n  const {ctx} = scale;\n  if (circular) {\n    // Draw circular arcs between the points\n    ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);\n  } else {\n    // Draw straight lines connecting each index\n    let pointPosition = scale.getPointPosition(0, radius);\n    ctx.moveTo(pointPosition.x, pointPosition.y);\n\n    for (let i = 1; i < labelCount; i++) {\n      pointPosition = scale.getPointPosition(i, radius);\n      ctx.lineTo(pointPosition.x, pointPosition.y);\n    }\n  }\n}\n\nfunction drawRadiusLine(scale, gridLineOpts, radius, labelCount, borderOpts) {\n  const ctx = scale.ctx;\n  const circular = gridLineOpts.circular;\n\n  const {color, lineWidth} = gridLineOpts;\n\n  if ((!circular && !labelCount) || !color || !lineWidth || radius < 0) {\n    return;\n  }\n\n  ctx.save();\n  ctx.strokeStyle = color;\n  ctx.lineWidth = lineWidth;\n  ctx.setLineDash(borderOpts.dash);\n  ctx.lineDashOffset = borderOpts.dashOffset;\n\n  ctx.beginPath();\n  pathRadiusLine(scale, radius, circular, labelCount);\n  ctx.closePath();\n  ctx.stroke();\n  ctx.restore();\n}\n\nfunction createPointLabelContext(parent, index, label) {\n  return createContext(parent, {\n    label,\n    index,\n    type: 'pointLabel'\n  });\n}\n\nexport default class RadialLinearScale extends LinearScaleBase {\n\n  static id = 'radialLinear';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    display: true,\n\n    // Boolean - Whether to animate scaling the chart from the centre\n    animate: true,\n    position: 'chartArea',\n\n    angleLines: {\n      display: true,\n      lineWidth: 1,\n      borderDash: [],\n      borderDashOffset: 0.0\n    },\n\n    grid: {\n      circular: false\n    },\n\n    startAngle: 0,\n\n    // label settings\n    ticks: {\n      // Boolean - Show a backdrop to the scale label\n      showLabelBackdrop: true,\n\n      callback: Ticks.formatters.numeric\n    },\n\n    pointLabels: {\n      backdropColor: undefined,\n\n      // Number - The backdrop padding above & below the label in pixels\n      backdropPadding: 2,\n\n      // Boolean - if true, show point labels\n      display: true,\n\n      // Number - Point label font size in pixels\n      font: {\n        size: 10\n      },\n\n      // Function - Used to convert point labels\n      callback(label) {\n        return label;\n      },\n\n      // Number - Additionl padding between scale and pointLabel\n      padding: 5,\n\n      // Boolean - if true, center point labels to slices in polar chart\n      centerPointLabels: false\n    }\n  };\n\n  static defaultRoutes = {\n    'angleLines.color': 'borderColor',\n    'pointLabels.color': 'color',\n    'ticks.color': 'color'\n  };\n\n  static descriptors = {\n    angleLines: {\n      _fallback: 'grid'\n    }\n  };\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this.xCenter = undefined;\n    /** @type {number} */\n    this.yCenter = undefined;\n    /** @type {number} */\n    this.drawingArea = undefined;\n    /** @type {string[]} */\n    this._pointLabels = [];\n    this._pointLabelItems = [];\n  }\n\n  setDimensions() {\n    // Set the unconstrained dimension before label rotation\n    const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);\n    const w = this.width = this.maxWidth - padding.width;\n    const h = this.height = this.maxHeight - padding.height;\n    this.xCenter = Math.floor(this.left + w / 2 + padding.left);\n    this.yCenter = Math.floor(this.top + h / 2 + padding.top);\n    this.drawingArea = Math.floor(Math.min(w, h) / 2);\n  }\n\n  determineDataLimits() {\n    const {min, max} = this.getMinMax(false);\n\n    this.min = isFinite(min) && !isNaN(min) ? min : 0;\n    this.max = isFinite(max) && !isNaN(max) ? max : 0;\n\n    // Common base implementation to handle min, max, beginAtZero\n    this.handleTickRangeOptions();\n  }\n\n  /**\n\t * Returns the maximum number of ticks based on the scale dimension\n\t * @protected\n\t */\n  computeTickLimit() {\n    return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));\n  }\n\n  generateTickLabels(ticks) {\n    LinearScaleBase.prototype.generateTickLabels.call(this, ticks);\n\n    // Point labels\n    this._pointLabels = this.getLabels()\n      .map((value, index) => {\n        const label = callCallback(this.options.pointLabels.callback, [value, index], this);\n        return label || label === 0 ? label : '';\n      })\n      .filter((v, i) => this.chart.getDataVisibility(i));\n  }\n\n  fit() {\n    const opts = this.options;\n\n    if (opts.display && opts.pointLabels.display) {\n      fitWithPointLabels(this);\n    } else {\n      this.setCenterPoint(0, 0, 0, 0);\n    }\n  }\n\n  setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {\n    this.xCenter += Math.floor((leftMovement - rightMovement) / 2);\n    this.yCenter += Math.floor((topMovement - bottomMovement) / 2);\n    this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));\n  }\n\n  getIndexAngle(index) {\n    const angleMultiplier = TAU / (this._pointLabels.length || 1);\n    const startAngle = this.options.startAngle || 0;\n\n    return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));\n  }\n\n  getDistanceFromCenterForValue(value) {\n    if (isNullOrUndef(value)) {\n      return NaN;\n    }\n\n    // Take into account half font size + the yPadding of the top value\n    const scalingFactor = this.drawingArea / (this.max - this.min);\n    if (this.options.reverse) {\n      return (this.max - value) * scalingFactor;\n    }\n    return (value - this.min) * scalingFactor;\n  }\n\n  getValueForDistanceFromCenter(distance) {\n    if (isNullOrUndef(distance)) {\n      return NaN;\n    }\n\n    const scaledDistance = distance / (this.drawingArea / (this.max - this.min));\n    return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;\n  }\n\n  getPointLabelContext(index) {\n    const pointLabels = this._pointLabels || [];\n\n    if (index >= 0 && index < pointLabels.length) {\n      const pointLabel = pointLabels[index];\n      return createPointLabelContext(this.getContext(), index, pointLabel);\n    }\n  }\n\n  getPointPosition(index, distanceFromCenter, additionalAngle = 0) {\n    const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;\n    return {\n      x: Math.cos(angle) * distanceFromCenter + this.xCenter,\n      y: Math.sin(angle) * distanceFromCenter + this.yCenter,\n      angle\n    };\n  }\n\n  getPointPositionForValue(index, value) {\n    return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));\n  }\n\n  getBasePosition(index) {\n    return this.getPointPositionForValue(index || 0, this.getBaseValue());\n  }\n\n  getPointLabelPosition(index) {\n    const {left, top, right, bottom} = this._pointLabelItems[index];\n    return {\n      left,\n      top,\n      right,\n      bottom,\n    };\n  }\n\n  /**\n\t * @protected\n\t */\n  drawBackground() {\n    const {backgroundColor, grid: {circular}} = this.options;\n    if (backgroundColor) {\n      const ctx = this.ctx;\n      ctx.save();\n      ctx.beginPath();\n      pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);\n      ctx.closePath();\n      ctx.fillStyle = backgroundColor;\n      ctx.fill();\n      ctx.restore();\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawGrid() {\n    const ctx = this.ctx;\n    const opts = this.options;\n    const {angleLines, grid, border} = opts;\n    const labelCount = this._pointLabels.length;\n\n    let i, offset, position;\n\n    if (opts.pointLabels.display) {\n      drawPointLabels(this, labelCount);\n    }\n\n    if (grid.display) {\n      this.ticks.forEach((tick, index) => {\n        if (index !== 0 || (index === 0 && this.min < 0)) {\n          offset = this.getDistanceFromCenterForValue(tick.value);\n          const context = this.getContext(index);\n          const optsAtIndex = grid.setContext(context);\n          const optsAtIndexBorder = border.setContext(context);\n\n          drawRadiusLine(this, optsAtIndex, offset, labelCount, optsAtIndexBorder);\n        }\n      });\n    }\n\n    if (angleLines.display) {\n      ctx.save();\n\n      for (i = labelCount - 1; i >= 0; i--) {\n        const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i));\n        const {color, lineWidth} = optsAtIndex;\n\n        if (!lineWidth || !color) {\n          continue;\n        }\n\n        ctx.lineWidth = lineWidth;\n        ctx.strokeStyle = color;\n\n        ctx.setLineDash(optsAtIndex.borderDash);\n        ctx.lineDashOffset = optsAtIndex.borderDashOffset;\n\n        offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max);\n        position = this.getPointPosition(i, offset);\n        ctx.beginPath();\n        ctx.moveTo(this.xCenter, this.yCenter);\n        ctx.lineTo(position.x, position.y);\n        ctx.stroke();\n      }\n\n      ctx.restore();\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawBorder() {}\n\n  /**\n\t * @protected\n\t */\n  drawLabels() {\n    const ctx = this.ctx;\n    const opts = this.options;\n    const tickOpts = opts.ticks;\n\n    if (!tickOpts.display) {\n      return;\n    }\n\n    const startAngle = this.getIndexAngle(0);\n    let offset, width;\n\n    ctx.save();\n    ctx.translate(this.xCenter, this.yCenter);\n    ctx.rotate(startAngle);\n    ctx.textAlign = 'center';\n    ctx.textBaseline = 'middle';\n\n    this.ticks.forEach((tick, index) => {\n      if ((index === 0 && this.min >= 0) && !opts.reverse) {\n        return;\n      }\n\n      const optsAtIndex = tickOpts.setContext(this.getContext(index));\n      const tickFont = toFont(optsAtIndex.font);\n      offset = this.getDistanceFromCenterForValue(this.ticks[index].value);\n\n      if (optsAtIndex.showLabelBackdrop) {\n        ctx.font = tickFont.string;\n        width = ctx.measureText(tick.label).width;\n        ctx.fillStyle = optsAtIndex.backdropColor;\n\n        const padding = toPadding(optsAtIndex.backdropPadding);\n        ctx.fillRect(\n          -width / 2 - padding.left,\n          -offset - tickFont.size / 2 - padding.top,\n          width + padding.width,\n          tickFont.size + padding.height\n        );\n      }\n\n      renderText(ctx, tick.label, 0, -offset, tickFont, {\n        color: optsAtIndex.color,\n        strokeColor: optsAtIndex.textStrokeColor,\n        strokeWidth: optsAtIndex.textStrokeWidth,\n      });\n    });\n\n    ctx.restore();\n  }\n\n  /**\n\t * @protected\n\t */\n  drawTitle() {}\n}\n","/*!\n * chartjs-plugin-datalabels v2.2.0\n * https://chartjs-plugin-datalabels.netlify.app\n * (c) 2017-2022 chartjs-plugin-datalabels contributors\n * Released under the MIT license\n */\nimport { isNullOrUndef, merge, toFont, resolve, toPadding, valueOrDefault, callback, isObject, each } from 'chart.js/helpers';\nimport { defaults as defaults$1, ArcElement, PointElement, BarElement } from 'chart.js';\n\nvar devicePixelRatio = (function() {\n  if (typeof window !== 'undefined') {\n    if (window.devicePixelRatio) {\n      return window.devicePixelRatio;\n    }\n\n    // devicePixelRatio is undefined on IE10\n    // https://stackoverflow.com/a/20204180/8837887\n    // https://github.com/chartjs/chartjs-plugin-datalabels/issues/85\n    var screen = window.screen;\n    if (screen) {\n      return (screen.deviceXDPI || 1) / (screen.logicalXDPI || 1);\n    }\n  }\n\n  return 1;\n}());\n\nvar utils = {\n  // @todo move this in Chart.helpers.toTextLines\n  toTextLines: function(inputs) {\n    var lines = [];\n    var input;\n\n    inputs = [].concat(inputs);\n    while (inputs.length) {\n      input = inputs.pop();\n      if (typeof input === 'string') {\n        lines.unshift.apply(lines, input.split('\\n'));\n      } else if (Array.isArray(input)) {\n        inputs.push.apply(inputs, input);\n      } else if (!isNullOrUndef(inputs)) {\n        lines.unshift('' + input);\n      }\n    }\n\n    return lines;\n  },\n\n  // @todo move this in Chart.helpers.canvas.textSize\n  // @todo cache calls of measureText if font doesn't change?!\n  textSize: function(ctx, lines, font) {\n    var items = [].concat(lines);\n    var ilen = items.length;\n    var prev = ctx.font;\n    var width = 0;\n    var i;\n\n    ctx.font = font.string;\n\n    for (i = 0; i < ilen; ++i) {\n      width = Math.max(ctx.measureText(items[i]).width, width);\n    }\n\n    ctx.font = prev;\n\n    return {\n      height: ilen * font.lineHeight,\n      width: width\n    };\n  },\n\n  /**\n   * Returns value bounded by min and max. This is equivalent to max(min, min(value, max)).\n   * @todo move this method in Chart.helpers.bound\n   * https://doc.qt.io/qt-5/qtglobal.html#qBound\n   */\n  bound: function(min, value, max) {\n    return Math.max(min, Math.min(value, max));\n  },\n\n  /**\n   * Returns an array of pair [value, state] where state is:\n   * * -1: value is only in a0 (removed)\n   * *  1: value is only in a1 (added)\n   */\n  arrayDiff: function(a0, a1) {\n    var prev = a0.slice();\n    var updates = [];\n    var i, j, ilen, v;\n\n    for (i = 0, ilen = a1.length; i < ilen; ++i) {\n      v = a1[i];\n      j = prev.indexOf(v);\n\n      if (j === -1) {\n        updates.push([v, 1]);\n      } else {\n        prev.splice(j, 1);\n      }\n    }\n\n    for (i = 0, ilen = prev.length; i < ilen; ++i) {\n      updates.push([prev[i], -1]);\n    }\n\n    return updates;\n  },\n\n  /**\n   * https://github.com/chartjs/chartjs-plugin-datalabels/issues/70\n   */\n  rasterize: function(v) {\n    return Math.round(v * devicePixelRatio) / devicePixelRatio;\n  }\n};\n\nfunction orient(point, origin) {\n  var x0 = origin.x;\n  var y0 = origin.y;\n\n  if (x0 === null) {\n    return {x: 0, y: -1};\n  }\n  if (y0 === null) {\n    return {x: 1, y: 0};\n  }\n\n  var dx = point.x - x0;\n  var dy = point.y - y0;\n  var ln = Math.sqrt(dx * dx + dy * dy);\n\n  return {\n    x: ln ? dx / ln : 0,\n    y: ln ? dy / ln : -1\n  };\n}\n\nfunction aligned(x, y, vx, vy, align) {\n  switch (align) {\n  case 'center':\n    vx = vy = 0;\n    break;\n  case 'bottom':\n    vx = 0;\n    vy = 1;\n    break;\n  case 'right':\n    vx = 1;\n    vy = 0;\n    break;\n  case 'left':\n    vx = -1;\n    vy = 0;\n    break;\n  case 'top':\n    vx = 0;\n    vy = -1;\n    break;\n  case 'start':\n    vx = -vx;\n    vy = -vy;\n    break;\n  case 'end':\n    // keep natural orientation\n    break;\n  default:\n    // clockwise rotation (in degree)\n    align *= (Math.PI / 180);\n    vx = Math.cos(align);\n    vy = Math.sin(align);\n    break;\n  }\n\n  return {\n    x: x,\n    y: y,\n    vx: vx,\n    vy: vy\n  };\n}\n\n// Line clipping (Cohen–Sutherland algorithm)\n// https://en.wikipedia.org/wiki/Cohen–Sutherland_algorithm\n\nvar R_INSIDE = 0;\nvar R_LEFT = 1;\nvar R_RIGHT = 2;\nvar R_BOTTOM = 4;\nvar R_TOP = 8;\n\nfunction region(x, y, rect) {\n  var res = R_INSIDE;\n\n  if (x < rect.left) {\n    res |= R_LEFT;\n  } else if (x > rect.right) {\n    res |= R_RIGHT;\n  }\n  if (y < rect.top) {\n    res |= R_TOP;\n  } else if (y > rect.bottom) {\n    res |= R_BOTTOM;\n  }\n\n  return res;\n}\n\nfunction clipped(segment, area) {\n  var x0 = segment.x0;\n  var y0 = segment.y0;\n  var x1 = segment.x1;\n  var y1 = segment.y1;\n  var r0 = region(x0, y0, area);\n  var r1 = region(x1, y1, area);\n  var r, x, y;\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    if (!(r0 | r1) || (r0 & r1)) {\n      // both points inside or on the same side: no clipping\n      break;\n    }\n\n    // at least one point is outside\n    r = r0 || r1;\n\n    if (r & R_TOP) {\n      x = x0 + (x1 - x0) * (area.top - y0) / (y1 - y0);\n      y = area.top;\n    } else if (r & R_BOTTOM) {\n      x = x0 + (x1 - x0) * (area.bottom - y0) / (y1 - y0);\n      y = area.bottom;\n    } else if (r & R_RIGHT) {\n      y = y0 + (y1 - y0) * (area.right - x0) / (x1 - x0);\n      x = area.right;\n    } else if (r & R_LEFT) {\n      y = y0 + (y1 - y0) * (area.left - x0) / (x1 - x0);\n      x = area.left;\n    }\n\n    if (r === r0) {\n      x0 = x;\n      y0 = y;\n      r0 = region(x0, y0, area);\n    } else {\n      x1 = x;\n      y1 = y;\n      r1 = region(x1, y1, area);\n    }\n  }\n\n  return {\n    x0: x0,\n    x1: x1,\n    y0: y0,\n    y1: y1\n  };\n}\n\nfunction compute$1(range, config) {\n  var anchor = config.anchor;\n  var segment = range;\n  var x, y;\n\n  if (config.clamp) {\n    segment = clipped(segment, config.area);\n  }\n\n  if (anchor === 'start') {\n    x = segment.x0;\n    y = segment.y0;\n  } else if (anchor === 'end') {\n    x = segment.x1;\n    y = segment.y1;\n  } else {\n    x = (segment.x0 + segment.x1) / 2;\n    y = (segment.y0 + segment.y1) / 2;\n  }\n\n  return aligned(x, y, range.vx, range.vy, config.align);\n}\n\nvar positioners = {\n  arc: function(el, config) {\n    var angle = (el.startAngle + el.endAngle) / 2;\n    var vx = Math.cos(angle);\n    var vy = Math.sin(angle);\n    var r0 = el.innerRadius;\n    var r1 = el.outerRadius;\n\n    return compute$1({\n      x0: el.x + vx * r0,\n      y0: el.y + vy * r0,\n      x1: el.x + vx * r1,\n      y1: el.y + vy * r1,\n      vx: vx,\n      vy: vy\n    }, config);\n  },\n\n  point: function(el, config) {\n    var v = orient(el, config.origin);\n    var rx = v.x * el.options.radius;\n    var ry = v.y * el.options.radius;\n\n    return compute$1({\n      x0: el.x - rx,\n      y0: el.y - ry,\n      x1: el.x + rx,\n      y1: el.y + ry,\n      vx: v.x,\n      vy: v.y\n    }, config);\n  },\n\n  bar: function(el, config) {\n    var v = orient(el, config.origin);\n    var x = el.x;\n    var y = el.y;\n    var sx = 0;\n    var sy = 0;\n\n    if (el.horizontal) {\n      x = Math.min(el.x, el.base);\n      sx = Math.abs(el.base - el.x);\n    } else {\n      y = Math.min(el.y, el.base);\n      sy = Math.abs(el.base - el.y);\n    }\n\n    return compute$1({\n      x0: x,\n      y0: y + sy,\n      x1: x + sx,\n      y1: y,\n      vx: v.x,\n      vy: v.y\n    }, config);\n  },\n\n  fallback: function(el, config) {\n    var v = orient(el, config.origin);\n\n    return compute$1({\n      x0: el.x,\n      y0: el.y,\n      x1: el.x + (el.width || 0),\n      y1: el.y + (el.height || 0),\n      vx: v.x,\n      vy: v.y\n    }, config);\n  }\n};\n\nvar rasterize = utils.rasterize;\n\nfunction boundingRects(model) {\n  var borderWidth = model.borderWidth || 0;\n  var padding = model.padding;\n  var th = model.size.height;\n  var tw = model.size.width;\n  var tx = -tw / 2;\n  var ty = -th / 2;\n\n  return {\n    frame: {\n      x: tx - padding.left - borderWidth,\n      y: ty - padding.top - borderWidth,\n      w: tw + padding.width + borderWidth * 2,\n      h: th + padding.height + borderWidth * 2\n    },\n    text: {\n      x: tx,\n      y: ty,\n      w: tw,\n      h: th\n    }\n  };\n}\n\nfunction getScaleOrigin(el, context) {\n  var scale = context.chart.getDatasetMeta(context.datasetIndex).vScale;\n\n  if (!scale) {\n    return null;\n  }\n\n  if (scale.xCenter !== undefined && scale.yCenter !== undefined) {\n    return {x: scale.xCenter, y: scale.yCenter};\n  }\n\n  var pixel = scale.getBasePixel();\n  return el.horizontal ?\n    {x: pixel, y: null} :\n    {x: null, y: pixel};\n}\n\nfunction getPositioner(el) {\n  if (el instanceof ArcElement) {\n    return positioners.arc;\n  }\n  if (el instanceof PointElement) {\n    return positioners.point;\n  }\n  if (el instanceof BarElement) {\n    return positioners.bar;\n  }\n  return positioners.fallback;\n}\n\nfunction drawRoundedRect(ctx, x, y, w, h, radius) {\n  var HALF_PI = Math.PI / 2;\n\n  if (radius) {\n    var r = Math.min(radius, h / 2, w / 2);\n    var left = x + r;\n    var top = y + r;\n    var right = x + w - r;\n    var bottom = y + h - r;\n\n    ctx.moveTo(x, top);\n    if (left < right && top < bottom) {\n      ctx.arc(left, top, r, -Math.PI, -HALF_PI);\n      ctx.arc(right, top, r, -HALF_PI, 0);\n      ctx.arc(right, bottom, r, 0, HALF_PI);\n      ctx.arc(left, bottom, r, HALF_PI, Math.PI);\n    } else if (left < right) {\n      ctx.moveTo(left, y);\n      ctx.arc(right, top, r, -HALF_PI, HALF_PI);\n      ctx.arc(left, top, r, HALF_PI, Math.PI + HALF_PI);\n    } else if (top < bottom) {\n      ctx.arc(left, top, r, -Math.PI, 0);\n      ctx.arc(left, bottom, r, 0, Math.PI);\n    } else {\n      ctx.arc(left, top, r, -Math.PI, Math.PI);\n    }\n    ctx.closePath();\n    ctx.moveTo(x, y);\n  } else {\n    ctx.rect(x, y, w, h);\n  }\n}\n\nfunction drawFrame(ctx, rect, model) {\n  var bgColor = model.backgroundColor;\n  var borderColor = model.borderColor;\n  var borderWidth = model.borderWidth;\n\n  if (!bgColor && (!borderColor || !borderWidth)) {\n    return;\n  }\n\n  ctx.beginPath();\n\n  drawRoundedRect(\n    ctx,\n    rasterize(rect.x) + borderWidth / 2,\n    rasterize(rect.y) + borderWidth / 2,\n    rasterize(rect.w) - borderWidth,\n    rasterize(rect.h) - borderWidth,\n    model.borderRadius);\n\n  ctx.closePath();\n\n  if (bgColor) {\n    ctx.fillStyle = bgColor;\n    ctx.fill();\n  }\n\n  if (borderColor && borderWidth) {\n    ctx.strokeStyle = borderColor;\n    ctx.lineWidth = borderWidth;\n    ctx.lineJoin = 'miter';\n    ctx.stroke();\n  }\n}\n\nfunction textGeometry(rect, align, font) {\n  var h = font.lineHeight;\n  var w = rect.w;\n  var x = rect.x;\n  var y = rect.y + h / 2;\n\n  if (align === 'center') {\n    x += w / 2;\n  } else if (align === 'end' || align === 'right') {\n    x += w;\n  }\n\n  return {\n    h: h,\n    w: w,\n    x: x,\n    y: y\n  };\n}\n\nfunction drawTextLine(ctx, text, cfg) {\n  var shadow = ctx.shadowBlur;\n  var stroked = cfg.stroked;\n  var x = rasterize(cfg.x);\n  var y = rasterize(cfg.y);\n  var w = rasterize(cfg.w);\n\n  if (stroked) {\n    ctx.strokeText(text, x, y, w);\n  }\n\n  if (cfg.filled) {\n    if (shadow && stroked) {\n      // Prevent drawing shadow on both the text stroke and fill, so\n      // if the text is stroked, remove the shadow for the text fill.\n      ctx.shadowBlur = 0;\n    }\n\n    ctx.fillText(text, x, y, w);\n\n    if (shadow && stroked) {\n      ctx.shadowBlur = shadow;\n    }\n  }\n}\n\nfunction drawText(ctx, lines, rect, model) {\n  var align = model.textAlign;\n  var color = model.color;\n  var filled = !!color;\n  var font = model.font;\n  var ilen = lines.length;\n  var strokeColor = model.textStrokeColor;\n  var strokeWidth = model.textStrokeWidth;\n  var stroked = strokeColor && strokeWidth;\n  var i;\n\n  if (!ilen || (!filled && !stroked)) {\n    return;\n  }\n\n  // Adjust coordinates based on text alignment and line height\n  rect = textGeometry(rect, align, font);\n\n  ctx.font = font.string;\n  ctx.textAlign = align;\n  ctx.textBaseline = 'middle';\n  ctx.shadowBlur = model.textShadowBlur;\n  ctx.shadowColor = model.textShadowColor;\n\n  if (filled) {\n    ctx.fillStyle = color;\n  }\n  if (stroked) {\n    ctx.lineJoin = 'round';\n    ctx.lineWidth = strokeWidth;\n    ctx.strokeStyle = strokeColor;\n  }\n\n  for (i = 0, ilen = lines.length; i < ilen; ++i) {\n    drawTextLine(ctx, lines[i], {\n      stroked: stroked,\n      filled: filled,\n      w: rect.w,\n      x: rect.x,\n      y: rect.y + rect.h * i\n    });\n  }\n}\n\nvar Label = function(config, ctx, el, index) {\n  var me = this;\n\n  me._config = config;\n  me._index = index;\n  me._model = null;\n  me._rects = null;\n  me._ctx = ctx;\n  me._el = el;\n};\n\nmerge(Label.prototype, {\n  /**\n   * @private\n   */\n  _modelize: function(display, lines, config, context) {\n    var me = this;\n    var index = me._index;\n    var font = toFont(resolve([config.font, {}], context, index));\n    var color = resolve([config.color, defaults$1.color], context, index);\n\n    return {\n      align: resolve([config.align, 'center'], context, index),\n      anchor: resolve([config.anchor, 'center'], context, index),\n      area: context.chart.chartArea,\n      backgroundColor: resolve([config.backgroundColor, null], context, index),\n      borderColor: resolve([config.borderColor, null], context, index),\n      borderRadius: resolve([config.borderRadius, 0], context, index),\n      borderWidth: resolve([config.borderWidth, 0], context, index),\n      clamp: resolve([config.clamp, false], context, index),\n      clip: resolve([config.clip, false], context, index),\n      color: color,\n      display: display,\n      font: font,\n      lines: lines,\n      offset: resolve([config.offset, 4], context, index),\n      opacity: resolve([config.opacity, 1], context, index),\n      origin: getScaleOrigin(me._el, context),\n      padding: toPadding(resolve([config.padding, 4], context, index)),\n      positioner: getPositioner(me._el),\n      rotation: resolve([config.rotation, 0], context, index) * (Math.PI / 180),\n      size: utils.textSize(me._ctx, lines, font),\n      textAlign: resolve([config.textAlign, 'start'], context, index),\n      textShadowBlur: resolve([config.textShadowBlur, 0], context, index),\n      textShadowColor: resolve([config.textShadowColor, color], context, index),\n      textStrokeColor: resolve([config.textStrokeColor, color], context, index),\n      textStrokeWidth: resolve([config.textStrokeWidth, 0], context, index)\n    };\n  },\n\n  update: function(context) {\n    var me = this;\n    var model = null;\n    var rects = null;\n    var index = me._index;\n    var config = me._config;\n    var value, label, lines;\n\n    // We first resolve the display option (separately) to avoid computing\n    // other options in case the label is hidden (i.e. display: false).\n    var display = resolve([config.display, true], context, index);\n\n    if (display) {\n      value = context.dataset.data[index];\n      label = valueOrDefault(callback(config.formatter, [value, context]), value);\n      lines = isNullOrUndef(label) ? [] : utils.toTextLines(label);\n\n      if (lines.length) {\n        model = me._modelize(display, lines, config, context);\n        rects = boundingRects(model);\n      }\n    }\n\n    me._model = model;\n    me._rects = rects;\n  },\n\n  geometry: function() {\n    return this._rects ? this._rects.frame : {};\n  },\n\n  rotation: function() {\n    return this._model ? this._model.rotation : 0;\n  },\n\n  visible: function() {\n    return this._model && this._model.opacity;\n  },\n\n  model: function() {\n    return this._model;\n  },\n\n  draw: function(chart, center) {\n    var me = this;\n    var ctx = chart.ctx;\n    var model = me._model;\n    var rects = me._rects;\n    var area;\n\n    if (!this.visible()) {\n      return;\n    }\n\n    ctx.save();\n\n    if (model.clip) {\n      area = model.area;\n      ctx.beginPath();\n      ctx.rect(\n        area.left,\n        area.top,\n        area.right - area.left,\n        area.bottom - area.top);\n      ctx.clip();\n    }\n\n    ctx.globalAlpha = utils.bound(0, model.opacity, 1);\n    ctx.translate(rasterize(center.x), rasterize(center.y));\n    ctx.rotate(model.rotation);\n\n    drawFrame(ctx, rects.frame, model);\n    drawText(ctx, model.lines, rects.text, model);\n\n    ctx.restore();\n  }\n});\n\nvar MIN_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991; // eslint-disable-line es/no-number-minsafeinteger\nvar MAX_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;  // eslint-disable-line es/no-number-maxsafeinteger\n\nfunction rotated(point, center, angle) {\n  var cos = Math.cos(angle);\n  var sin = Math.sin(angle);\n  var cx = center.x;\n  var cy = center.y;\n\n  return {\n    x: cx + cos * (point.x - cx) - sin * (point.y - cy),\n    y: cy + sin * (point.x - cx) + cos * (point.y - cy)\n  };\n}\n\nfunction projected(points, axis) {\n  var min = MAX_INTEGER;\n  var max = MIN_INTEGER;\n  var origin = axis.origin;\n  var i, pt, vx, vy, dp;\n\n  for (i = 0; i < points.length; ++i) {\n    pt = points[i];\n    vx = pt.x - origin.x;\n    vy = pt.y - origin.y;\n    dp = axis.vx * vx + axis.vy * vy;\n    min = Math.min(min, dp);\n    max = Math.max(max, dp);\n  }\n\n  return {\n    min: min,\n    max: max\n  };\n}\n\nfunction toAxis(p0, p1) {\n  var vx = p1.x - p0.x;\n  var vy = p1.y - p0.y;\n  var ln = Math.sqrt(vx * vx + vy * vy);\n\n  return {\n    vx: (p1.x - p0.x) / ln,\n    vy: (p1.y - p0.y) / ln,\n    origin: p0,\n    ln: ln\n  };\n}\n\nvar HitBox = function() {\n  this._rotation = 0;\n  this._rect = {\n    x: 0,\n    y: 0,\n    w: 0,\n    h: 0\n  };\n};\n\nmerge(HitBox.prototype, {\n  center: function() {\n    var r = this._rect;\n    return {\n      x: r.x + r.w / 2,\n      y: r.y + r.h / 2\n    };\n  },\n\n  update: function(center, rect, rotation) {\n    this._rotation = rotation;\n    this._rect = {\n      x: rect.x + center.x,\n      y: rect.y + center.y,\n      w: rect.w,\n      h: rect.h\n    };\n  },\n\n  contains: function(point) {\n    var me = this;\n    var margin = 1;\n    var rect = me._rect;\n\n    point = rotated(point, me.center(), -me._rotation);\n\n    return !(point.x < rect.x - margin\n      || point.y < rect.y - margin\n      || point.x > rect.x + rect.w + margin * 2\n      || point.y > rect.y + rect.h + margin * 2);\n  },\n\n  // Separating Axis Theorem\n  // https://gamedevelopment.tutsplus.com/tutorials/collision-detection-using-the-separating-axis-theorem--gamedev-169\n  intersects: function(other) {\n    var r0 = this._points();\n    var r1 = other._points();\n    var axes = [\n      toAxis(r0[0], r0[1]),\n      toAxis(r0[0], r0[3])\n    ];\n    var i, pr0, pr1;\n\n    if (this._rotation !== other._rotation) {\n      // Only separate with r1 axis if the rotation is different,\n      // else it's enough to separate r0 and r1 with r0 axis only!\n      axes.push(\n        toAxis(r1[0], r1[1]),\n        toAxis(r1[0], r1[3])\n      );\n    }\n\n    for (i = 0; i < axes.length; ++i) {\n      pr0 = projected(r0, axes[i]);\n      pr1 = projected(r1, axes[i]);\n\n      if (pr0.max < pr1.min || pr1.max < pr0.min) {\n        return false;\n      }\n    }\n\n    return true;\n  },\n\n  /**\n   * @private\n   */\n  _points: function() {\n    var me = this;\n    var rect = me._rect;\n    var angle = me._rotation;\n    var center = me.center();\n\n    return [\n      rotated({x: rect.x, y: rect.y}, center, angle),\n      rotated({x: rect.x + rect.w, y: rect.y}, center, angle),\n      rotated({x: rect.x + rect.w, y: rect.y + rect.h}, center, angle),\n      rotated({x: rect.x, y: rect.y + rect.h}, center, angle)\n    ];\n  }\n});\n\nfunction coordinates(el, model, geometry) {\n  var point = model.positioner(el, model);\n  var vx = point.vx;\n  var vy = point.vy;\n\n  if (!vx && !vy) {\n    // if aligned center, we don't want to offset the center point\n    return {x: point.x, y: point.y};\n  }\n\n  var w = geometry.w;\n  var h = geometry.h;\n\n  // take in account the label rotation\n  var rotation = model.rotation;\n  var dx = Math.abs(w / 2 * Math.cos(rotation)) + Math.abs(h / 2 * Math.sin(rotation));\n  var dy = Math.abs(w / 2 * Math.sin(rotation)) + Math.abs(h / 2 * Math.cos(rotation));\n\n  // scale the unit vector (vx, vy) to get at least dx or dy equal to\n  // w or h respectively (else we would calculate the distance to the\n  // ellipse inscribed in the bounding rect)\n  var vs = 1 / Math.max(Math.abs(vx), Math.abs(vy));\n  dx *= vx * vs;\n  dy *= vy * vs;\n\n  // finally, include the explicit offset\n  dx += model.offset * vx;\n  dy += model.offset * vy;\n\n  return {\n    x: point.x + dx,\n    y: point.y + dy\n  };\n}\n\nfunction collide(labels, collider) {\n  var i, j, s0, s1;\n\n  // IMPORTANT Iterate in the reverse order since items at the end of the\n  // list have an higher weight/priority and thus should be less impacted\n  // by the overlapping strategy.\n\n  for (i = labels.length - 1; i >= 0; --i) {\n    s0 = labels[i].$layout;\n\n    for (j = i - 1; j >= 0 && s0._visible; --j) {\n      s1 = labels[j].$layout;\n\n      if (s1._visible && s0._box.intersects(s1._box)) {\n        collider(s0, s1);\n      }\n    }\n  }\n\n  return labels;\n}\n\nfunction compute(labels) {\n  var i, ilen, label, state, geometry, center, proxy;\n\n  // Initialize labels for overlap detection\n  for (i = 0, ilen = labels.length; i < ilen; ++i) {\n    label = labels[i];\n    state = label.$layout;\n\n    if (state._visible) {\n      // Chart.js 3 removed el._model in favor of getProps(), making harder to\n      // abstract reading values in positioners. Also, using string arrays to\n      // read values (i.e. var {a,b,c} = el.getProps([\"a\",\"b\",\"c\"])) would make\n      // positioners inefficient in the normal case (i.e. not the final values)\n      // and the code a bit ugly, so let's use a Proxy instead.\n      proxy = new Proxy(label._el, {get: (el, p) => el.getProps([p], true)[p]});\n\n      geometry = label.geometry();\n      center = coordinates(proxy, label.model(), geometry);\n      state._box.update(center, geometry, label.rotation());\n    }\n  }\n\n  // Auto hide overlapping labels\n  return collide(labels, function(s0, s1) {\n    var h0 = s0._hidable;\n    var h1 = s1._hidable;\n\n    if ((h0 && h1) || h1) {\n      s1._visible = false;\n    } else if (h0) {\n      s0._visible = false;\n    }\n  });\n}\n\nvar layout = {\n  prepare: function(datasets) {\n    var labels = [];\n    var i, j, ilen, jlen, label;\n\n    for (i = 0, ilen = datasets.length; i < ilen; ++i) {\n      for (j = 0, jlen = datasets[i].length; j < jlen; ++j) {\n        label = datasets[i][j];\n        labels.push(label);\n        label.$layout = {\n          _box: new HitBox(),\n          _hidable: false,\n          _visible: true,\n          _set: i,\n          _idx: label._index\n        };\n      }\n    }\n\n    // TODO New `z` option: labels with a higher z-index are drawn\n    // of top of the ones with a lower index. Lowest z-index labels\n    // are also discarded first when hiding overlapping labels.\n    labels.sort(function(a, b) {\n      var sa = a.$layout;\n      var sb = b.$layout;\n\n      return sa._idx === sb._idx\n        ? sb._set - sa._set\n        : sb._idx - sa._idx;\n    });\n\n    this.update(labels);\n\n    return labels;\n  },\n\n  update: function(labels) {\n    var dirty = false;\n    var i, ilen, label, model, state;\n\n    for (i = 0, ilen = labels.length; i < ilen; ++i) {\n      label = labels[i];\n      model = label.model();\n      state = label.$layout;\n      state._hidable = model && model.display === 'auto';\n      state._visible = label.visible();\n      dirty |= state._hidable;\n    }\n\n    if (dirty) {\n      compute(labels);\n    }\n  },\n\n  lookup: function(labels, point) {\n    var i, state;\n\n    // IMPORTANT Iterate in the reverse order since items at the end of\n    // the list have an higher z-index, thus should be picked first.\n\n    for (i = labels.length - 1; i >= 0; --i) {\n      state = labels[i].$layout;\n\n      if (state && state._visible && state._box.contains(point)) {\n        return labels[i];\n      }\n    }\n\n    return null;\n  },\n\n  draw: function(chart, labels) {\n    var i, ilen, label, state, geometry, center;\n\n    for (i = 0, ilen = labels.length; i < ilen; ++i) {\n      label = labels[i];\n      state = label.$layout;\n\n      if (state._visible) {\n        geometry = label.geometry();\n        center = coordinates(label._el, label.model(), geometry);\n        state._box.update(center, geometry, label.rotation());\n        label.draw(chart, center);\n      }\n    }\n  }\n};\n\nvar formatter = function(value) {\n  if (isNullOrUndef(value)) {\n    return null;\n  }\n\n  var label = value;\n  var keys, klen, k;\n  if (isObject(value)) {\n    if (!isNullOrUndef(value.label)) {\n      label = value.label;\n    } else if (!isNullOrUndef(value.r)) {\n      label = value.r;\n    } else {\n      label = '';\n      keys = Object.keys(value);\n      for (k = 0, klen = keys.length; k < klen; ++k) {\n        label += (k !== 0 ? ', ' : '') + keys[k] + ': ' + value[keys[k]];\n      }\n    }\n  }\n\n  return '' + label;\n};\n\n/**\n * IMPORTANT: make sure to also update tests and TypeScript definition\n * files (`/test/specs/defaults.spec.js` and `/types/options.d.ts`)\n */\n\nvar defaults = {\n  align: 'center',\n  anchor: 'center',\n  backgroundColor: null,\n  borderColor: null,\n  borderRadius: 0,\n  borderWidth: 0,\n  clamp: false,\n  clip: false,\n  color: undefined,\n  display: true,\n  font: {\n    family: undefined,\n    lineHeight: 1.2,\n    size: undefined,\n    style: undefined,\n    weight: null\n  },\n  formatter: formatter,\n  labels: undefined,\n  listeners: {},\n  offset: 4,\n  opacity: 1,\n  padding: {\n    top: 4,\n    right: 4,\n    bottom: 4,\n    left: 4\n  },\n  rotation: 0,\n  textAlign: 'start',\n  textStrokeColor: undefined,\n  textStrokeWidth: 0,\n  textShadowBlur: 0,\n  textShadowColor: undefined\n};\n\n/**\n * @see https://github.com/chartjs/Chart.js/issues/4176\n */\n\nvar EXPANDO_KEY = '$datalabels';\nvar DEFAULT_KEY = '$default';\n\nfunction configure(dataset, options) {\n  var override = dataset.datalabels;\n  var listeners = {};\n  var configs = [];\n  var labels, keys;\n\n  if (override === false) {\n    return null;\n  }\n  if (override === true) {\n    override = {};\n  }\n\n  options = merge({}, [options, override]);\n  labels = options.labels || {};\n  keys = Object.keys(labels);\n  delete options.labels;\n\n  if (keys.length) {\n    keys.forEach(function(key) {\n      if (labels[key]) {\n        configs.push(merge({}, [\n          options,\n          labels[key],\n          {_key: key}\n        ]));\n      }\n    });\n  } else {\n    // Default label if no \"named\" label defined.\n    configs.push(options);\n  }\n\n  // listeners: {<event-type>: {<label-key>: <fn>}}\n  listeners = configs.reduce(function(target, config) {\n    each(config.listeners || {}, function(fn, event) {\n      target[event] = target[event] || {};\n      target[event][config._key || DEFAULT_KEY] = fn;\n    });\n\n    delete config.listeners;\n    return target;\n  }, {});\n\n  return {\n    labels: configs,\n    listeners: listeners\n  };\n}\n\nfunction dispatchEvent(chart, listeners, label, event) {\n  if (!listeners) {\n    return;\n  }\n\n  var context = label.$context;\n  var groups = label.$groups;\n  var callback$1;\n\n  if (!listeners[groups._set]) {\n    return;\n  }\n\n  callback$1 = listeners[groups._set][groups._key];\n  if (!callback$1) {\n    return;\n  }\n\n  if (callback(callback$1, [context, event]) === true) {\n    // Users are allowed to tweak the given context by injecting values that can be\n    // used in scriptable options to display labels differently based on the current\n    // event (e.g. highlight an hovered label). That's why we update the label with\n    // the output context and schedule a new chart render by setting it dirty.\n    chart[EXPANDO_KEY]._dirty = true;\n    label.update(context);\n  }\n}\n\nfunction dispatchMoveEvents(chart, listeners, previous, label, event) {\n  var enter, leave;\n\n  if (!previous && !label) {\n    return;\n  }\n\n  if (!previous) {\n    enter = true;\n  } else if (!label) {\n    leave = true;\n  } else if (previous !== label) {\n    leave = enter = true;\n  }\n\n  if (leave) {\n    dispatchEvent(chart, listeners.leave, previous, event);\n  }\n  if (enter) {\n    dispatchEvent(chart, listeners.enter, label, event);\n  }\n}\n\nfunction handleMoveEvents(chart, event) {\n  var expando = chart[EXPANDO_KEY];\n  var listeners = expando._listeners;\n  var previous, label;\n\n  if (!listeners.enter && !listeners.leave) {\n    return;\n  }\n\n  if (event.type === 'mousemove') {\n    label = layout.lookup(expando._labels, event);\n  } else if (event.type !== 'mouseout') {\n    return;\n  }\n\n  previous = expando._hovered;\n  expando._hovered = label;\n  dispatchMoveEvents(chart, listeners, previous, label, event);\n}\n\nfunction handleClickEvents(chart, event) {\n  var expando = chart[EXPANDO_KEY];\n  var handlers = expando._listeners.click;\n  var label = handlers && layout.lookup(expando._labels, event);\n  if (label) {\n    dispatchEvent(chart, handlers, label, event);\n  }\n}\n\nvar plugin = {\n  id: 'datalabels',\n\n  defaults: defaults,\n\n  beforeInit: function(chart) {\n    chart[EXPANDO_KEY] = {\n      _actives: []\n    };\n  },\n\n  beforeUpdate: function(chart) {\n    var expando = chart[EXPANDO_KEY];\n    expando._listened = false;\n    expando._listeners = {};     // {<event-type>: {<dataset-index>: {<label-key>: <fn>}}}\n    expando._datasets = [];      // per dataset labels: [Label[]]\n    expando._labels = [];        // layouted labels: Label[]\n  },\n\n  afterDatasetUpdate: function(chart, args, options) {\n    var datasetIndex = args.index;\n    var expando = chart[EXPANDO_KEY];\n    var labels = expando._datasets[datasetIndex] = [];\n    var visible = chart.isDatasetVisible(datasetIndex);\n    var dataset = chart.data.datasets[datasetIndex];\n    var config = configure(dataset, options);\n    var elements = args.meta.data || [];\n    var ctx = chart.ctx;\n    var i, j, ilen, jlen, cfg, key, el, label;\n\n    ctx.save();\n\n    for (i = 0, ilen = elements.length; i < ilen; ++i) {\n      el = elements[i];\n      el[EXPANDO_KEY] = [];\n\n      if (visible && el && chart.getDataVisibility(i) && !el.skip) {\n        for (j = 0, jlen = config.labels.length; j < jlen; ++j) {\n          cfg = config.labels[j];\n          key = cfg._key;\n\n          label = new Label(cfg, ctx, el, i);\n          label.$groups = {\n            _set: datasetIndex,\n            _key: key || DEFAULT_KEY\n          };\n          label.$context = {\n            active: false,\n            chart: chart,\n            dataIndex: i,\n            dataset: dataset,\n            datasetIndex: datasetIndex\n          };\n\n          label.update(label.$context);\n          el[EXPANDO_KEY].push(label);\n          labels.push(label);\n        }\n      }\n    }\n\n    ctx.restore();\n\n    // Store listeners at the chart level and per event type to optimize\n    // cases where no listeners are registered for a specific event.\n    merge(expando._listeners, config.listeners, {\n      merger: function(event, target, source) {\n        target[event] = target[event] || {};\n        target[event][args.index] = source[event];\n        expando._listened = true;\n      }\n    });\n  },\n\n  afterUpdate: function(chart) {\n    chart[EXPANDO_KEY]._labels = layout.prepare(chart[EXPANDO_KEY]._datasets);\n  },\n\n  // Draw labels on top of all dataset elements\n  // https://github.com/chartjs/chartjs-plugin-datalabels/issues/29\n  // https://github.com/chartjs/chartjs-plugin-datalabels/issues/32\n  afterDatasetsDraw: function(chart) {\n    layout.draw(chart, chart[EXPANDO_KEY]._labels);\n  },\n\n  beforeEvent: function(chart, args) {\n    // If there is no listener registered for this chart, `listened` will be false,\n    // meaning we can immediately ignore the incoming event and avoid useless extra\n    // computation for users who don't implement label interactions.\n    if (chart[EXPANDO_KEY]._listened) {\n      var event = args.event;\n      switch (event.type) {\n      case 'mousemove':\n      case 'mouseout':\n        handleMoveEvents(chart, event);\n        break;\n      case 'click':\n        handleClickEvents(chart, event);\n        break;\n      }\n    }\n  },\n\n  afterEvent: function(chart) {\n    var expando = chart[EXPANDO_KEY];\n    var previous = expando._actives;\n    var actives = expando._actives = chart.getActiveElements();\n    var updates = utils.arrayDiff(previous, actives);\n    var i, ilen, j, jlen, update, label, labels;\n\n    for (i = 0, ilen = updates.length; i < ilen; ++i) {\n      update = updates[i];\n      if (update[1]) {\n        labels = update[0].element[EXPANDO_KEY] || [];\n        for (j = 0, jlen = labels.length; j < jlen; ++j) {\n          label = labels[j];\n          label.$context.active = (update[1] === 1);\n          label.update(label.$context);\n        }\n      }\n    }\n\n    if (expando._dirty || updates.length) {\n      layout.update(expando._labels);\n      chart.render();\n    }\n\n    delete expando._dirty;\n  }\n};\n\nexport { plugin as default };\n","import ChartLib, { ChartConfiguration, ChartItem, Chart, BarController, PieController, CategoryScale, LinearScale, BarElement, LineController, PointElement, LineElement, ArcElement, Colors, Title, Tooltip } from \"chart.js\";\nimport ChartDataLabels from 'chartjs-plugin-datalabels';\n\nChart.register(ChartDataLabels, BarController, PieController, CategoryScale, LinearScale, BarElement, LineController, PointElement, LineElement, ArcElement, Colors, Title, Tooltip);\nChart.defaults.set('plugins.datalabels', {\n  anchor: 'end',\n  align: 'top'\n})\n\nconst tooltipDollar = (tooltipItem: any) => {\n  const item = tooltipItem.raw;\n  if (item === \"0\") return item;\n  return \"$\" + tooltipItem.raw;\n}\n\nconst MONTHS: Month[] = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\nconst getPrevMonths = (\n  numberOfMonths: number = 12,\n  startingDate: Date = new Date()\n): [Month, Year][] => {\n  let out: [Month, Year][] = [];\n  let month: number = startingDate.getMonth();\n  let year: number = startingDate.getFullYear();\n  for (let i = 0; i < numberOfMonths; i++) {\n    out.push([MONTHS[month], year]);\n    month--;\n    if (month < 0) {\n      month = 11;\n      year--;\n    }\n  }\n  return out.reverse();\n};\n\nconst renderChart = async function (\n  el: HTMLElement,\n  cfg: ChartConfiguration\n): Promise<Chart<any>> {\n  return new Chart(el as ChartItem, cfg);\n};\n\nString.prototype.capitalize = function (): string {\n  return this.charAt(0).toUpperCase() + this.slice(1);\n};\n\nconst getDates = async (user: string = ''): Promise<Object[]> => {\n  const dates = await fetch(`/api/dates/${user}`);\n  const jsonDates = await dates.json();\n  return jsonDates;\n};\n\nconst aggDatesByMonth = (\n  dates: DateData[],\n  months: [Month, Year][]\n): number[] => {\n  const buckets: number[] = Array(months.length).fill(0);\n  for (let i = 0; i < months.length; i++) {\n    const [month, year] = months[i];\n    buckets[i] = dates.filter((dateData) => {\n      const occurrence: Date = new Date(dateData.date);\n      return (\n        occurrence.getFullYear() == year &&\n        occurrence.getMonth() == MONTHS.indexOf(month)\n      );\n    }).length;\n  }\n  return buckets;\n};\n\nconst aggCostByMonth = (\n  dates: DateData[],\n  months: [Month, Year][]\n): number[] => {\n  const buckets: number[] = Array(months.length).fill(0);\n  for (let i = 0; i < months.length; i++) {\n    const [month, year] = months[i];\n    buckets[i] = dates\n      .filter((dateData) => {\n        const occurrence: Date = new Date(dateData.date);\n        return (\n          occurrence.getFullYear() == year &&\n          occurrence.getMonth() == MONTHS.indexOf(month)\n        );\n      })\n      .reduce((acc, currentValue) => {\n        return acc + (currentValue.cost || 0);\n      }, 0);\n  }\n  return buckets;\n};\n\nconst avgCostPerDateByMonth = (\n  dates: DateData[],\n  months: [Month, Year][]\n): number[] => {\n  const buckets: number[] = Array(months.length).fill(0);\n  for (let i = 0; i < months.length; i++) {\n    const [month, year] = months[i];\n    const datesInMonth = dates.filter((dateData) => {\n      const occurrence: Date = new Date(dateData.date);\n      return (\n        occurrence.getFullYear() == year &&\n        occurrence.getMonth() == MONTHS.indexOf(month)\n      );\n    });\n    const costInMonth = datesInMonth.reduce((acc, currentValue) => {\n      return acc + (currentValue.cost || 0);\n    }, 0);\n    if (datesInMonth.length == 0) continue;\n    buckets[i] = parseFloat((costInMonth / datesInMonth.length).toFixed(2));\n  }\n  return buckets;\n};\n\nconst formatDollar = (value: number) => {\n  if (value === 0) return value;\n  return \"$\" + value.toFixed(2);\n};\n\nconst getSplitData = (dates: DateData[]): number[] => {\n  let numberSplit = dates.filter(date => date.split).length;\n  let numberNoSplit = dates.filter(date => !date.split).length;\n  // Label this [Split, NoSplit]\n  return [numberSplit, numberNoSplit];\n};\n\nfunction addVenue(event: Event) {\n  const datesField:HTMLElement | null = document.querySelector(\"#places\");\n  if (datesField) {\n    datesField.innerHTML +=\n    `<fieldset>\n    <div class=\"vertical\">\n        <label for=\"place\" class=\"block\">Location:</label>\n        <input type=\"text\" name=\"place\" id=\"place\" required>\n    </div>\n    <div class=\"vertical\">\n        <label for=\"type_of_place\" class=\"block\">Type of Date:</label>\n        <select name=\"type_of_place\" id=\"type_of_place\" required>\n            <option value=\"\">Select Type</option>\n            <option value=\"Restaurant\">Restaurant</option>\n            <option value=\"Drinks\">Drinks</option>\n            <option value=\"Dessert\">Dessert</option>\n            <option value=\"Casual\">Casual</option>\n            <option value=\"Formal\">Formal</option>\n            <option value=\"Adventure\">Adventure</option>\n        </select>\n    </div>\n    <div class=\"vertical\">\n        <label for=\"cost\" class=\"block\">Cost:</label>\n        <input type=\"text\" name=\"cost\" id=\"cost\" required>\n    </div>\n    </fieldset>`\n  }\n  event.preventDefault();\n}\n\nwindow._dt = {\n  renderChart,\n  getDates,\n  getPrevMonths,\n  aggDatesByMonth,\n  aggCostByMonth,\n  avgCostPerDateByMonth,\n  formatDollar,\n  tooltipDollar,\n  getSplitData,\n  addVenue,\n};\n","import DoughnutController from './controller.doughnut.js';\n\n// Pie charts are Doughnut chart with different defaults\nexport default class PieController extends DoughnutController {\n\n  static id = 'pie';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    // The percentage of the chart that we cut out of the middle.\n    cutout: 0,\n\n    // The rotation of the chart, where the first data arc begins.\n    rotation: 0,\n\n    // The total circumference of the chart.\n    circumference: 360,\n\n    // The outer radius of the chart\n    radius: '100%'\n  };\n}\n","import DatasetController from '../core/core.datasetController.js';\nimport {isNullOrUndef} from '../helpers/index.js';\nimport {isNumber} from '../helpers/helpers.math.js';\nimport {_getStartAndCountOfVisiblePoints, _scaleRangesChanged} from '../helpers/helpers.extras.js';\n\nexport default class LineController extends DatasetController {\n\n  static id = 'line';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    datasetElementType: 'line',\n    dataElementType: 'point',\n\n    showLine: true,\n    spanGaps: false,\n  };\n\n  /**\n   * @type {any}\n   */\n  static overrides = {\n    scales: {\n      _index_: {\n        type: 'category',\n      },\n      _value_: {\n        type: 'linear',\n      },\n    }\n  };\n\n  initialize() {\n    this.enableOptionSharing = true;\n    this.supportsDecimation = true;\n    super.initialize();\n  }\n\n  update(mode) {\n    const meta = this._cachedMeta;\n    const {dataset: line, data: points = [], _dataset} = meta;\n    // @ts-ignore\n    const animationsDisabled = this.chart._animationsDisabled;\n    let {start, count} = _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);\n\n    this._drawStart = start;\n    this._drawCount = count;\n\n    if (_scaleRangesChanged(meta)) {\n      start = 0;\n      count = points.length;\n    }\n\n    // Update Line\n    line._chart = this.chart;\n    line._datasetIndex = this.index;\n    line._decimated = !!_dataset._decimated;\n    line.points = points;\n\n    const options = this.resolveDatasetElementOptions(mode);\n    if (!this.options.showLine) {\n      options.borderWidth = 0;\n    }\n    options.segment = this.options.segment;\n    this.updateElement(line, undefined, {\n      animated: !animationsDisabled,\n      options\n    }, mode);\n\n    // Update Points\n    this.updateElements(points, start, count, mode);\n  }\n\n  updateElements(points, start, count, mode) {\n    const reset = mode === 'reset';\n    const {iScale, vScale, _stacked, _dataset} = this._cachedMeta;\n    const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode);\n    const iAxis = iScale.axis;\n    const vAxis = vScale.axis;\n    const {spanGaps, segment} = this.options;\n    const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;\n    const directUpdate = this.chart._animationsDisabled || reset || mode === 'none';\n    const end = start + count;\n    const pointsCount = points.length;\n    let prevParsed = start > 0 && this.getParsed(start - 1);\n\n    for (let i = 0; i < pointsCount; ++i) {\n      const point = points[i];\n      const properties = directUpdate ? point : {};\n\n      if (i < start || i >= end) {\n        properties.skip = true;\n        continue;\n      }\n\n      const parsed = this.getParsed(i);\n      const nullData = isNullOrUndef(parsed[vAxis]);\n      const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);\n      const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);\n\n      properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;\n      properties.stop = i > 0 && (Math.abs(parsed[iAxis] - prevParsed[iAxis])) > maxGapLength;\n      if (segment) {\n        properties.parsed = parsed;\n        properties.raw = _dataset.data[i];\n      }\n\n      if (includeOptions) {\n        properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n      }\n\n      if (!directUpdate) {\n        this.updateElement(point, i, properties, mode);\n      }\n\n      prevParsed = parsed;\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  getMaxOverflow() {\n    const meta = this._cachedMeta;\n    const dataset = meta.dataset;\n    const border = dataset.options && dataset.options.borderWidth || 0;\n    const data = meta.data || [];\n    if (!data.length) {\n      return border;\n    }\n    const firstPoint = data[0].size(this.resolveDataElementOptions(0));\n    const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));\n    return Math.max(border, firstPoint, lastPoint) / 2;\n  }\n\n  draw() {\n    const meta = this._cachedMeta;\n    meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis);\n    super.draw();\n  }\n}\n"],"names":["document","addEventListener","browseButtons","querySelectorAll","forEach","button","browse","querySelector","event","classList","add","remove","tokenInput","getElementById","tokenList","addToken","tokenValue","trim","capitalize","token","createElement","tokenLabel","textContent","appendChild","closeToken","innerHTML","input","setAttribute","value","removeToken","this","removeChild","preventDefault","key","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","exports","module","__webpack_modules__","round","v","lim","l","h","Math","max","min","p2b","n2b","b2n","n2p","map$1","A","B","C","D","E","F","a","b","c","d","e","f","hex","h1","h2","eq","HUE_RE","hsl2rgbn","s","n","k","hsv2rgbn","hwb2rgbn","w","rgb","i","rgb2hsl","r","g","hueValue","calln","Array","isArray","map","hsl2rgb","hue","x","Z","Y","X","W","V","U","T","S","R","Q","P","O","N","M","L","K","G","H","I","J","names$1","OiceXe","antiquewEte","aqua","aquamarRe","azuY","beige","bisque","black","blanKedOmond","Xe","XeviTet","bPwn","burlywood","caMtXe","KartYuse","KocTate","cSO","cSnflowerXe","cSnsilk","crimson","cyan","xXe","xcyan","xgTMnPd","xWay","xgYF","xgYy","xkhaki","xmagFta","xTivegYF","xSange","xScEd","xYd","xsOmon","xsHgYF","xUXe","xUWay","xUgYy","xQe","xviTet","dAppRk","dApskyXe","dimWay","dimgYy","dodgerXe","fiYbrick","flSOwEte","foYstWAn","fuKsia","gaRsbSo","ghostwEte","gTd","gTMnPd","Way","gYF","gYFLw","gYy","honeyMw","hotpRk","RdianYd","Rdigo","ivSy","khaki","lavFMr","lavFMrXsh","lawngYF","NmoncEffon","ZXe","ZcSO","Zcyan","ZgTMnPdLw","ZWay","ZgYF","ZgYy","ZpRk","ZsOmon","ZsHgYF","ZskyXe","ZUWay","ZUgYy","ZstAlXe","ZLw","lime","limegYF","lRF","magFta","maPon","VaquamarRe","VXe","VScEd","VpurpN","VsHgYF","VUXe","VsprRggYF","VQe","VviTetYd","midnightXe","mRtcYam","mistyPse","moccasR","navajowEte","navy","Tdlace","Tive","TivedBb","Sange","SangeYd","ScEd","pOegTMnPd","pOegYF","pOeQe","pOeviTetYd","papayawEp","pHKpuff","peru","pRk","plum","powMrXe","purpN","YbeccapurpN","Yd","Psybrown","PyOXe","saddNbPwn","sOmon","sandybPwn","sHgYF","sHshell","siFna","silver","skyXe","UXe","UWay","UgYy","snow","sprRggYF","stAlXe","tan","teO","tEstN","tomato","Qe","viTet","JHt","wEte","wEtesmoke","Lw","LwgYF","names","RGB_RE","to","pow","from","modHSL","ratio","tmp","clone","proto","Object","assign","fromObject","length","functionParse","str","charAt","m","exec","rgbParse","p1","p2","hwb2rgb","hsv2rgb","hueParse","Color","constructor","type","ret","len","unpacked","keys","tkeys","j","ok","nk","replace","parseInt","unpack","transparent","toLowerCase","nameParse","_rgb","_valid","valid","obj","rgbString","hexString","isShort","alpha","hslString","mix","color","weight","c1","c2","w2","p","w1","interpolate","t","rgb1","rgb2","clearer","greyscale","val","opaquer","negate","lighten","darken","saturate","desaturate","rotate","deg","noop","uid","id","isNullOrUndef","prototype","toString","call","slice","isObject","isNumberFinite","Number","isFinite","finiteOrDefault","defaultValue","valueOrDefault","toDimension","dimension","endsWith","parseFloat","callback","fn","args","thisArg","apply","each","loopable","reverse","_elementsEqual","a0","a1","ilen","v0","v1","datasetIndex","index","source","target","create","klen","isValidKey","indexOf","_merger","options","tval","sval","merge","sources","merger","current","mergeIf","_mergerIf","hasOwnProperty","keyResolvers","o","y","resolveObjectKey","resolver","parts","split","part","push","_splitKey","_getKeyResolver","_capitalize","toUpperCase","defined","isFunction","setsEqual","size","item","has","PI","TAU","PITAU","INFINITY","POSITIVE_INFINITY","RAD_PER_DEG","HALF_PI","QUARTER_PI","TWO_THIRDS_PI","log10","sign","almostEquals","epsilon","abs","niceNum","range","roundedRange","niceRange","floor","fraction","isNumber","isNaN","toRadians","degrees","_decimalPlaces","isFiniteNumber","getAngleFromPoint","centrePoint","anglePoint","distanceFromXCenter","distanceFromYCenter","radialDistanceFromCenter","sqrt","angle","atan2","distance","distanceBetweenPoints","pt1","pt2","_angleDiff","_normalizeAngle","_angleBetween","start","end","sameAngleIsFullCircle","angleToStart","angleToEnd","startToAngle","endToAngle","_limitValue","_isBetween","_lookup","table","cmp","mid","hi","lo","_lookupByKey","last","ti","_rlookupByKey","arrayEvents","unlistenArrayEvents","array","listener","stub","_chartjs","listeners","splice","requestAnimFrame","window","requestAnimationFrame","throttled","argsToUse","ticking","_toLeftRightCenter","align","_alignStartEnd","atEdge","elasticIn","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","easeInOutBounce","isPatternOrGradient","getHoverColor","numbers","colors","intlCache","Map","formatNumber","num","locale","cacheKey","JSON","stringify","formatter","get","Intl","NumberFormat","set","getNumberFormat","format","formatters","values","numeric","tickValue","ticks","chart","notation","delta","maxTick","calculateDelta","logDelta","numDecimal","minimumFractionDigits","maximumFractionDigits","logarithmic","remain","significand","includes","overrides","descriptors","getScope","node","root","scope","Defaults","_descriptors","_appliers","animation","backgroundColor","borderColor","datasets","devicePixelRatio","context","platform","getDevicePixelRatio","elements","events","font","family","style","lineHeight","hover","hoverBackgroundColor","ctx","hoverBorderColor","hoverColor","indexAxis","interaction","mode","intersect","includeInvisible","maintainAspectRatio","onHover","onClick","parsing","plugins","responsive","scale","scales","showLine","drawActiveElementsOnTop","describe","override","route","name","targetScope","targetName","scopeObject","targetScopeObject","privateName","defineProperties","writable","enumerable","local","appliers","_scriptable","startsWith","_indexable","_fallback","defaults","delay","duration","easing","loop","properties","active","resize","show","animations","visible","hide","autoPadding","padding","top","right","bottom","left","display","offset","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","Ticks","minor","major","crossAlign","showLabelBackdrop","backdropColor","backdropPadding","_measureText","data","gc","longest","string","textWidth","measureText","_alignPixel","pixel","currentDevicePixelRatio","halfWidth","clearCanvas","canvas","getContext","save","resetTransform","clearRect","height","restore","drawPoint","xOffset","yOffset","cornerRadius","xOffsetW","yOffsetW","pointStyle","rotation","radius","rad","translate","drawImage","beginPath","ellipse","arc","closePath","moveTo","lineTo","SQRT1_2","rect","fill","borderWidth","stroke","drawPointLegend","_isPointInArea","point","area","margin","clipArea","unclipArea","_steppedLineTo","previous","flip","midpoint","_bezierCurveTo","bezierCurveTo","cp1x","cp2x","cp1y","cp2y","decorateText","line","opts","strikethrough","underline","metrics","actualBoundingBoxLeft","actualBoundingBoxRight","actualBoundingBoxAscent","actualBoundingBoxDescent","yDecoration","strokeStyle","fillStyle","decorationWidth","drawBackdrop","oldColor","fillRect","renderText","lines","strokeWidth","strokeColor","translation","textAlign","textBaseline","setRenderOpts","backdrop","strokeText","maxWidth","fillText","addRoundedRectPath","topLeft","bottomLeft","bottomRight","topRight","LINE_HEIGHT","FONT_STYLE","toLineHeight","matches","match","numberOrZero","_readValueToProps","props","objProps","read","prop","toTRBL","toTRBLCorners","toPadding","toFont","fallback","console","warn","toFontString","resolve","inputs","info","cacheable","createContext","parentContext","_createResolver","scopes","prefixes","rootScopes","getTarget","finalRootScopes","_resolve","cache","Symbol","toStringTag","_cacheable","_scopes","_rootScopes","_getTarget","Proxy","deleteProperty","_keys","_cached","proxy","prefix","readKey","needsSubResolver","createSubResolver","_resolveWithPrefixes","getOwnPropertyDescriptor","Reflect","getPrototypeOf","getKeysFromAllScopes","ownKeys","storage","_storage","_attachContext","subProxy","descriptorDefaults","_proxy","_context","_subProxy","_stack","Set","setContext","receiver","isScriptable","getValue","Error","join","delete","_resolveScriptable","isIndexable","arr","filter","_resolveArray","_resolveWithContext","allKeys","configurable","scriptable","indexable","_allKeys","resolveFallback","parent","addScopes","parentScopes","parentFallback","allScopes","addScopesFromKey","subGetTarget","resolveKeysFromAllScopes","_parseObjectDataRadialScale","meta","count","iScale","_parsing","parsed","parse","EPSILON","getPoint","points","skip","getValueAxis","splineCurve","firstPoint","middlePoint","afterPoint","next","d01","d12","s01","s12","fa","fb","capControlPoint","pt","_updateBezierControlPoints","controlPoints","spanGaps","cubicInterpolationMode","valueAxis","pointsLen","deltaK","mK","pointBefore","pointCurrent","pointAfter","slopeDelta","alphaK","betaK","tauK","squaredMagnitude","monotoneAdjust","iPixel","vPixel","monotoneCompute","splineCurveMonotone","prev","tension","capBezierPoints","inArea","inAreaPrev","inAreaNext","_isDomSupported","_getParentNode","domNode","parentNode","host","parseMaxStyle","styleValue","parentProperty","valueInPixels","getComputedStyle","element","ownerDocument","defaultView","positions","getPositionedStyle","styles","suffix","result","pos","useOffsetPos","shadowRoot","getRelativePosition","borderBox","boxSizing","paddings","borders","box","touches","offsetX","offsetY","getBoundingClientRect","clientX","clientY","getCanvasPosition","round1","retinaScale","forceRatio","forceStyle","pixelRatio","deviceHeight","deviceWidth","setTransform","supportsEventListenerOptions","passiveSupported","passive","removeEventListener","readUsedSize","property","el","getPropertyValue","getStyle","_pointInLine","_steppedInterpolation","_bezierInterpolation","cp1","cp2","getRtlAdapter","rtl","rectX","setWidth","xPlus","leftForLtr","itemWidth","getRightToLeftAdapter","_itemWidth","propertyFn","between","compare","normalize","normalizeSegment","_boundSegment","segment","startBound","endBound","getSegment","prevValue","inside","subStart","readStyle","borderCapStyle","borderDash","borderDashOffset","borderJoinStyle","styleChanged","prevStyle","replacer","Animator","_request","_charts","_running","_lastDate","_notify","anims","date","callbacks","numSteps","initial","currentStep","_refresh","_update","Date","now","remaining","running","items","draw","_active","_total","tick","pop","_getAnims","charts","complete","progress","listen","cb","reduce","acc","cur","_duration","stop","cancel","interpolators","boolean","factor","c0","helpersColor","number","Animation","cfg","currentValue","_fn","_easing","_start","_loop","_target","_prop","_from","_to","_promises","update","elapsed","wait","promises","Promise","res","rej","resolved","method","Animations","config","_chart","_properties","configure","animationOptions","animatedProps","getOwnPropertyNames","option","_animateOptions","newOptions","$shared","$animations","resolveTargetOptions","_createAnimations","anim","all","awaitAll","then","animator","scaleClip","allowedOverflow","getSortedDatasetIndices","filterVisible","metasets","_getSortedDatasetMetas","applyStack","stack","dsIndex","singleMode","otherValue","isStacked","stacked","getOrCreateStack","stacks","stackKey","indexValue","subStack","getLastIndexInStack","vScale","positive","getMatchingVisibleMetas","updateStacks","controller","_cachedMeta","_stacks","iAxis","axis","vAxis","indexScale","valueScale","getStackKey","_top","_bottom","_visualValues","getFirstScaleId","shift","clearStacks","_parsed","isDirectUpdateMode","cloneIfNotShared","cached","shared","DatasetController","static","_cachedDataOpts","getMeta","_type","_data","_objectData","_sharedOptions","_drawStart","_drawCount","enableOptionSharing","supportsDecimation","$context","_syncList","datasetElementType","dataElementType","initialize","linkScales","_stacked","addElements","isPluginEnabled","updateIndex","dataset","getDataset","chooseId","xid","xAxisID","yid","yAxisID","rid","rAxisID","iid","iAxisID","vid","vAxisID","xScale","getScaleForId","yScale","rScale","getDatasetMeta","scaleID","_getOtherScale","reset","_destroy","_dataCheck","iAxisKey","vAxisKey","adata","convertObjectDataToArray","isExtensible","defineProperty","base","object","buildOrUpdateElements","resetNewElements","stackChanged","oldStacked","_resyncElements","scopeKeys","datasetScopeKeys","getOptionScopes","createResolver","sorted","_sorted","parseArrayData","parseObjectData","parsePrimitiveData","isNotInOrderComparedToPrev","labels","getLabels","singleScale","xAxisKey","yAxisKey","getParsed","getDataElement","updateRangeFromParsed","parsedValue","NaN","getMinMax","canStack","otherScale","hidden","createStack","NEGATIVE_INFINITY","otherMin","otherMax","minDefined","maxDefined","getUserBounds","_skip","getAllParsedValues","getMaxOverflow","getLabelAndValue","label","getLabelForValue","_clip","disabled","toClip","defaultClip","chartArea","resolveDatasetElementOptions","resolveDataElementOptions","dataIndex","raw","createDataContext","createDatasetContext","_resolveElementOptions","elementType","sharing","datasetElementScopeKeys","resolveNamedOptions","freeze","_resolveAnimations","transition","datasetAnimationScopeKeys","getSharedOptions","includeOptions","sharedOptions","_animationsDisabled","_getSharedOptions","firstOpts","previouslySharedOptions","updateSharedOptions","updateElement","_setStyle","removeHoverStyle","setHoverStyle","_removeDatasetHoverStyle","_setDatasetHoverStyle","arg1","arg2","numMeta","numData","_insertElements","_removeElements","move","updateElements","removed","_sync","_dataChanges","_onDataPush","arguments","_onDataPop","_onDataShift","_onDataSplice","newCount","_onDataUnshift","computeMinSampleSize","_cache","$bar","visibleMetas","concat","_arrayUnique","sort","getAllScaleValues","curr","_length","updateMinAndPrev","getPixelForValue","getPixelForTick","parseValue","entry","startValue","endValue","barStart","barEnd","_custom","parseFloatBar","parseArrayOrPrimitive","isFloatBar","custom","setBorderSkipped","edge","borderSkipped","horizontal","borderProps","enableBorderRadius","parseEdge","orig","v2","startEnd","setInflateAmount","inflateAmount","DoughnutController","animateRotate","animateScale","cutout","circumference","spacing","aspectRatio","legend","generateLabels","fontColor","getDataVisibility","legendItem","toggleDataVisibility","super","innerRadius","outerRadius","getter","_getRotation","_getCircumference","_getRotationExtents","isDatasetVisible","arcs","getMaxBorderWidth","getMaxOffset","maxSize","chartWeight","_getRingWeight","ratioX","ratioY","startAngle","endAngle","startX","startY","endX","endY","calcMax","calcMin","maxX","maxY","minX","minY","getRatioAndOffset","maxHeight","maxRadius","radiusLength","_getVisibleDatasetWeightTotal","total","calculateTotal","_getRingWeightOffset","_circumference","calculateCircumference","animationOpts","centerX","centerY","metaData","borderAlign","hoverBorderWidth","hoverOffset","ringWeightOffset","PolarAreaController","angleLines","circular","pointLabels","bind","_updateRadius","minSize","cutoutPercentage","getVisibleDatasetCount","xCenter","yCenter","datasetStartAngle","getIndexAngle","defaultAngle","countVisibleElements","_computeAngle","getDistanceFromCenterForValue","binarySearch","metaset","lookupMethod","_reversePixels","getRange","evaluateInteractionItems","position","handler","getSortedVisibleDatasetMetas","getIntersectItems","useFinalPosition","isPointInArea","inRange","getNearestItems","distanceMetric","useX","useY","deltaX","deltaY","getDistanceMetricForAxis","minDistance","center","getCenterPoint","getNearestCartesianItems","getProps","getNearestRadialItems","getAxisItems","rangeMethod","intersectsItem","modes","nearest","STATIC_POSITIONS","filterByPosition","filterDynamicPositionByAxis","sortByWeight","getCombinedMax","maxPadding","updateMaxPadding","boxPadding","updateDims","params","layout","getPadding","newWidth","outerWidth","newHeight","outerHeight","widthChanged","heightChanged","same","other","getMargins","marginForPositions","fitBoxes","boxes","refitBoxes","refit","changed","fullSize","setBoxDims","placeBoxes","userPadding","placed","stackWeight","addBox","_layers","z","removeBox","layoutItem","minPadding","availableWidth","availableHeight","layoutBoxes","isHorizontal","wrapBoxes","wrap","centerHorizontal","centerVertical","leftAndTop","rightAndBottom","vertical","buildLayoutBoxes","verticalBoxes","horizontalBoxes","beforeLayout","visibleVerticalBoxCount","vBoxMaxWidth","hBoxMaxHeight","layouts","buildStacks","setLayoutDims","updatePos","change","handleMaxPadding","BasePlatform","acquireContext","releaseContext","getMaximumSize","isAttached","updateConfig","BasicPlatform","EXPANDO_KEY","EVENT_TYPES","touchstart","touchmove","touchend","pointerenter","pointerdown","pointermove","pointerup","pointerleave","pointerout","isNullOrEmpty","eventListenerOptions","removeListener","nodeListContains","nodeList","contains","createAttachObserver","observer","MutationObserver","entries","trigger","addedNodes","removedNodes","observe","childList","subtree","createDetachObserver","drpListeningCharts","oldDevicePixelRatio","onWindowResize","dpr","createResizeObserver","container","clientWidth","ResizeObserver","contentRect","listenDevicePixelRatioChanges","releaseObserver","disconnect","unlistenDevicePixelRatioChanges","createProxyAndListen","native","fromNativeEvent","addListener","DomPlatform","renderHeight","getAttribute","renderWidth","displayWidth","displayHeight","initCanvas","removeAttribute","proxies","$proxies","attach","detach","bbWidth","bbHeight","margins","containerSize","containerStyle","containerBorder","containerPadding","clientHeight","getContainerSize","isConnected","Element","tooltipPosition","hasValue","final","newTicks","majorStart","majorEnd","ceil","offsetFromEdge","getTicksLimit","ticksLength","maxTicksLimit","sample","numItems","increment","getPixelForGridLine","offsetGridLines","validIndex","_startPixel","_endPixel","lineValue","getTickMarkLength","getTitleHeight","titleAlign","reverseAlign","Scale","_margins","paddingTop","paddingBottom","paddingLeft","paddingRight","labelRotation","_range","_gridLineItems","_labelItems","_labelSizes","_maxLength","_longestTextCache","_userMax","_userMin","_suggestedMax","_suggestedMin","_ticksLength","_borderValue","_dataLimitsCached","init","suggestedMin","suggestedMax","metas","getTicks","xLabels","yLabels","getLabelItems","_computeLabelItems","beforeUpdate","tickOpts","sampleSize","beforeSetDimensions","setDimensions","afterSetDimensions","beforeDataLimits","determineDataLimits","afterDataLimits","minmax","keepZero","_addGrace","beforeBuildTicks","buildTicks","afterBuildTicks","samplingEnabled","_convertTicksToLabels","beforeCalculateLabelRotation","calculateLabelRotation","afterCalculateLabelRotation","determinedMaxTicks","_tickSize","maxScale","maxChart","determineMaxTicks","ticksLimit","majorIndices","enabled","getMajorIndices","numMajorIndices","first","skipMajors","evenMajorSpacing","diff","getEvenSpacing","factors","_factorize","calculateSpacing","avgMajorSpacing","afterAutoSkip","beforeFit","fit","afterFit","afterUpdate","startPixel","endPixel","reversePixels","_alignToPixels","alignToPixels","_callHooks","notifyPlugins","beforeTickToLabelConversion","generateTickLabels","afterTickToLabelConversion","numTicks","maxLabelDiagonal","_isVisible","labelSizes","_getLabelSizes","maxLabelWidth","widest","maxLabelHeight","highest","asin","titleOpts","gridOpts","titleHeight","tickPadding","angleRadians","labelHeight","labelWidth","_calculatePadding","_handleMargins","isRotated","labelsBelowTicks","offsetLeft","offsetRight","isFullSize","_computeLabelSizes","caches","widths","heights","jlen","tickFont","fontString","nestedLabel","widestLabelSize","highestLabelSize","_resolveTickFontOptions","gcLen","garbageCollect","valueAt","idx","getValueForPixel","getPixelForDecimal","decimal","getDecimalForPixel","getBasePixel","getBaseValue","createTickContext","optionTicks","rot","_computeGridLineItems","tl","borderOpts","axisWidth","axisHalfWidth","alignBorderValue","borderValue","alignedLineValue","tx1","ty1","tx2","ty2","x1","y1","x2","y2","positionAxisID","limit","step","optsAtIndex","optsAtIndexBorder","lineColor","tickBorderDash","tickBorderDashOffset","tickAndPadding","hTickAndPadding","lineCount","textOffset","_getXAxisLabelAlignment","_getYAxisLabelAlignment","halfCount","tickTextAlign","labelPadding","_computeLabelArea","drawBackground","getLineWidthForValue","findIndex","drawGrid","drawLine","setLineDash","lineDashOffset","drawBorder","lastLineWidth","drawLabels","renderTextOptions","drawTitle","titleX","titleY","titleArgs","tz","gz","bz","axisID","_maxDigits","fontSize","TypedRegistry","isForType","isPrototypeOf","register","parentScope","isIChartComponent","itemDefaults","defaultRoutes","routes","propertyParts","sourceName","sourceScope","routeDefaults","registerDefaults","unregister","Registry","controllers","_typedRegistries","_each","addControllers","addPlugins","addScales","getController","_get","getElement","getPlugin","getScale","removeControllers","removeElements","removePlugins","removeScales","typedRegistry","arg","reg","_getRegistryForType","_exec","itemReg","registry","component","camelMethod","PluginService","_init","notify","hook","_createDescriptors","descriptor","plugin","callCallback","cancelable","invalidate","_oldCache","_notifyStateChanges","localIds","allPlugins","getOpts","pluginOpts","createDescriptors","previousDescriptors","some","pluginScopeKeys","getIndexAxis","datasetDefaults","idMatchesAxis","determineAxis","scaleOptions","getAxisFromDataset","initOptions","chartDefaults","configScales","chartIndexAxis","scaleConf","error","boundDs","retrieveAxisFromDatasets","defaultId","getDefaultScaleIDFromAxis","defaultScaleOptions","defaultID","getAxisFromDefaultScaleID","mergeScaleConfig","initData","keyCache","keysCached","cachedKeys","generate","addIfFound","Config","_config","initConfig","_scopeCache","_resolverCache","clearCache","clear","datasetType","additionalOptionScopes","_cachedScopes","mainScope","resetCache","keyLists","chartOptionScopes","subPrefixes","getResolver","hasFunction","needContext","resolverCache","KNOWN_POSITIONS","positionIsHorizontal","compare2Level","l1","l2","onAnimationsComplete","onComplete","onAnimationProgress","onProgress","getCanvas","instances","getChart","moveNumericKeys","intKey","getSizeForArea","field","Chart","invalidatePlugins","userConfig","initialCanvas","existingChart","OffscreenCanvas","_detectPlatform","_options","_aspectRatio","_metasets","_lastEvent","_listeners","_responsiveListeners","_sortedMetasets","_plugins","_hiddenIndices","attached","_doResize","timeout","clearTimeout","setTimeout","debounce","resizeDelay","_initialize","bindEvents","_resizeBeforeDraw","_resize","newSize","newRatio","onResize","render","ensureScalesHaveIDs","axisOptions","buildOrUpdateScales","scaleOpts","updated","isRadial","dposition","dtype","scaleType","hasUpdated","_updateMetasets","_destroyDatasetMeta","_removeUnreferencedMetasets","_dataset","buildOrUpdateControllers","newControllers","order","ControllerClass","_resetElements","animsDisabled","_updateScales","_checkEventBindings","_updateHiddenIndices","_minPadding","_updateLayout","_updateDatasets","_eventHandler","_updateHoverStyles","existingEvents","newEvents","unbindEvents","changes","_getUniformDataChanges","datasetCount","makeSet","changeSet","noArea","_idx","_updateDataset","layers","_drawDatasets","_drawDataset","useClip","getDatasetArea","getElementsAtEventForMode","Interaction","setDatasetVisibility","_updateVisibility","_stop","destroy","toBase64Image","toDataURL","bindUserEvents","bindResponsiveEvents","_add","_remove","detached","updateHoverStyle","getActiveElements","setActiveElements","activeElements","lastActive","pluginId","replay","hoverOptions","deactivated","activated","inChartArea","eventFilter","_handleEvent","_getActiveElements","isClick","_isClickEvent","lastEvent","determineLastEvent","rThetaToXY","theta","pathArc","pixelMargin","innerR","spacingOffset","avNogSpacingRadius","angleOffset","outerStart","outerEnd","innerStart","innerEnd","angleDelta","borderRadius","halfThickness","innerLimit","computeOuterLimit","outerArcLimit","parseBorderRadius","outerStartAdjustedRadius","outerEndAdjustedRadius","outerStartAdjustedAngle","outerEndAdjustedAngle","innerStartAdjustedRadius","innerEndAdjustedRadius","innerStartAdjustedAngle","innerEndAdjustedAngle","outerMidAdjustedAngle","pCenter","p4","innerMidAdjustedAngle","p8","outerStartX","outerStartY","outerEndX","outerEndY","ArcElement","fullCircles","chartX","chartY","rAdjust","betweenAngles","withinRadius","halfAngle","halfRadius","radiusOffset","drawArc","inner","lineJoin","angleMargin","clipArc","setStyle","lineCap","pathVars","paramsStart","paramsEnd","segmentStart","segmentEnd","outside","pathSegment","lineMethod","stepped","getLineMethod","fastPathSegment","prevX","lastY","avgX","countX","pointIndex","drawX","truncX","_getSegmentMethod","_decimated","usePath2D","Path2D","hitRadius","PointElement","hoverRadius","mouseX","mouseY","inXRange","inYRange","getBarBounds","bar","half","skipOrLimit","skipX","skipY","addNormalRectPath","inflateRect","amount","refRect","BarElement","outer","maxW","maxH","parseBorderWidth","maxR","enableBorder","boundingRects","addRectPath","BORDER_COLORS","BACKGROUND_COLORS","getBorderColor","getBackgroundColor","containsColorsDefinitions","forceOverride","_args","chartOptions","colorizer","colorizeDoughnutDataset","colorizePolarAreaDataset","colorizeDefaultDataset","getColorizer","Title","_padding","textSize","_drawArgs","fontOpts","_element","titleBlock","createTitle","WeakMap","positioners","average","xSet","eventPosition","nearestElement","tp","pushOrConcat","toPush","splitNewlines","String","createTooltipItem","formattedValue","getTooltipSize","tooltip","body","footer","boxWidth","boxHeight","bodyFont","titleFont","footerFont","titleLineCount","footerLineCount","bodyLineItemCount","combinedBodyLength","bodyItem","before","after","beforeBody","afterBody","titleSpacing","titleMarginBottom","displayColors","bodySpacing","footerMarginTop","footerSpacing","widthPadding","maxLineWidth","determineXAlign","yAlign","chartWidth","xAlign","caret","caretSize","caretPadding","doesNotFitWithAlign","determineAlignment","determineYAlign","getBackgroundPoint","alignment","paddingAndSize","alignX","alignY","getAlignedX","getBeforeAfterBodyLines","overrideCallbacks","defaultCallbacks","beforeTitle","tooltipItems","labelCount","afterTitle","beforeLabel","tooltipItem","labelColor","labelTextColor","bodyColor","labelPointStyle","afterLabel","beforeFooter","afterFooter","invokeCallbackWithFallback","Tooltip","opacity","_eventPosition","_size","_cachedAnimations","_tooltipItems","dataPoints","caretX","caretY","labelColors","labelPointStyles","labelTextColors","getTitle","getBeforeBody","getBody","bodyItems","scoped","getAfterBody","getFooter","_createItems","itemSort","positionAndSize","backgroundPoint","external","drawCaret","tooltipPoint","caretPosition","getCaretPosition","x3","y3","ptX","ptY","rtlHelper","titleColor","_drawColorBox","colorX","rtlColorX","yOffSet","colorY","usePointStyle","drawOptions","multiKeyBackground","outerX","innerX","strokeRect","drawBody","bodyAlign","bodyLineHeight","xLinePadding","fillLineOfText","bodyAlignForCalculation","textColor","drawFooter","footerAlign","footerColor","tooltipSize","quadraticCurveTo","_updateAnimationTarget","animX","animY","_willRender","hasTooltipContent","globalAlpha","direction","original","getPropertyPriority","setProperty","prevTextDirection","overrideTextDirection","textDirection","restoreTextDirection","positionChanged","_positionChanged","_ignoreReplayEvents","handleEvent","afterInit","afterDraw","afterEvent","_getLabelForValue","relativeLabelSize","minSpacing","LinearScaleBase","_startValue","_endValue","_valueRange","handleTickRangeOptions","setMin","setMax","minSign","maxSign","getTickLimit","maxTicks","stepSize","computeTickLimit","generationOptions","dataRange","precision","maxDigits","includeBounds","unit","maxSpaces","rmin","rmax","countDefined","niceMin","niceMax","numSpaces","rounded","almostWhole","decimalPlaces","generateTicks","_setMinAndMaxByKey","LinearScale","screen","deviceXDPI","logicalXDPI","utils","orient","origin","x0","y0","dx","dy","ln","R_INSIDE","R_LEFT","R_RIGHT","R_BOTTOM","R_TOP","region","compute$1","anchor","clamp","r0","r1","clipped","vx","vy","aligned","rx","ry","sx","sy","rasterize","getScaleOrigin","drawTextLine","shadow","shadowBlur","stroked","filled","Label","me","_index","_model","_rects","_el","_modelize","positioner","textShadowBlur","textShadowColor","model","rects","unshift","th","tw","tx","ty","frame","geometry","bgColor","drawRoundedRect","drawFrame","textGeometry","shadowColor","drawText","MIN_INTEGER","MIN_SAFE_INTEGER","MAX_INTEGER","MAX_SAFE_INTEGER","rotated","cx","cy","projected","dp","toAxis","p0","HitBox","_rotation","_rect","coordinates","vs","intersects","pr0","pr1","_points","axes","prepare","$layout","_box","_hidable","_visible","_set","sa","sb","state","dirty","collider","s0","s1","collide","h0","compute","lookup","DEFAULT_KEY","dispatchEvent","callback$1","groups","$groups","_key","_dirty","beforeInit","_actives","expando","_listened","_datasets","_labels","afterDatasetUpdate","datalabels","configs","afterDatasetsDraw","beforeEvent","enter","leave","_hovered","dispatchMoveEvents","handleMoveEvents","handlers","click","handleClickEvents","updates","categoryPercentage","barPercentage","grouped","_index_","_value_","bars","ruler","_getRuler","vpixels","head","_calculateBarValuePixels","ipixels","_calculateBarIndexPixels","_getStacks","skipNull","_getStackCount","_getStackIndex","pixels","barThickness","stackCount","baseValue","minBarLength","actualBase","floating","barSign","halfGrid","maxBarThickness","Infinity","percent","chunk","computeFlexCategoryTraits","thickness","computeFitCategoryTraits","stackIndex","_addedLabels","added","addedLabels","addIfString","lastIndexOf","findOrAddLabel","animationsDisabled","pointCount","_getStartAndCountOfVisiblePoints","_scaleRanges","newRanges","xmin","xmax","ymin","ymax","_scaleRangesChanged","_datasetIndex","animated","maxGapLength","directUpdate","pointsCount","prevParsed","nullData","lastPoint","updateControlPoints","_fullLoop","_path","_segments","_pointsUpdated","segments","segmentOptions","findStartAndEnd","chartContext","baseStyle","addStyle","st","dir","p0DataIndex","p1DataIndex","doSplitByStyles","splitByStyles","solidSegments","_computeSegments","sub","_boundSegments","_interpolate","_getInterpolationMethod","interpolated","segmentMethod","path","strokePathWithCache","strokePathDirect","MONTHS","_dt","renderChart","async","getDates","user","dates","fetch","json","getPrevMonths","numberOfMonths","startingDate","out","month","getMonth","year","getFullYear","aggDatesByMonth","months","buckets","dateData","occurrence","aggCostByMonth","cost","avgCostPerDateByMonth","datesInMonth","costInMonth","toFixed","formatDollar","tooltipDollar","getSplitData","addVenue","datesField"],"sourceRoot":""}