aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJJ <nicetry@noemail.com>2025-03-21 13:45:32 +0000
committerJJ <nicetry@noemail.com>2025-03-21 13:45:32 +0000
commitb679c6c2e28621ca6810bcdd14ef7a5db0236a6b (patch)
tree8ca164f4804ee1e8fb1ea106f4c1a45e5f094d7e
parentfa8ad82036fc8964f19dd38a9a2ef5acb1970f17 (diff)
chess pageHEADmain
Diffstat
-rw-r--r--content/_index.md2
-rw-r--r--content/chess.md4
-rw-r--r--content/notes/index.njk40
-rw-r--r--content/projects/indexcooking.md3
-rw-r--r--content/projects/polypubs.md2
-rw-r--r--content/projects/tubestat.md11
-rw-r--r--content/snippets/rsync.md13
-rw-r--r--data/chess/chessdata.json1
-rw-r--r--layouts/_default/baseof.html11
-rw-r--r--layouts/page/chess.html8
-rw-r--r--layouts/partials/footer.html5
-rw-r--r--layouts/partials/nav.html6
-rw-r--r--static/chart.js9459
-rw-r--r--static/chess-charts.js46
-rw-r--r--static/style.css14
15 files changed, 9577 insertions, 48 deletions
diff --git a/content/_index.md b/content/_index.md
index 9ae96f3..b1c45a6 100644
--- a/content/_index.md
+++ b/content/_index.md
@@ -6,4 +6,4 @@ This is my personal <a href="/blog">blog</a>, where I can jot down my thoughts o
I also use it as a personal references for <a href="/snippets">code snippets</a> I routinely re-use and <a href="/notes">notes</a> on the things I am currently studying.
-When i'm not doing this, i'm probably playing chess.
+When i'm not doing this, i'm probably playing <a href="chess">chess</a>.
diff --git a/content/chess.md b/content/chess.md
new file mode 100644
index 0000000..a4d11f3
--- /dev/null
+++ b/content/chess.md
@@ -0,0 +1,4 @@
++++
+title = "chess"
+layout= "chess"
++++
diff --git a/content/notes/index.njk b/content/notes/index.njk
deleted file mode 100644
index 3dabc96..0000000
--- a/content/notes/index.njk
+++ /dev/null
@@ -1,40 +0,0 @@
----
-layout: /layouts/layout.njk
-title: All notes
-description: A list of all notes
----
-{% set coursesArr = [] %}
-
-{% for item in collections.coursesList %}
- {% if coursesArr.indexOf(item.data.course) == -1 %}
- {% set coursesArr = (coursesArr.push( item.data.course ), coursesArr) %}
- {% endif %}
-{% endfor %}
-
-<div class="container">
-
-<ul class="list-disc pl-3">
-{% for theCourse in coursesArr %}
- <li class="mb-3">
- <input type="checkbox" class="hidden peer" id="checkbox-{{ loop.index }}">
- <label for="checkbox-{{ loop.index }}">
- <h2 class="mb-2 cursor-pointer font-heading text-xl text-teal-900 mb-2 capitalize">{{ theCourse }} <span>⏵</span></h2>
- </label>
- {% for item in collections.coursesList %}
- {% if item.data.course == theCourse %}
- <ul class="hidden peer-checked:block">
- <li>
- <h3 class="font-body font-light">
- <a href="{{ item.url }}" class="text-[18px] mr-2 visited:text-red-600 no-underline">
- {{ item.data.title }}
- </a>
- </h3>
- </li>
- </ul>
- {% endif %}
- {% endfor %}
- </li>
-{% endfor %}
-</ul>
-
-</div>
diff --git a/content/projects/indexcooking.md b/content/projects/indexcooking.md
index 290d1d9..a3eaafa 100644
--- a/content/projects/indexcooking.md
+++ b/content/projects/indexcooking.md
@@ -5,6 +5,7 @@ tags = [
"flask",
"mongodb",
]
+draft = true
[params]
- link = "https://pubs.jezl.xyz"
+ link = "https://example.com"
+++
diff --git a/content/projects/polypubs.md b/content/projects/polypubs.md
index 49b34f5..3e79e39 100644
--- a/content/projects/polypubs.md
+++ b/content/projects/polypubs.md
@@ -5,4 +5,6 @@ tags = [
"maps",
"algolia",
]
+[params]
+ link = "https://pubs.jezl.xyz"
+++
diff --git a/content/projects/tubestat.md b/content/projects/tubestat.md
new file mode 100644
index 0000000..a745454
--- /dev/null
+++ b/content/projects/tubestat.md
@@ -0,0 +1,11 @@
++++
+title = "tubestat"
+description = "London tube statuses from the command line"
+tags = [
+ "cli",
+ "python",
+]
+[params]
+ link = "https://pypi.org/project/tube-stat/"
+date = 2025-03-20
++++
diff --git a/content/snippets/rsync.md b/content/snippets/rsync.md
new file mode 100644
index 0000000..21e43fa
--- /dev/null
+++ b/content/snippets/rsync.md
@@ -0,0 +1,13 @@
+---
+title: Basic rsync commands
+description: Basic rsync commands
+tags: ["rsync"]
+---
+
+I use these rscync commands regularly to sync local data and remote servers:
+
+```console
+rsync -avz --progress /local/path /remote/path
+```
+
+`a` is archive mode, which keeps permissions, timestamps, symlinks etc, `v` means verbose and shows transfer progress in a human readable format, `z` compresses data during send and `---progress` shows files transer progress.
diff --git a/data/chess/chessdata.json b/data/chess/chessdata.json
new file mode 100644
index 0000000..61637a1
--- /dev/null
+++ b/data/chess/chessdata.json
@@ -0,0 +1 @@
+[{"time_control": "Bullet", "data": [{"x": "2022-6-28", "y": "1744"}, {"x": "2022-7-2", "y": "1727"}, {"x": "2022-7-12", "y": "1682"}, {"x": "2022-7-13", "y": "1637"}, {"x": "2022-7-14", "y": "1590"}, {"x": "2022-7-15", "y": "1606"}, {"x": "2022-7-18", "y": "1603"}, {"x": "2022-7-19", "y": "1590"}, {"x": "2022-7-22", "y": "1584"}, {"x": "2022-7-25", "y": "1577"}, {"x": "2022-7-26", "y": "1567"}, {"x": "2022-8-1", "y": "1554"}, {"x": "2022-8-2", "y": "1548"}, {"x": "2022-8-3", "y": "1541"}, {"x": "2022-8-16", "y": "1549"}, {"x": "2022-8-26", "y": "1552"}, {"x": "2022-8-30", "y": "1573"}, {"x": "2022-9-5", "y": "1548"}, {"x": "2022-9-20", "y": "1522"}, {"x": "2022-10-6", "y": "1503"}, {"x": "2023-1-29", "y": "1566"}, {"x": "2023-12-22", "y": "1760"}, {"x": "2023-12-24", "y": "1805"}, {"x": "2023-12-25", "y": "1730"}, {"x": "2023-12-26", "y": "1776"}, {"x": "2023-12-27", "y": "1746"}, {"x": "2023-12-28", "y": "1746"}, {"x": "2023-12-29", "y": "1699"}, {"x": "2023-12-30", "y": "1678"}, {"x": "2023-12-31", "y": "1684"}, {"x": "2024-1-1", "y": "1673"}, {"x": "2024-1-2", "y": "1679"}, {"x": "2024-1-3", "y": "1685"}, {"x": "2024-1-4", "y": "1686"}, {"x": "2024-1-5", "y": "1729"}, {"x": "2024-1-6", "y": "1728"}, {"x": "2024-1-7", "y": "1711"}, {"x": "2024-1-8", "y": "1680"}, {"x": "2024-1-9", "y": "1675"}, {"x": "2024-1-10", "y": "1695"}, {"x": "2024-1-11", "y": "1701"}, {"x": "2024-1-12", "y": "1694"}, {"x": "2024-1-13", "y": "1699"}, {"x": "2024-1-14", "y": "1692"}, {"x": "2024-1-15", "y": "1683"}, {"x": "2024-1-16", "y": "1676"}, {"x": "2024-1-17", "y": "1660"}, {"x": "2024-1-18", "y": "1661"}, {"x": "2024-1-19", "y": "1611"}, {"x": "2024-1-21", "y": "1604"}, {"x": "2024-1-22", "y": "1569"}, {"x": "2024-1-23", "y": "1576"}, {"x": "2024-1-24", "y": "1558"}, {"x": "2024-1-25", "y": "1553"}, {"x": "2024-1-26", "y": "1570"}, {"x": "2024-1-27", "y": "1559"}, {"x": "2024-1-28", "y": "1566"}, {"x": "2024-1-29", "y": "1564"}, {"x": "2024-1-30", "y": "1537"}, {"x": "2024-1-31", "y": "1531"}, {"x": "2024-2-1", "y": "1511"}, {"x": "2024-2-2", "y": "1506"}, {"x": "2024-2-3", "y": "1530"}, {"x": "2024-2-4", "y": "1556"}, {"x": "2024-2-5", "y": "1567"}, {"x": "2024-2-6", "y": "1589"}, {"x": "2024-2-7", "y": "1596"}, {"x": "2024-2-8", "y": "1599"}, {"x": "2024-2-9", "y": "1587"}, {"x": "2024-2-10", "y": "1584"}, {"x": "2024-2-11", "y": "1583"}, {"x": "2024-2-12", "y": "1577"}, {"x": "2024-2-13", "y": "1593"}, {"x": "2024-2-14", "y": "1575"}, {"x": "2024-2-15", "y": "1579"}, {"x": "2024-2-16", "y": "1576"}, {"x": "2024-2-17", "y": "1576"}, {"x": "2024-2-20", "y": "1578"}, {"x": "2024-2-23", "y": "1584"}, {"x": "2024-2-26", "y": "1578"}, {"x": "2024-2-27", "y": "1573"}, {"x": "2024-2-28", "y": "1590"}, {"x": "2024-2-29", "y": "1565"}, {"x": "2024-3-1", "y": "1570"}, {"x": "2024-3-2", "y": "1576"}, {"x": "2024-3-4", "y": "1615"}, {"x": "2024-3-5", "y": "1601"}, {"x": "2024-3-6", "y": "1577"}, {"x": "2024-3-7", "y": "1577"}, {"x": "2024-3-11", "y": "1567"}, {"x": "2024-3-12", "y": "1543"}, {"x": "2024-3-13", "y": "1555"}, {"x": "2024-3-14", "y": "1576"}, {"x": "2024-3-15", "y": "1570"}, {"x": "2024-3-18", "y": "1614"}, {"x": "2024-3-19", "y": "1668"}, {"x": "2024-3-20", "y": "1698"}, {"x": "2024-3-21", "y": "1677"}, {"x": "2024-3-22", "y": "1641"}, {"x": "2024-3-23", "y": "1641"}, {"x": "2024-3-24", "y": "1635"}, {"x": "2024-3-25", "y": "1638"}, {"x": "2024-3-26", "y": "1632"}, {"x": "2024-3-27", "y": "1627"}, {"x": "2024-3-29", "y": "1633"}, {"x": "2024-4-11", "y": "1626"}, {"x": "2024-9-2", "y": "1632"}, {"x": "2024-9-24", "y": "1632"}, {"x": "2024-10-13", "y": "1635"}, {"x": "2024-12-16", "y": "1665"}, {"x": "2024-12-17", "y": "1724"}, {"x": "2024-12-18", "y": "1717"}, {"x": "2024-12-19", "y": "1703"}, {"x": "2024-12-20", "y": "1724"}, {"x": "2024-12-23", "y": "1717"}, {"x": "2024-12-24", "y": "1710"}, {"x": "2024-12-26", "y": "1694"}, {"x": "2024-12-27", "y": "1687"}, {"x": "2024-12-30", "y": "1694"}, {"x": "2025-1-1", "y": "1680"}, {"x": "2025-1-27", "y": "1669"}, {"x": "2025-1-28", "y": "1686"}, {"x": "2025-1-29", "y": "1707"}, {"x": "2025-1-31", "y": "1671"}, {"x": "2025-2-3", "y": "1665"}, {"x": "2025-2-4", "y": "1665"}, {"x": "2025-2-5", "y": "1676"}, {"x": "2025-2-6", "y": "1664"}, {"x": "2025-2-7", "y": "1656"}, {"x": "2025-2-10", "y": "1648"}, {"x": "2025-2-11", "y": "1645"}, {"x": "2025-2-12", "y": "1645"}, {"x": "2025-2-13", "y": "1650"}, {"x": "2025-2-14", "y": "1674"}, {"x": "2025-2-17", "y": "1640"}, {"x": "2025-2-18", "y": "1634"}, {"x": "2025-2-21", "y": "1634"}, {"x": "2025-2-22", "y": "1628"}, {"x": "2025-2-23", "y": "1653"}, {"x": "2025-2-24", "y": "1621"}, {"x": "2025-2-25", "y": "1605"}, {"x": "2025-2-26", "y": "1597"}, {"x": "2025-2-27", "y": "1583"}, {"x": "2025-2-28", "y": "1602"}, {"x": "2025-3-2", "y": "1597"}, {"x": "2025-3-3", "y": "1602"}, {"x": "2025-3-4", "y": "1590"}, {"x": "2025-3-5", "y": "1585"}, {"x": "2025-3-6", "y": "1591"}, {"x": "2025-3-8", "y": "1631"}, {"x": "2025-3-9", "y": "1637"}, {"x": "2025-3-10", "y": "1630"}, {"x": "2025-3-11", "y": "1645"}, {"x": "2025-3-12", "y": "1634"}, {"x": "2025-3-13", "y": "1630"}, {"x": "2025-3-14", "y": "1628"}, {"x": "2025-3-17", "y": "1667"}, {"x": "2025-3-18", "y": "1691"}, {"x": "2025-3-19", "y": "1707"}, {"x": "2025-3-20", "y": "1719"}, {"x": "2025-3-21", "y": "1719"}]}, {"time_control": "Blitz", "data": [{"x": "2022-6-28", "y": "1606"}, {"x": "2022-7-2", "y": "1740"}, {"x": "2022-7-3", "y": "1725"}, {"x": "2022-7-5", "y": "1705"}, {"x": "2022-7-7", "y": "1701"}, {"x": "2022-7-12", "y": "1681"}, {"x": "2022-7-13", "y": "1628"}, {"x": "2022-7-14", "y": "1629"}, {"x": "2022-7-15", "y": "1646"}, {"x": "2022-7-16", "y": "1656"}, {"x": "2022-7-18", "y": "1659"}, {"x": "2022-7-19", "y": "1644"}, {"x": "2022-7-20", "y": "1611"}, {"x": "2022-7-21", "y": "1628"}, {"x": "2022-7-22", "y": "1618"}, {"x": "2022-7-25", "y": "1597"}, {"x": "2022-7-26", "y": "1627"}, {"x": "2022-7-29", "y": "1601"}, {"x": "2022-7-30", "y": "1607"}, {"x": "2022-8-1", "y": "1632"}, {"x": "2022-8-2", "y": "1657"}, {"x": "2022-8-3", "y": "1657"}, {"x": "2022-8-5", "y": "1640"}, {"x": "2022-8-8", "y": "1646"}, {"x": "2022-8-9", "y": "1647"}, {"x": "2022-8-10", "y": "1653"}, {"x": "2022-8-16", "y": "1629"}, {"x": "2022-8-26", "y": "1628"}, {"x": "2022-9-5", "y": "1639"}, {"x": "2022-10-4", "y": "1668"}, {"x": "2023-12-18", "y": "1786"}, {"x": "2023-12-19", "y": "1813"}, {"x": "2023-12-20", "y": "1806"}, {"x": "2023-12-21", "y": "1795"}, {"x": "2023-12-22", "y": "1750"}, {"x": "2023-12-23", "y": "1743"}, {"x": "2023-12-24", "y": "1735"}, {"x": "2023-12-25", "y": "1744"}, {"x": "2023-12-26", "y": "1698"}, {"x": "2023-12-27", "y": "1705"}, {"x": "2023-12-28", "y": "1699"}, {"x": "2023-12-29", "y": "1724"}, {"x": "2023-12-30", "y": "1718"}, {"x": "2024-1-1", "y": "1725"}, {"x": "2024-1-5", "y": "1719"}, {"x": "2024-1-8", "y": "1714"}, {"x": "2024-1-9", "y": "1707"}, {"x": "2024-1-10", "y": "1712"}, {"x": "2024-1-11", "y": "1705"}, {"x": "2024-1-12", "y": "1705"}, {"x": "2024-1-14", "y": "1698"}, {"x": "2024-1-15", "y": "1679"}, {"x": "2024-1-23", "y": "1665"}, {"x": "2024-1-24", "y": "1650"}, {"x": "2024-1-27", "y": "1643"}, {"x": "2024-1-29", "y": "1658"}, {"x": "2024-1-30", "y": "1652"}, {"x": "2024-1-31", "y": "1652"}, {"x": "2024-2-1", "y": "1645"}, {"x": "2024-2-13", "y": "1654"}, {"x": "2024-2-26", "y": "1643"}, {"x": "2024-3-25", "y": "1632"}, {"x": "2024-10-3", "y": "1627"}, {"x": "2024-10-13", "y": "1617"}, {"x": "2024-12-17", "y": "1599"}, {"x": "2024-12-24", "y": "1579"}, {"x": "2024-12-26", "y": "1593"}, {"x": "2024-12-27", "y": "1584"}, {"x": "2024-12-28", "y": "1607"}, {"x": "2024-12-30", "y": "1633"}, {"x": "2024-12-31", "y": "1598"}, {"x": "2025-1-1", "y": "1591"}, {"x": "2025-1-2", "y": "1590"}, {"x": "2025-1-26", "y": "1601"}, {"x": "2025-1-27", "y": "1608"}, {"x": "2025-1-28", "y": "1587"}, {"x": "2025-1-29", "y": "1575"}, {"x": "2025-1-31", "y": "1582"}, {"x": "2025-2-2", "y": "1575"}, {"x": "2025-2-3", "y": "1596"}, {"x": "2025-2-5", "y": "1591"}, {"x": "2025-2-6", "y": "1596"}, {"x": "2025-2-7", "y": "1589"}, {"x": "2025-2-9", "y": "1580"}, {"x": "2025-2-10", "y": "1575"}, {"x": "2025-2-11", "y": "1582"}, {"x": "2025-2-12", "y": "1582"}, {"x": "2025-2-13", "y": "1573"}, {"x": "2025-2-16", "y": "1578"}, {"x": "2025-2-17", "y": "1581"}, {"x": "2025-2-18", "y": "1563"}, {"x": "2025-2-19", "y": "1562"}, {"x": "2025-2-21", "y": "1574"}, {"x": "2025-2-22", "y": "1569"}, {"x": "2025-2-23", "y": "1626"}, {"x": "2025-2-24", "y": "1644"}, {"x": "2025-2-25", "y": "1632"}, {"x": "2025-2-26", "y": "1653"}, {"x": "2025-2-28", "y": "1643"}, {"x": "2025-3-3", "y": "1643"}, {"x": "2025-3-4", "y": "1644"}, {"x": "2025-3-5", "y": "1615"}, {"x": "2025-3-6", "y": "1620"}, {"x": "2025-3-7", "y": "1632"}, {"x": "2025-3-8", "y": "1626"}, {"x": "2025-3-9", "y": "1645"}, {"x": "2025-3-10", "y": "1650"}, {"x": "2025-3-11", "y": "1644"}, {"x": "2025-3-13", "y": "1639"}, {"x": "2025-3-15", "y": "1632"}, {"x": "2025-3-20", "y": "1611"}]}, {"time_control": "Rapid", "data": [{"x": "2020-12-15", "y": "1366"}, {"x": "2022-6-28", "y": "1246"}, {"x": "2022-7-2", "y": "1336"}, {"x": "2023-12-27", "y": "1512"}, {"x": "2023-12-28", "y": "1453"}, {"x": "2023-12-29", "y": "1399"}, {"x": "2024-1-1", "y": "1350"}, {"x": "2024-1-3", "y": "1388"}, {"x": "2024-1-5", "y": "1424"}, {"x": "2024-12-30", "y": "1365"}, {"x": "2025-1-26", "y": "1573"}, {"x": "2025-1-27", "y": "1593"}, {"x": "2025-1-28", "y": "1610"}, {"x": "2025-1-29", "y": "1591"}, {"x": "2025-1-31", "y": "1591"}, {"x": "2025-2-2", "y": "1589"}, {"x": "2025-2-4", "y": "1616"}, {"x": "2025-2-5", "y": "1625"}, {"x": "2025-2-6", "y": "1675"}, {"x": "2025-2-7", "y": "1676"}, {"x": "2025-2-8", "y": "1671"}, {"x": "2025-2-9", "y": "1677"}, {"x": "2025-2-10", "y": "1682"}, {"x": "2025-2-11", "y": "1683"}, {"x": "2025-2-13", "y": "1688"}, {"x": "2025-2-14", "y": "1682"}, {"x": "2025-2-15", "y": "1670"}, {"x": "2025-2-16", "y": "1674"}, {"x": "2025-2-17", "y": "1691"}, {"x": "2025-2-18", "y": "1691"}, {"x": "2025-2-19", "y": "1687"}, {"x": "2025-2-20", "y": "1689"}, {"x": "2025-2-21", "y": "1683"}, {"x": "2025-2-22", "y": "1676"}, {"x": "2025-2-23", "y": "1681"}, {"x": "2025-2-25", "y": "1693"}, {"x": "2025-2-26", "y": "1688"}, {"x": "2025-2-27", "y": "1693"}, {"x": "2025-2-28", "y": "1675"}, {"x": "2025-3-2", "y": "1705"}, {"x": "2025-3-3", "y": "1715"}, {"x": "2025-3-4", "y": "1699"}, {"x": "2025-3-5", "y": "1677"}, {"x": "2025-3-6", "y": "1679"}, {"x": "2025-3-7", "y": "1679"}, {"x": "2025-3-8", "y": "1660"}, {"x": "2025-3-9", "y": "1659"}, {"x": "2025-3-10", "y": "1666"}, {"x": "2025-3-11", "y": "1662"}, {"x": "2025-3-12", "y": "1666"}, {"x": "2025-3-13", "y": "1660"}, {"x": "2025-3-14", "y": "1649"}, {"x": "2025-3-15", "y": "1654"}, {"x": "2025-3-17", "y": "1641"}, {"x": "2025-3-18", "y": "1641"}, {"x": "2025-3-19", "y": "1696"}, {"x": "2025-3-20", "y": "1695"}, {"x": "2025-3-21", "y": "1702"}]}] \ No newline at end of file
diff --git a/layouts/_default/baseof.html b/layouts/_default/baseof.html
index 56818d7..bd45fdf 100644
--- a/layouts/_default/baseof.html
+++ b/layouts/_default/baseof.html
@@ -21,13 +21,20 @@
<link rel="%s" type="%s" href="%s" title="%s" />
` .Rel .MediaType.Type .Permalink $.Site.Title | safeHTML }} {{ end -}} {{-
partial "custom_head.html" . -}}
- <link rel="preconnect" href="https://fonts.googleapis.com" />
+
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
<link
href="https://fonts.googleapis.com/css2?family=DM+Sans:ital,opsz,wght@0,9..40,100..1000;1,9..40,100..1000&family=Merriweather:ital,wght@0,300;0,400;0,700;0,900;1,300;1,400;1,700;1,900&family=Raleway:ital,wght@0,100..900;1,100..900&display=swap"
rel="stylesheet"
/>
- <script src="/index.js" defer></script>
+ {{ if eq .RelPermalink "/chess/" }} {{ $chessData := index .Site.Data.chess
+ "chessdata" }}
+ <script type="application/json" id="chessData">
+ {{ $chessData | jsonify | safeJS }}
+ </script>
+ <script src="https://cdn.jsdelivr.net/npm/chart.js" defer></script>
+ <script src="/chess-charts.js" defer></script>
+ {{ end }}
</head>
<body>
diff --git a/layouts/page/chess.html b/layouts/page/chess.html
new file mode 100644
index 0000000..4b3fba1
--- /dev/null
+++ b/layouts/page/chess.html
@@ -0,0 +1,8 @@
+{{ define "main" }}
+<p class="txt-right">
+ *all data comes from <a href="https://lichess.org/api">Lichess</a>
+</p>
+<canvas id="rapidChart"></canvas>
+<canvas id="blitzChart"></canvas>
+<canvas id="bulletChart"></canvas>
+{{ end }}
diff --git a/layouts/partials/footer.html b/layouts/partials/footer.html
index 861b2cc..613a73a 100644
--- a/layouts/partials/footer.html
+++ b/layouts/partials/footer.html
@@ -1 +1,4 @@
-<p>Find me here: <a href="https://git.jezl.xyz">git</a></p>
+<p>
+ Find me here: <a href="https://git.jezl.xyz">git</a>
+ <a href="https://pypi.org/user/Jezl/">pypi</a>
+</p>
diff --git a/layouts/partials/nav.html b/layouts/partials/nav.html
index be5539c..f9abda2 100644
--- a/layouts/partials/nav.html
+++ b/layouts/partials/nav.html
@@ -1,9 +1,9 @@
-{{ with .Site.GetPage "/blog" }}
+{{ with .Site.GetPage "blog" }}
<a href="{{ "blog" | relURL }}">blog</a>
{{ end }}
-{{ with .Site.GetPage "/snippets" }}
+{{ with .Site.GetPage "snippets" }}
<a href="{{ "snippets" | relURL }}">snippets</a>
{{ end }}
-{{ with .Site.GetPage "/projects" }}
+{{ with .Site.GetPage "projects" }}
<a href="{{ "projects" | relURL }}">projects</a>
{{ end }} \ No newline at end of file
diff --git a/static/chart.js b/static/chart.js
new file mode 100644
index 0000000..8983115
--- /dev/null
+++ b/static/chart.js
@@ -0,0 +1,9459 @@
+import {
+ r as requestAnimFrame,
+ a as resolve,
+ e as effects,
+ c as color,
+ i as isObject,
+ d as defaults,
+ b as isArray,
+ v as valueOrDefault,
+ u as unlistenArrayEvents,
+ l as listenArrayEvents,
+ f as resolveObjectKey,
+ g as isNumberFinite,
+ h as defined,
+ s as sign,
+ j as createContext,
+ k as isNullOrUndef,
+ _ as _arrayUnique,
+ t as toRadians,
+ m as toPercentage,
+ n as toDimension,
+ T as TAU,
+ o as formatNumber,
+ p as _angleBetween,
+ H as HALF_PI,
+ P as PI,
+ q as _getStartAndCountOfVisiblePoints,
+ w as _scaleRangesChanged,
+ x as isNumber,
+ y as _parseObjectDataRadialScale,
+ z as getRelativePosition,
+ A as _rlookupByKey,
+ B as _lookupByKey,
+ C as _isPointInArea,
+ D as getAngleFromPoint,
+ E as toPadding,
+ F as each,
+ G as getMaximumSize,
+ I as _getParentNode,
+ J as readUsedSize,
+ K as supportsEventListenerOptions,
+ L as throttled,
+ M as _isDomSupported,
+ N as _factorize,
+ O as finiteOrDefault,
+ Q as callback,
+ R as _addGrace,
+ S as _limitValue,
+ U as toDegrees,
+ V as _measureText,
+ W as _int16Range,
+ X as _alignPixel,
+ Y as clipArea,
+ Z as renderText,
+ $ as unclipArea,
+ a0 as toFont,
+ a1 as _toLeftRightCenter,
+ a2 as _alignStartEnd,
+ a3 as overrides,
+ a4 as merge,
+ a5 as _capitalize,
+ a6 as descriptors,
+ a7 as isFunction,
+ a8 as _attachContext,
+ a9 as _createResolver,
+ aa as _descriptors,
+ ab as mergeIf,
+ ac as uid,
+ ad as debounce,
+ ae as retinaScale,
+ af as clearCanvas,
+ ag as setsEqual,
+ ah as _elementsEqual,
+ ai as _isClickEvent,
+ aj as _isBetween,
+ ak as _readValueToProps,
+ al as _updateBezierControlPoints,
+ am as _computeSegments,
+ an as _boundSegments,
+ ao as _steppedInterpolation,
+ ap as _bezierInterpolation,
+ aq as _pointInLine,
+ ar as _steppedLineTo,
+ as as _bezierCurveTo,
+ at as drawPoint,
+ au as addRoundedRectPath,
+ av as toTRBL,
+ aw as toTRBLCorners,
+ ax as _boundSegment,
+ ay as _normalizeAngle,
+ az as getRtlAdapter,
+ aA as overrideTextDirection,
+ aB as _textX,
+ aC as restoreTextDirection,
+ aD as drawPointLegend,
+ aE as distanceBetweenPoints,
+ aF as noop,
+ aG as _setMinAndMaxByKey,
+ aH as niceNum,
+ aI as almostWhole,
+ aJ as almostEquals,
+ aK as _decimalPlaces,
+ aL as Ticks,
+ aM as log10,
+ aN as _longestText,
+ aO as _filterBetween,
+ aP as _lookup,
+} from "./chunks/helpers.segment.js";
+import "@kurkle/color";
+class Animator {
+ constructor() {
+ (this._request = null),
+ (this._charts = new Map()),
+ (this._running = !1),
+ (this._lastDate = void 0);
+ }
+ _notify(e, i, a, t) {
+ const s = i.listeners[t],
+ n = i.duration;
+ s.forEach((t) =>
+ t({
+ chart: e,
+ initial: i.initial,
+ numSteps: n,
+ currentStep: Math.min(a - i.start, n),
+ })
+ );
+ }
+ _refresh() {
+ this._request ||
+ ((this._running = !0),
+ (this._request = requestAnimFrame.call(window, () => {
+ this._update(),
+ (this._request = null),
+ this._running && this._refresh();
+ })));
+ }
+ _update(r = Date.now()) {
+ let o = 0;
+ this._charts.forEach((a, s) => {
+ if (a.running && a.items.length) {
+ const n = a.items;
+ let t = n.length - 1,
+ e = !1,
+ i;
+ for (; 0 <= t; --t)
+ (i = n[t])._active
+ ? (i._total > a.duration && (a.duration = i._total),
+ i.tick(r),
+ (e = !0))
+ : ((n[t] = n[n.length - 1]), n.pop());
+ e && (s.draw(), this._notify(s, a, r, "progress")),
+ n.length ||
+ ((a.running = !1),
+ this._notify(s, a, r, "complete"),
+ (a.initial = !1)),
+ (o += n.length);
+ }
+ }),
+ (this._lastDate = r),
+ 0 === o && (this._running = !1);
+ }
+ _getAnims(t) {
+ const e = this._charts;
+ let i = e.get(t);
+ return (
+ i ||
+ ((i = {
+ running: !1,
+ initial: !0,
+ items: [],
+ listeners: { complete: [], progress: [] },
+ }),
+ e.set(t, i)),
+ i
+ );
+ }
+ listen(t, e, i) {
+ this._getAnims(t).listeners[e].push(i);
+ }
+ add(t, e) {
+ e && e.length && this._getAnims(t).items.push(...e);
+ }
+ has(t) {
+ return 0 < this._getAnims(t).items.length;
+ }
+ start(t) {
+ const e = this._charts.get(t);
+ e &&
+ ((e.running = !0),
+ (e.start = Date.now()),
+ (e.duration = e.items.reduce((t, e) => Math.max(t, e._duration), 0)),
+ this._refresh());
+ }
+ running(t) {
+ if (!this._running) return !1;
+ t = this._charts.get(t);
+ return !!(t && t.running && t.items.length);
+ }
+ stop(e) {
+ const i = this._charts.get(e);
+ if (i && i.items.length) {
+ const a = i.items;
+ let t = a.length - 1;
+ for (; 0 <= t; --t) a[t].cancel();
+ (i.items = []), this._notify(e, i, Date.now(), "complete");
+ }
+ }
+ remove(t) {
+ return this._charts.delete(t);
+ }
+}
+var animator = new Animator();
+const transparent = "transparent",
+ interpolators = {
+ boolean(t, e, i) {
+ return 0.5 < i ? e : t;
+ },
+ color(t, e, i) {
+ t = color(t || transparent);
+ const a = t.valid && color(e || transparent);
+ return a && a.valid ? a.mix(t, i).hexString() : e;
+ },
+ number(t, e, i) {
+ return t + (e - t) * i;
+ },
+ };
+class Animation {
+ constructor(t, e, i, a) {
+ var s = e[i],
+ s = ((a = resolve([t.to, a, s, t.from])), resolve([t.from, s, a]));
+ (this._active = !0),
+ (this._fn = t.fn || interpolators[t.type || typeof s]),
+ (this._easing = effects[t.easing] || effects.linear),
+ (this._start = Math.floor(Date.now() + (t.delay || 0))),
+ (this._duration = this._total = Math.floor(t.duration)),
+ (this._loop = !!t.loop),
+ (this._target = e),
+ (this._prop = i),
+ (this._from = s),
+ (this._to = a),
+ (this._promises = void 0);
+ }
+ active() {
+ return this._active;
+ }
+ update(t, e, i) {
+ var a, s, n;
+ this._active &&
+ (this._notify(!1),
+ (a = this._target[this._prop]),
+ (s = i - this._start),
+ (n = this._duration - s),
+ (this._start = i),
+ (this._duration = Math.floor(Math.max(n, t.duration))),
+ (this._total += s),
+ (this._loop = !!t.loop),
+ (this._to = resolve([t.to, e, a, t.from])),
+ (this._from = resolve([t.from, a, e])));
+ }
+ cancel() {
+ this._active &&
+ (this.tick(Date.now()), (this._active = !1), this._notify(!1));
+ }
+ tick(t) {
+ var t = t - this._start,
+ e = this._duration,
+ i = this._prop,
+ a = this._from,
+ s = this._loop,
+ n = this._to;
+ let r;
+ if (((this._active = a !== n && (s || t < e)), !this._active))
+ return (this._target[i] = n), void this._notify(!0);
+ t < 0
+ ? (this._target[i] = a)
+ : ((r = (t / e) % 2),
+ (r = s && 1 < r ? 2 - r : r),
+ (r = this._easing(Math.min(1, Math.max(0, r)))),
+ (this._target[i] = this._fn(a, n, r)));
+ }
+ wait() {
+ const i = this._promises || (this._promises = []);
+ return new Promise((t, e) => {
+ i.push({ res: t, rej: e });
+ });
+ }
+ _notify(t) {
+ var e = t ? "res" : "rej";
+ const i = this._promises || [];
+ for (let t = 0; t < i.length; t++) i[t][e]();
+ }
+}
+class Animations {
+ constructor(t, e) {
+ (this._chart = t), (this._properties = new Map()), this.configure(e);
+ }
+ configure(s) {
+ if (isObject(s)) {
+ const n = Object.keys(defaults.animation),
+ r = this._properties;
+ Object.getOwnPropertyNames(s).forEach((e) => {
+ const t = s[e];
+ if (isObject(t)) {
+ const i = {};
+ for (const a of n) i[a] = t[a];
+ ((isArray(t.properties) && t.properties) || [e]).forEach((t) => {
+ (t !== e && r.has(t)) || r.set(t, i);
+ });
+ }
+ });
+ }
+ }
+ _animateOptions(t, e) {
+ const i = e.options;
+ e = resolveTargetOptions(t, i);
+ if (!e) return [];
+ e = this._createAnimations(e, i);
+ return (
+ i.$shared &&
+ awaitAll(t.options.$animations, i).then(
+ () => {
+ t.options = i;
+ },
+ () => {}
+ ),
+ e
+ );
+ }
+ _createAnimations(e, i) {
+ const a = this._properties,
+ s = [],
+ n = e.$animations || (e.$animations = {});
+ var t = Object.keys(i),
+ r = Date.now();
+ let o;
+ for (o = t.length - 1; 0 <= o; --o) {
+ const d = t[o];
+ if ("$" !== d.charAt(0))
+ if ("options" === d) s.push(...this._animateOptions(e, i));
+ else {
+ var l = i[d];
+ let t = n[d];
+ var h = a.get(d);
+ if (t) {
+ if (h && t.active()) {
+ t.update(h, l, r);
+ continue;
+ }
+ t.cancel();
+ }
+ h && h.duration
+ ? ((n[d] = t = new Animation(h, e, d, l)), s.push(t))
+ : (e[d] = l);
+ }
+ }
+ return s;
+ }
+ update(t, e) {
+ {
+ if (0 !== this._properties.size)
+ return (t = this._createAnimations(t, e)).length
+ ? (animator.add(this._chart, t), !0)
+ : void 0;
+ Object.assign(t, e);
+ }
+ }
+}
+function awaitAll(e, t) {
+ const i = [];
+ var a = Object.keys(t);
+ for (let t = 0; t < a.length; t++) {
+ const s = e[a[t]];
+ s && s.active() && i.push(s.wait());
+ }
+ return Promise.all(i);
+}
+function resolveTargetOptions(e, i) {
+ if (i) {
+ let t = e.options;
+ if (t)
+ return (
+ t.$shared &&
+ (e.options = t =
+ Object.assign({}, t, { $shared: !1, $animations: {} })),
+ t
+ );
+ e.options = i;
+ }
+}
+function scaleClip(t, e) {
+ var t = (t && t.options) || {},
+ i = t.reverse,
+ a = void 0 === t.min ? e : 0,
+ t = void 0 === t.max ? e : 0;
+ return { start: i ? t : a, end: i ? a : t };
+}
+function defaultClip(t, e, i) {
+ if (!1 === i) return !1;
+ (t = scaleClip(t, i)), (e = scaleClip(e, i));
+ return { top: e.end, right: t.end, bottom: e.start, left: t.start };
+}
+function toClip(t) {
+ let e, i, a, s;
+ return (
+ isObject(t)
+ ? ((e = t.top), (i = t.right), (a = t.bottom), (s = t.left))
+ : (e = i = a = s = t),
+ { top: e, right: i, bottom: a, left: s, disabled: !1 === t }
+ );
+}
+function getSortedDatasetIndices(t, e) {
+ const i = [];
+ var a = t._getSortedDatasetMetas(e);
+ let s, n;
+ for (s = 0, n = a.length; s < n; ++s) i.push(a[s].index);
+ return i;
+}
+function applyStack(t, e, i, a = {}) {
+ var s = t.keys,
+ n = "single" === a.mode;
+ let r, o, l, h;
+ if (null !== e) {
+ for (r = 0, o = s.length; r < o; ++r) {
+ if ((l = +s[r]) === i) {
+ if (a.all) continue;
+ break;
+ }
+ (h = t.values[l]),
+ isNumberFinite(h) && (n || 0 === e || sign(e) === sign(h)) && (e += h);
+ }
+ return e;
+ }
+}
+function convertObjectDataToArray(t) {
+ var e = Object.keys(t);
+ const i = new Array(e.length);
+ let a, s, n;
+ for (a = 0, s = e.length; a < s; ++a) (n = e[a]), (i[a] = { x: n, y: t[n] });
+ return i;
+}
+function isStacked(t, e) {
+ t = t && t.options.stacked;
+ return t || (void 0 === t && void 0 !== e.stack);
+}
+function getStackKey(t, e, i) {
+ return `${t.id}.${e.id}.` + (i.stack || i.type);
+}
+function getUserBounds(t) {
+ var { min: t, max: e, minDefined: i, maxDefined: a } = t.getUserBounds();
+ return {
+ min: i ? t : Number.NEGATIVE_INFINITY,
+ max: a ? e : Number.POSITIVE_INFINITY,
+ };
+}
+function getOrCreateStack(t, e, i) {
+ const a = t[e] || (t[e] = {});
+ return a[i] || (a[i] = {});
+}
+function getLastIndexInStack(t, e, i, a) {
+ for (const n of e.getMatchingVisibleMetas(a).reverse()) {
+ var s = t[n.index];
+ if ((i && 0 < s) || (!i && s < 0)) return n.index;
+ }
+ return null;
+}
+function updateStacks(t, e) {
+ const { chart: i, _cachedMeta: a } = t;
+ var s = i._stacks || (i._stacks = {}),
+ { iScale: t, vScale: n, index: r } = a,
+ o = t.axis,
+ l = n.axis,
+ h = getStackKey(t, n, a),
+ d = e.length;
+ let c;
+ for (let t = 0; t < d; ++t) {
+ const p = e[t];
+ var { [o]: u, [l]: g } = p;
+ const f = p._stacks || (p._stacks = {}),
+ m =
+ (((c = f[l] = getOrCreateStack(s, h, u))[r] = g),
+ (c._top = getLastIndexInStack(c, n, !0, a.type)),
+ (c._bottom = getLastIndexInStack(c, n, !1, a.type)),
+ c._visualValues || (c._visualValues = {}));
+ m[r] = g;
+ }
+}
+function getFirstScaleId(t, e) {
+ const i = t.scales;
+ return Object.keys(i)
+ .filter((t) => i[t].axis === e)
+ .shift();
+}
+function createDatasetContext(t, e) {
+ return createContext(t, {
+ active: !1,
+ dataset: void 0,
+ datasetIndex: e,
+ index: e,
+ mode: "default",
+ type: "dataset",
+ });
+}
+function createDataContext(t, e, i) {
+ return createContext(t, {
+ active: !1,
+ dataIndex: e,
+ parsed: void 0,
+ raw: void 0,
+ element: i,
+ index: e,
+ mode: "default",
+ type: "data",
+ });
+}
+function clearStacks(t, e) {
+ var i = t.controller.index,
+ a = t.vScale && t.vScale.axis;
+ if (a)
+ for (const s of (e = e || t._parsed)) {
+ const n = s._stacks;
+ if (!n || void 0 === n[a] || void 0 === n[a][i]) return;
+ delete n[a][i],
+ void 0 !== n[a]._visualValues &&
+ void 0 !== n[a]._visualValues[i] &&
+ delete n[a]._visualValues[i];
+ }
+}
+const isDirectUpdateMode = (t) => "reset" === t || "none" === t,
+ cloneIfNotShared = (t, e) => (e ? t : Object.assign({}, t)),
+ createStack = (t, e, i) =>
+ t &&
+ !e.hidden &&
+ e._stacked && { keys: getSortedDatasetIndices(i, !0), values: null };
+class DatasetController {
+ static defaults = {};
+ static datasetElementType = null;
+ static dataElementType = null;
+ constructor(t, e) {
+ (this.chart = t),
+ (this._ctx = t.ctx),
+ (this.index = e),
+ (this._cachedDataOpts = {}),
+ (this._cachedMeta = this.getMeta()),
+ (this._type = this._cachedMeta.type),
+ (this.options = void 0),
+ (this._parsing = !1),
+ (this._data = void 0),
+ (this._objectData = void 0),
+ (this._sharedOptions = void 0),
+ (this._drawStart = void 0),
+ (this._drawCount = void 0),
+ (this.enableOptionSharing = !1),
+ (this.supportsDecimation = !1),
+ (this.$context = void 0),
+ (this._syncList = []),
+ (this.datasetElementType = new.target.datasetElementType),
+ (this.dataElementType = new.target.dataElementType),
+ this.initialize();
+ }
+ initialize() {
+ const t = this._cachedMeta;
+ this.configure(),
+ this.linkScales(),
+ (t._stacked = isStacked(t.vScale, t)),
+ this.addElements(),
+ this.options.fill &&
+ !this.chart.isPluginEnabled("filler") &&
+ 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"
+ );
+ }
+ updateIndex(t) {
+ this.index !== t && clearStacks(this._cachedMeta), (this.index = t);
+ }
+ linkScales() {
+ var t = this.chart;
+ const e = this._cachedMeta;
+ var i = this.getDataset(),
+ a = (t, e, i, a) => ("x" === t ? e : "r" === t ? a : i),
+ s = (e.xAxisID = valueOrDefault(i.xAxisID, getFirstScaleId(t, "x"))),
+ n = (e.yAxisID = valueOrDefault(i.yAxisID, getFirstScaleId(t, "y"))),
+ i = (e.rAxisID = valueOrDefault(i.rAxisID, getFirstScaleId(t, "r"))),
+ t = e.indexAxis,
+ r = (e.iAxisID = a(t, s, n, i)),
+ a = (e.vAxisID = a(t, n, s, i));
+ (e.xScale = this.getScaleForId(s)),
+ (e.yScale = this.getScaleForId(n)),
+ (e.rScale = this.getScaleForId(i)),
+ (e.iScale = this.getScaleForId(r)),
+ (e.vScale = this.getScaleForId(a));
+ }
+ getDataset() {
+ return this.chart.data.datasets[this.index];
+ }
+ getMeta() {
+ return this.chart.getDatasetMeta(this.index);
+ }
+ getScaleForId(t) {
+ return this.chart.scales[t];
+ }
+ _getOtherScale(t) {
+ var e = this._cachedMeta;
+ return t === e.iScale ? e.vScale : e.iScale;
+ }
+ reset() {
+ this._update("reset");
+ }
+ _destroy() {
+ var t = this._cachedMeta;
+ this._data && unlistenArrayEvents(this._data, this),
+ t._stacked && clearStacks(t);
+ }
+ _dataCheck() {
+ const t = this.getDataset();
+ var e = t.data || (t.data = []),
+ i = this._data;
+ if (isObject(e)) this._data = convertObjectDataToArray(e);
+ else if (i !== e) {
+ if (i) {
+ unlistenArrayEvents(i, this);
+ const a = this._cachedMeta;
+ clearStacks(a), (a._parsed = []);
+ }
+ e && Object.isExtensible(e) && listenArrayEvents(e, this),
+ (this._syncList = []),
+ (this._data = e);
+ }
+ }
+ addElements() {
+ const t = this._cachedMeta;
+ this._dataCheck(),
+ this.datasetElementType && (t.dataset = new this.datasetElementType());
+ }
+ buildOrUpdateElements(t) {
+ const e = this._cachedMeta;
+ var i = this.getDataset();
+ let a = !1;
+ this._dataCheck();
+ var s = e._stacked;
+ (e._stacked = isStacked(e.vScale, e)),
+ e.stack !== i.stack && ((a = !0), clearStacks(e), (e.stack = i.stack)),
+ this._resyncElements(t),
+ (!a && s === e._stacked) || updateStacks(this, e._parsed);
+ }
+ configure() {
+ const t = this.chart.config;
+ var e = t.datasetScopeKeys(this._type),
+ e = t.getOptionScopes(this.getDataset(), e, !0);
+ (this.options = t.createResolver(e, this.getContext())),
+ (this._parsing = this.options.parsing),
+ (this._cachedDataOpts = {});
+ }
+ parse(t, e) {
+ const { _cachedMeta: i, _data: a } = this;
+ var { iScale: s, _stacked: n } = i;
+ const r = s.axis;
+ let o = (0 === t && e === a.length) || i._sorted,
+ l = 0 < t && i._parsed[t - 1],
+ h,
+ d,
+ c;
+ if (!1 === this._parsing) (i._parsed = a), (i._sorted = !0), (c = a);
+ else {
+ c = isArray(a[t])
+ ? this.parseArrayData(i, a, t, e)
+ : isObject(a[t])
+ ? this.parseObjectData(i, a, t, e)
+ : this.parsePrimitiveData(i, a, t, e);
+ for (h = 0; h < e; ++h)
+ (i._parsed[h + t] = d = c[h]),
+ o && ((null === d[r] || (l && d[r] < l[r])) && (o = !1), (l = d));
+ i._sorted = o;
+ }
+ n && updateStacks(this, c);
+ }
+ parsePrimitiveData(t, e, i, a) {
+ const { iScale: s, vScale: n } = t;
+ var r = s.axis,
+ o = n.axis,
+ l = s.getLabels(),
+ h = s === n;
+ const d = new Array(a);
+ let c, u, g;
+ for (c = 0, u = a; c < u; ++c)
+ (g = c + i),
+ (d[c] = { [r]: h || s.parse(l[g], g), [o]: n.parse(e[g], g) });
+ return d;
+ }
+ parseArrayData(t, e, i, a) {
+ const { xScale: s, yScale: n } = t,
+ r = new Array(a);
+ let o, l, h, d;
+ for (o = 0, l = a; o < l; ++o)
+ (d = e[(h = o + i)]),
+ (r[o] = { x: s.parse(d[0], h), y: n.parse(d[1], h) });
+ return r;
+ }
+ parseObjectData(t, e, i, a) {
+ const { xScale: s, yScale: n } = t;
+ var { xAxisKey: r = "x", yAxisKey: o = "y" } = this._parsing;
+ const l = new Array(a);
+ let h, d, c, u;
+ for (h = 0, d = a; h < d; ++h)
+ (u = e[(c = h + i)]),
+ (l[h] = {
+ x: s.parse(resolveObjectKey(u, r), c),
+ y: n.parse(resolveObjectKey(u, o), c),
+ });
+ return l;
+ }
+ getParsed(t) {
+ return this._cachedMeta._parsed[t];
+ }
+ getDataElement(t) {
+ return this._cachedMeta.data[t];
+ }
+ applyStack(t, e, i) {
+ var a = this.chart,
+ s = this._cachedMeta,
+ n = e[t.axis];
+ return applyStack(
+ {
+ keys: getSortedDatasetIndices(a, !0),
+ values: e._stacks[t.axis]._visualValues,
+ },
+ n,
+ s.index,
+ { mode: i }
+ );
+ }
+ updateRangeFromParsed(t, e, i, a) {
+ var s = i[e.axis];
+ let n = null === s ? NaN : s;
+ i = a && i._stacks[e.axis];
+ a && i && ((a.values = i), (n = applyStack(a, s, this._cachedMeta.index))),
+ (t.min = Math.min(t.min, n)),
+ (t.max = Math.max(t.max, n));
+ }
+ getMinMax(e, t) {
+ var i = this._cachedMeta;
+ const a = i._parsed;
+ var s = i._sorted && e === i.iScale,
+ n = a.length;
+ const r = this._getOtherScale(e);
+ var o = createStack(t, i, this.chart),
+ l = { min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY };
+ const { min: h, max: d } = getUserBounds(r);
+ let c, u;
+ function g() {
+ var t = (u = a[c])[r.axis];
+ return !isNumberFinite(u[e.axis]) || h > t || d < t;
+ }
+ for (
+ c = 0;
+ c < n && (g() || (this.updateRangeFromParsed(l, e, u, o), !s));
+ ++c
+ );
+ if (s)
+ for (c = n - 1; 0 <= c; --c)
+ if (!g()) {
+ this.updateRangeFromParsed(l, e, u, o);
+ break;
+ }
+ return l;
+ }
+ getAllParsedValues(t) {
+ var e = this._cachedMeta._parsed;
+ const i = [];
+ let a, s, n;
+ for (a = 0, s = e.length; a < s; ++a)
+ (n = e[a][t.axis]), isNumberFinite(n) && i.push(n);
+ return i;
+ }
+ getMaxOverflow() {
+ return !1;
+ }
+ getLabelAndValue(t) {
+ var e = this._cachedMeta;
+ const i = e.iScale,
+ a = e.vScale;
+ e = this.getParsed(t);
+ return {
+ label: i ? "" + i.getLabelForValue(e[i.axis]) : "",
+ value: a ? "" + a.getLabelForValue(e[a.axis]) : "",
+ };
+ }
+ _update(t) {
+ const e = this._cachedMeta;
+ this.update(t || "default"),
+ (e._clip = toClip(
+ valueOrDefault(
+ this.options.clip,
+ defaultClip(e.xScale, e.yScale, this.getMaxOverflow())
+ )
+ ));
+ }
+ update(t) {}
+ draw() {
+ var t = this._ctx,
+ e = this.chart;
+ const i = this._cachedMeta;
+ var a = i.data || [],
+ s = e.chartArea;
+ const n = [];
+ var r = this._drawStart || 0,
+ o = this._drawCount || a.length - r,
+ l = this.options.drawActiveElementsOnTop;
+ let h;
+ for (i.dataset && i.dataset.draw(t, s, r, o), h = r; h < r + o; ++h) {
+ const d = a[h];
+ d.hidden || (d.active && l ? n.push(d) : d.draw(t, s));
+ }
+ for (h = 0; h < n.length; ++h) n[h].draw(t, s);
+ }
+ getStyle(t, e) {
+ e = e ? "active" : "default";
+ return void 0 === t && this._cachedMeta.dataset
+ ? this.resolveDatasetElementOptions(e)
+ : this.resolveDataElementOptions(t || 0, e);
+ }
+ getContext(t, e, i) {
+ var a = this.getDataset();
+ let s;
+ if (0 <= t && t < this._cachedMeta.data.length) {
+ const n = this._cachedMeta.data[t];
+ ((s =
+ n.$context ||
+ (n.$context = createDataContext(this.getContext(), t, n))).parsed =
+ this.getParsed(t)),
+ (s.raw = a.data[t]),
+ (s.index = s.dataIndex = t);
+ } else
+ ((s =
+ this.$context ||
+ (this.$context = createDatasetContext(
+ this.chart.getContext(),
+ this.index
+ ))).dataset = a),
+ (s.index = s.datasetIndex = this.index);
+ return (s.active = !!e), (s.mode = i), s;
+ }
+ resolveDatasetElementOptions(t) {
+ return this._resolveElementOptions(this.datasetElementType.id, t);
+ }
+ resolveDataElementOptions(t, e) {
+ return this._resolveElementOptions(this.dataElementType.id, e, t);
+ }
+ _resolveElementOptions(t, e = "default", i) {
+ const a = "active" === e,
+ s = this._cachedDataOpts;
+ var n = t + "-" + e,
+ r = s[n],
+ o = this.enableOptionSharing && defined(i);
+ if (r) return cloneIfNotShared(r, o);
+ const l = this.chart.config;
+ var r = l.datasetElementScopeKeys(this._type, t),
+ h = a ? [t + "Hover", "hover", t, ""] : [t, ""],
+ r = l.getOptionScopes(this.getDataset(), r),
+ t = Object.keys(defaults.elements[t]);
+ const d = l.resolveNamedOptions(r, t, () => this.getContext(i, a, e), h);
+ return (
+ d.$shared &&
+ ((d.$shared = o), (s[n] = Object.freeze(cloneIfNotShared(d, o)))),
+ d
+ );
+ }
+ _resolveAnimations(t, e, i) {
+ var a = this.chart;
+ const s = this._cachedDataOpts;
+ var n = "animation-" + e,
+ r = s[n];
+ if (r) return r;
+ let o;
+ if (!1 !== a.options.animation) {
+ const l = this.chart.config;
+ (r = l.datasetAnimationScopeKeys(this._type, e)),
+ (r = l.getOptionScopes(this.getDataset(), r));
+ o = l.createResolver(r, this.getContext(t, i, e));
+ }
+ r = new Animations(a, o && o.animations);
+ return o && o._cacheable && (s[n] = Object.freeze(r)), r;
+ }
+ getSharedOptions(t) {
+ if (t.$shared)
+ return (
+ this._sharedOptions || (this._sharedOptions = Object.assign({}, t))
+ );
+ }
+ includeOptions(t, e) {
+ return !e || isDirectUpdateMode(t) || this.chart._animationsDisabled;
+ }
+ _getSharedOptions(t, e) {
+ var t = this.resolveDataElementOptions(t, e),
+ i = this._sharedOptions,
+ a = this.getSharedOptions(t),
+ i = this.includeOptions(e, a) || a !== i;
+ return (
+ this.updateSharedOptions(a, e, t), { sharedOptions: a, includeOptions: i }
+ );
+ }
+ updateElement(t, e, i, a) {
+ isDirectUpdateMode(a)
+ ? Object.assign(t, i)
+ : this._resolveAnimations(e, a).update(t, i);
+ }
+ updateSharedOptions(t, e, i) {
+ t &&
+ !isDirectUpdateMode(e) &&
+ this._resolveAnimations(void 0, e).update(t, i);
+ }
+ _setStyle(t, e, i, a) {
+ t.active = a;
+ var s = this.getStyle(e, a);
+ this._resolveAnimations(e, i, a).update(t, {
+ options: (!a && this.getSharedOptions(s)) || s,
+ });
+ }
+ removeHoverStyle(t, e, i) {
+ this._setStyle(t, i, "active", !1);
+ }
+ setHoverStyle(t, e, i) {
+ this._setStyle(t, i, "active", !0);
+ }
+ _removeDatasetHoverStyle() {
+ var t = this._cachedMeta.dataset;
+ t && this._setStyle(t, void 0, "active", !1);
+ }
+ _setDatasetHoverStyle() {
+ var t = this._cachedMeta.dataset;
+ t && this._setStyle(t, void 0, "active", !0);
+ }
+ _resyncElements(t) {
+ var e,
+ i,
+ a,
+ s = this._data,
+ n = this._cachedMeta.data;
+ for ([e, i, a] of this._syncList) this[e](i, a);
+ this._syncList = [];
+ var n = n.length,
+ s = s.length,
+ r = Math.min(s, n);
+ r && this.parse(0, r),
+ n < s
+ ? this._insertElements(n, s - n, t)
+ : s < n && this._removeElements(s, n - s);
+ }
+ _insertElements(t, e, i = !0) {
+ var a = this._cachedMeta;
+ const s = a.data,
+ n = t + e;
+ let r;
+ var o = (t) => {
+ for (t.length += e, r = t.length - 1; r >= n; r--) t[r] = t[r - e];
+ };
+ for (o(s), r = t; r < n; ++r) s[r] = new this.dataElementType();
+ this._parsing && o(a._parsed),
+ this.parse(t, e),
+ i && this.updateElements(s, t, e, "reset");
+ }
+ updateElements(t, e, i, a) {}
+ _removeElements(t, e) {
+ const i = this._cachedMeta;
+ var a;
+ this._parsing &&
+ ((a = i._parsed.splice(t, e)), i._stacked && clearStacks(i, a)),
+ i.data.splice(t, e);
+ }
+ _sync(t) {
+ var e, i, a;
+ this._parsing ? this._syncList.push(t) : (([e, i, a] = t), this[e](i, a)),
+ this.chart._dataChanges.push([this.index, ...t]);
+ }
+ _onDataPush() {
+ var t = arguments.length;
+ this._sync(["_insertElements", this.getDataset().data.length - t, t]);
+ }
+ _onDataPop() {
+ this._sync(["_removeElements", this._cachedMeta.data.length - 1, 1]);
+ }
+ _onDataShift() {
+ this._sync(["_removeElements", 0, 1]);
+ }
+ _onDataSplice(t, e) {
+ e && this._sync(["_removeElements", t, e]);
+ var i = arguments.length - 2;
+ i && this._sync(["_insertElements", t, i]);
+ }
+ _onDataUnshift() {
+ this._sync(["_insertElements", 0, arguments.length]);
+ }
+}
+function getAllScaleValues(a, t) {
+ if (!a._cache.$bar) {
+ const s = a.getMatchingVisibleMetas(t);
+ let i = [];
+ for (let t = 0, e = s.length; t < e; t++)
+ i = i.concat(s[t].controller.getAllParsedValues(a));
+ a._cache.$bar = _arrayUnique(i.sort((t, e) => t - e));
+ }
+ return a._cache.$bar;
+}
+function computeMinSampleSize(t) {
+ const e = t.iScale;
+ var i = getAllScaleValues(e, t.type);
+ let a = e._length,
+ s,
+ n,
+ r,
+ o;
+ var l = () => {
+ 32767 !== r &&
+ -32768 !== r &&
+ (defined(o) && (a = Math.min(a, Math.abs(r - o) || a)), (o = r));
+ };
+ for (s = 0, n = i.length; s < n; ++s) (r = e.getPixelForValue(i[s])), l();
+ for (o = void 0, s = 0, n = e.ticks.length; s < n; ++s)
+ (r = e.getPixelForTick(s)), l();
+ return a;
+}
+function computeFitCategoryTraits(t, e, i, a) {
+ var s = i.barThickness;
+ let n, r;
+ return (
+ (r = isNullOrUndef(s)
+ ? ((n = e.min * i.categoryPercentage), i.barPercentage)
+ : ((n = s * a), 1)),
+ { chunk: n / a, ratio: r, start: e.pixels[t] - n / 2 }
+ );
+}
+function computeFlexCategoryTraits(t, e, i, a) {
+ var s = e.pixels,
+ n = s[t];
+ let r = 0 < t ? s[t - 1] : null,
+ o = t < s.length - 1 ? s[t + 1] : null;
+ (s = i.categoryPercentage),
+ null === r && (r = n - (null === o ? e.end - e.start : o - n)),
+ null === o && (o = n + n - r),
+ (t = n - ((n - Math.min(r, o)) / 2) * s);
+ return {
+ chunk: ((Math.abs(o - r) / 2) * s) / a,
+ ratio: i.barPercentage,
+ start: t,
+ };
+}
+function parseFloatBar(t, e, i, a) {
+ var s = i.parse(t[0], a),
+ t = i.parse(t[1], a),
+ a = Math.min(s, t),
+ n = Math.max(s, t);
+ let r = a,
+ o = n;
+ Math.abs(a) > Math.abs(n) && ((r = n), (o = a)),
+ (e[i.axis] = o),
+ (e._custom = { barStart: r, barEnd: o, start: s, end: t, min: a, max: n });
+}
+function parseValue(t, e, i, a) {
+ return (
+ isArray(t) ? parseFloatBar(t, e, i, a) : (e[i.axis] = i.parse(t, a)), e
+ );
+}
+function parseArrayOrPrimitive(t, e, i, a) {
+ const s = t.iScale;
+ var n = t.vScale,
+ r = s.getLabels(),
+ o = s === n;
+ const l = [];
+ let h, d, c, u;
+ for (d = (h = i) + a; h < d; ++h)
+ (u = e[h]),
+ ((c = {})[s.axis] = o || s.parse(r[h], h)),
+ l.push(parseValue(u, c, n, h));
+ return l;
+}
+function isFloatBar(t) {
+ return t && void 0 !== t.barStart && void 0 !== t.barEnd;
+}
+function barSign(t, e, i) {
+ return 0 !== t
+ ? sign(t)
+ : (e.isHorizontal() ? 1 : -1) * (e.min >= i ? 1 : -1);
+}
+function borderProps(t) {
+ let e, i, a, s, n;
+ return (
+ (a = t.horizontal
+ ? ((e = t.base > t.x), (i = "left"), "right")
+ : ((e = t.base < t.y), (i = "bottom"), "top")),
+ (n = e ? ((s = "end"), "start") : ((s = "start"), "end")),
+ { start: i, end: a, reverse: e, top: s, bottom: n }
+ );
+}
+function setBorderSkipped(t, e, i, a) {
+ let s = e.borderSkipped;
+ const n = {};
+ var r, o, l, h;
+ s
+ ? !0 === s
+ ? (t.borderSkipped = { top: !0, right: !0, bottom: !0, left: !0 })
+ : (({ start: e, end: r, reverse: o, top: l, bottom: h } = borderProps(t)),
+ "middle" === s &&
+ i &&
+ ((t.enableBorderRadius = !0),
+ (s =
+ (i._top || 0) === a
+ ? l
+ : (i._bottom || 0) === a
+ ? h
+ : ((n[parseEdge(h, e, r, o)] = !0), l))),
+ (n[parseEdge(s, e, r, o)] = !0),
+ (t.borderSkipped = n))
+ : (t.borderSkipped = n);
+}
+function parseEdge(t, e, i, a) {
+ return (t = a ? startEnd((t = swap(t, e, i)), i, e) : startEnd(t, e, i));
+}
+function swap(t, e, i) {
+ return t === e ? i : t === i ? e : t;
+}
+function startEnd(t, e, i) {
+ return "start" === t ? e : "end" === t ? i : t;
+}
+function setInflateAmount(t, { inflateAmount: e }, i) {
+ t.inflateAmount = "auto" === e ? (1 === i ? 0.33 : 0) : e;
+}
+class BarController extends DatasetController {
+ static id = "bar";
+ static defaults = {
+ datasetElementType: !1,
+ dataElementType: "bar",
+ categoryPercentage: 0.8,
+ barPercentage: 0.9,
+ grouped: !0,
+ animations: {
+ numbers: {
+ type: "number",
+ properties: ["x", "y", "base", "width", "height"],
+ },
+ },
+ };
+ static overrides = {
+ scales: {
+ _index_: { type: "category", offset: !0, grid: { offset: !0 } },
+ _value_: { type: "linear", beginAtZero: !0 },
+ },
+ };
+ parsePrimitiveData(t, e, i, a) {
+ return parseArrayOrPrimitive(t, e, i, a);
+ }
+ parseArrayData(t, e, i, a) {
+ return parseArrayOrPrimitive(t, e, i, a);
+ }
+ parseObjectData(t, e, i, a) {
+ const { iScale: s, vScale: n } = t;
+ var { xAxisKey: t = "x", yAxisKey: r = "y" } = this._parsing,
+ o = "x" === s.axis ? t : r,
+ l = "x" === n.axis ? t : r;
+ const h = [];
+ let d, c, u, g;
+ for (c = (d = i) + a; d < c; ++d)
+ (g = e[d]),
+ ((u = {})[s.axis] = s.parse(resolveObjectKey(g, o), d)),
+ h.push(parseValue(resolveObjectKey(g, l), u, n, d));
+ return h;
+ }
+ updateRangeFromParsed(t, e, i, a) {
+ super.updateRangeFromParsed(t, e, i, a);
+ a = i._custom;
+ a &&
+ e === this._cachedMeta.vScale &&
+ ((t.min = Math.min(t.min, a.min)), (t.max = Math.max(t.max, a.max)));
+ }
+ getMaxOverflow() {
+ return 0;
+ }
+ getLabelAndValue(t) {
+ const { iScale: e, vScale: i } = this._cachedMeta;
+ var t = this.getParsed(t),
+ a = t._custom,
+ a = isFloatBar(a)
+ ? "[" + a.start + ", " + a.end + "]"
+ : "" + i.getLabelForValue(t[i.axis]);
+ return { label: "" + e.getLabelForValue(t[e.axis]), value: a };
+ }
+ initialize() {
+ (this.enableOptionSharing = !0), super.initialize();
+ const t = this._cachedMeta;
+ t.stack = this.getDataset().stack;
+ }
+ update(t) {
+ var e = this._cachedMeta;
+ this.updateElements(e.data, 0, e.data.length, t);
+ }
+ updateElements(e, i, a, s) {
+ var n = "reset" === s;
+ const {
+ index: r,
+ _cachedMeta: { vScale: o },
+ } = this;
+ var l = o.getBasePixel(),
+ h = o.isHorizontal(),
+ d = this._getRuler(),
+ { sharedOptions: c, includeOptions: u } = this._getSharedOptions(i, s);
+ for (let t = i; t < i + a; t++) {
+ var g = this.getParsed(t),
+ p =
+ n || isNullOrUndef(g[o.axis])
+ ? { base: l, head: l }
+ : this._calculateBarValuePixels(t),
+ f = this._calculateBarIndexPixels(t, d),
+ m = (g._stacks || {})[o.axis];
+ const v = {
+ horizontal: h,
+ base: p.base,
+ enableBorderRadius:
+ !m || isFloatBar(g._custom) || r === m._top || r === m._bottom,
+ x: h ? p.head : f.center,
+ y: h ? f.center : p.head,
+ height: h ? f.size : Math.abs(p.size),
+ width: h ? Math.abs(p.size) : f.size,
+ };
+ u &&
+ (v.options =
+ c || this.resolveDataElementOptions(t, e[t].active ? "active" : s));
+ g = v.options || e[t].options;
+ setBorderSkipped(v, g, m, r),
+ setInflateAmount(v, g, d.ratio),
+ this.updateElement(e[t], t, v, s);
+ }
+ }
+ _getStacks(t, i) {
+ const e = this._cachedMeta["iScale"];
+ var a = e
+ .getMatchingVisibleMetas(this._type)
+ .filter((t) => t.controller.options.grouped),
+ s = e.options.stacked;
+ const n = [];
+ for (const r of a)
+ if (
+ (void 0 === i ||
+ !((t) => {
+ var e = t.controller.getParsed(i),
+ e = e && e[t.vScale.axis];
+ if (isNullOrUndef(e) || isNaN(e)) return !0;
+ })(r)) &&
+ ((!1 === s ||
+ -1 === n.indexOf(r.stack) ||
+ (void 0 === s && void 0 === r.stack)) &&
+ n.push(r.stack),
+ r.index === t)
+ )
+ break;
+ return n.length || n.push(void 0), n;
+ }
+ _getStackCount(t) {
+ return this._getStacks(void 0, t).length;
+ }
+ _getStackIndex(t, e, i) {
+ const a = this._getStacks(t, i);
+ t = void 0 !== e ? a.indexOf(e) : -1;
+ return -1 === t ? a.length - 1 : t;
+ }
+ _getRuler() {
+ var t = this.options,
+ e = this._cachedMeta;
+ const i = e.iScale,
+ a = [];
+ let s, n;
+ for (s = 0, n = e.data.length; s < n; ++s)
+ a.push(i.getPixelForValue(this.getParsed(s)[i.axis], s));
+ var r = t.barThickness;
+ return {
+ min: r || computeMinSampleSize(e),
+ pixels: a,
+ start: i._startPixel,
+ end: i._endPixel,
+ stackCount: this._getStackCount(),
+ scale: i,
+ grouped: t.grouped,
+ ratio: r ? 1 : t.categoryPercentage * t.barPercentage,
+ };
+ }
+ _calculateBarValuePixels(t) {
+ const {
+ _cachedMeta: { vScale: e, _stacked: i, index: a },
+ options: { base: s, minBarLength: n },
+ } = this;
+ var r = s || 0;
+ const o = this.getParsed(t);
+ var l = o._custom,
+ h = isFloatBar(l);
+ let d = o[e.axis],
+ c = 0,
+ u = i ? this.applyStack(e, o, i) : d,
+ g,
+ p;
+ u !== d && ((c = u - d), (u = d)),
+ h &&
+ ((d = l.barStart),
+ (u = l.barEnd - l.barStart),
+ 0 !== d && sign(d) !== sign(l.barEnd) && (c = 0),
+ (c += d));
+ var f,
+ l = isNullOrUndef(s) || h ? c : s;
+ let m = e.getPixelForValue(l);
+ return (
+ (g = this.chart.getDataVisibility(t) ? e.getPixelForValue(c + u) : m),
+ (p = g - m),
+ Math.abs(p) < n &&
+ ((p = barSign(p, e, r) * n),
+ d === r && (m -= p / 2),
+ (l = e.getPixelForDecimal(0)),
+ (t = e.getPixelForDecimal(1)),
+ (f = Math.min(l, t)),
+ (l = Math.max(l, t)),
+ (m = Math.max(Math.min(m, l), f)),
+ (g = m + p),
+ i &&
+ !h &&
+ (o._stacks[e.axis]._visualValues[a] =
+ e.getValueForPixel(g) - e.getValueForPixel(m))),
+ m === e.getPixelForValue(r) &&
+ ((t = (sign(p) * e.getLineWidthForValue(r)) / 2), (m += t), (p -= t)),
+ { size: p, base: m, head: g, center: g + p / 2 }
+ );
+ }
+ _calculateBarIndexPixels(t, e) {
+ const i = e.scale;
+ var a,
+ s = this.options,
+ n = s.skipNull,
+ r = valueOrDefault(s.maxBarThickness, 1 / 0);
+ let o, l;
+ return (
+ (l = e.grouped
+ ? ((a = n ? this._getStackCount(t) : e.stackCount),
+ (s = (
+ "flex" === s.barThickness
+ ? computeFlexCategoryTraits
+ : computeFitCategoryTraits
+ )(t, e, s, a)),
+ (a = this._getStackIndex(
+ this.index,
+ this._cachedMeta.stack,
+ n ? t : void 0
+ )),
+ (o = s.start + s.chunk * a + s.chunk / 2),
+ Math.min(r, s.chunk * s.ratio))
+ : ((o = i.getPixelForValue(this.getParsed(t)[i.axis], t)),
+ Math.min(r, e.min * e.ratio))),
+ { base: o - l / 2, head: o + l / 2, center: o, size: l }
+ );
+ }
+ draw() {
+ var t = this._cachedMeta,
+ e = t.vScale;
+ const i = t.data;
+ var a = i.length;
+ let s = 0;
+ for (; s < a; ++s)
+ null !== this.getParsed(s)[e.axis] && i[s].draw(this._ctx);
+ }
+}
+class BubbleController extends DatasetController {
+ static id = "bubble";
+ static defaults = {
+ datasetElementType: !1,
+ dataElementType: "point",
+ animations: {
+ numbers: {
+ type: "number",
+ properties: ["x", "y", "borderWidth", "radius"],
+ },
+ },
+ };
+ static overrides = {
+ scales: { x: { type: "linear" }, y: { type: "linear" } },
+ };
+ initialize() {
+ (this.enableOptionSharing = !0), super.initialize();
+ }
+ parsePrimitiveData(t, e, i, a) {
+ const s = super.parsePrimitiveData(t, e, i, a);
+ for (let t = 0; t < s.length; t++)
+ s[t]._custom = this.resolveDataElementOptions(t + i).radius;
+ return s;
+ }
+ parseArrayData(t, e, i, a) {
+ const s = super.parseArrayData(t, e, i, a);
+ for (let t = 0; t < s.length; t++) {
+ var n = e[i + t];
+ s[t]._custom = valueOrDefault(
+ n[2],
+ this.resolveDataElementOptions(t + i).radius
+ );
+ }
+ return s;
+ }
+ parseObjectData(t, e, i, a) {
+ const s = super.parseObjectData(t, e, i, a);
+ for (let t = 0; t < s.length; t++) {
+ var n = e[i + t];
+ s[t]._custom = valueOrDefault(
+ n && n.r && +n.r,
+ this.resolveDataElementOptions(t + i).radius
+ );
+ }
+ return s;
+ }
+ getMaxOverflow() {
+ const e = this._cachedMeta.data;
+ let i = 0;
+ for (let t = e.length - 1; 0 <= t; --t)
+ i = Math.max(i, e[t].size(this.resolveDataElementOptions(t)) / 2);
+ return 0 < i && i;
+ }
+ getLabelAndValue(t) {
+ var e = this._cachedMeta,
+ i = this.chart.data.labels || [];
+ const { xScale: a, yScale: s } = e;
+ var e = this.getParsed(t),
+ n = a.getLabelForValue(e.x),
+ r = s.getLabelForValue(e.y),
+ e = e._custom;
+ return {
+ label: i[t] || "",
+ value: "(" + n + ", " + r + (e ? ", " + e : "") + ")",
+ };
+ }
+ update(t) {
+ var e = this._cachedMeta.data;
+ this.updateElements(e, 0, e.length, t);
+ }
+ updateElements(e, i, a, s) {
+ var n = "reset" === s;
+ const { iScale: r, vScale: o } = this._cachedMeta;
+ var { sharedOptions: l, includeOptions: h } = this._getSharedOptions(i, s),
+ d = r.axis,
+ c = o.axis;
+ for (let t = i; t < i + a; t++) {
+ var u = e[t],
+ g = !n && this.getParsed(t);
+ const f = {};
+ var p = (f[d] = n ? r.getPixelForDecimal(0.5) : r.getPixelForValue(g[d])),
+ g = (f[c] = n ? o.getBasePixel() : o.getPixelForValue(g[c]));
+ (f.skip = isNaN(p) || isNaN(g)),
+ h &&
+ ((f.options =
+ l || this.resolveDataElementOptions(t, u.active ? "active" : s)),
+ n && (f.options.radius = 0)),
+ this.updateElement(u, t, f, s);
+ }
+ }
+ resolveDataElementOptions(t, e) {
+ var i = this.getParsed(t);
+ let a = super.resolveDataElementOptions(t, e);
+ t = (a = a.$shared ? Object.assign({}, a, { $shared: !1 }) : a).radius;
+ return (
+ "active" !== e && (a.radius = 0),
+ (a.radius += valueOrDefault(i && i._custom, t)),
+ a
+ );
+ }
+}
+function getRatioAndOffset(t, e, a) {
+ let i = 1,
+ s = 1,
+ n = 0,
+ r = 0;
+ if (e < TAU) {
+ const u = t,
+ g = u + e;
+ var t = Math.cos(u),
+ e = Math.sin(u),
+ o = Math.cos(g),
+ l = Math.sin(g),
+ h = (t, e, i) =>
+ _angleBetween(t, u, g, !0) ? 1 : Math.max(e, e * a, i, i * a),
+ d = (t, e, i) =>
+ _angleBetween(t, u, g, !0) ? -1 : Math.min(e, e * a, i, i * a),
+ c = h(0, t, o),
+ h = h(HALF_PI, e, l),
+ t = d(PI, t, o),
+ o = d(PI + HALF_PI, e, l);
+ (i = (c - t) / 2),
+ (s = (h - o) / 2),
+ (n = -(c + t) / 2),
+ (r = -(h + o) / 2);
+ }
+ return { ratioX: i, ratioY: s, offsetX: n, offsetY: r };
+}
+class DoughnutController extends DatasetController {
+ static id = "doughnut";
+ static defaults = {
+ datasetElementType: !1,
+ dataElementType: "arc",
+ animation: { animateRotate: !0, animateScale: !1 },
+ animations: {
+ numbers: {
+ type: "number",
+ properties: [
+ "circumference",
+ "endAngle",
+ "innerRadius",
+ "outerRadius",
+ "startAngle",
+ "x",
+ "y",
+ "offset",
+ "borderWidth",
+ "spacing",
+ ],
+ },
+ },
+ cutout: "50%",
+ rotation: 0,
+ circumference: 360,
+ radius: "100%",
+ spacing: 0,
+ indexAxis: "r",
+ };
+ static descriptors = {
+ _scriptable: (t) => "spacing" !== t,
+ _indexable: (t) =>
+ "spacing" !== t &&
+ !t.startsWith("borderDash") &&
+ !t.startsWith("hoverBorderDash"),
+ };
+ static overrides = {
+ aspectRatio: 1,
+ plugins: {
+ legend: {
+ labels: {
+ generateLabels(s) {
+ const t = s.data;
+ if (t.labels.length && t.datasets.length) {
+ const { pointStyle: n, color: r } = s.legend.options["labels"];
+ return t.labels.map((t, e) => {
+ const i = s.getDatasetMeta(0);
+ var a = i.controller.getStyle(e);
+ return {
+ text: t,
+ fillStyle: a.backgroundColor,
+ strokeStyle: a.borderColor,
+ fontColor: r,
+ lineWidth: a.borderWidth,
+ pointStyle: n,
+ hidden: !s.getDataVisibility(e),
+ index: e,
+ };
+ });
+ }
+ return [];
+ },
+ },
+ onClick(t, e, i) {
+ i.chart.toggleDataVisibility(e.index), i.chart.update();
+ },
+ },
+ },
+ };
+ constructor(t, e) {
+ super(t, e),
+ (this.enableOptionSharing = !0),
+ (this.innerRadius = void 0),
+ (this.outerRadius = void 0),
+ (this.offsetX = void 0),
+ (this.offsetY = void 0);
+ }
+ linkScales() {}
+ parse(a, s) {
+ const n = this.getDataset().data,
+ r = this._cachedMeta;
+ if (!1 === this._parsing) r._parsed = n;
+ else {
+ let t = (t) => +n[t];
+ if (isObject(n[a])) {
+ const { key: o = "value" } = this._parsing;
+ t = (t) => +resolveObjectKey(n[t], o);
+ }
+ let e, i;
+ for (i = (e = a) + s; e < i; ++e) r._parsed[e] = t(e);
+ }
+ }
+ _getRotation() {
+ return toRadians(this.options.rotation - 90);
+ }
+ _getCircumference() {
+ return toRadians(this.options.circumference);
+ }
+ _getRotationExtents() {
+ let e = TAU,
+ i = -TAU;
+ for (let t = 0; t < this.chart.data.datasets.length; ++t)
+ if (
+ this.chart.isDatasetVisible(t) &&
+ this.chart.getDatasetMeta(t).type === this._type
+ ) {
+ const n = this.chart.getDatasetMeta(t).controller;
+ var a = n._getRotation(),
+ s = n._getCircumference();
+ (e = Math.min(e, a)), (i = Math.max(i, a + s));
+ }
+ return { rotation: e, circumference: i - e };
+ }
+ update(t) {
+ var e = this.chart["chartArea"];
+ const i = this._cachedMeta;
+ var a = i.data,
+ s =
+ this.getMaxBorderWidth() + this.getMaxOffset(a) + this.options.spacing,
+ n = Math.max((Math.min(e.width, e.height) - s) / 2, 0),
+ n = Math.min(toPercentage(this.options.cutout, n), 1),
+ r = this._getRingWeight(this.index),
+ { circumference: o, rotation: l } = this._getRotationExtents(),
+ {
+ ratioX: l,
+ ratioY: o,
+ offsetX: h,
+ offsetY: d,
+ } = getRatioAndOffset(l, o, n),
+ l = (e.width - s) / l,
+ e = (e.height - s) / o,
+ s = Math.max(Math.min(l, e) / 2, 0),
+ o = toDimension(this.options.radius, s),
+ l = (o - Math.max(o * n, 0)) / this._getVisibleDatasetWeightTotal();
+ (this.offsetX = h * o),
+ (this.offsetY = d * o),
+ (i.total = this.calculateTotal()),
+ (this.outerRadius = o - l * this._getRingWeightOffset(this.index)),
+ (this.innerRadius = Math.max(this.outerRadius - l * r, 0)),
+ this.updateElements(a, 0, a.length, t);
+ }
+ _circumference(t, e) {
+ var i = this.options,
+ a = this._cachedMeta,
+ s = this._getCircumference();
+ return (e && i.animation.animateRotate) ||
+ !this.chart.getDataVisibility(t) ||
+ null === a._parsed[t] ||
+ a.data[t].hidden
+ ? 0
+ : this.calculateCircumference((a._parsed[t] * s) / TAU);
+ }
+ updateElements(t, e, i, a) {
+ var s = "reset" === a,
+ n = this.chart,
+ r = n.chartArea,
+ n = n.options.animation,
+ o = (r.left + r.right) / 2,
+ l = (r.top + r.bottom) / 2,
+ r = s && n.animateScale,
+ h = r ? 0 : this.innerRadius,
+ d = r ? 0 : this.outerRadius,
+ { sharedOptions: c, includeOptions: u } = this._getSharedOptions(e, a);
+ let g = this._getRotation(),
+ p;
+ for (p = 0; p < e; ++p) g += this._circumference(p, s);
+ for (p = e; p < e + i; ++p) {
+ var f = this._circumference(p, s),
+ m = t[p];
+ const v = {
+ x: o + this.offsetX,
+ y: l + this.offsetY,
+ startAngle: g,
+ endAngle: g + f,
+ circumference: f,
+ outerRadius: d,
+ innerRadius: h,
+ };
+ u &&
+ (v.options =
+ c || this.resolveDataElementOptions(p, m.active ? "active" : a)),
+ (g += f),
+ this.updateElement(m, p, v, a);
+ }
+ }
+ calculateTotal() {
+ var t = this._cachedMeta,
+ e = t.data;
+ let i = 0,
+ a;
+ for (a = 0; a < e.length; a++) {
+ var s = t._parsed[a];
+ null === s ||
+ isNaN(s) ||
+ !this.chart.getDataVisibility(a) ||
+ e[a].hidden ||
+ (i += Math.abs(s));
+ }
+ return i;
+ }
+ calculateCircumference(t) {
+ var e = this._cachedMeta.total;
+ return 0 < e && !isNaN(t) ? TAU * (Math.abs(t) / e) : 0;
+ }
+ getLabelAndValue(t) {
+ var e = this._cachedMeta,
+ i = this.chart,
+ a = i.data.labels || [],
+ e = formatNumber(e._parsed[t], i.options.locale);
+ return { label: a[t] || "", value: e };
+ }
+ getMaxBorderWidth(t) {
+ let e = 0;
+ const i = this.chart;
+ let a, s, n, r, o;
+ if (!t)
+ for (a = 0, s = i.data.datasets.length; a < s; ++a)
+ if (i.isDatasetVisible(a)) {
+ (t = (n = i.getDatasetMeta(a)).data), (r = n.controller);
+ break;
+ }
+ if (!t) return 0;
+ for (a = 0, s = t.length; a < s; ++a)
+ "inner" !== (o = r.resolveDataElementOptions(a)).borderAlign &&
+ (e = Math.max(e, o.borderWidth || 0, o.hoverBorderWidth || 0));
+ return e;
+ }
+ getMaxOffset(i) {
+ let a = 0;
+ for (let t = 0, e = i.length; t < e; ++t) {
+ var s = this.resolveDataElementOptions(t);
+ a = Math.max(a, s.offset || 0, s.hoverOffset || 0);
+ }
+ return a;
+ }
+ _getRingWeightOffset(e) {
+ let i = 0;
+ for (let t = 0; t < e; ++t)
+ this.chart.isDatasetVisible(t) && (i += this._getRingWeight(t));
+ return i;
+ }
+ _getRingWeight(t) {
+ return Math.max(valueOrDefault(this.chart.data.datasets[t].weight, 1), 0);
+ }
+ _getVisibleDatasetWeightTotal() {
+ return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;
+ }
+}
+class LineController extends DatasetController {
+ static id = "line";
+ static defaults = {
+ datasetElementType: "line",
+ dataElementType: "point",
+ showLine: !0,
+ spanGaps: !1,
+ };
+ static overrides = {
+ scales: { _index_: { type: "category" }, _value_: { type: "linear" } },
+ };
+ initialize() {
+ (this.enableOptionSharing = !0),
+ (this.supportsDecimation = !0),
+ super.initialize();
+ }
+ update(t) {
+ var e = this._cachedMeta;
+ const { dataset: i, data: a = [], _dataset: s } = e;
+ var n = this.chart._animationsDisabled;
+ let { start: r, count: o } = _getStartAndCountOfVisiblePoints(e, a, n);
+ (this._drawStart = r),
+ (this._drawCount = o),
+ _scaleRangesChanged(e) && ((r = 0), (o = a.length)),
+ (i._chart = this.chart),
+ (i._datasetIndex = this.index),
+ (i._decimated = !!s._decimated),
+ (i.points = a);
+ const l = this.resolveDatasetElementOptions(t);
+ this.options.showLine || (l.borderWidth = 0),
+ (l.segment = this.options.segment),
+ this.updateElement(i, void 0, { animated: !n, options: l }, t),
+ this.updateElements(a, r, o, t);
+ }
+ updateElements(e, i, t, a) {
+ var s = "reset" === a;
+ const { iScale: n, vScale: r, _stacked: o, _dataset: l } = this._cachedMeta;
+ var { sharedOptions: h, includeOptions: d } = this._getSharedOptions(i, a),
+ c = n.axis,
+ u = r.axis,
+ { spanGaps: g, segment: p } = this.options,
+ f = isNumber(g) ? g : Number.POSITIVE_INFINITY,
+ m = this.chart._animationsDisabled || s || "none" === a,
+ v = i + t,
+ x = e.length;
+ let b = 0 < i && this.getParsed(i - 1);
+ for (let t = 0; t < x; ++t) {
+ var _,
+ y,
+ k,
+ S,
+ D = e[t];
+ const M = m ? D : {};
+ t < i || t >= v
+ ? (M.skip = !0)
+ : ((_ = this.getParsed(t)),
+ (y = isNullOrUndef(_[u])),
+ (k = M[c] = n.getPixelForValue(_[c], t)),
+ (S = M[u] =
+ s || y
+ ? r.getBasePixel()
+ : r.getPixelForValue(o ? this.applyStack(r, _, o) : _[u], t)),
+ (M.skip = isNaN(k) || isNaN(S) || y),
+ (M.stop = 0 < t && Math.abs(_[c] - b[c]) > f),
+ p && ((M.parsed = _), (M.raw = l.data[t])),
+ d &&
+ (M.options =
+ h || this.resolveDataElementOptions(t, D.active ? "active" : a)),
+ m || this.updateElement(D, t, M, a),
+ (b = _));
+ }
+ }
+ getMaxOverflow() {
+ var t = this._cachedMeta,
+ e = t.dataset,
+ e = (e.options && e.options.borderWidth) || 0;
+ const i = t.data || [];
+ if (!i.length) return e;
+ var t = i[0].size(this.resolveDataElementOptions(0)),
+ a = i[i.length - 1].size(this.resolveDataElementOptions(i.length - 1));
+ return Math.max(e, t, a) / 2;
+ }
+ draw() {
+ const t = this._cachedMeta;
+ t.dataset.updateControlPoints(this.chart.chartArea, t.iScale.axis),
+ super.draw();
+ }
+}
+class PolarAreaController extends DatasetController {
+ static id = "polarArea";
+ static defaults = {
+ dataElementType: "arc",
+ animation: { animateRotate: !0, animateScale: !0 },
+ animations: {
+ numbers: {
+ type: "number",
+ properties: [
+ "x",
+ "y",
+ "startAngle",
+ "endAngle",
+ "innerRadius",
+ "outerRadius",
+ ],
+ },
+ },
+ indexAxis: "r",
+ startAngle: 0,
+ };
+ static overrides = {
+ aspectRatio: 1,
+ plugins: {
+ legend: {
+ labels: {
+ generateLabels(s) {
+ const t = s.data;
+ if (t.labels.length && t.datasets.length) {
+ const { pointStyle: n, color: r } = s.legend.options["labels"];
+ return t.labels.map((t, e) => {
+ const i = s.getDatasetMeta(0);
+ var a = i.controller.getStyle(e);
+ return {
+ text: t,
+ fillStyle: a.backgroundColor,
+ strokeStyle: a.borderColor,
+ fontColor: r,
+ lineWidth: a.borderWidth,
+ pointStyle: n,
+ hidden: !s.getDataVisibility(e),
+ index: e,
+ };
+ });
+ }
+ return [];
+ },
+ },
+ onClick(t, e, i) {
+ i.chart.toggleDataVisibility(e.index), i.chart.update();
+ },
+ },
+ },
+ scales: {
+ r: {
+ type: "radialLinear",
+ angleLines: { display: !1 },
+ beginAtZero: !0,
+ grid: { circular: !0 },
+ pointLabels: { display: !1 },
+ startAngle: 0,
+ },
+ },
+ };
+ constructor(t, e) {
+ super(t, e), (this.innerRadius = void 0), (this.outerRadius = void 0);
+ }
+ getLabelAndValue(t) {
+ var e = this._cachedMeta,
+ i = this.chart,
+ a = i.data.labels || [],
+ e = formatNumber(e._parsed[t].r, i.options.locale);
+ return { label: a[t] || "", value: e };
+ }
+ parseObjectData(t, e, i, a) {
+ return _parseObjectDataRadialScale.bind(this)(t, e, i, a);
+ }
+ update(t) {
+ var e = this._cachedMeta.data;
+ this._updateRadius(), this.updateElements(e, 0, e.length, t);
+ }
+ getMinMax() {
+ const t = this._cachedMeta,
+ a = { min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY };
+ return (
+ t.data.forEach((t, e) => {
+ var i = this.getParsed(e).r;
+ !isNaN(i) &&
+ this.chart.getDataVisibility(e) &&
+ (i < a.min && (a.min = i), i > a.max && (a.max = i));
+ }),
+ a
+ );
+ }
+ _updateRadius() {
+ const t = this.chart;
+ var e = t.chartArea,
+ i = t.options,
+ e = Math.min(e.right - e.left, e.bottom - e.top),
+ e = Math.max(e / 2, 0),
+ i =
+ (e -
+ Math.max(
+ i.cutoutPercentage ? (e / 100) * i.cutoutPercentage : 1,
+ 0
+ )) /
+ t.getVisibleDatasetCount();
+ (this.outerRadius = e - i * this.index),
+ (this.innerRadius = this.outerRadius - i);
+ }
+ updateElements(a, t, e, s) {
+ var n = "reset" === s;
+ const r = this.chart;
+ var o = r.options.animation;
+ const l = this._cachedMeta.rScale;
+ var h = l.xCenter,
+ d = l.yCenter,
+ c = l.getIndexAngle(0) - 0.5 * PI;
+ let u = c,
+ g;
+ var p = 360 / this.countVisibleElements();
+ for (g = 0; g < t; ++g) u += this._computeAngle(g, s, p);
+ for (g = t; g < t + e; g++) {
+ var f = a[g];
+ let t = u,
+ e = u + this._computeAngle(g, s, p),
+ i = r.getDataVisibility(g)
+ ? l.getDistanceFromCenterForValue(this.getParsed(g).r)
+ : 0;
+ (u = e), n && (o.animateScale && (i = 0), o.animateRotate && (t = e = c));
+ var m = {
+ x: h,
+ y: d,
+ innerRadius: 0,
+ outerRadius: i,
+ startAngle: t,
+ endAngle: e,
+ options: this.resolveDataElementOptions(g, f.active ? "active" : s),
+ };
+ this.updateElement(f, g, m, s);
+ }
+ }
+ countVisibleElements() {
+ const t = this._cachedMeta;
+ let i = 0;
+ return (
+ t.data.forEach((t, e) => {
+ !isNaN(this.getParsed(e).r) && this.chart.getDataVisibility(e) && i++;
+ }),
+ i
+ );
+ }
+ _computeAngle(t, e, i) {
+ return this.chart.getDataVisibility(t)
+ ? toRadians(this.resolveDataElementOptions(t, e).angle || i)
+ : 0;
+ }
+}
+class PieController extends DoughnutController {
+ static id = "pie";
+ static defaults = {
+ cutout: 0,
+ rotation: 0,
+ circumference: 360,
+ radius: "100%",
+ };
+}
+class RadarController extends DatasetController {
+ static id = "radar";
+ static defaults = {
+ datasetElementType: "line",
+ dataElementType: "point",
+ indexAxis: "r",
+ showLine: !0,
+ elements: { line: { fill: "start" } },
+ };
+ static overrides = {
+ aspectRatio: 1,
+ scales: { r: { type: "radialLinear" } },
+ };
+ getLabelAndValue(t) {
+ const e = this._cachedMeta.vScale;
+ var i = this.getParsed(t);
+ return {
+ label: e.getLabels()[t],
+ value: "" + e.getLabelForValue(i[e.axis]),
+ };
+ }
+ parseObjectData(t, e, i, a) {
+ return _parseObjectDataRadialScale.bind(this)(t, e, i, a);
+ }
+ update(t) {
+ const e = this._cachedMeta,
+ i = e.dataset;
+ var a = e.data || [],
+ s = e.iScale.getLabels();
+ if (((i.points = a), "resize" !== t)) {
+ const n = this.resolveDatasetElementOptions(t);
+ this.options.showLine || (n.borderWidth = 0);
+ s = { _loop: !0, _fullLoop: s.length === a.length, options: n };
+ this.updateElement(i, void 0, s, t);
+ }
+ this.updateElements(a, 0, a.length, t);
+ }
+ updateElements(e, i, a, s) {
+ const n = this._cachedMeta.rScale;
+ var r = "reset" === s;
+ for (let t = i; t < i + a; t++) {
+ var o = e[t],
+ l = this.resolveDataElementOptions(t, o.active ? "active" : s),
+ h = n.getPointPositionForValue(t, this.getParsed(t).r),
+ d = r ? n.xCenter : h.x,
+ c = r ? n.yCenter : h.y,
+ h = {
+ x: d,
+ y: c,
+ angle: h.angle,
+ skip: isNaN(d) || isNaN(c),
+ options: l,
+ };
+ this.updateElement(o, t, h, s);
+ }
+ }
+}
+class ScatterController extends DatasetController {
+ static id = "scatter";
+ static defaults = {
+ datasetElementType: !1,
+ dataElementType: "point",
+ showLine: !1,
+ fill: !1,
+ };
+ static overrides = {
+ interaction: { mode: "point" },
+ scales: { x: { type: "linear" }, y: { type: "linear" } },
+ };
+ getLabelAndValue(t) {
+ var e = this._cachedMeta,
+ i = this.chart.data.labels || [];
+ const { xScale: a, yScale: s } = e;
+ var e = this.getParsed(t),
+ n = a.getLabelForValue(e.x),
+ e = s.getLabelForValue(e.y);
+ return { label: i[t] || "", value: "(" + n + ", " + e + ")" };
+ }
+ update(t) {
+ const e = this._cachedMeta;
+ var { data: i = [] } = e,
+ a = this.chart._animationsDisabled;
+ let { start: s, count: n } = _getStartAndCountOfVisiblePoints(e, i, a);
+ if (
+ ((this._drawStart = s),
+ (this._drawCount = n),
+ _scaleRangesChanged(e) && ((s = 0), (n = i.length)),
+ this.options.showLine)
+ ) {
+ this.datasetElementType || this.addElements();
+ const { dataset: r, _dataset: o } = e,
+ l =
+ ((r._chart = this.chart),
+ (r._datasetIndex = this.index),
+ (r._decimated = !!o._decimated),
+ (r.points = i),
+ this.resolveDatasetElementOptions(t));
+ (l.segment = this.options.segment),
+ this.updateElement(r, void 0, { animated: !a, options: l }, t);
+ } else
+ this.datasetElementType &&
+ (delete e.dataset, (this.datasetElementType = !1));
+ this.updateElements(i, s, n, t);
+ }
+ addElements() {
+ var t = this.options["showLine"];
+ !this.datasetElementType &&
+ t &&
+ (this.datasetElementType = this.chart.registry.getElement("line")),
+ super.addElements();
+ }
+ updateElements(e, i, a, s) {
+ var n = "reset" === s;
+ const { iScale: r, vScale: o, _stacked: l, _dataset: h } = this._cachedMeta;
+ var t = this.resolveDataElementOptions(i, s),
+ d = this.getSharedOptions(t),
+ c = this.includeOptions(s, d),
+ u = r.axis,
+ g = o.axis,
+ { spanGaps: p, segment: f } = this.options,
+ m = isNumber(p) ? p : Number.POSITIVE_INFINITY,
+ v = this.chart._animationsDisabled || n || "none" === s;
+ let x = 0 < i && this.getParsed(i - 1);
+ for (let t = i; t < i + a; ++t) {
+ var b = e[t],
+ _ = this.getParsed(t);
+ const D = v ? b : {};
+ var y = isNullOrUndef(_[g]),
+ k = (D[u] = r.getPixelForValue(_[u], t)),
+ S = (D[g] =
+ n || y
+ ? o.getBasePixel()
+ : o.getPixelForValue(l ? this.applyStack(o, _, l) : _[g], t));
+ (D.skip = isNaN(k) || isNaN(S) || y),
+ (D.stop = 0 < t && Math.abs(_[u] - x[u]) > m),
+ f && ((D.parsed = _), (D.raw = h.data[t])),
+ c &&
+ (D.options =
+ d || this.resolveDataElementOptions(t, b.active ? "active" : s)),
+ v || this.updateElement(b, t, D, s),
+ (x = _);
+ }
+ this.updateSharedOptions(d, s, t);
+ }
+ getMaxOverflow() {
+ var t = this._cachedMeta;
+ const i = t.data || [];
+ if (!this.options.showLine) {
+ let e = 0;
+ for (let t = i.length - 1; 0 <= t; --t)
+ e = Math.max(e, i[t].size(this.resolveDataElementOptions(t)) / 2);
+ return 0 < e && e;
+ }
+ (t = t.dataset), (t = (t.options && t.options.borderWidth) || 0);
+ if (!i.length) return t;
+ var e = i[0].size(this.resolveDataElementOptions(0)),
+ a = i[i.length - 1].size(this.resolveDataElementOptions(i.length - 1));
+ return Math.max(t, e, a) / 2;
+ }
+}
+var controllers = Object.freeze({
+ __proto__: null,
+ BarController: BarController,
+ BubbleController: BubbleController,
+ DoughnutController: DoughnutController,
+ LineController: LineController,
+ PieController: PieController,
+ PolarAreaController: PolarAreaController,
+ RadarController: RadarController,
+ ScatterController: ScatterController,
+});
+function abstract() {
+ throw new Error(
+ "This method is not implemented: Check that a complete date adapter is provided."
+ );
+}
+class DateAdapterBase {
+ static override(t) {
+ Object.assign(DateAdapterBase.prototype, t);
+ }
+ options;
+ constructor(t) {
+ this.options = t || {};
+ }
+ init() {}
+ formats() {
+ return abstract();
+ }
+ parse() {
+ return abstract();
+ }
+ format() {
+ return abstract();
+ }
+ add() {
+ return abstract();
+ }
+ diff() {
+ return abstract();
+ }
+ startOf() {
+ return abstract();
+ }
+ endOf() {
+ return abstract();
+ }
+}
+var adapters = { _date: DateAdapterBase };
+function binarySearch(t, e, i, a) {
+ var { controller: t, data: s, _sorted: n } = t,
+ r = t._cachedMeta.iScale;
+ if (r && e === r.axis && "r" !== e && n && s.length) {
+ const o = r._reversePixels ? _rlookupByKey : _lookupByKey;
+ if (!a) return o(s, e, i);
+ if (t._sharedOptions) {
+ const l = s[0];
+ n = "function" == typeof l.getRange && l.getRange(e);
+ if (n)
+ return (
+ (r = o(s, e, i - n)), (a = o(s, e, i + n)), { lo: r.lo, hi: a.hi }
+ );
+ }
+ }
+ return { lo: 0, hi: s.length - 1 };
+}
+function evaluateInteractionItems(t, i, e, a, s) {
+ var n = t.getSortedVisibleDatasetMetas(),
+ r = e[i];
+ for (let t = 0, e = n.length; t < e; ++t) {
+ var { index: o, data: l } = n[t],
+ { lo: h, hi: d } = binarySearch(n[t], i, r, s);
+ for (let t = h; t <= d; ++t) {
+ var c = l[t];
+ c.skip || a(c, o, t);
+ }
+ }
+}
+function getDistanceMetricForAxis(t) {
+ const a = -1 !== t.indexOf("x"),
+ s = -1 !== t.indexOf("y");
+ return function (t, e) {
+ var i = a ? Math.abs(t.x - e.x) : 0,
+ t = s ? Math.abs(t.y - e.y) : 0;
+ return Math.sqrt(Math.pow(i, 2) + Math.pow(t, 2));
+ };
+}
+function getIntersectItems(a, s, t, n, r) {
+ const o = [];
+ if (!r && !a.isPointInArea(s)) return o;
+ return (
+ evaluateInteractionItems(
+ a,
+ t,
+ s,
+ function (t, e, i) {
+ (r || _isPointInArea(t, a.chartArea, 0)) &&
+ t.inRange(s.x, s.y, n) &&
+ o.push({ element: t, datasetIndex: e, index: i });
+ },
+ !0
+ ),
+ o
+ );
+}
+function getNearestRadialItems(t, r, e, o) {
+ let l = [];
+ return (
+ evaluateInteractionItems(t, e, r, function (t, e, i) {
+ var { startAngle: a, endAngle: s } = t.getProps(
+ ["startAngle", "endAngle"],
+ o
+ ),
+ n = getAngleFromPoint(t, { x: r.x, y: r.y })["angle"];
+ _angleBetween(n, a, s) &&
+ l.push({ element: t, datasetIndex: e, index: i });
+ }),
+ l
+ );
+}
+function getNearestCartesianItems(n, r, t, o, l, h) {
+ let d = [];
+ const c = getDistanceMetricForAxis(t);
+ let u = Number.POSITIVE_INFINITY;
+ return (
+ evaluateInteractionItems(n, t, r, function (t, e, i) {
+ var a,
+ s = t.inRange(r.x, r.y, l);
+ (o && !s) ||
+ ((a = t.getCenterPoint(l)),
+ (h || n.isPointInArea(a) || s) &&
+ ((s = c(r, a)) < u
+ ? ((d = [{ element: t, datasetIndex: e, index: i }]), (u = s))
+ : s === u && d.push({ element: t, datasetIndex: e, index: i })));
+ }),
+ d
+ );
+}
+function getNearestItems(t, e, i, a, s, n) {
+ return n || t.isPointInArea(e)
+ ? "r" !== i || a
+ ? getNearestCartesianItems(t, e, i, a, s, n)
+ : getNearestRadialItems(t, e, i, s)
+ : [];
+}
+function getAxisItems(t, a, s, e, n) {
+ const r = [],
+ o = "x" === s ? "inXRange" : "inYRange";
+ let l = !1;
+ return (
+ evaluateInteractionItems(t, s, a, (t, e, i) => {
+ t[o](a[s], n) &&
+ (r.push({ element: t, datasetIndex: e, index: i }),
+ (l = l || t.inRange(a.x, a.y, n)));
+ }),
+ e && !l ? [] : r
+ );
+}
+var Interaction = {
+ evaluateInteractionItems: evaluateInteractionItems,
+ modes: {
+ index(t, e, i, a) {
+ var e = getRelativePosition(e, t),
+ s = i.axis || "x",
+ n = i.includeInvisible || !1;
+ const r = i.intersect
+ ? getIntersectItems(t, e, s, a, n)
+ : getNearestItems(t, e, s, !1, a, n),
+ o = [];
+ return r.length
+ ? (t.getSortedVisibleDatasetMetas().forEach((t) => {
+ var e = r[0].index,
+ i = t.data[e];
+ i &&
+ !i.skip &&
+ o.push({ element: i, datasetIndex: t.index, index: e });
+ }),
+ o)
+ : [];
+ },
+ dataset(t, e, i, a) {
+ var e = getRelativePosition(e, t),
+ s = i.axis || "xy",
+ n = i.includeInvisible || !1;
+ let r = i.intersect
+ ? getIntersectItems(t, e, s, a, n)
+ : getNearestItems(t, e, s, !1, a, n);
+ if (0 < r.length) {
+ var o = r[0].datasetIndex,
+ l = t.getDatasetMeta(o).data;
+ r = [];
+ for (let t = 0; t < l.length; ++t)
+ r.push({ element: l[t], datasetIndex: o, index: t });
+ }
+ return r;
+ },
+ point(t, e, i, a) {
+ return getIntersectItems(
+ t,
+ getRelativePosition(e, t),
+ i.axis || "xy",
+ a,
+ i.includeInvisible || !1
+ );
+ },
+ nearest(t, e, i, a) {
+ var e = getRelativePosition(e, t),
+ s = i.axis || "xy",
+ n = i.includeInvisible || !1;
+ return getNearestItems(t, e, s, i.intersect, a, n);
+ },
+ x(t, e, i, a) {
+ return getAxisItems(t, getRelativePosition(e, t), "x", i.intersect, a);
+ },
+ y(t, e, i, a) {
+ return getAxisItems(t, getRelativePosition(e, t), "y", i.intersect, a);
+ },
+ },
+};
+const STATIC_POSITIONS = ["left", "top", "right", "bottom"];
+function filterByPosition(t, e) {
+ return t.filter((t) => t.pos === e);
+}
+function filterDynamicPositionByAxis(t, e) {
+ return t.filter(
+ (t) => -1 === STATIC_POSITIONS.indexOf(t.pos) && t.box.axis === e
+ );
+}
+function sortByWeight(t, a) {
+ return t.sort((t, e) => {
+ var i = a ? e : t,
+ t = a ? t : e;
+ return i.weight === t.weight ? i.index - t.index : i.weight - t.weight;
+ });
+}
+function wrapBoxes(t) {
+ const e = [];
+ let i, a, s, n, r, o;
+ for (i = 0, a = (t || []).length; i < a; ++i)
+ ({
+ position: n,
+ options: { stack: r, stackWeight: o = 1 },
+ } = s =
+ t[i]),
+ e.push({
+ index: i,
+ box: s,
+ pos: n,
+ horizontal: s.isHorizontal(),
+ weight: s.weight,
+ stack: r && n + r,
+ stackWeight: o,
+ });
+ return e;
+}
+function buildStacks(t) {
+ const e = {};
+ for (const n of t) {
+ var { stack: i, pos: a, stackWeight: s } = n;
+ if (i && STATIC_POSITIONS.includes(a)) {
+ const r = e[i] || (e[i] = { count: 0, placed: 0, weight: 0, size: 0 });
+ r.count++, (r.weight += s);
+ }
+ }
+ return e;
+}
+function setLayoutDims(t, e) {
+ var i = buildStacks(t),
+ { vBoxMaxWidth: a, hBoxMaxHeight: s } = e;
+ let n, r, o;
+ for (n = 0, r = t.length; n < r; ++n) {
+ var l = (o = t[n]).box["fullSize"],
+ h = i[o.stack],
+ h = h && o.stackWeight / h.weight;
+ o.horizontal
+ ? ((o.width = h ? h * a : l && e.availableWidth), (o.height = s))
+ : ((o.width = a), (o.height = h ? h * s : l && e.availableHeight));
+ }
+ return i;
+}
+function buildLayoutBoxes(t) {
+ const e = wrapBoxes(t);
+ t = sortByWeight(
+ e.filter((t) => t.box.fullSize),
+ !0
+ );
+ const i = sortByWeight(filterByPosition(e, "left"), !0),
+ a = sortByWeight(filterByPosition(e, "right")),
+ s = sortByWeight(filterByPosition(e, "top"), !0);
+ var n = sortByWeight(filterByPosition(e, "bottom")),
+ r = filterDynamicPositionByAxis(e, "x"),
+ o = filterDynamicPositionByAxis(e, "y");
+ return {
+ fullSize: t,
+ leftAndTop: i.concat(s),
+ rightAndBottom: a.concat(o).concat(n).concat(r),
+ chartArea: filterByPosition(e, "chartArea"),
+ vertical: i.concat(a).concat(o),
+ horizontal: s.concat(n).concat(r),
+ };
+}
+function getCombinedMax(t, e, i, a) {
+ return Math.max(t[i], e[i]) + Math.max(t[a], e[a]);
+}
+function updateMaxPadding(t, e) {
+ (t.top = Math.max(t.top, e.top)),
+ (t.left = Math.max(t.left, e.left)),
+ (t.bottom = Math.max(t.bottom, e.bottom)),
+ (t.right = Math.max(t.right, e.right));
+}
+function updateDims(t, e, i, a) {
+ const { pos: s, box: n } = i;
+ var r = t.maxPadding;
+ if (!isObject(s)) {
+ i.size && (t[s] -= i.size);
+ const l = a[i.stack] || { size: 0, count: 1 };
+ (l.size = Math.max(l.size, i.horizontal ? n.height : n.width)),
+ (i.size = l.size / l.count),
+ (t[s] += i.size);
+ }
+ n.getPadding && updateMaxPadding(r, n.getPadding());
+ var a = Math.max(0, e.outerWidth - getCombinedMax(r, t, "left", "right")),
+ e = Math.max(0, e.outerHeight - getCombinedMax(r, t, "top", "bottom")),
+ r = a !== t.w,
+ o = e !== t.h;
+ return (
+ (t.w = a),
+ (t.h = e),
+ i.horizontal ? { same: r, other: o } : { same: o, other: r }
+ );
+}
+function handleMaxPadding(i) {
+ const a = i.maxPadding;
+ function t(t) {
+ var e = Math.max(a[t] - i[t], 0);
+ return (i[t] += e), e;
+ }
+ (i.y += t("top")), (i.x += t("left")), t("right"), t("bottom");
+}
+function getMargins(t, i) {
+ const a = i.maxPadding;
+ function e(t) {
+ const e = { left: 0, top: 0, right: 0, bottom: 0 };
+ return (
+ t.forEach((t) => {
+ e[t] = Math.max(i[t], a[t]);
+ }),
+ e
+ );
+ }
+ return e(t ? ["left", "right"] : ["top", "bottom"]);
+}
+function fitBoxes(t, e, i, a) {
+ const s = [];
+ let n, r, o, l, h, d;
+ for (n = 0, r = t.length, h = 0; n < r; ++n) {
+ (o = t[n]),
+ (l = o.box).update(
+ o.width || e.w,
+ o.height || e.h,
+ getMargins(o.horizontal, e)
+ );
+ var { same: c, other: u } = updateDims(e, i, o, a);
+ (h |= c && s.length), (d = d || u), l.fullSize || s.push(o);
+ }
+ return (h && fitBoxes(s, e, i, a)) || d;
+}
+function setBoxDims(t, e, i, a, s) {
+ (t.top = i),
+ (t.left = e),
+ (t.right = e + a),
+ (t.bottom = i + s),
+ (t.width = a),
+ (t.height = s);
+}
+function placeBoxes(t, e, i, a) {
+ var s = i.padding;
+ let { x: n, y: r } = e;
+ for (const c of t) {
+ var o = c.box;
+ const u = a[c.stack] || { count: 1, placed: 0, weight: 1 };
+ var l,
+ h,
+ d = c.stackWeight / u.weight || 1;
+ c.horizontal
+ ? ((h = e.w * d),
+ (l = u.size || o.height),
+ defined(u.start) && (r = u.start),
+ o.fullSize
+ ? setBoxDims(o, s.left, r, i.outerWidth - s.right - s.left, l)
+ : setBoxDims(o, e.left + u.placed, r, h, l),
+ (u.start = r),
+ (u.placed += h),
+ (r = o.bottom))
+ : ((l = e.h * d),
+ (h = u.size || o.width),
+ defined(u.start) && (n = u.start),
+ o.fullSize
+ ? setBoxDims(o, n, s.top, h, i.outerHeight - s.bottom - s.top)
+ : setBoxDims(o, n, e.top + u.placed, h, l),
+ (u.start = n),
+ (u.placed += l),
+ (n = o.right));
+ }
+ (e.x = n), (e.y = r);
+}
+var layouts = {
+ addBox(t, e) {
+ t.boxes || (t.boxes = []),
+ (e.fullSize = e.fullSize || !1),
+ (e.position = e.position || "top"),
+ (e.weight = e.weight || 0),
+ (e._layers =
+ e._layers ||
+ function () {
+ return [
+ {
+ z: 0,
+ draw(t) {
+ e.draw(t);
+ },
+ },
+ ];
+ }),
+ t.boxes.push(e);
+ },
+ removeBox(t, e) {
+ e = t.boxes ? t.boxes.indexOf(e) : -1;
+ -1 !== e && t.boxes.splice(e, 1);
+ },
+ configure(t, e, i) {
+ (e.fullSize = i.fullSize), (e.position = i.position), (e.weight = i.weight);
+ },
+ update(i, t, e, a) {
+ if (i) {
+ var s = toPadding(i.options.layout.padding),
+ n = Math.max(t - s.width, 0),
+ r = Math.max(e - s.height, 0),
+ o = buildLayoutBoxes(i.boxes);
+ const d = o.vertical;
+ var l = o.horizontal,
+ h =
+ (each(i.boxes, (t) => {
+ "function" == typeof t.beforeLayout && t.beforeLayout();
+ }),
+ d.reduce(
+ (t, e) =>
+ e.box.options && !1 === e.box.options.display ? t : t + 1,
+ 0
+ ) || 1),
+ t = Object.freeze({
+ outerWidth: t,
+ outerHeight: e,
+ padding: s,
+ availableWidth: n,
+ availableHeight: r,
+ vBoxMaxWidth: n / 2 / h,
+ hBoxMaxHeight: r / 2,
+ }),
+ e = Object.assign({}, s);
+ updateMaxPadding(e, toPadding(a));
+ const c = Object.assign(
+ { maxPadding: e, w: n, h: r, x: s.left, y: s.top },
+ s
+ );
+ h = setLayoutDims(d.concat(l), t);
+ fitBoxes(o.fullSize, c, t, h),
+ fitBoxes(d, c, t, h),
+ fitBoxes(l, c, t, h) && fitBoxes(d, c, t, h),
+ handleMaxPadding(c),
+ placeBoxes(o.leftAndTop, c, t, h),
+ (c.x += c.w),
+ (c.y += c.h),
+ placeBoxes(o.rightAndBottom, c, t, h),
+ (i.chartArea = {
+ left: c.left,
+ top: c.top,
+ right: c.left + c.w,
+ bottom: c.top + c.h,
+ height: c.h,
+ width: c.w,
+ }),
+ each(o.chartArea, (t) => {
+ const e = t.box;
+ Object.assign(e, i.chartArea),
+ e.update(c.w, c.h, { left: 0, top: 0, right: 0, bottom: 0 });
+ });
+ }
+ },
+};
+class BasePlatform {
+ acquireContext(t, e) {}
+ releaseContext(t) {
+ return !1;
+ }
+ addEventListener(t, e, i) {}
+ removeEventListener(t, e, i) {}
+ getDevicePixelRatio() {
+ return 1;
+ }
+ getMaximumSize(t, e, i, a) {
+ return (
+ (e = Math.max(0, e || t.width)),
+ (i = i || t.height),
+ { width: e, height: Math.max(0, a ? Math.floor(e / a) : i) }
+ );
+ }
+ isAttached(t) {
+ return !0;
+ }
+ updateConfig(t) {}
+}
+class BasicPlatform extends BasePlatform {
+ acquireContext(t) {
+ return (t && t.getContext && t.getContext("2d")) || null;
+ }
+ updateConfig(t) {
+ t.options.animation = !1;
+ }
+}
+const EXPANDO_KEY = "$chartjs",
+ EVENT_TYPES = {
+ touchstart: "mousedown",
+ touchmove: "mousemove",
+ touchend: "mouseup",
+ pointerenter: "mouseenter",
+ pointerdown: "mousedown",
+ pointermove: "mousemove",
+ pointerup: "mouseup",
+ pointerleave: "mouseout",
+ pointerout: "mouseout",
+ },
+ isNullOrEmpty = (t) => null === t || "" === t;
+function initCanvas(t, e) {
+ const i = t.style;
+ var a = t.getAttribute("height"),
+ s = t.getAttribute("width");
+ return (
+ (t[EXPANDO_KEY] = {
+ initial: {
+ height: a,
+ width: s,
+ style: { display: i.display, height: i.height, width: i.width },
+ },
+ }),
+ (i.display = i.display || "block"),
+ (i.boxSizing = i.boxSizing || "border-box"),
+ isNullOrEmpty(s) &&
+ void 0 !== (s = readUsedSize(t, "width")) &&
+ (t.width = s),
+ isNullOrEmpty(a) &&
+ ("" === t.style.height
+ ? (t.height = t.width / (e || 2))
+ : void 0 !== (s = readUsedSize(t, "height")) && (t.height = s)),
+ t
+ );
+}
+const eventListenerOptions = !!supportsEventListenerOptions && { passive: !0 };
+function addListener(t, e, i) {
+ t.addEventListener(e, i, eventListenerOptions);
+}
+function removeListener(t, e, i) {
+ t.canvas.removeEventListener(e, i, eventListenerOptions);
+}
+function fromNativeEvent(t, e) {
+ var i = EVENT_TYPES[t.type] || t.type,
+ { x: a, y: s } = getRelativePosition(t, e);
+ return {
+ type: i,
+ chart: e,
+ native: t,
+ x: void 0 !== a ? a : null,
+ y: void 0 !== s ? s : null,
+ };
+}
+function nodeListContains(t, e) {
+ for (const i of t) if (i === e || i.contains(e)) return !0;
+}
+function createAttachObserver(t, e, a) {
+ const s = t.canvas,
+ i = new MutationObserver((t) => {
+ let e = !1;
+ for (const i of t)
+ e =
+ (e = e || nodeListContains(i.addedNodes, s)) &&
+ !nodeListContains(i.removedNodes, s);
+ e && a();
+ });
+ return i.observe(document, { childList: !0, subtree: !0 }), i;
+}
+function createDetachObserver(t, e, a) {
+ const s = t.canvas,
+ i = new MutationObserver((t) => {
+ let e = !1;
+ for (const i of t)
+ e =
+ (e = e || nodeListContains(i.removedNodes, s)) &&
+ !nodeListContains(i.addedNodes, s);
+ e && a();
+ });
+ return i.observe(document, { childList: !0, subtree: !0 }), i;
+}
+const drpListeningCharts = new Map();
+let oldDevicePixelRatio = 0;
+function onWindowResize() {
+ const i = window.devicePixelRatio;
+ i !== oldDevicePixelRatio &&
+ ((oldDevicePixelRatio = i),
+ drpListeningCharts.forEach((t, e) => {
+ e.currentDevicePixelRatio !== i && t();
+ }));
+}
+function listenDevicePixelRatioChanges(t, e) {
+ drpListeningCharts.size || window.addEventListener("resize", onWindowResize),
+ drpListeningCharts.set(t, e);
+}
+function unlistenDevicePixelRatioChanges(t) {
+ drpListeningCharts.delete(t),
+ drpListeningCharts.size ||
+ window.removeEventListener("resize", onWindowResize);
+}
+function createResizeObserver(t, e, a) {
+ var i = t.canvas;
+ const s = i && _getParentNode(i);
+ if (s) {
+ const n = throttled((t, e) => {
+ var i = s.clientWidth;
+ a(t, e), i < s.clientWidth && a();
+ }, window),
+ r = new ResizeObserver((t) => {
+ var t = t[0],
+ e = t.contentRect.width,
+ t = t.contentRect.height;
+ (0 === e && 0 === t) || n(e, t);
+ });
+ return r.observe(s), listenDevicePixelRatioChanges(t, n), r;
+ }
+}
+function releaseObserver(t, e, i) {
+ i && i.disconnect(), "resize" === e && unlistenDevicePixelRatioChanges(t);
+}
+function createProxyAndListen(e, t, i) {
+ var a = e.canvas,
+ s = throttled((t) => {
+ null !== e.ctx && i(fromNativeEvent(t, e));
+ }, e);
+ return addListener(a, t, s), s;
+}
+class DomPlatform extends BasePlatform {
+ acquireContext(t, e) {
+ var i = t && t.getContext && t.getContext("2d");
+ return i && i.canvas === t ? (initCanvas(t, e), i) : null;
+ }
+ releaseContext(t) {
+ const i = t.canvas;
+ if (!i[EXPANDO_KEY]) return !1;
+ const a = i[EXPANDO_KEY].initial,
+ e =
+ (["height", "width"].forEach((t) => {
+ var e = a[t];
+ isNullOrUndef(e) ? i.removeAttribute(t) : i.setAttribute(t, e);
+ }),
+ a.style || {});
+ return (
+ Object.keys(e).forEach((t) => {
+ i.style[t] = e[t];
+ }),
+ (i.width = i.width),
+ delete i[EXPANDO_KEY],
+ !0
+ );
+ }
+ addEventListener(t, e, i) {
+ this.removeEventListener(t, e);
+ const a = t.$proxies || (t.$proxies = {});
+ const s =
+ {
+ attach: createAttachObserver,
+ detach: createDetachObserver,
+ resize: createResizeObserver,
+ }[e] || createProxyAndListen;
+ a[e] = s(t, e, i);
+ }
+ removeEventListener(t, e) {
+ const i = t.$proxies || (t.$proxies = {});
+ var a = i[e];
+ if (a) {
+ const s =
+ {
+ attach: releaseObserver,
+ detach: releaseObserver,
+ resize: releaseObserver,
+ }[e] || removeListener;
+ s(t, e, a), (i[e] = void 0);
+ }
+ }
+ getDevicePixelRatio() {
+ return window.devicePixelRatio;
+ }
+ getMaximumSize(t, e, i, a) {
+ return getMaximumSize(t, e, i, a);
+ }
+ isAttached(t) {
+ t = _getParentNode(t);
+ return !(!t || !t.isConnected);
+ }
+}
+function _detectPlatform(t) {
+ return !_isDomSupported() ||
+ ("undefined" != typeof OffscreenCanvas && t instanceof OffscreenCanvas)
+ ? BasicPlatform
+ : DomPlatform;
+}
+class Element {
+ static defaults = {};
+ static defaultRoutes = void 0;
+ x;
+ y;
+ active = !1;
+ options;
+ $animations;
+ tooltipPosition(t) {
+ var { x: t, y: e } = this.getProps(["x", "y"], t);
+ return { x: t, y: e };
+ }
+ hasValue() {
+ return isNumber(this.x) && isNumber(this.y);
+ }
+ getProps(t, e) {
+ const i = this.$animations;
+ if (!e || !i) return this;
+ const a = {};
+ return (
+ t.forEach((t) => {
+ a[t] = i[t] && i[t].active() ? i[t]._to : this[t];
+ }),
+ a
+ );
+ }
+}
+function autoSkip(i, a) {
+ var s = i.options.ticks,
+ i = determineMaxTicks(i),
+ i = Math.min(s.maxTicksLimit || i, i),
+ n = s.major.enabled ? getMajorIndices(a) : [],
+ s = n.length,
+ r = n[0],
+ o = n[s - 1],
+ l = [];
+ if (i < s) return skipMajors(a, l, n, s / i), l;
+ var h = calculateSpacing(n, a, i);
+ if (0 < s) {
+ let t, e;
+ i = 1 < s ? Math.round((o - r) / (s - 1)) : null;
+ for (
+ skip(a, l, h, isNullOrUndef(i) ? 0 : r - i, r), t = 0, e = s - 1;
+ t < e;
+ t++
+ )
+ skip(a, l, h, n[t], n[t + 1]);
+ return skip(a, l, h, o, isNullOrUndef(i) ? a.length : o + i), l;
+ }
+ return skip(a, l, h), l;
+}
+function determineMaxTicks(t) {
+ var e = t.options.offset,
+ i = t._tickSize(),
+ e = t._length / i + (e ? 0 : 1),
+ t = t._maxLength / i;
+ return Math.floor(Math.min(e, t));
+}
+function calculateSpacing(t, e, i) {
+ var t = getEvenSpacing(t),
+ a = e.length / i;
+ if (!t) return Math.max(a, 1);
+ var s = _factorize(t);
+ for (let t = 0, e = s.length - 1; t < e; t++) {
+ var n = s[t];
+ if (a < n) return n;
+ }
+ return Math.max(a, 1);
+}
+function getMajorIndices(t) {
+ const e = [];
+ let i, a;
+ for (i = 0, a = t.length; i < a; i++) t[i].major && e.push(i);
+ return e;
+}
+function skipMajors(t, e, i, a) {
+ let s = 0,
+ n = i[0],
+ r;
+ for (a = Math.ceil(a), r = 0; r < t.length; r++)
+ r === n && (e.push(t[r]), s++, (n = i[s * a]));
+}
+function skip(t, e, i, a, s) {
+ var n = valueOrDefault(a, 0),
+ r = Math.min(valueOrDefault(s, t.length), t.length);
+ let o = 0,
+ l,
+ h,
+ d;
+ for (
+ i = Math.ceil(i), s && (i = (l = s - a) / Math.floor(l / i)), d = n;
+ d < 0;
+
+ )
+ o++, (d = Math.round(n + o * i));
+ for (h = Math.max(n, 0); h < r; h++)
+ h === d && (e.push(t[h]), o++, (d = Math.round(n + o * i)));
+}
+function getEvenSpacing(t) {
+ var e = t.length;
+ let i, a;
+ if (e < 2) return !1;
+ for (a = t[0], i = 1; i < e; ++i) if (t[i] - t[i - 1] !== a) return !1;
+ return a;
+}
+const reverseAlign = (t) =>
+ "left" === t ? "right" : "right" === t ? "left" : t,
+ offsetFromEdge = (t, e, i) =>
+ "top" === e || "left" === e ? t[e] + i : t[e] - i,
+ getTicksLimit = (t, e) => Math.min(e || t, t);
+function sample(t, e) {
+ const i = [];
+ var a = t.length / e,
+ s = t.length;
+ let n = 0;
+ for (; n < s; n += a) i.push(t[Math.floor(n)]);
+ return i;
+}
+function getPixelForGridLine(t, e, i) {
+ var a = t.ticks.length,
+ s = Math.min(e, a - 1),
+ n = t._startPixel,
+ r = t._endPixel;
+ let o = t.getPixelForTick(s),
+ l;
+ if (
+ !(
+ i &&
+ ((l =
+ 1 === a
+ ? Math.max(o - n, r - o)
+ : 0 === e
+ ? (t.getPixelForTick(1) - o) / 2
+ : (o - t.getPixelForTick(s - 1)) / 2),
+ (o += s < e ? l : -l) < n - 1e-6 || o > r + 1e-6)
+ )
+ )
+ return o;
+}
+function garbageCollect(t, s) {
+ each(t, (t) => {
+ const e = t.gc;
+ var i = e.length / 2;
+ let a;
+ if (s < i) {
+ for (a = 0; a < i; ++a) delete t.data[e[a]];
+ e.splice(0, i);
+ }
+ });
+}
+function getTickMarkLength(t) {
+ return t.drawTicks ? t.tickLength : 0;
+}
+function getTitleHeight(t, e) {
+ if (!t.display) return 0;
+ var e = toFont(t.font, e),
+ i = toPadding(t.padding);
+ return (isArray(t.text) ? t.text.length : 1) * e.lineHeight + i.height;
+}
+function createScaleContext(t, e) {
+ return createContext(t, { scale: e, type: "scale" });
+}
+function createTickContext(t, e, i) {
+ return createContext(t, { tick: i, index: e, type: "tick" });
+}
+function titleAlign(t, e, i) {
+ let a = _toLeftRightCenter(t);
+ return (a =
+ (i && "right" !== e) || (!i && "right" === e) ? reverseAlign(a) : a);
+}
+function titleArgs(t, e, i, a) {
+ var { top: s, left: n, bottom: r, right: o, chart: l } = t;
+ const { chartArea: h, scales: d } = l;
+ let c = 0,
+ u,
+ g,
+ p;
+ var f,
+ m,
+ l = r - s,
+ v = o - n;
+ return (
+ t.isHorizontal()
+ ? ((g = _alignStartEnd(a, n, o)),
+ (p = isObject(i)
+ ? ((m = i[(f = Object.keys(i)[0])]), d[f].getPixelForValue(m) + l - e)
+ : "center" === i
+ ? (h.bottom + h.top) / 2 + l - e
+ : offsetFromEdge(t, i, e)),
+ (u = o - n))
+ : ((g = isObject(i)
+ ? ((m = i[(f = Object.keys(i)[0])]), d[f].getPixelForValue(m) - v + e)
+ : "center" === i
+ ? (h.left + h.right) / 2 - v + e
+ : offsetFromEdge(t, i, e)),
+ (p = _alignStartEnd(a, r, s)),
+ (c = "left" === i ? -HALF_PI : HALF_PI)),
+ { titleX: g, titleY: p, maxWidth: u, rotation: c }
+ );
+}
+class Scale extends Element {
+ constructor(t) {
+ super(),
+ (this.id = t.id),
+ (this.type = t.type),
+ (this.options = void 0),
+ (this.ctx = t.ctx),
+ (this.chart = t.chart),
+ (this.top = void 0),
+ (this.bottom = void 0),
+ (this.left = void 0),
+ (this.right = void 0),
+ (this.width = void 0),
+ (this.height = void 0),
+ (this._margins = { left: 0, right: 0, top: 0, bottom: 0 }),
+ (this.maxWidth = void 0),
+ (this.maxHeight = void 0),
+ (this.paddingTop = void 0),
+ (this.paddingBottom = void 0),
+ (this.paddingLeft = void 0),
+ (this.paddingRight = void 0),
+ (this.axis = void 0),
+ (this.labelRotation = void 0),
+ (this.min = void 0),
+ (this.max = void 0),
+ (this._range = void 0),
+ (this.ticks = []),
+ (this._gridLineItems = null),
+ (this._labelItems = null),
+ (this._labelSizes = null),
+ (this._length = 0),
+ (this._maxLength = 0),
+ (this._longestTextCache = {}),
+ (this._startPixel = void 0),
+ (this._endPixel = void 0),
+ (this._reversePixels = !1),
+ (this._userMax = void 0),
+ (this._userMin = void 0),
+ (this._suggestedMax = void 0),
+ (this._suggestedMin = void 0),
+ (this._ticksLength = 0),
+ (this._borderValue = 0),
+ (this._cache = {}),
+ (this._dataLimitsCached = !1),
+ (this.$context = void 0);
+ }
+ init(t) {
+ (this.options = t.setContext(this.getContext())),
+ (this.axis = t.axis),
+ (this._userMin = this.parse(t.min)),
+ (this._userMax = this.parse(t.max)),
+ (this._suggestedMin = this.parse(t.suggestedMin)),
+ (this._suggestedMax = this.parse(t.suggestedMax));
+ }
+ parse(t, e) {
+ return t;
+ }
+ getUserBounds() {
+ var { _userMin: t, _userMax: e, _suggestedMin: i, _suggestedMax: a } = this,
+ t = finiteOrDefault(t, Number.POSITIVE_INFINITY),
+ e = finiteOrDefault(e, Number.NEGATIVE_INFINITY),
+ i = finiteOrDefault(i, Number.POSITIVE_INFINITY),
+ a = finiteOrDefault(a, Number.NEGATIVE_INFINITY);
+ return {
+ min: finiteOrDefault(t, i),
+ max: finiteOrDefault(e, a),
+ minDefined: isNumberFinite(t),
+ maxDefined: isNumberFinite(e),
+ };
+ }
+ getMinMax(i) {
+ let { min: a, max: s, minDefined: n, maxDefined: r } = this.getUserBounds();
+ var o;
+ if (n && r) return { min: a, max: s };
+ const l = this.getMatchingVisibleMetas();
+ for (let t = 0, e = l.length; t < e; ++t)
+ (o = l[t].controller.getMinMax(this, i)),
+ n || (a = Math.min(a, o.min)),
+ r || (s = Math.max(s, o.max));
+ return (
+ (a = r && a > s ? s : a),
+ (s = n && a > s ? a : s),
+ {
+ min: finiteOrDefault(a, finiteOrDefault(s, a)),
+ max: finiteOrDefault(s, finiteOrDefault(a, s)),
+ }
+ );
+ }
+ getPadding() {
+ return {
+ left: this.paddingLeft || 0,
+ top: this.paddingTop || 0,
+ right: this.paddingRight || 0,
+ bottom: this.paddingBottom || 0,
+ };
+ }
+ getTicks() {
+ return this.ticks;
+ }
+ getLabels() {
+ var t = this.chart.data;
+ return (
+ this.options.labels ||
+ (this.isHorizontal() ? t.xLabels : t.yLabels) ||
+ t.labels ||
+ []
+ );
+ }
+ getLabelItems(t = this.chart.chartArea) {
+ return this._labelItems || (this._labelItems = this._computeLabelItems(t));
+ }
+ beforeLayout() {
+ (this._cache = {}), (this._dataLimitsCached = !1);
+ }
+ beforeUpdate() {
+ callback(this.options.beforeUpdate, [this]);
+ }
+ update(t, e, i) {
+ var { beginAtZero: a, grace: s, ticks: n } = this.options,
+ r = n.sampleSize,
+ t =
+ (this.beforeUpdate(),
+ (this.maxWidth = t),
+ (this.maxHeight = e),
+ (this._margins = i =
+ Object.assign({ left: 0, right: 0, top: 0, bottom: 0 }, i)),
+ (this.ticks = null),
+ (this._labelSizes = null),
+ (this._gridLineItems = null),
+ (this._labelItems = null),
+ this.beforeSetDimensions(),
+ this.setDimensions(),
+ this.afterSetDimensions(),
+ (this._maxLength = this.isHorizontal()
+ ? this.width + i.left + i.right
+ : this.height + i.top + i.bottom),
+ this._dataLimitsCached ||
+ (this.beforeDataLimits(),
+ this.determineDataLimits(),
+ this.afterDataLimits(),
+ (this._range = _addGrace(this, s, a)),
+ (this._dataLimitsCached = !0)),
+ this.beforeBuildTicks(),
+ (this.ticks = this.buildTicks() || []),
+ this.afterBuildTicks(),
+ r < this.ticks.length);
+ this._convertTicksToLabels(t ? sample(this.ticks, r) : this.ticks),
+ this.configure(),
+ this.beforeCalculateLabelRotation(),
+ this.calculateLabelRotation(),
+ this.afterCalculateLabelRotation(),
+ n.display &&
+ (n.autoSkip || "auto" === n.source) &&
+ ((this.ticks = autoSkip(this, this.ticks)),
+ (this._labelSizes = null),
+ this.afterAutoSkip()),
+ t && this._convertTicksToLabels(this.ticks),
+ this.beforeFit(),
+ this.fit(),
+ this.afterFit(),
+ this.afterUpdate();
+ }
+ configure() {
+ let t = this.options.reverse,
+ e,
+ i;
+ this.isHorizontal()
+ ? ((e = this.left), (i = this.right))
+ : ((e = this.top), (i = this.bottom), (t = !t)),
+ (this._startPixel = e),
+ (this._endPixel = i),
+ (this._reversePixels = t),
+ (this._length = i - e),
+ (this._alignToPixels = this.options.alignToPixels);
+ }
+ afterUpdate() {
+ callback(this.options.afterUpdate, [this]);
+ }
+ beforeSetDimensions() {
+ callback(this.options.beforeSetDimensions, [this]);
+ }
+ setDimensions() {
+ this.isHorizontal()
+ ? ((this.width = this.maxWidth),
+ (this.left = 0),
+ (this.right = this.width))
+ : ((this.height = this.maxHeight),
+ (this.top = 0),
+ (this.bottom = this.height)),
+ (this.paddingLeft = 0),
+ (this.paddingTop = 0),
+ (this.paddingRight = 0),
+ (this.paddingBottom = 0);
+ }
+ afterSetDimensions() {
+ callback(this.options.afterSetDimensions, [this]);
+ }
+ _callHooks(t) {
+ this.chart.notifyPlugins(t, this.getContext()),
+ callback(this.options[t], [this]);
+ }
+ beforeDataLimits() {
+ this._callHooks("beforeDataLimits");
+ }
+ determineDataLimits() {}
+ afterDataLimits() {
+ this._callHooks("afterDataLimits");
+ }
+ beforeBuildTicks() {
+ this._callHooks("beforeBuildTicks");
+ }
+ buildTicks() {
+ return [];
+ }
+ afterBuildTicks() {
+ this._callHooks("afterBuildTicks");
+ }
+ beforeTickToLabelConversion() {
+ callback(this.options.beforeTickToLabelConversion, [this]);
+ }
+ generateTickLabels(t) {
+ var e = this.options.ticks;
+ let i, a, s;
+ for (i = 0, a = t.length; i < a; i++)
+ (s = t[i]).label = callback(e.callback, [s.value, i, t], this);
+ }
+ afterTickToLabelConversion() {
+ callback(this.options.afterTickToLabelConversion, [this]);
+ }
+ beforeCalculateLabelRotation() {
+ callback(this.options.beforeCalculateLabelRotation, [this]);
+ }
+ calculateLabelRotation() {
+ var t,
+ e,
+ i,
+ a,
+ s = this.options,
+ n = s.ticks,
+ r = getTicksLimit(this.ticks.length, s.ticks.maxTicksLimit),
+ o = n.minRotation || 0,
+ l = n.maxRotation;
+ let h = o;
+ !this._isVisible() || !n.display || l <= o || r <= 1 || !this.isHorizontal()
+ ? (this.labelRotation = o)
+ : ((e = (t = this._getLabelSizes()).widest.width),
+ (i = t.highest.height),
+ (a = _limitValue(this.chart.width - e, 0, this.maxWidth)),
+ (s.offset ? this.maxWidth / r : a / (r - 1)) < e + 6 &&
+ ((a = a / (r - (s.offset ? 0.5 : 1))),
+ (r =
+ this.maxHeight -
+ getTickMarkLength(s.grid) -
+ n.padding -
+ getTitleHeight(s.title, this.chart.options.font)),
+ (n = Math.sqrt(e * e + i * i)),
+ (h = toDegrees(
+ Math.min(
+ Math.asin(_limitValue((t.highest.height + 6) / a, -1, 1)),
+ Math.asin(_limitValue(r / n, -1, 1)) -
+ Math.asin(_limitValue(i / n, -1, 1))
+ )
+ )),
+ (h = Math.max(o, Math.min(l, h)))),
+ (this.labelRotation = h));
+ }
+ afterCalculateLabelRotation() {
+ callback(this.options.afterCalculateLabelRotation, [this]);
+ }
+ afterAutoSkip() {}
+ beforeFit() {
+ callback(this.options.beforeFit, [this]);
+ }
+ fit() {
+ const t = { width: 0, height: 0 };
+ var e,
+ i,
+ a,
+ s,
+ n,
+ {
+ chart: r,
+ options: { ticks: o, title: l, grid: h },
+ } = this,
+ d = this._isVisible(),
+ c = this.isHorizontal();
+ d &&
+ ((d = getTitleHeight(l, r.options.font)),
+ c
+ ? ((t.width = this.maxWidth), (t.height = getTickMarkLength(h) + d))
+ : ((t.height = this.maxHeight), (t.width = getTickMarkLength(h) + d)),
+ o.display &&
+ this.ticks.length &&
+ (({ first: l, last: h, widest: d, highest: e } = this._getLabelSizes()),
+ (i = 2 * o.padding),
+ (s = toRadians(this.labelRotation)),
+ (a = Math.cos(s)),
+ (s = Math.sin(s)),
+ c
+ ? ((n = o.mirror ? 0 : s * d.width + a * e.height),
+ (t.height = Math.min(this.maxHeight, t.height + n + i)))
+ : ((n = o.mirror ? 0 : a * d.width + s * e.height),
+ (t.width = Math.min(this.maxWidth, t.width + n + i))),
+ this._calculatePadding(l, h, s, a))),
+ this._handleMargins(),
+ c
+ ? ((this.width = this._length =
+ r.width - this._margins.left - this._margins.right),
+ (this.height = t.height))
+ : ((this.width = t.width),
+ (this.height = this._length =
+ r.height - this._margins.top - this._margins.bottom));
+ }
+ _calculatePadding(i, a, s, n) {
+ var {
+ ticks: { align: r, padding: o },
+ position: l,
+ } = this.options,
+ h = 0 !== this.labelRotation,
+ l = "top" !== l && "x" === this.axis;
+ if (this.isHorizontal()) {
+ var d = this.getPixelForTick(0) - this.left,
+ c = this.right - this.getPixelForTick(this.ticks.length - 1);
+ let t = 0,
+ e = 0;
+ h
+ ? (e = l
+ ? ((t = n * i.width), s * a.height)
+ : ((t = s * i.height), n * a.width))
+ : "start" === r
+ ? (e = a.width)
+ : "end" === r
+ ? (t = i.width)
+ : "inner" !== r && ((t = i.width / 2), (e = a.width / 2)),
+ (this.paddingLeft = Math.max(
+ ((t - d + o) * this.width) / (this.width - d),
+ 0
+ )),
+ (this.paddingRight = Math.max(
+ ((e - c + o) * this.width) / (this.width - c),
+ 0
+ ));
+ } else {
+ let t = a.height / 2,
+ e = i.height / 2;
+ "start" === r
+ ? ((t = 0), (e = i.height))
+ : "end" === r && ((t = a.height), (e = 0)),
+ (this.paddingTop = t + o),
+ (this.paddingBottom = e + o);
+ }
+ }
+ _handleMargins() {
+ this._margins &&
+ ((this._margins.left = Math.max(this.paddingLeft, this._margins.left)),
+ (this._margins.top = Math.max(this.paddingTop, this._margins.top)),
+ (this._margins.right = Math.max(this.paddingRight, this._margins.right)),
+ (this._margins.bottom = Math.max(
+ this.paddingBottom,
+ this._margins.bottom
+ )));
+ }
+ afterFit() {
+ callback(this.options.afterFit, [this]);
+ }
+ isHorizontal() {
+ var { axis: t, position: e } = this.options;
+ return "top" === e || "bottom" === e || "x" === t;
+ }
+ isFullSize() {
+ return this.options.fullSize;
+ }
+ _convertTicksToLabels(t) {
+ this.beforeTickToLabelConversion(), this.generateTickLabels(t);
+ let e, i;
+ for (e = 0, i = t.length; e < i; e++)
+ isNullOrUndef(t[e].label) && (t.splice(e, 1), i--, e--);
+ this.afterTickToLabelConversion();
+ }
+ _getLabelSizes() {
+ let e = this._labelSizes;
+ if (!e) {
+ var i = this.options.ticks.sampleSize;
+ let t = this.ticks;
+ i < t.length && (t = sample(t, i)),
+ (this._labelSizes = e =
+ this._computeLabelSizes(
+ t,
+ t.length,
+ this.options.ticks.maxTicksLimit
+ ));
+ }
+ return e;
+ }
+ _computeLabelSizes(t, e, i) {
+ const { ctx: a, _longestTextCache: s } = this,
+ n = [],
+ r = [];
+ var o = Math.floor(e / getTicksLimit(e, i));
+ let l = 0,
+ h = 0,
+ d,
+ c,
+ u,
+ g,
+ p,
+ f,
+ m,
+ v,
+ x,
+ b,
+ _;
+ for (d = 0; d < e; d += o) {
+ if (
+ ((g = t[d].label),
+ (p = this._resolveTickFontOptions(d)),
+ (a.font = f = p.string),
+ (m = s[f] = s[f] || { data: {}, gc: [] }),
+ (v = p.lineHeight),
+ (x = b = 0),
+ isNullOrUndef(g) || isArray(g))
+ ) {
+ if (isArray(g))
+ for (c = 0, u = g.length; c < u; ++c)
+ (_ = g[c]),
+ isNullOrUndef(_) ||
+ isArray(_) ||
+ ((x = _measureText(a, m.data, m.gc, x, _)), (b += v));
+ } else (x = _measureText(a, m.data, m.gc, x, g)), (b = v);
+ n.push(x), r.push(b), (l = Math.max(x, l)), (h = Math.max(b, h));
+ }
+ garbageCollect(s, e);
+ var i = n.indexOf(l),
+ y = r.indexOf(h),
+ k = (t) => ({ width: n[t] || 0, height: r[t] || 0 });
+ return {
+ first: k(0),
+ last: k(e - 1),
+ widest: k(i),
+ highest: k(y),
+ widths: n,
+ heights: r,
+ };
+ }
+ getLabelForValue(t) {
+ return t;
+ }
+ getPixelForValue(t, e) {
+ return NaN;
+ }
+ getValueForPixel(t) {}
+ getPixelForTick(t) {
+ var e = this.ticks;
+ return t < 0 || t > e.length - 1 ? null : this.getPixelForValue(e[t].value);
+ }
+ getPixelForDecimal(t) {
+ this._reversePixels && (t = 1 - t);
+ t = this._startPixel + t * this._length;
+ return _int16Range(this._alignToPixels ? _alignPixel(this.chart, t, 0) : t);
+ }
+ getDecimalForPixel(t) {
+ t = (t - this._startPixel) / this._length;
+ return this._reversePixels ? 1 - t : t;
+ }
+ getBasePixel() {
+ return this.getPixelForValue(this.getBaseValue());
+ }
+ getBaseValue() {
+ var { min: t, max: e } = this;
+ return t < 0 && e < 0 ? e : 0 < t && 0 < e ? t : 0;
+ }
+ getContext(t) {
+ var e = this.ticks || [];
+ if (0 <= t && t < e.length) {
+ const i = e[t];
+ return (
+ i.$context || (i.$context = createTickContext(this.getContext(), t, i))
+ );
+ }
+ return (
+ this.$context ||
+ (this.$context = createScaleContext(this.chart.getContext(), this))
+ );
+ }
+ _tickSize() {
+ var t = this.options.ticks,
+ e = toRadians(this.labelRotation),
+ i = Math.abs(Math.cos(e)),
+ e = Math.abs(Math.sin(e)),
+ a = this._getLabelSizes(),
+ t = t.autoSkipPadding || 0,
+ s = a ? a.widest.width + t : 0,
+ a = a ? a.highest.height + t : 0;
+ return this.isHorizontal()
+ ? s * e < a * i
+ ? s / i
+ : a / e
+ : a * e < s * i
+ ? a / i
+ : s / e;
+ }
+ _isVisible() {
+ var t = this.options.display;
+ return "auto" !== t ? !!t : 0 < this.getMatchingVisibleMetas().length;
+ }
+ _computeGridLineItems(t) {
+ var e = this.axis;
+ const i = this.chart;
+ var a = this.options;
+ const { grid: s, position: n, border: r } = a;
+ var o = s.offset,
+ l = this.isHorizontal(),
+ h = this.ticks.length + (o ? 1 : 0),
+ d = getTickMarkLength(s);
+ const c = [];
+ var u = r.setContext(this.getContext());
+ const g = u.display ? u.width : 0;
+ function p(t) {
+ return _alignPixel(i, t, g);
+ }
+ var f,
+ m,
+ u = g / 2;
+ let v, x, b, _, y, k, S, D, M, P, A, w;
+ "top" === n
+ ? ((v = p(this.bottom)),
+ (k = this.bottom - d),
+ (D = v - u),
+ (P = p(t.top) + u),
+ (w = t.bottom))
+ : "bottom" === n
+ ? ((v = p(this.top)),
+ (P = t.top),
+ (w = p(t.bottom) - u),
+ (k = v + u),
+ (D = this.top + d))
+ : "left" === n
+ ? ((v = p(this.right)),
+ (y = this.right - d),
+ (S = v - u),
+ (M = p(t.left) + u),
+ (A = t.right))
+ : "right" === n
+ ? ((v = p(this.left)),
+ (M = t.left),
+ (A = p(t.right) - u),
+ (y = v + u),
+ (S = this.left + d))
+ : "x" === e
+ ? ("center" === n
+ ? (v = p((t.top + t.bottom) / 2 + 0.5))
+ : isObject(n) &&
+ ((m = n[(f = Object.keys(n)[0])]),
+ (v = p(this.chart.scales[f].getPixelForValue(m)))),
+ (P = t.top),
+ (w = t.bottom),
+ (k = v + u),
+ (D = k + d))
+ : "y" === e &&
+ ("center" === n
+ ? (v = p((t.left + t.right) / 2))
+ : isObject(n) &&
+ ((m = n[(f = Object.keys(n)[0])]),
+ (v = p(this.chart.scales[f].getPixelForValue(m)))),
+ (y = v - u),
+ (S = y - d),
+ (M = t.left),
+ (A = t.right));
+ var e = valueOrDefault(a.ticks.maxTicksLimit, h),
+ C = Math.max(1, Math.ceil(h / e));
+ for (x = 0; x < h; x += C) {
+ var O = this.getContext(x),
+ L = s.setContext(O),
+ O = r.setContext(O),
+ T = L.lineWidth,
+ E = L.color,
+ I = O.dash || [],
+ O = O.dashOffset,
+ R = L.tickWidth,
+ F = L.tickColor,
+ B = L.tickBorderDash || [],
+ L = L.tickBorderDashOffset;
+ void 0 !== (b = getPixelForGridLine(this, x, o)) &&
+ ((_ = _alignPixel(i, b, T)),
+ l ? (y = S = M = A = _) : (k = D = P = w = _),
+ c.push({
+ tx1: y,
+ ty1: k,
+ tx2: S,
+ ty2: D,
+ x1: M,
+ y1: P,
+ x2: A,
+ y2: w,
+ width: T,
+ color: E,
+ borderDash: I,
+ borderDashOffset: O,
+ tickWidth: R,
+ tickColor: F,
+ tickBorderDash: B,
+ tickBorderDashOffset: L,
+ }));
+ }
+ return (this._ticksLength = h), (this._borderValue = v), c;
+ }
+ _computeLabelItems(t) {
+ var e = this.axis,
+ i = this.options;
+ const { position: a, ticks: s } = i;
+ var n,
+ r = this.isHorizontal(),
+ o = this.ticks,
+ { align: l, crossAlign: h, padding: d, mirror: c } = s,
+ i = getTickMarkLength(i.grid),
+ u = i + d,
+ d = c ? -d : u,
+ g = -toRadians(this.labelRotation);
+ const p = [];
+ let f,
+ m,
+ v,
+ x,
+ b,
+ _,
+ y,
+ k,
+ S,
+ D,
+ M,
+ P = "middle";
+ "top" === a
+ ? ((b = this.bottom - d), (_ = this._getXAxisLabelAlignment()))
+ : "bottom" === a
+ ? ((b = this.top + d), (_ = this._getXAxisLabelAlignment()))
+ : "left" === a
+ ? ((d = this._getYAxisLabelAlignment(i)), (_ = d.textAlign), (x = d.x))
+ : "right" === a
+ ? ((d = this._getYAxisLabelAlignment(i)), (_ = d.textAlign), (x = d.x))
+ : "x" === e
+ ? ("center" === a
+ ? (b = (t.top + t.bottom) / 2 + u)
+ : isObject(a) &&
+ ((n = a[(d = Object.keys(a)[0])]),
+ (b = this.chart.scales[d].getPixelForValue(n) + u)),
+ (_ = this._getXAxisLabelAlignment()))
+ : "y" === e &&
+ ("center" === a
+ ? (x = (t.left + t.right) / 2 - u)
+ : isObject(a) &&
+ ((n = a[(d = Object.keys(a)[0])]),
+ (x = this.chart.scales[d].getPixelForValue(n))),
+ (_ = this._getYAxisLabelAlignment(i).textAlign)),
+ "y" === e &&
+ ("start" === l ? (P = "top") : "end" === l && (P = "bottom"));
+ var A = this._getLabelSizes();
+ for (f = 0, m = o.length; f < m; ++f) {
+ v = o[f].label;
+ var w = s.setContext(this.getContext(f)),
+ C =
+ ((y = this.getPixelForTick(f) + s.labelOffset),
+ (S = (k = this._resolveTickFontOptions(f)).lineHeight),
+ (D = isArray(v) ? v.length : 1) / 2),
+ O = w.color,
+ L = w.textStrokeColor,
+ T = w.textStrokeWidth;
+ let t = _;
+ r
+ ? ((x = y),
+ "inner" === _ &&
+ (t =
+ f === m - 1
+ ? this.options.reverse
+ ? "left"
+ : "right"
+ : 0 === f
+ ? this.options.reverse
+ ? "right"
+ : "left"
+ : "center"),
+ (M =
+ "top" === a
+ ? "near" === h || 0 != g
+ ? -D * S + S / 2
+ : "center" === h
+ ? -A.highest.height / 2 - C * S + S
+ : -A.highest.height + S / 2
+ : "near" === h || 0 != g
+ ? S / 2
+ : "center" === h
+ ? A.highest.height / 2 - C * S
+ : A.highest.height - D * S),
+ c && (M *= -1),
+ 0 == g || w.showLabelBackdrop || (x += (S / 2) * Math.sin(g)))
+ : ((b = y), (M = ((1 - D) * S) / 2));
+ let i;
+ if (w.showLabelBackdrop) {
+ var C = toPadding(w.backdropPadding),
+ E = A.heights[f],
+ I = A.widths[f];
+ let t = M - C.top,
+ e = 0 - C.left;
+ switch (P) {
+ case "middle":
+ t -= E / 2;
+ break;
+ case "bottom":
+ t -= E;
+ }
+ switch (_) {
+ case "center":
+ e -= I / 2;
+ break;
+ case "right":
+ e -= I;
+ break;
+ case "inner":
+ f === m - 1 ? (e -= I) : 0 < f && (e -= I / 2);
+ }
+ i = {
+ left: e,
+ top: t,
+ width: I + C.width,
+ height: E + C.height,
+ color: w.backdropColor,
+ };
+ }
+ p.push({
+ label: v,
+ font: k,
+ textOffset: M,
+ options: {
+ rotation: g,
+ color: O,
+ strokeColor: L,
+ strokeWidth: T,
+ textAlign: t,
+ textBaseline: P,
+ translation: [x, b],
+ backdrop: i,
+ },
+ });
+ }
+ return p;
+ }
+ _getXAxisLabelAlignment() {
+ var { position: t, ticks: e } = this.options;
+ if (-toRadians(this.labelRotation)) return "top" === t ? "left" : "right";
+ let i = "center";
+ return (
+ "start" === e.align
+ ? (i = "left")
+ : "end" === e.align
+ ? (i = "right")
+ : "inner" === e.align && (i = "inner"),
+ i
+ );
+ }
+ _getYAxisLabelAlignment(t) {
+ var {
+ position: e,
+ ticks: { crossAlign: i, mirror: a, padding: s },
+ } = this.options,
+ t = t + s,
+ n = this._getLabelSizes().widest.width;
+ let r, o;
+ return (
+ "left" === e
+ ? a
+ ? ((o = this.right + s),
+ "near" === i
+ ? (r = "left")
+ : "center" === i
+ ? ((r = "center"), (o += n / 2))
+ : ((r = "right"), (o += n)))
+ : ((o = this.right - t),
+ "near" === i
+ ? (r = "right")
+ : "center" === i
+ ? ((r = "center"), (o -= n / 2))
+ : ((r = "left"), (o = this.left)))
+ : "right" === e
+ ? a
+ ? ((o = this.left + s),
+ "near" === i
+ ? (r = "right")
+ : "center" === i
+ ? ((r = "center"), (o -= n / 2))
+ : ((r = "left"), (o -= n)))
+ : ((o = this.left + t),
+ "near" === i
+ ? (r = "left")
+ : "center" === i
+ ? ((r = "center"), (o += n / 2))
+ : ((r = "right"), (o = this.right)))
+ : (r = "right"),
+ { textAlign: r, x: o }
+ );
+ }
+ _computeLabelArea() {
+ var t, e;
+ if (!this.options.ticks.mirror)
+ return (
+ (t = this.chart),
+ (e = this.options.position),
+ "left" === e || "right" === e
+ ? { top: 0, left: this.left, bottom: t.height, right: this.right }
+ : "top" === e || "bottom" === e
+ ? { top: this.top, left: 0, bottom: this.bottom, right: t.width }
+ : void 0
+ );
+ }
+ drawBackground() {
+ const {
+ ctx: t,
+ options: { backgroundColor: e },
+ left: i,
+ top: a,
+ width: s,
+ height: n,
+ } = this;
+ e && (t.save(), (t.fillStyle = e), t.fillRect(i, a, s, n), t.restore());
+ }
+ getLineWidthForValue(e) {
+ const t = this.options.grid;
+ if (!this._isVisible() || !t.display) return 0;
+ const i = this.ticks;
+ var a = i.findIndex((t) => t.value === e);
+ return 0 <= a ? t.setContext(this.getContext(a)).lineWidth : 0;
+ }
+ drawGrid(t) {
+ var e = this.options.grid;
+ const a = this.ctx;
+ var i =
+ this._gridLineItems ||
+ (this._gridLineItems = this._computeGridLineItems(t));
+ let s, n;
+ var r = (t, e, i) => {
+ i.width &&
+ i.color &&
+ (a.save(),
+ (a.lineWidth = i.width),
+ (a.strokeStyle = i.color),
+ a.setLineDash(i.borderDash || []),
+ (a.lineDashOffset = i.borderDashOffset),
+ a.beginPath(),
+ a.moveTo(t.x, t.y),
+ a.lineTo(e.x, e.y),
+ a.stroke(),
+ a.restore());
+ };
+ if (e.display)
+ for (s = 0, n = i.length; s < n; ++s) {
+ var o = i[s];
+ e.drawOnChartArea && r({ x: o.x1, y: o.y1 }, { x: o.x2, y: o.y2 }, o),
+ e.drawTicks &&
+ r(
+ { x: o.tx1, y: o.ty1 },
+ { x: o.tx2, y: o.ty2 },
+ {
+ color: o.tickColor,
+ width: o.tickWidth,
+ borderDash: o.tickBorderDash,
+ borderDashOffset: o.tickBorderDashOffset,
+ }
+ );
+ }
+ }
+ drawBorder() {
+ const {
+ chart: s,
+ ctx: n,
+ options: { border: t, grid: r },
+ } = this;
+ var o = t.setContext(this.getContext()),
+ l = t.display ? o.width : 0;
+ if (l) {
+ var h = r.setContext(this.getContext(0)).lineWidth,
+ d = this._borderValue;
+ let t, e, i, a;
+ this.isHorizontal()
+ ? ((t = _alignPixel(s, this.left, l) - l / 2),
+ (e = _alignPixel(s, this.right, h) + h / 2),
+ (i = a = d))
+ : ((i = _alignPixel(s, this.top, l) - l / 2),
+ (a = _alignPixel(s, this.bottom, h) + h / 2),
+ (t = e = d)),
+ n.save(),
+ (n.lineWidth = o.width),
+ (n.strokeStyle = o.color),
+ n.beginPath(),
+ n.moveTo(t, i),
+ n.lineTo(e, a),
+ n.stroke(),
+ n.restore();
+ }
+ }
+ drawLabels(t) {
+ if (this.options.ticks.display) {
+ var e = this.ctx,
+ i = this._computeLabelArea(),
+ t = (i && clipArea(e, i), this.getLabelItems(t));
+ for (const o of t) {
+ var a = o.options,
+ s = o.font,
+ n = o.label,
+ r = o.textOffset;
+ renderText(e, n, 0, r, s, a);
+ }
+ i && unclipArea(e);
+ }
+ }
+ drawTitle() {
+ var {
+ ctx: e,
+ options: { position: i, title: a, reverse: s },
+ } = this;
+ if (a.display) {
+ var n = toFont(a.font),
+ r = toPadding(a.padding),
+ o = a.align;
+ let t = n.lineHeight / 2;
+ "bottom" === i || "center" === i || isObject(i)
+ ? ((t += r.bottom),
+ isArray(a.text) && (t += n.lineHeight * (a.text.length - 1)))
+ : (t += r.top);
+ var {
+ titleX: r,
+ titleY: l,
+ maxWidth: h,
+ rotation: d,
+ } = titleArgs(this, t, i, o);
+ renderText(e, a.text, 0, 0, n, {
+ color: a.color,
+ maxWidth: h,
+ rotation: d,
+ textAlign: titleAlign(o, i, s),
+ textBaseline: "middle",
+ translation: [r, l],
+ });
+ }
+ }
+ draw(t) {
+ this._isVisible() &&
+ (this.drawBackground(),
+ this.drawGrid(t),
+ this.drawBorder(),
+ this.drawTitle(),
+ this.drawLabels(t));
+ }
+ _layers() {
+ var t = this.options,
+ e = (t.ticks && t.ticks.z) || 0,
+ i = valueOrDefault(t.grid && t.grid.z, -1),
+ t = valueOrDefault(t.border && t.border.z, 0);
+ return this._isVisible() && this.draw === Scale.prototype.draw
+ ? [
+ {
+ z: i,
+ draw: (t) => {
+ this.drawBackground(), this.drawGrid(t), this.drawTitle();
+ },
+ },
+ {
+ z: t,
+ draw: () => {
+ this.drawBorder();
+ },
+ },
+ {
+ z: e,
+ draw: (t) => {
+ this.drawLabels(t);
+ },
+ },
+ ]
+ : [
+ {
+ z: e,
+ draw: (t) => {
+ this.draw(t);
+ },
+ },
+ ];
+ }
+ getMatchingVisibleMetas(t) {
+ var e = this.chart.getSortedVisibleDatasetMetas(),
+ i = this.axis + "AxisID";
+ const a = [];
+ let s, n;
+ for (s = 0, n = e.length; s < n; ++s) {
+ var r = e[s];
+ r[i] !== this.id || (t && r.type !== t) || a.push(r);
+ }
+ return a;
+ }
+ _resolveTickFontOptions(t) {
+ t = this.options.ticks.setContext(this.getContext(t));
+ return toFont(t.font);
+ }
+ _maxDigits() {
+ var t = this._resolveTickFontOptions(0).lineHeight;
+ return (this.isHorizontal() ? this.width : this.height) / t;
+ }
+}
+class TypedRegistry {
+ constructor(t, e, i) {
+ (this.type = t),
+ (this.scope = e),
+ (this.override = i),
+ (this.items = Object.create(null));
+ }
+ isForType(t) {
+ return Object.prototype.isPrototypeOf.call(
+ this.type.prototype,
+ t.prototype
+ );
+ }
+ register(t) {
+ var e = Object.getPrototypeOf(t);
+ let i;
+ isIChartComponent(e) && (i = this.register(e));
+ const a = this.items;
+ var e = t.id,
+ s = this.scope + "." + e;
+ if (e)
+ return (
+ e in a ||
+ (registerDefaults((a[e] = t), s, i),
+ this.override && defaults.override(t.id, t.overrides)),
+ s
+ );
+ throw new Error("class does not have id: " + t);
+ }
+ get(t) {
+ return this.items[t];
+ }
+ unregister(t) {
+ const e = this.items;
+ var t = t.id,
+ i = this.scope;
+ t in e && delete e[t],
+ i &&
+ t in defaults[i] &&
+ (delete defaults[i][t], this.override && delete overrides[t]);
+ }
+}
+function registerDefaults(t, e, i) {
+ i = merge(Object.create(null), [
+ i ? defaults.get(i) : {},
+ defaults.get(e),
+ t.defaults,
+ ]);
+ defaults.set(e, i),
+ t.defaultRoutes && routeDefaults(e, t.defaultRoutes),
+ t.descriptors && defaults.describe(e, t.descriptors);
+}
+function routeDefaults(r, o) {
+ Object.keys(o).forEach((t) => {
+ const e = t.split(".");
+ var i = e.pop(),
+ a = [r].concat(e).join(".");
+ const s = o[t].split(".");
+ var t = s.pop(),
+ n = s.join(".");
+ defaults.route(a, i, n, t);
+ });
+}
+function isIChartComponent(t) {
+ return "id" in t && "defaults" in t;
+}
+class Registry {
+ constructor() {
+ (this.controllers = new TypedRegistry(DatasetController, "datasets", !0)),
+ (this.elements = new TypedRegistry(Element, "elements")),
+ (this.plugins = new TypedRegistry(Object, "plugins")),
+ (this.scales = new TypedRegistry(Scale, "scales")),
+ (this._typedRegistries = [this.controllers, this.scales, this.elements]);
+ }
+ add(...t) {
+ this._each("register", t);
+ }
+ remove(...t) {
+ this._each("unregister", t);
+ }
+ addControllers(...t) {
+ this._each("register", t, this.controllers);
+ }
+ addElements(...t) {
+ this._each("register", t, this.elements);
+ }
+ addPlugins(...t) {
+ this._each("register", t, this.plugins);
+ }
+ addScales(...t) {
+ this._each("register", t, this.scales);
+ }
+ getController(t) {
+ return this._get(t, this.controllers, "controller");
+ }
+ getElement(t) {
+ return this._get(t, this.elements, "element");
+ }
+ getPlugin(t) {
+ return this._get(t, this.plugins, "plugin");
+ }
+ getScale(t) {
+ return this._get(t, this.scales, "scale");
+ }
+ removeControllers(...t) {
+ this._each("unregister", t, this.controllers);
+ }
+ removeElements(...t) {
+ this._each("unregister", t, this.elements);
+ }
+ removePlugins(...t) {
+ this._each("unregister", t, this.plugins);
+ }
+ removeScales(...t) {
+ this._each("unregister", t, this.scales);
+ }
+ _each(i, t, a) {
+ [...t].forEach((t) => {
+ const e = a || this._getRegistryForType(t);
+ a || e.isForType(t) || (e === this.plugins && t.id)
+ ? this._exec(i, e, t)
+ : each(t, (t) => {
+ var e = a || this._getRegistryForType(t);
+ this._exec(i, e, t);
+ });
+ });
+ }
+ _exec(t, e, i) {
+ var a = _capitalize(t);
+ callback(i["before" + a], [], i), e[t](i), callback(i["after" + a], [], i);
+ }
+ _getRegistryForType(e) {
+ for (let t = 0; t < this._typedRegistries.length; t++) {
+ const i = this._typedRegistries[t];
+ if (i.isForType(e)) return i;
+ }
+ return this.plugins;
+ }
+ _get(t, e, i) {
+ e = e.get(t);
+ if (void 0 === e)
+ throw new Error('"' + t + '" is not a registered ' + i + ".");
+ return e;
+ }
+}
+var registry = new Registry();
+class PluginService {
+ constructor() {
+ this._init = [];
+ }
+ notify(t, e, i, a) {
+ "beforeInit" === e &&
+ ((this._init = this._createDescriptors(t, !0)),
+ this._notify(this._init, t, "install"));
+ (a = a ? this._descriptors(t).filter(a) : this._descriptors(t)),
+ (i = this._notify(a, t, e, i));
+ return (
+ "afterDestroy" === e &&
+ (this._notify(a, t, "stop"), this._notify(this._init, t, "uninstall")),
+ i
+ );
+ }
+ _notify(t, e, i, a) {
+ a = a || {};
+ for (const o of t) {
+ var s = o.plugin,
+ n = s[i],
+ r = [e, a, o.options];
+ if (!1 === callback(n, r, s) && a.cancelable) return !1;
+ }
+ return !0;
+ }
+ invalidate() {
+ isNullOrUndef(this._cache) ||
+ ((this._oldCache = this._cache), (this._cache = void 0));
+ }
+ _descriptors(t) {
+ if (this._cache) return this._cache;
+ var e = (this._cache = this._createDescriptors(t));
+ return this._notifyStateChanges(t), e;
+ }
+ _createDescriptors(t, e) {
+ var i = t && t.config,
+ a = valueOrDefault(i.options && i.options.plugins, {}),
+ i = allPlugins(i);
+ return !1 !== a || e ? createDescriptors(t, i, a, e) : [];
+ }
+ _notifyStateChanges(t) {
+ var e = this._oldCache || [],
+ i = this._cache,
+ a = (t, i) =>
+ t.filter((e) => !i.some((t) => e.plugin.id === t.plugin.id));
+ this._notify(a(e, i), t, "stop"), this._notify(a(i, e), t, "start");
+ }
+}
+function allPlugins(t) {
+ const e = {},
+ i = [];
+ var a = Object.keys(registry.plugins.items);
+ for (let t = 0; t < a.length; t++) i.push(registry.getPlugin(a[t]));
+ var s = t.plugins || [];
+ for (let t = 0; t < s.length; t++) {
+ var n = s[t];
+ -1 === i.indexOf(n) && (i.push(n), (e[n.id] = !0));
+ }
+ return { plugins: i, localIds: e };
+}
+function getOpts(t, e) {
+ return e || !1 !== t ? (!0 === t ? {} : t) : null;
+}
+function createDescriptors(t, { plugins: e, localIds: i }, a, s) {
+ const n = [];
+ var r = t.getContext();
+ for (const h of e) {
+ var o = h.id,
+ l = getOpts(a[o], s);
+ null !== l &&
+ n.push({
+ plugin: h,
+ options: pluginOpts(t.config, { plugin: h, local: i[o] }, l, r),
+ });
+ }
+ return n;
+}
+function pluginOpts(t, { plugin: e, local: i }, a, s) {
+ var n = t.pluginScopeKeys(e);
+ const r = t.getOptionScopes(a, n);
+ return (
+ i && e.defaults && r.push(e.defaults),
+ t.createResolver(r, s, [""], { scriptable: !1, indexable: !1, allKeys: !0 })
+ );
+}
+function getIndexAxis(t, e) {
+ var i = defaults.datasets[t] || {};
+ return (
+ ((e.datasets || {})[t] || {}).indexAxis || e.indexAxis || i.indexAxis || "x"
+ );
+}
+function getAxisFromDefaultScaleID(t, e) {
+ let i = t;
+ return (
+ "_index_" === t ? (i = e) : "_value_" === t && (i = "x" === e ? "y" : "x"),
+ i
+ );
+}
+function getDefaultScaleIDFromAxis(t, e) {
+ return t === e ? "_index_" : "_value_";
+}
+function idMatchesAxis(t) {
+ if ("x" === t || "y" === t || "r" === t) return t;
+}
+function axisFromPosition(t) {
+ return "top" === t || "bottom" === t
+ ? "x"
+ : "left" === t || "right" === t
+ ? "y"
+ : void 0;
+}
+function determineAxis(t, ...e) {
+ if (idMatchesAxis(t)) return t;
+ for (const a of e) {
+ var i =
+ a.axis ||
+ axisFromPosition(a.position) ||
+ (1 < t.length && idMatchesAxis(t[0].toLowerCase()));
+ if (i) return i;
+ }
+ throw new Error(
+ `Cannot determine type of '${t}' axis. Please provide 'axis' or 'position' option.`
+ );
+}
+function getAxisFromDataset(t, e, i) {
+ if (i[e + "AxisID"] === t) return { axis: e };
+}
+function retrieveAxisFromDatasets(e, t) {
+ if (t.data && t.data.datasets) {
+ t = t.data.datasets.filter((t) => t.xAxisID === e || t.yAxisID === e);
+ if (t.length)
+ return (
+ getAxisFromDataset(e, "x", t[0]) || getAxisFromDataset(e, "y", t[0])
+ );
+ }
+ return {};
+}
+function mergeScaleConfig(r, e) {
+ const n = overrides[r.type] || { scales: {} },
+ o = e.scales || {},
+ l = getIndexAxis(r.type, e),
+ h = Object.create(null);
+ return (
+ Object.keys(o).forEach((t) => {
+ var e = o[t];
+ if (!isObject(e))
+ return console.error("Invalid scale configuration for scale: " + t);
+ if (e._proxy)
+ return console.warn(
+ "Ignoring resolver passed as options for scale: " + t
+ );
+ var i = determineAxis(
+ t,
+ e,
+ retrieveAxisFromDatasets(t, r),
+ defaults.scales[e.type]
+ ),
+ a = getDefaultScaleIDFromAxis(i, l),
+ s = n.scales || {};
+ h[t] = mergeIf(Object.create(null), [{ axis: i }, e, s[i], s[a]]);
+ }),
+ r.data.datasets.forEach((a) => {
+ var t = a.type || r.type;
+ const s = a.indexAxis || getIndexAxis(t, e),
+ n = (overrides[t] || {}).scales || {};
+ Object.keys(n).forEach((t) => {
+ var e = getAxisFromDefaultScaleID(t, s),
+ i = a[e + "AxisID"] || e;
+ (h[i] = h[i] || Object.create(null)),
+ mergeIf(h[i], [{ axis: e }, o[i], n[t]]);
+ });
+ }),
+ Object.keys(h).forEach((t) => {
+ t = h[t];
+ mergeIf(t, [defaults.scales[t.type], defaults.scale]);
+ }),
+ h
+ );
+}
+function initOptions(t) {
+ const e = t.options || (t.options = {});
+ (e.plugins = valueOrDefault(e.plugins, {})),
+ (e.scales = mergeScaleConfig(t, e));
+}
+function initData(t) {
+ return (
+ ((t = t || {}).datasets = t.datasets || []), (t.labels = t.labels || []), t
+ );
+}
+function initConfig(t) {
+ return ((t = t || {}).data = initData(t.data)), initOptions(t), t;
+}
+const keyCache = new Map(),
+ keysCached = new Set();
+function cachedKeys(t, e) {
+ let i = keyCache.get(t);
+ return i || ((i = e()), keyCache.set(t, i), keysCached.add(i)), i;
+}
+const addIfFound = (t, e, i) => {
+ e = resolveObjectKey(e, i);
+ void 0 !== e && t.add(e);
+};
+class Config {
+ constructor(t) {
+ (this._config = initConfig(t)),
+ (this._scopeCache = new Map()),
+ (this._resolverCache = new Map());
+ }
+ get platform() {
+ return this._config.platform;
+ }
+ get type() {
+ return this._config.type;
+ }
+ set type(t) {
+ this._config.type = t;
+ }
+ get data() {
+ return this._config.data;
+ }
+ set data(t) {
+ this._config.data = initData(t);
+ }
+ get options() {
+ return this._config.options;
+ }
+ set options(t) {
+ this._config.options = t;
+ }
+ get plugins() {
+ return this._config.plugins;
+ }
+ update() {
+ var t = this._config;
+ this.clearCache(), initOptions(t);
+ }
+ clearCache() {
+ this._scopeCache.clear(), this._resolverCache.clear();
+ }
+ datasetScopeKeys(t) {
+ return cachedKeys(t, () => [["datasets." + t, ""]]);
+ }
+ datasetAnimationScopeKeys(t, e) {
+ return cachedKeys(t + ".transition." + e, () => [
+ [`datasets.${t}.transitions.` + e, "transitions." + e],
+ ["datasets." + t, ""],
+ ]);
+ }
+ datasetElementScopeKeys(t, e) {
+ return cachedKeys(t + "-" + e, () => [
+ [`datasets.${t}.elements.` + e, "datasets." + t, "elements." + e, ""],
+ ]);
+ }
+ pluginScopeKeys(t) {
+ const e = t.id;
+ return cachedKeys(this.type + "-plugin-" + e, () => [
+ ["plugins." + e, ...(t.additionalOptionScopes || [])],
+ ]);
+ }
+ _cachedScopes(t, e) {
+ const i = this._scopeCache;
+ let a = i.get(t);
+ return (a && !e) || ((a = new Map()), i.set(t, a)), a;
+ }
+ getOptionScopes(e, t, i) {
+ const { options: a, type: s } = this,
+ n = this._cachedScopes(e, i);
+ i = n.get(t);
+ if (i) return i;
+ const r = new Set(),
+ o =
+ (t.forEach((t) => {
+ e && (r.add(e), t.forEach((t) => addIfFound(r, e, t))),
+ t.forEach((t) => addIfFound(r, a, t)),
+ t.forEach((t) => addIfFound(r, overrides[s] || {}, t)),
+ t.forEach((t) => addIfFound(r, defaults, t)),
+ t.forEach((t) => addIfFound(r, descriptors, t));
+ }),
+ Array.from(r));
+ return (
+ 0 === o.length && o.push(Object.create(null)),
+ keysCached.has(t) && n.set(t, o),
+ o
+ );
+ }
+ chartOptionScopes() {
+ var { options: t, type: e } = this;
+ return [
+ t,
+ overrides[e] || {},
+ defaults.datasets[e] || {},
+ { type: e },
+ defaults,
+ descriptors,
+ ];
+ }
+ resolveNamedOptions(t, e, i, a = [""]) {
+ const s = { $shared: !0 };
+ var { resolver: a, subPrefixes: n } = getResolver(
+ this._resolverCache,
+ t,
+ a
+ );
+ let r = a;
+ needContext(a, e) &&
+ ((s.$shared = !1),
+ (i = isFunction(i) ? i() : i),
+ (t = this.createResolver(t, i, n)),
+ (r = _attachContext(a, i, t)));
+ for (const o of e) s[o] = r[o];
+ return s;
+ }
+ createResolver(t, e, i = [""], a) {
+ t = getResolver(this._resolverCache, t, i).resolver;
+ return isObject(e) ? _attachContext(t, e, void 0, a) : t;
+ }
+}
+function getResolver(t, e, i) {
+ let a = t.get(e);
+ a || ((a = new Map()), t.set(e, a));
+ t = i.join();
+ let s = a.get(t);
+ return (
+ s ||
+ ((e = _createResolver(e, i)),
+ (s = {
+ resolver: e,
+ subPrefixes: i.filter((t) => !t.toLowerCase().includes("hover")),
+ }),
+ a.set(t, s)),
+ s
+ );
+}
+const hasFunction = (e) =>
+ isObject(e) && Object.getOwnPropertyNames(e).some((t) => isFunction(e[t]));
+function needContext(t, e) {
+ const { isScriptable: i, isIndexable: a } = _descriptors(t);
+ for (const o of e) {
+ var s = i(o),
+ n = a(o),
+ r = (n || s) && t[o];
+ if ((s && (isFunction(r) || hasFunction(r))) || (n && isArray(r)))
+ return !0;
+ }
+ return !1;
+}
+var version = "4.4.1";
+const KNOWN_POSITIONS = ["top", "bottom", "left", "right", "chartArea"];
+function positionIsHorizontal(t, e) {
+ return (
+ "top" === t ||
+ "bottom" === t ||
+ (-1 === KNOWN_POSITIONS.indexOf(t) && "x" === e)
+ );
+}
+function compare2Level(i, a) {
+ return function (t, e) {
+ return t[i] === e[i] ? t[a] - e[a] : t[i] - e[i];
+ };
+}
+function onAnimationsComplete(t) {
+ const e = t.chart;
+ var i = e.options.animation;
+ e.notifyPlugins("afterRender"), callback(i && i.onComplete, [t], e);
+}
+function onAnimationProgress(t) {
+ var e = t.chart,
+ i = e.options.animation;
+ callback(i && i.onProgress, [t], e);
+}
+function getCanvas(t) {
+ return (
+ _isDomSupported() && "string" == typeof t
+ ? (t = document.getElementById(t))
+ : t && t.length && (t = t[0]),
+ (t = t && t.canvas ? t.canvas : t)
+ );
+}
+const instances = {},
+ getChart = (t) => {
+ const e = getCanvas(t);
+ return Object.values(instances)
+ .filter((t) => t.canvas === e)
+ .pop();
+ };
+function moveNumericKeys(t, e, i) {
+ for (const n of Object.keys(t)) {
+ var a,
+ s = +n;
+ e <= s && ((a = t[n]), delete t[n], (0 < i || e < s) && (t[s + i] = a));
+ }
+}
+function determineLastEvent(t, e, i, a) {
+ return i && "mouseout" !== t.type ? (a ? e : t) : null;
+}
+function getSizeForArea(t, e, i) {
+ return (t.options.clip ? t : e)[i];
+}
+function getDatasetArea(t, e) {
+ var { xScale: t, yScale: i } = t;
+ return t && i
+ ? {
+ left: getSizeForArea(t, e, "left"),
+ right: getSizeForArea(t, e, "right"),
+ top: getSizeForArea(i, e, "top"),
+ bottom: getSizeForArea(i, e, "bottom"),
+ }
+ : e;
+}
+class Chart {
+ static defaults = defaults;
+ static instances = instances;
+ static overrides = overrides;
+ static registry = registry;
+ static version = version;
+ static getChart = getChart;
+ static register(...t) {
+ registry.add(...t), invalidatePlugins();
+ }
+ static unregister(...t) {
+ registry.remove(...t), invalidatePlugins();
+ }
+ constructor(t, e) {
+ const i = (this.config = new Config(e));
+ (e = getCanvas(t)), (t = getChart(e));
+ if (t)
+ throw new Error(
+ "Canvas is already in use. Chart with ID '" +
+ t.id +
+ "' must be destroyed before the canvas with ID '" +
+ t.canvas.id +
+ "' can be reused."
+ );
+ var t = i.createResolver(i.chartOptionScopes(), this.getContext()),
+ e =
+ ((this.platform = new (i.platform || _detectPlatform(e))()),
+ this.platform.updateConfig(i),
+ this.platform.acquireContext(e, t.aspectRatio)),
+ a = e && e.canvas,
+ s = a && a.height,
+ n = a && a.width;
+ (this.id = uid()),
+ (this.ctx = e),
+ (this.canvas = a),
+ (this.width = n),
+ (this.height = s),
+ (this._options = t),
+ (this._aspectRatio = this.aspectRatio),
+ (this._layers = []),
+ (this._metasets = []),
+ (this._stacks = void 0),
+ (this.boxes = []),
+ (this.currentDevicePixelRatio = void 0),
+ (this.chartArea = void 0),
+ (this._active = []),
+ (this._lastEvent = void 0),
+ (this._listeners = {}),
+ (this._responsiveListeners = void 0),
+ (this._sortedMetasets = []),
+ (this.scales = {}),
+ (this._plugins = new PluginService()),
+ (this.$proxies = {}),
+ (this._hiddenIndices = {}),
+ (this.attached = !1),
+ (this._animationsDisabled = void 0),
+ (this.$context = void 0),
+ (this._doResize = debounce((t) => this.update(t), t.resizeDelay || 0)),
+ (this._dataChanges = []),
+ (instances[this.id] = this),
+ e && a
+ ? (animator.listen(this, "complete", onAnimationsComplete),
+ animator.listen(this, "progress", onAnimationProgress),
+ this._initialize(),
+ this.attached && this.update())
+ : console.error(
+ "Failed to create chart: can't acquire context from the given item"
+ );
+ }
+ get aspectRatio() {
+ var {
+ options: { aspectRatio: t, maintainAspectRatio: e },
+ width: i,
+ height: a,
+ _aspectRatio: s,
+ } = this;
+ return isNullOrUndef(t) ? (e && s ? s : a ? i / a : null) : t;
+ }
+ get data() {
+ return this.config.data;
+ }
+ set data(t) {
+ this.config.data = t;
+ }
+ get options() {
+ return this._options;
+ }
+ set options(t) {
+ this.config.options = t;
+ }
+ get registry() {
+ return registry;
+ }
+ _initialize() {
+ return (
+ this.notifyPlugins("beforeInit"),
+ this.options.responsive
+ ? this.resize()
+ : retinaScale(this, this.options.devicePixelRatio),
+ this.bindEvents(),
+ this.notifyPlugins("afterInit"),
+ this
+ );
+ }
+ clear() {
+ return clearCanvas(this.canvas, this.ctx), this;
+ }
+ stop() {
+ return animator.stop(this), this;
+ }
+ resize(t, e) {
+ animator.running(this)
+ ? (this._resizeBeforeDraw = { width: t, height: e })
+ : this._resize(t, e);
+ }
+ _resize(t, e) {
+ var i = this.options,
+ a = this.canvas,
+ s = i.maintainAspectRatio && this.aspectRatio,
+ a = this.platform.getMaximumSize(a, t, e, s),
+ t = i.devicePixelRatio || this.platform.getDevicePixelRatio(),
+ e = this.width ? "resize" : "attach";
+ (this.width = a.width),
+ (this.height = a.height),
+ (this._aspectRatio = this.aspectRatio),
+ retinaScale(this, t, !0) &&
+ (this.notifyPlugins("resize", { size: a }),
+ callback(i.onResize, [this, a], this),
+ this.attached && this._doResize(e) && this.render());
+ }
+ ensureScalesHaveIDs() {
+ var t = this.options.scales || {};
+ each(t, (t, e) => {
+ t.id = e;
+ });
+ }
+ buildOrUpdateScales() {
+ const o = this.options,
+ a = o.scales,
+ l = this.scales,
+ h = Object.keys(l).reduce((t, e) => ((t[e] = !1), t), {});
+ let t = [];
+ a &&
+ (t = t.concat(
+ Object.keys(a).map((t) => {
+ var e = a[t],
+ t = determineAxis(t, e),
+ i = "r" === t,
+ t = "x" === t;
+ return {
+ options: e,
+ dposition: i ? "chartArea" : t ? "bottom" : "left",
+ dtype: i ? "radialLinear" : t ? "category" : "linear",
+ };
+ })
+ )),
+ each(t, (t) => {
+ const e = t.options;
+ var i = e.id,
+ a = determineAxis(i, e),
+ s = valueOrDefault(e.type, t.dtype);
+ (void 0 !== e.position &&
+ positionIsHorizontal(e.position, a) ===
+ positionIsHorizontal(t.dposition)) ||
+ (e.position = t.dposition),
+ (h[i] = !0);
+ let n = null;
+ if (i in l && l[i].type === s) n = l[i];
+ else {
+ const r = registry.getScale(s);
+ (n = new r({ id: i, type: s, ctx: this.ctx, chart: this })),
+ (l[n.id] = n);
+ }
+ n.init(e, o);
+ }),
+ each(h, (t, e) => {
+ t || delete l[e];
+ }),
+ each(l, (t) => {
+ layouts.configure(this, t, t.options), layouts.addBox(this, t);
+ });
+ }
+ _updateMetasets() {
+ const t = this._metasets;
+ var e = this.data.datasets.length,
+ i = t.length;
+ if ((t.sort((t, e) => t.index - e.index), e < i)) {
+ for (let t = e; t < i; ++t) this._destroyDatasetMeta(t);
+ t.splice(e, i - e);
+ }
+ this._sortedMetasets = t.slice(0).sort(compare2Level("order", "index"));
+ }
+ _removeUnreferencedMetasets() {
+ const {
+ _metasets: t,
+ data: { datasets: i },
+ } = this;
+ t.length > i.length && delete this._stacks,
+ t.forEach((e, t) => {
+ 0 === i.filter((t) => t === e._dataset).length &&
+ this._destroyDatasetMeta(t);
+ });
+ }
+ buildOrUpdateControllers() {
+ const e = [];
+ var i = this.data.datasets;
+ let a, t;
+ for (this._removeUnreferencedMetasets(), a = 0, t = i.length; a < t; a++) {
+ var s = i[a];
+ let t = this.getDatasetMeta(a);
+ var n = s.type || this.config.type;
+ if (
+ (t.type &&
+ t.type !== n &&
+ (this._destroyDatasetMeta(a), (t = this.getDatasetMeta(a))),
+ (t.type = n),
+ (t.indexAxis = s.indexAxis || getIndexAxis(n, this.options)),
+ (t.order = s.order || 0),
+ (t.index = a),
+ (t.label = "" + s.label),
+ (t.visible = this.isDatasetVisible(a)),
+ t.controller)
+ )
+ t.controller.updateIndex(a), t.controller.linkScales();
+ else {
+ const r = registry.getController(n);
+ var { datasetElementType: s, dataElementType: n } =
+ defaults.datasets[n];
+ Object.assign(r, {
+ dataElementType: registry.getElement(n),
+ datasetElementType: s && registry.getElement(s),
+ }),
+ (t.controller = new r(this, a)),
+ e.push(t.controller);
+ }
+ }
+ return this._updateMetasets(), e;
+ }
+ _resetElements() {
+ each(
+ this.data.datasets,
+ (t, e) => {
+ this.getDatasetMeta(e).controller.reset();
+ },
+ this
+ );
+ }
+ reset() {
+ this._resetElements(), this.notifyPlugins("reset");
+ }
+ update(t) {
+ const e = this.config;
+ e.update();
+ var a = (this._options = e.createResolver(
+ e.chartOptionScopes(),
+ this.getContext()
+ )),
+ s = (this._animationsDisabled = !a.animation);
+ if (
+ (this._updateScales(),
+ this._checkEventBindings(),
+ this._updateHiddenIndices(),
+ this._plugins.invalidate(),
+ !1 !== this.notifyPlugins("beforeUpdate", { mode: t, cancelable: !0 }))
+ ) {
+ const r = this.buildOrUpdateControllers();
+ this.notifyPlugins("beforeElementsUpdate");
+ let i = 0;
+ for (let t = 0, e = this.data.datasets.length; t < e; t++) {
+ const o = this.getDatasetMeta(t)["controller"];
+ var n = !s && -1 === r.indexOf(o);
+ o.buildOrUpdateElements(n), (i = Math.max(+o.getMaxOverflow(), i));
+ }
+ (i = this._minPadding = a.layout.autoPadding ? i : 0),
+ this._updateLayout(i),
+ s ||
+ each(r, (t) => {
+ t.reset();
+ }),
+ this._updateDatasets(t),
+ this.notifyPlugins("afterUpdate", { mode: t }),
+ this._layers.sort(compare2Level("z", "_idx"));
+ var { _active: a, _lastEvent: t } = this;
+ t
+ ? this._eventHandler(t, !0)
+ : a.length && this._updateHoverStyles(a, a, !0),
+ this.render();
+ }
+ }
+ _updateScales() {
+ each(this.scales, (t) => {
+ layouts.removeBox(this, t);
+ }),
+ this.ensureScalesHaveIDs(),
+ this.buildOrUpdateScales();
+ }
+ _checkEventBindings() {
+ var t = this.options,
+ e = new Set(Object.keys(this._listeners)),
+ i = new Set(t.events);
+ (setsEqual(e, i) && !!this._responsiveListeners === t.responsive) ||
+ (this.unbindEvents(), this.bindEvents());
+ }
+ _updateHiddenIndices() {
+ var t,
+ e,
+ i,
+ a = this["_hiddenIndices"];
+ for ({ method: t, start: e, count: i } of this._getUniformDataChanges() ||
+ []) {
+ var s = "_removeElements" === t ? -i : i;
+ moveNumericKeys(a, e, s);
+ }
+ }
+ _getUniformDataChanges() {
+ const t = this._dataChanges;
+ if (t && t.length) {
+ this._dataChanges = [];
+ var e = this.data.datasets.length,
+ i = (e) =>
+ new Set(
+ t
+ .filter((t) => t[0] === e)
+ .map((t, e) => e + "," + t.splice(1).join(","))
+ ),
+ a = i(0);
+ for (let t = 1; t < e; t++) if (!setsEqual(a, i(t))) return;
+ return Array.from(a)
+ .map((t) => t.split(","))
+ .map((t) => ({ method: t[1], start: +t[2], count: +t[3] }));
+ }
+ }
+ _updateLayout(t) {
+ if (!1 !== this.notifyPlugins("beforeLayout", { cancelable: !0 })) {
+ layouts.update(this, this.width, this.height, t);
+ t = this.chartArea;
+ const e = t.width <= 0 || t.height <= 0;
+ (this._layers = []),
+ each(
+ this.boxes,
+ (t) => {
+ (e && "chartArea" === t.position) ||
+ (t.configure && t.configure(), this._layers.push(...t._layers()));
+ },
+ this
+ ),
+ this._layers.forEach((t, e) => {
+ t._idx = e;
+ }),
+ this.notifyPlugins("afterLayout");
+ }
+ }
+ _updateDatasets(i) {
+ if (
+ !1 !==
+ this.notifyPlugins("beforeDatasetsUpdate", { mode: i, cancelable: !0 })
+ ) {
+ for (let t = 0, e = this.data.datasets.length; t < e; ++t)
+ this.getDatasetMeta(t).controller.configure();
+ for (let t = 0, e = this.data.datasets.length; t < e; ++t)
+ this._updateDataset(t, isFunction(i) ? i({ datasetIndex: t }) : i);
+ this.notifyPlugins("afterDatasetsUpdate", { mode: i });
+ }
+ }
+ _updateDataset(t, e) {
+ const i = this.getDatasetMeta(t),
+ a = { meta: i, index: t, mode: e, cancelable: !0 };
+ !1 !== this.notifyPlugins("beforeDatasetUpdate", a) &&
+ (i.controller._update(e),
+ (a.cancelable = !1),
+ this.notifyPlugins("afterDatasetUpdate", a));
+ }
+ render() {
+ !1 !== this.notifyPlugins("beforeRender", { cancelable: !0 }) &&
+ (animator.has(this)
+ ? this.attached && !animator.running(this) && animator.start(this)
+ : (this.draw(), onAnimationsComplete({ chart: this })));
+ }
+ draw() {
+ let t;
+ var e, i;
+ if (
+ (this._resizeBeforeDraw &&
+ (({ width: e, height: i } = this._resizeBeforeDraw),
+ this._resize(e, i),
+ (this._resizeBeforeDraw = null)),
+ this.clear(),
+ !(this.width <= 0 || this.height <= 0) &&
+ !1 !== this.notifyPlugins("beforeDraw", { cancelable: !0 }))
+ ) {
+ const a = this._layers;
+ for (t = 0; t < a.length && a[t].z <= 0; ++t) a[t].draw(this.chartArea);
+ for (this._drawDatasets(); t < a.length; ++t) a[t].draw(this.chartArea);
+ this.notifyPlugins("afterDraw");
+ }
+ }
+ _getSortedDatasetMetas(t) {
+ var e = this._sortedMetasets;
+ const i = [];
+ let a, s;
+ for (a = 0, s = e.length; a < s; ++a) {
+ var n = e[a];
+ (t && !n.visible) || i.push(n);
+ }
+ return i;
+ }
+ getSortedVisibleDatasetMetas() {
+ return this._getSortedDatasetMetas(!0);
+ }
+ _drawDatasets() {
+ if (!1 !== this.notifyPlugins("beforeDatasetsDraw", { cancelable: !0 })) {
+ var e = this.getSortedVisibleDatasetMetas();
+ for (let t = e.length - 1; 0 <= t; --t) this._drawDataset(e[t]);
+ this.notifyPlugins("afterDatasetsDraw");
+ }
+ }
+ _drawDataset(t) {
+ var e = this.ctx,
+ i = t._clip,
+ a = !i.disabled,
+ s = getDatasetArea(t, this.chartArea);
+ const n = { meta: t, index: t.index, cancelable: !0 };
+ !1 !== this.notifyPlugins("beforeDatasetDraw", n) &&
+ (a &&
+ clipArea(e, {
+ left: !1 === i.left ? 0 : s.left - i.left,
+ right: !1 === i.right ? this.width : s.right + i.right,
+ top: !1 === i.top ? 0 : s.top - i.top,
+ bottom: !1 === i.bottom ? this.height : s.bottom + i.bottom,
+ }),
+ t.controller.draw(),
+ a && unclipArea(e),
+ (n.cancelable = !1),
+ this.notifyPlugins("afterDatasetDraw", n));
+ }
+ isPointInArea(t) {
+ return _isPointInArea(t, this.chartArea, this._minPadding);
+ }
+ getElementsAtEventForMode(t, e, i, a) {
+ const s = Interaction.modes[e];
+ return "function" == typeof s ? s(this, t, i, a) : [];
+ }
+ getDatasetMeta(t) {
+ const e = this.data.datasets[t],
+ i = this._metasets;
+ let a = i.filter((t) => t && t._dataset === e).pop();
+ return (
+ a ||
+ ((a = {
+ type: null,
+ data: [],
+ dataset: null,
+ controller: null,
+ hidden: null,
+ xAxisID: null,
+ yAxisID: null,
+ order: (e && e.order) || 0,
+ index: t,
+ _dataset: e,
+ _parsed: [],
+ _sorted: !1,
+ }),
+ i.push(a)),
+ a
+ );
+ }
+ getContext() {
+ return (
+ this.$context ||
+ (this.$context = createContext(null, { chart: this, type: "chart" }))
+ );
+ }
+ getVisibleDatasetCount() {
+ return this.getSortedVisibleDatasetMetas().length;
+ }
+ isDatasetVisible(t) {
+ var e = this.data.datasets[t];
+ if (!e) return !1;
+ t = this.getDatasetMeta(t);
+ return "boolean" == typeof t.hidden ? !t.hidden : !e.hidden;
+ }
+ setDatasetVisibility(t, e) {
+ const i = this.getDatasetMeta(t);
+ i.hidden = !e;
+ }
+ toggleDataVisibility(t) {
+ this._hiddenIndices[t] = !this._hiddenIndices[t];
+ }
+ getDataVisibility(t) {
+ return !this._hiddenIndices[t];
+ }
+ _updateVisibility(e, t, i) {
+ const a = i ? "show" : "hide",
+ s = this.getDatasetMeta(e),
+ n = s.controller._resolveAnimations(void 0, a);
+ defined(t)
+ ? ((s.data[t].hidden = !i), this.update())
+ : (this.setDatasetVisibility(e, i),
+ n.update(s, { visible: i }),
+ this.update((t) => (t.datasetIndex === e ? a : void 0)));
+ }
+ hide(t, e) {
+ this._updateVisibility(t, e, !1);
+ }
+ show(t, e) {
+ this._updateVisibility(t, e, !0);
+ }
+ _destroyDatasetMeta(t) {
+ const e = this._metasets[t];
+ e && e.controller && e.controller._destroy(), delete this._metasets[t];
+ }
+ _stop() {
+ let t, e;
+ for (
+ this.stop(), animator.remove(this), t = 0, e = this.data.datasets.length;
+ t < e;
+ ++t
+ )
+ this._destroyDatasetMeta(t);
+ }
+ destroy() {
+ this.notifyPlugins("beforeDestroy");
+ var { canvas: t, ctx: e } = this;
+ this._stop(),
+ this.config.clearCache(),
+ t &&
+ (this.unbindEvents(),
+ clearCanvas(t, e),
+ this.platform.releaseContext(e),
+ (this.canvas = null),
+ (this.ctx = null)),
+ delete instances[this.id],
+ this.notifyPlugins("afterDestroy");
+ }
+ toBase64Image(...t) {
+ return this.canvas.toDataURL(...t);
+ }
+ bindEvents() {
+ this.bindUserEvents(),
+ this.options.responsive
+ ? this.bindResponsiveEvents()
+ : (this.attached = !0);
+ }
+ bindUserEvents() {
+ const i = this._listeners,
+ a = this.platform,
+ e = (t, e) => {
+ a.addEventListener(this, t, e), (i[t] = e);
+ },
+ s = (t, e, i) => {
+ (t.offsetX = e), (t.offsetY = i), this._eventHandler(t);
+ };
+ each(this.options.events, (t) => e(t, s));
+ }
+ bindResponsiveEvents() {
+ this._responsiveListeners || (this._responsiveListeners = {});
+ const i = this._responsiveListeners,
+ a = this.platform,
+ t = (t, e) => {
+ a.addEventListener(this, t, e), (i[t] = e);
+ },
+ e = (t, e) => {
+ i[t] && (a.removeEventListener(this, t, e), delete i[t]);
+ },
+ s = (t, e) => {
+ this.canvas && this.resize(t, e);
+ };
+ let n;
+ const r = () => {
+ e("attach", r),
+ (this.attached = !0),
+ this.resize(),
+ t("resize", s),
+ t("detach", n);
+ };
+ (n = () => {
+ (this.attached = !1),
+ e("resize", s),
+ this._stop(),
+ this._resize(0, 0),
+ t("attach", r);
+ }),
+ (a.isAttached(this.canvas) ? r : n)();
+ }
+ unbindEvents() {
+ each(this._listeners, (t, e) => {
+ this.platform.removeEventListener(this, e, t);
+ }),
+ (this._listeners = {}),
+ each(this._responsiveListeners, (t, e) => {
+ this.platform.removeEventListener(this, e, t);
+ }),
+ (this._responsiveListeners = void 0);
+ }
+ updateHoverStyle(t, e, i) {
+ var a = i ? "set" : "remove";
+ let s, n, r, o;
+ for (
+ "dataset" === e &&
+ (s = this.getDatasetMeta(t[0].datasetIndex)).controller[
+ "_" + a + "DatasetHoverStyle"
+ ](),
+ r = 0,
+ o = t.length;
+ r < o;
+ ++r
+ ) {
+ const l = (n = t[r]) && this.getDatasetMeta(n.datasetIndex).controller;
+ l && l[a + "HoverStyle"](n.element, n.datasetIndex, n.index);
+ }
+ }
+ getActiveElements() {
+ return this._active || [];
+ }
+ setActiveElements(t) {
+ var e = this._active || [],
+ t = t.map(({ datasetIndex: t, index: e }) => {
+ var i = this.getDatasetMeta(t);
+ if (i) return { datasetIndex: t, element: i.data[e], index: e };
+ throw new Error("No dataset found at index " + t);
+ });
+ _elementsEqual(t, e) ||
+ ((this._active = t),
+ (this._lastEvent = null),
+ this._updateHoverStyles(t, e));
+ }
+ notifyPlugins(t, e, i) {
+ return this._plugins.notify(this, t, e, i);
+ }
+ isPluginEnabled(e) {
+ return 1 === this._plugins._cache.filter((t) => t.plugin.id === e).length;
+ }
+ _updateHoverStyles(t, e, i) {
+ var a = this.options.hover,
+ s = (t, i) =>
+ t.filter(
+ (e) =>
+ !i.some(
+ (t) => e.datasetIndex === t.datasetIndex && e.index === t.index
+ )
+ ),
+ n = s(e, t),
+ i = i ? t : s(t, e);
+ n.length && this.updateHoverStyle(n, a.mode, !1),
+ i.length && a.mode && this.updateHoverStyle(i, a.mode, !0);
+ }
+ _eventHandler(e, t) {
+ const i = {
+ event: e,
+ replay: t,
+ cancelable: !0,
+ inChartArea: this.isPointInArea(e),
+ };
+ var a = (t) =>
+ (t.options.events || this.options.events).includes(e.native.type);
+ if (!1 !== this.notifyPlugins("beforeEvent", i, a))
+ return (
+ (t = this._handleEvent(e, t, i.inChartArea)),
+ (i.cancelable = !1),
+ this.notifyPlugins("afterEvent", i, a),
+ (t || i.changed) && this.render(),
+ this
+ );
+ }
+ _handleEvent(t, e, i) {
+ var { _active: a = [], options: s } = this,
+ n = this._getActiveElements(t, a, i, e),
+ r = _isClickEvent(t),
+ o = determineLastEvent(t, this._lastEvent, i, r),
+ i =
+ (i &&
+ ((this._lastEvent = null),
+ callback(s.onHover, [t, n, this], this),
+ r && callback(s.onClick, [t, n, this], this)),
+ !_elementsEqual(n, a));
+ return (
+ (i || e) && ((this._active = n), this._updateHoverStyles(n, a, e)),
+ (this._lastEvent = o),
+ i
+ );
+ }
+ _getActiveElements(t, e, i, a) {
+ if ("mouseout" === t.type) return [];
+ if (!i) return e;
+ i = this.options.hover;
+ return this.getElementsAtEventForMode(t, i.mode, i, a);
+ }
+}
+function invalidatePlugins() {
+ return each(Chart.instances, (t) => t._plugins.invalidate());
+}
+function clipArc(t, e, i) {
+ var {
+ startAngle: e,
+ pixelMargin: a,
+ x: s,
+ y: n,
+ outerRadius: r,
+ innerRadius: o,
+ } = e,
+ l = a / r;
+ t.beginPath(),
+ t.arc(s, n, r, e - l, i + l),
+ a < o
+ ? t.arc(s, n, o, i + (l = a / o), e - l, !0)
+ : t.arc(s, n, a, i + HALF_PI, e - HALF_PI),
+ t.closePath(),
+ t.clip();
+}
+function toRadiusCorners(t) {
+ return _readValueToProps(t, [
+ "outerStart",
+ "outerEnd",
+ "innerStart",
+ "innerEnd",
+ ]);
+}
+function parseBorderRadius$1(t, e, i, a) {
+ t = toRadiusCorners(t.options.borderRadius);
+ const s = (i - e) / 2;
+ var e = Math.min(s, (a * e) / 2),
+ n = (t) => {
+ var e = ((i - Math.min(s, t)) * a) / 2;
+ return _limitValue(t, 0, Math.min(s, e));
+ };
+ return {
+ outerStart: n(t.outerStart),
+ outerEnd: n(t.outerEnd),
+ innerStart: _limitValue(t.innerStart, 0, e),
+ innerEnd: _limitValue(t.innerEnd, 0, e),
+ };
+}
+function rThetaToXY(t, e, i, a) {
+ return { x: i + t * Math.cos(e), y: a + t * Math.sin(e) };
+}
+function pathArc(t, e, i, a, s, n) {
+ var { x: r, y: o, startAngle: l, pixelMargin: h, innerRadius: d } = e,
+ c = Math.max(e.outerRadius + a + i - h, 0),
+ h = 0 < d ? d + a + i + h : 0;
+ let u = 0;
+ var g = s - l,
+ d =
+ (a &&
+ ((d = ((0 < d ? d - a : 0) + (0 < c ? c - a : 0)) / 2),
+ (u = (g - (0 != d ? (g * d) / (d + a) : g)) / 2)),
+ Math.max(0.001, g * c - i / PI) / c),
+ a = (g - d) / 2,
+ i = l + a + u,
+ g = s - a - u,
+ {
+ outerStart: d,
+ outerEnd: l,
+ innerStart: s,
+ innerEnd: a,
+ } = parseBorderRadius$1(e, h, c, g - i),
+ e = c - d,
+ p = c - l,
+ f = i + d / e,
+ m = g - l / p,
+ v = h + s,
+ x = h + a,
+ b = i + s / v,
+ _ = g - a / x;
+ t.beginPath(),
+ n
+ ? (t.arc(r, o, c, f, (n = (f + m) / 2)),
+ t.arc(r, o, c, n, m),
+ 0 < l &&
+ ((n = rThetaToXY(p, m, r, o)), t.arc(n.x, n.y, l, m, g + HALF_PI)),
+ (p = rThetaToXY(x, g, r, o)),
+ t.lineTo(p.x, p.y),
+ 0 < a &&
+ ((n = rThetaToXY(x, _, r, o)),
+ t.arc(n.x, n.y, a, g + HALF_PI, _ + Math.PI)),
+ t.arc(r, o, h, g - a / h, (l = (g - a / h + (i + s / h)) / 2), !0),
+ t.arc(r, o, h, l, i + s / h, !0),
+ 0 < s &&
+ ((p = rThetaToXY(v, b, r, o)),
+ t.arc(p.x, p.y, s, b + Math.PI, i - HALF_PI)),
+ (x = rThetaToXY(e, i, r, o)),
+ t.lineTo(x.x, x.y),
+ 0 < d &&
+ ((n = rThetaToXY(e, f, r, o)), t.arc(n.x, n.y, d, i - HALF_PI, f)))
+ : (t.moveTo(r, o),
+ (_ = Math.cos(f) * c + r),
+ (g = Math.sin(f) * c + o),
+ t.lineTo(_, g),
+ (a = Math.cos(m) * c + r),
+ (l = Math.sin(m) * c + o),
+ t.lineTo(a, l)),
+ t.closePath();
+}
+function drawArc(e, t, i, a, s) {
+ var { fullCircles: n, startAngle: r, circumference: o } = t;
+ let l = t.endAngle;
+ if (n) {
+ pathArc(e, t, i, a, l, s);
+ for (let t = 0; t < n; ++t) e.fill();
+ isNaN(o) || (l = r + (o % TAU || TAU));
+ }
+ return pathArc(e, t, i, a, l, s), e.fill(), l;
+}
+function drawBorder(e, i, a, s, n) {
+ var { fullCircles: r, startAngle: o, circumference: l, options: h } = i,
+ {
+ borderWidth: d,
+ borderJoinStyle: c,
+ borderDash: u,
+ borderDashOffset: g,
+ } = h,
+ h = "inner" === h.borderAlign;
+ if (d) {
+ e.setLineDash(u || []),
+ (e.lineDashOffset = g),
+ h
+ ? ((e.lineWidth = 2 * d), (e.lineJoin = c || "round"))
+ : ((e.lineWidth = d), (e.lineJoin = c || "bevel"));
+ let t = i.endAngle;
+ if (r) {
+ pathArc(e, i, a, s, t, n);
+ for (let t = 0; t < r; ++t) e.stroke();
+ isNaN(l) || (t = o + (l % TAU || TAU));
+ }
+ h && clipArc(e, i, t), r || (pathArc(e, i, a, s, t, n), e.stroke());
+ }
+}
+class ArcElement extends Element {
+ static id = "arc";
+ static defaults = {
+ borderAlign: "center",
+ borderColor: "#fff",
+ borderDash: [],
+ borderDashOffset: 0,
+ borderJoinStyle: void 0,
+ borderRadius: 0,
+ borderWidth: 2,
+ offset: 0,
+ spacing: 0,
+ angle: void 0,
+ circular: !0,
+ };
+ static defaultRoutes = { backgroundColor: "backgroundColor" };
+ static descriptors = {
+ _scriptable: !0,
+ _indexable: (t) => "borderDash" !== t,
+ };
+ circumference;
+ endAngle;
+ fullCircles;
+ innerRadius;
+ outerRadius;
+ pixelMargin;
+ startAngle;
+ constructor(t) {
+ super(),
+ (this.options = void 0),
+ (this.circumference = void 0),
+ (this.startAngle = void 0),
+ (this.endAngle = void 0),
+ (this.innerRadius = void 0),
+ (this.outerRadius = void 0),
+ (this.pixelMargin = 0),
+ (this.fullCircles = 0),
+ t && Object.assign(this, t);
+ }
+ inRange(t, e, i) {
+ var a = this.getProps(["x", "y"], i),
+ { angle: a, distance: t } = getAngleFromPoint(a, { x: t, y: e }),
+ {
+ startAngle: e,
+ endAngle: i,
+ innerRadius: s,
+ outerRadius: n,
+ circumference: r,
+ } = this.getProps(
+ [
+ "startAngle",
+ "endAngle",
+ "innerRadius",
+ "outerRadius",
+ "circumference",
+ ],
+ i
+ ),
+ o = (this.options.spacing + this.options.borderWidth) / 2,
+ r = valueOrDefault(r, i - e),
+ r = TAU <= r || _angleBetween(a, e, i),
+ a = _isBetween(t, s + o, n + o);
+ return r && a;
+ }
+ getCenterPoint(t) {
+ var {
+ x: t,
+ y: e,
+ startAngle: i,
+ endAngle: a,
+ innerRadius: s,
+ outerRadius: n,
+ } = this.getProps(
+ ["x", "y", "startAngle", "endAngle", "innerRadius", "outerRadius"],
+ t
+ ),
+ { offset: r, spacing: o } = this.options,
+ i = (i + a) / 2,
+ a = (s + n + o + r) / 2;
+ return { x: t + Math.cos(i) * a, y: e + Math.sin(i) * a };
+ }
+ tooltipPosition(t) {
+ return this.getCenterPoint(t);
+ }
+ draw(t) {
+ var e,
+ { options: i, circumference: a } = this,
+ s = (i.offset || 0) / 4,
+ n = (i.spacing || 0) / 2,
+ r = i.circular;
+ (this.pixelMargin = "inner" === i.borderAlign ? 0.33 : 0),
+ (this.fullCircles = TAU < a ? Math.floor(a / TAU) : 0),
+ 0 === a ||
+ this.innerRadius < 0 ||
+ this.outerRadius < 0 ||
+ (t.save(),
+ (e = (this.startAngle + this.endAngle) / 2),
+ t.translate(Math.cos(e) * s, Math.sin(e) * s),
+ (e = s * (1 - Math.sin(Math.min(PI, a || 0)))),
+ (t.fillStyle = i.backgroundColor),
+ (t.strokeStyle = i.borderColor),
+ drawArc(t, this, e, n, r),
+ drawBorder(t, this, e, n, r),
+ t.restore());
+ }
+}
+function setStyle(t, e, i = e) {
+ (t.lineCap = valueOrDefault(i.borderCapStyle, e.borderCapStyle)),
+ t.setLineDash(valueOrDefault(i.borderDash, e.borderDash)),
+ (t.lineDashOffset = valueOrDefault(i.borderDashOffset, e.borderDashOffset)),
+ (t.lineJoin = valueOrDefault(i.borderJoinStyle, e.borderJoinStyle)),
+ (t.lineWidth = valueOrDefault(i.borderWidth, e.borderWidth)),
+ (t.strokeStyle = valueOrDefault(i.borderColor, e.borderColor));
+}
+function lineTo(t, e, i) {
+ t.lineTo(i.x, i.y);
+}
+function getLineMethod(t) {
+ return t.stepped
+ ? _steppedLineTo
+ : t.tension || "monotone" === t.cubicInterpolationMode
+ ? _bezierCurveTo
+ : lineTo;
+}
+function pathVars(t, e, i = {}) {
+ var t = t.length,
+ { start: i = 0, end: a = t - 1 } = i,
+ { start: s, end: n } = e,
+ r = Math.max(i, s),
+ o = Math.min(a, n);
+ return {
+ count: t,
+ start: r,
+ loop: e.loop,
+ ilen: o < r && !((i < s && a < s) || (n < i && n < a)) ? t + o - r : o - r,
+ };
+}
+function pathSegment(t, e, i, a) {
+ var { points: s, options: n } = e,
+ { count: r, start: o, loop: e, ilen: l } = pathVars(s, i, a);
+ const h = getLineMethod(n);
+ let { move: d = !0, reverse: c } = a || {},
+ u,
+ g,
+ p;
+ for (u = 0; u <= l; ++u)
+ (g = s[(o + (c ? l - u : u)) % r]).skip ||
+ (d ? (t.moveTo(g.x, g.y), (d = !1)) : h(t, p, g, c, n.stepped), (p = g));
+ return e && ((g = s[(o + (c ? l : 0)) % r]), h(t, p, g, c, n.stepped)), !!e;
+}
+function fastPathSegment(t, e, i, a) {
+ var s = e.points;
+ const { count: n, start: r, ilen: o } = pathVars(s, i, a),
+ { move: l = !0, reverse: h } = a || {};
+ let d = 0,
+ c = 0,
+ u,
+ g,
+ p,
+ f,
+ m,
+ v;
+ var x,
+ b,
+ _,
+ y = (t) => (r + (h ? o - t : t)) % n,
+ k = () => {
+ f !== m && (t.lineTo(d, m), t.lineTo(d, f), t.lineTo(d, v));
+ };
+ for (l && ((g = s[y(0)]), t.moveTo(g.x, g.y)), u = 0; u <= o; ++u)
+ (g = s[y(u)]).skip ||
+ ((x = g.x),
+ (b = g.y),
+ (_ = 0 | x) === p
+ ? (b < f ? (f = b) : b > m && (m = b), (d = (c * d + x) / ++c))
+ : (k(), t.lineTo(x, b), (p = _), (c = 0), (f = m = b)),
+ (v = b));
+ k();
+}
+function _getSegmentMethod(t) {
+ var e = t.options,
+ i = e.borderDash && e.borderDash.length;
+ return !(
+ t._decimated ||
+ t._loop ||
+ e.tension ||
+ "monotone" === e.cubicInterpolationMode ||
+ e.stepped ||
+ i
+ )
+ ? fastPathSegment
+ : pathSegment;
+}
+function _getInterpolationMethod(t) {
+ return t.stepped
+ ? _steppedInterpolation
+ : t.tension || "monotone" === t.cubicInterpolationMode
+ ? _bezierInterpolation
+ : _pointInLine;
+}
+function strokePathWithCache(t, e, i, a) {
+ let s = e._path;
+ s || ((s = e._path = new Path2D()), e.path(s, i, a) && s.closePath()),
+ setStyle(t, e.options),
+ t.stroke(s);
+}
+function strokePathDirect(t, e, i, a) {
+ var { segments: s, options: n } = e;
+ const r = _getSegmentMethod(e);
+ for (const o of s)
+ setStyle(t, n, o.style),
+ t.beginPath(),
+ r(t, e, o, { start: i, end: i + a - 1 }) && t.closePath(),
+ t.stroke();
+}
+const usePath2D = "function" == typeof Path2D;
+function draw(t, e, i, a) {
+ (usePath2D && !e.options.segment ? strokePathWithCache : strokePathDirect)(
+ t,
+ e,
+ i,
+ a
+ );
+}
+class LineElement extends Element {
+ static id = "line";
+ static defaults = {
+ borderCapStyle: "butt",
+ borderDash: [],
+ borderDashOffset: 0,
+ borderJoinStyle: "miter",
+ borderWidth: 3,
+ capBezierPoints: !0,
+ cubicInterpolationMode: "default",
+ fill: !1,
+ spanGaps: !1,
+ stepped: !1,
+ tension: 0,
+ };
+ static defaultRoutes = {
+ backgroundColor: "backgroundColor",
+ borderColor: "borderColor",
+ };
+ static descriptors = {
+ _scriptable: !0,
+ _indexable: (t) => "borderDash" !== t && "fill" !== t,
+ };
+ constructor(t) {
+ super(),
+ (this.animated = !0),
+ (this.options = void 0),
+ (this._chart = void 0),
+ (this._loop = void 0),
+ (this._fullLoop = void 0),
+ (this._path = void 0),
+ (this._points = void 0),
+ (this._segments = void 0),
+ (this._decimated = !1),
+ (this._pointsUpdated = !1),
+ (this._datasetIndex = void 0),
+ t && Object.assign(this, t);
+ }
+ updateControlPoints(t, e) {
+ var i,
+ a = this.options;
+ (!a.tension && "monotone" !== a.cubicInterpolationMode) ||
+ a.stepped ||
+ this._pointsUpdated ||
+ ((i = a.spanGaps ? this._loop : this._fullLoop),
+ _updateBezierControlPoints(this._points, a, t, i, e),
+ (this._pointsUpdated = !0));
+ }
+ set points(t) {
+ (this._points = t),
+ delete this._segments,
+ delete this._path,
+ (this._pointsUpdated = !1);
+ }
+ get points() {
+ return this._points;
+ }
+ get segments() {
+ return (
+ this._segments ||
+ (this._segments = _computeSegments(this, this.options.segment))
+ );
+ }
+ first() {
+ var t = this.segments,
+ e = this.points;
+ return t.length && e[t[0].start];
+ }
+ last() {
+ var t = this.segments,
+ e = this.points,
+ i = t.length;
+ return i && e[t[i - 1].end];
+ }
+ interpolate(i, a) {
+ var s = this.options,
+ n = i[a],
+ r = this.points,
+ o = _boundSegments(this, { property: a, start: n, end: n });
+ if (o.length) {
+ const c = [],
+ u = _getInterpolationMethod(s);
+ let t, e;
+ for (t = 0, e = o.length; t < e; ++t) {
+ var { start: l, end: h } = o[t],
+ l = r[l],
+ h = r[h];
+ if (l === h) c.push(l);
+ else {
+ var d = Math.abs((n - l[a]) / (h[a] - l[a]));
+ const g = u(l, h, d, s.stepped);
+ (g[a] = i[a]), c.push(g);
+ }
+ }
+ return 1 === c.length ? c[0] : c;
+ }
+ }
+ pathSegment(t, e, i) {
+ const a = _getSegmentMethod(this);
+ return a(t, this, e, i);
+ }
+ path(t, e, i) {
+ var a = this.segments;
+ const s = _getSegmentMethod(this);
+ let n = this._loop;
+ (e = e || 0), (i = i || this.points.length - e);
+ for (const r of a) n &= s(t, this, r, { start: e, end: e + i - 1 });
+ return !!n;
+ }
+ draw(t, e, i, a) {
+ var s = this.options || {};
+ (this.points || []).length &&
+ s.borderWidth &&
+ (t.save(), draw(t, this, i, a), t.restore()),
+ this.animated && ((this._pointsUpdated = !1), (this._path = void 0));
+ }
+}
+function inRange$1(t, e, i, a) {
+ var s = t.options,
+ { [i]: t } = t.getProps([i], a);
+ return Math.abs(e - t) < s.radius + s.hitRadius;
+}
+class PointElement extends Element {
+ static id = "point";
+ parsed;
+ skip;
+ stop;
+ static defaults = {
+ borderWidth: 1,
+ hitRadius: 1,
+ hoverBorderWidth: 1,
+ hoverRadius: 4,
+ pointStyle: "circle",
+ radius: 3,
+ rotation: 0,
+ };
+ static defaultRoutes = {
+ backgroundColor: "backgroundColor",
+ borderColor: "borderColor",
+ };
+ constructor(t) {
+ super(),
+ (this.options = void 0),
+ (this.parsed = void 0),
+ (this.skip = void 0),
+ (this.stop = void 0),
+ t && Object.assign(this, t);
+ }
+ inRange(t, e, i) {
+ var a = this.options,
+ { x: i, y: s } = this.getProps(["x", "y"], i);
+ return (
+ Math.pow(t - i, 2) + Math.pow(e - s, 2) <
+ Math.pow(a.hitRadius + a.radius, 2)
+ );
+ }
+ inXRange(t, e) {
+ return inRange$1(this, t, "x", e);
+ }
+ inYRange(t, e) {
+ return inRange$1(this, t, "y", e);
+ }
+ getCenterPoint(t) {
+ var { x: t, y: e } = this.getProps(["x", "y"], t);
+ return { x: t, y: e };
+ }
+ size(t) {
+ var e = (t = t || this.options || {}).radius || 0;
+ return (
+ 2 *
+ ((e = Math.max(e, (e && t.hoverRadius) || 0)) +
+ ((e && t.borderWidth) || 0))
+ );
+ }
+ draw(t, e) {
+ var i = this.options;
+ this.skip ||
+ i.radius < 0.1 ||
+ !_isPointInArea(this, e, this.size(i) / 2) ||
+ ((t.strokeStyle = i.borderColor),
+ (t.lineWidth = i.borderWidth),
+ (t.fillStyle = i.backgroundColor),
+ drawPoint(t, i, this.x, this.y));
+ }
+ getRange() {
+ var t = this.options || {};
+ return t.radius + t.hitRadius;
+ }
+}
+function getBarBounds(t, e) {
+ var {
+ x: e,
+ y: i,
+ base: a,
+ width: s,
+ height: n,
+ } = t.getProps(["x", "y", "base", "width", "height"], e);
+ let r, o, l, h, d;
+ return (
+ (h = t.horizontal
+ ? ((d = n / 2),
+ (r = Math.min(e, a)),
+ (o = Math.max(e, a)),
+ (l = i - d),
+ i + d)
+ : ((d = s / 2),
+ (r = e - d),
+ (o = e + d),
+ (l = Math.min(i, a)),
+ Math.max(i, a))),
+ { left: r, top: l, right: o, bottom: h }
+ );
+}
+function skipOrLimit(t, e, i, a) {
+ return t ? 0 : _limitValue(e, i, a);
+}
+function parseBorderWidth(t, e, i) {
+ var a = t.options.borderWidth,
+ t = t.borderSkipped,
+ a = toTRBL(a);
+ return {
+ t: skipOrLimit(t.top, a.top, 0, i),
+ r: skipOrLimit(t.right, a.right, 0, e),
+ b: skipOrLimit(t.bottom, a.bottom, 0, i),
+ l: skipOrLimit(t.left, a.left, 0, e),
+ };
+}
+function parseBorderRadius(t, e, i) {
+ var a = t.getProps(["enableBorderRadius"])["enableBorderRadius"],
+ s = t.options.borderRadius,
+ n = toTRBLCorners(s),
+ e = Math.min(e, i),
+ i = t.borderSkipped,
+ t = a || isObject(s);
+ return {
+ topLeft: skipOrLimit(!t || i.top || i.left, n.topLeft, 0, e),
+ topRight: skipOrLimit(!t || i.top || i.right, n.topRight, 0, e),
+ bottomLeft: skipOrLimit(!t || i.bottom || i.left, n.bottomLeft, 0, e),
+ bottomRight: skipOrLimit(!t || i.bottom || i.right, n.bottomRight, 0, e),
+ };
+}
+function boundingRects(t) {
+ var e = getBarBounds(t),
+ i = e.right - e.left,
+ a = e.bottom - e.top,
+ s = parseBorderWidth(t, i / 2, a / 2),
+ t = parseBorderRadius(t, i / 2, a / 2);
+ return {
+ outer: { x: e.left, y: e.top, w: i, h: a, radius: t },
+ inner: {
+ x: e.left + s.l,
+ y: e.top + s.t,
+ w: i - s.l - s.r,
+ h: a - s.t - s.b,
+ radius: {
+ topLeft: Math.max(0, t.topLeft - Math.max(s.t, s.l)),
+ topRight: Math.max(0, t.topRight - Math.max(s.t, s.r)),
+ bottomLeft: Math.max(0, t.bottomLeft - Math.max(s.b, s.l)),
+ bottomRight: Math.max(0, t.bottomRight - Math.max(s.b, s.r)),
+ },
+ },
+ };
+}
+function inRange(t, e, i, a) {
+ var s = null === e,
+ n = null === i,
+ t = t && !(s && n) && getBarBounds(t, a);
+ return (
+ t &&
+ (s || _isBetween(e, t.left, t.right)) &&
+ (n || _isBetween(i, t.top, t.bottom))
+ );
+}
+function hasRadius(t) {
+ return t.topLeft || t.topRight || t.bottomLeft || t.bottomRight;
+}
+function addNormalRectPath(t, e) {
+ t.rect(e.x, e.y, e.w, e.h);
+}
+function inflateRect(t, e, i = {}) {
+ var a = t.x !== i.x ? -e : 0,
+ s = t.y !== i.y ? -e : 0,
+ n = (t.x + t.w !== i.x + i.w ? e : 0) - a,
+ i = (t.y + t.h !== i.y + i.h ? e : 0) - s;
+ return { x: t.x + a, y: t.y + s, w: t.w + n, h: t.h + i, radius: t.radius };
+}
+class BarElement extends Element {
+ static id = "bar";
+ static defaults = {
+ borderSkipped: "start",
+ borderWidth: 0,
+ borderRadius: 0,
+ inflateAmount: "auto",
+ pointStyle: void 0,
+ };
+ static defaultRoutes = {
+ backgroundColor: "backgroundColor",
+ borderColor: "borderColor",
+ };
+ constructor(t) {
+ super(),
+ (this.options = void 0),
+ (this.horizontal = void 0),
+ (this.base = void 0),
+ (this.width = void 0),
+ (this.height = void 0),
+ (this.inflateAmount = void 0),
+ t && Object.assign(this, t);
+ }
+ draw(t) {
+ var {
+ inflateAmount: e,
+ options: { borderColor: i, backgroundColor: a },
+ } = this,
+ { inner: s, outer: n } = boundingRects(this);
+ const r = hasRadius(n.radius) ? addRoundedRectPath : addNormalRectPath;
+ t.save(),
+ (n.w === s.w && n.h === s.h) ||
+ (t.beginPath(),
+ r(t, inflateRect(n, e, s)),
+ t.clip(),
+ r(t, inflateRect(s, -e, n)),
+ (t.fillStyle = i),
+ t.fill("evenodd")),
+ t.beginPath(),
+ r(t, inflateRect(s, e)),
+ (t.fillStyle = a),
+ t.fill(),
+ t.restore();
+ }
+ inRange(t, e, i) {
+ return inRange(this, t, e, i);
+ }
+ inXRange(t, e) {
+ return inRange(this, t, null, e);
+ }
+ inYRange(t, e) {
+ return inRange(this, null, t, e);
+ }
+ getCenterPoint(t) {
+ var {
+ x: t,
+ y: e,
+ base: i,
+ horizontal: a,
+ } = this.getProps(["x", "y", "base", "horizontal"], t);
+ return { x: a ? (t + i) / 2 : t, y: a ? e : (e + i) / 2 };
+ }
+ getRange(t) {
+ return "x" === t ? this.width / 2 : this.height / 2;
+ }
+}
+var elements = Object.freeze({
+ __proto__: null,
+ ArcElement: ArcElement,
+ BarElement: BarElement,
+ LineElement: LineElement,
+ PointElement: PointElement,
+});
+const BORDER_COLORS = [
+ "rgb(54, 162, 235)",
+ "rgb(255, 99, 132)",
+ "rgb(255, 159, 64)",
+ "rgb(255, 205, 86)",
+ "rgb(75, 192, 192)",
+ "rgb(153, 102, 255)",
+ "rgb(201, 203, 207)",
+ ],
+ BACKGROUND_COLORS = BORDER_COLORS.map((t) =>
+ t.replace("rgb(", "rgba(").replace(")", ", 0.5)")
+ );
+function getBorderColor(t) {
+ return BORDER_COLORS[t % BORDER_COLORS.length];
+}
+function getBackgroundColor(t) {
+ return BACKGROUND_COLORS[t % BACKGROUND_COLORS.length];
+}
+function colorizeDefaultDataset(t, e) {
+ return (
+ (t.borderColor = getBorderColor(e)),
+ (t.backgroundColor = getBackgroundColor(e)),
+ ++e
+ );
+}
+function colorizeDoughnutDataset(t, e) {
+ return (t.backgroundColor = t.data.map(() => getBorderColor(e++))), e;
+}
+function colorizePolarAreaDataset(t, e) {
+ return (t.backgroundColor = t.data.map(() => getBackgroundColor(e++))), e;
+}
+function getColorizer(i) {
+ let a = 0;
+ return (t, e) => {
+ e = i.getDatasetMeta(e).controller;
+ e instanceof DoughnutController
+ ? (a = colorizeDoughnutDataset(t, a))
+ : e instanceof PolarAreaController
+ ? (a = colorizePolarAreaDataset(t, a))
+ : e && (a = colorizeDefaultDataset(t, a));
+ };
+}
+function containsColorsDefinitions(t) {
+ let e;
+ for (e in t) if (t[e].borderColor || t[e].backgroundColor) return !0;
+ return !1;
+}
+function containsColorsDefinition(t) {
+ return t && (t.borderColor || t.backgroundColor);
+}
+var plugin_colors = {
+ id: "colors",
+ defaults: { enabled: !0, forceOverride: !1 },
+ beforeLayout(t, e, i) {
+ if (i.enabled) {
+ const {
+ data: { datasets: s },
+ options: n,
+ } = t.config;
+ var a = n["elements"];
+ (!i.forceOverride &&
+ (containsColorsDefinitions(s) ||
+ containsColorsDefinition(n) ||
+ (a && containsColorsDefinitions(a)))) ||
+ ((i = getColorizer(t)), s.forEach(i));
+ }
+ },
+};
+function lttbDecimation(a, s, n, t, e) {
+ var i = e.samples || t;
+ if (n <= i) return a.slice(s, s + n);
+ const r = [];
+ var o = (n - 2) / (i - 2);
+ let l = 0;
+ e = s + n - 1;
+ let h = s,
+ d,
+ c,
+ u,
+ g,
+ p;
+ for (r[l++] = a[h], d = 0; d < i - 2; d++) {
+ let t = 0,
+ e = 0,
+ i;
+ var f = Math.floor((d + 1) * o) + 1 + s,
+ m = Math.min(Math.floor((d + 2) * o) + 1, n) + s,
+ v = m - f;
+ for (i = f; i < m; i++) (t += a[i].x), (e += a[i].y);
+ (t /= v), (e /= v);
+ var f = Math.floor(d * o) + 1 + s,
+ x = Math.min(Math.floor((d + 1) * o) + 1, n) + s,
+ { x: b, y: _ } = a[h];
+ for (u = -1, i = f; i < x; i++)
+ (g = 0.5 * Math.abs((b - t) * (a[i].y - _) - (b - a[i].x) * (e - _))) >
+ u && ((u = g), (c = a[i]), (p = i));
+ (r[l++] = c), (h = p);
+ }
+ return (r[l++] = a[e]), r;
+}
+function minMaxDecimation(t, e, i, a) {
+ let s = 0,
+ n = 0,
+ r,
+ o,
+ l,
+ h,
+ d,
+ c,
+ u,
+ g,
+ p,
+ f;
+ const m = [];
+ var v = t[e].x,
+ x = t[e + i - 1].x - v;
+ for (r = e; r < e + i; ++r) {
+ (l = (((o = t[r]).x - v) / x) * a), (h = o.y);
+ var b,
+ _,
+ y,
+ k = 0 | l;
+ k === d
+ ? (h < p ? ((p = h), (c = r)) : h > f && ((f = h), (u = r)),
+ (s = (n * s + o.x) / ++n))
+ : ((b = r - 1),
+ isNullOrUndef(c) ||
+ isNullOrUndef(u) ||
+ ((_ = Math.min(c, u)),
+ (y = Math.max(c, u)),
+ _ !== g && _ !== b && m.push({ ...t[_], x: s }),
+ y !== g && y !== b && m.push({ ...t[y], x: s })),
+ 0 < r && b !== g && m.push(t[b]),
+ m.push(o),
+ (d = k),
+ (n = 0),
+ (p = f = h),
+ (c = u = g = r));
+ }
+ return m;
+}
+function cleanDecimatedDataset(t) {
+ var e;
+ t._decimated &&
+ ((e = t._data),
+ delete t._decimated,
+ delete t._data,
+ Object.defineProperty(t, "data", {
+ configurable: !0,
+ enumerable: !0,
+ writable: !0,
+ value: e,
+ }));
+}
+function cleanDecimatedData(t) {
+ t.data.datasets.forEach((t) => {
+ cleanDecimatedDataset(t);
+ });
+}
+function getStartAndCountOfVisiblePointsSimplified(t, e) {
+ var i = e.length;
+ let a = 0,
+ s;
+ const n = t["iScale"];
+ var { min: t, max: r, minDefined: o, maxDefined: l } = n.getUserBounds();
+ return (
+ o && (a = _limitValue(_lookupByKey(e, n.axis, t).lo, 0, i - 1)),
+ (s = l ? _limitValue(_lookupByKey(e, n.axis, r).hi + 1, a, i) - a : i - a),
+ { start: a, count: s }
+ );
+}
+var plugin_decimation = {
+ id: "decimation",
+ defaults: { algorithm: "min-max", enabled: !1 },
+ beforeElementsUpdate: (o, t, l) => {
+ if (l.enabled) {
+ const h = o.width;
+ o.data.datasets.forEach((e, t) => {
+ var { _data: i, indexAxis: a } = e,
+ t = o.getDatasetMeta(t),
+ s = i || e.data;
+ if (
+ "y" !== resolve([a, o.options.indexAxis]) &&
+ t.controller.supportsDecimation
+ ) {
+ a = o.scales[t.xAxisID];
+ if (
+ ("linear" === a.type || "time" === a.type) &&
+ !o.options.parsing
+ ) {
+ var { start: n, count: r } =
+ getStartAndCountOfVisiblePointsSimplified(t, s);
+ if (r <= (l.threshold || 4 * h)) cleanDecimatedDataset(e);
+ else {
+ isNullOrUndef(i) &&
+ ((e._data = s),
+ delete e.data,
+ Object.defineProperty(e, "data", {
+ configurable: !0,
+ enumerable: !0,
+ get: function () {
+ return this._decimated;
+ },
+ set: function (t) {
+ this._data = t;
+ },
+ }));
+ let t;
+ switch (l.algorithm) {
+ case "lttb":
+ t = lttbDecimation(s, n, r, h, l);
+ break;
+ case "min-max":
+ t = minMaxDecimation(s, n, r, h);
+ break;
+ default:
+ throw new Error(
+ `Unsupported decimation algorithm '${l.algorithm}'`
+ );
+ }
+ e._decimated = t;
+ }
+ }
+ }
+ });
+ } else cleanDecimatedData(o);
+ },
+ destroy(t) {
+ cleanDecimatedData(t);
+ },
+};
+function _segments(t, e, i) {
+ var a = t.segments,
+ s = t.points,
+ n = e.points;
+ const r = [];
+ for (const c of a) {
+ var { start: o, end: l } = c,
+ l = _findSegmentEnd(o, l, s),
+ h = _getBounds(i, s[o], s[l], c.loop);
+ if (e.segments)
+ for (const u of _boundSegments(e, h)) {
+ var d = _getBounds(i, n[u.start], n[u.end], u.loop);
+ for (const g of _boundSegment(c, s, d))
+ r.push({
+ source: g,
+ target: u,
+ start: { [i]: _getEdge(h, d, "start", Math.max) },
+ end: { [i]: _getEdge(h, d, "end", Math.min) },
+ });
+ }
+ else r.push({ source: c, target: h, start: s[o], end: s[l] });
+ }
+ return r;
+}
+function _getBounds(i, a, s, t) {
+ if (!t) {
+ let t = a[i],
+ e = s[i];
+ return (
+ "angle" === i && ((t = _normalizeAngle(t)), (e = _normalizeAngle(e))),
+ { property: i, start: t, end: e }
+ );
+ }
+}
+function _pointsFromSegments(t, e) {
+ const { x: i = null, y: a = null } = t || {},
+ s = e.points,
+ n = [];
+ return (
+ e.segments.forEach(({ start: t, end: e }) => {
+ e = _findSegmentEnd(t, e, s);
+ (t = s[t]), (e = s[e]);
+ null !== a
+ ? (n.push({ x: t.x, y: a }), n.push({ x: e.x, y: a }))
+ : null !== i && (n.push({ x: i, y: t.y }), n.push({ x: i, y: e.y }));
+ }),
+ n
+ );
+}
+function _findSegmentEnd(t, e, i) {
+ for (; t < e; e--) {
+ var a = i[e];
+ if (!isNaN(a.x) && !isNaN(a.y)) break;
+ }
+ return e;
+}
+function _getEdge(t, e, i, a) {
+ return t && e ? a(t[i], e[i]) : t ? t[i] : e ? e[i] : 0;
+}
+function _createBoundaryLine(t, e) {
+ let i = [],
+ a = !1;
+ return (i = isArray(t) ? ((a = !0), t) : _pointsFromSegments(t, e)).length
+ ? new LineElement({
+ points: i,
+ options: { tension: 0 },
+ _loop: a,
+ _fullLoop: a,
+ })
+ : null;
+}
+function _shouldApplyFill(t) {
+ return t && !1 !== t.fill;
+}
+function _resolveTarget(t, e, i) {
+ var a;
+ let s = t[e].fill;
+ const n = [e];
+ if (!i) return s;
+ for (; !1 !== s && -1 === n.indexOf(s); ) {
+ if (!isNumberFinite(s)) return s;
+ if (!(a = t[s])) return !1;
+ if (a.visible) return s;
+ n.push(s), (s = a.fill);
+ }
+ return !1;
+}
+function _decodeFill(t, e, i) {
+ t = parseFillOption(t);
+ if (isObject(t)) return !isNaN(t.value) && t;
+ var a = parseFloat(t);
+ return isNumberFinite(a) && Math.floor(a) === a
+ ? decodeTargetIndex(t[0], e, a, i)
+ : 0 <= ["origin", "start", "end", "stack", "shape"].indexOf(t) && t;
+}
+function decodeTargetIndex(t, e, i, a) {
+ return (
+ !((i = "-" !== t && "+" !== t ? i : e + i) === e || i < 0 || a <= i) && i
+ );
+}
+function _getTargetPixel(t, e) {
+ let i = null;
+ return (
+ "start" === t
+ ? (i = e.bottom)
+ : "end" === t
+ ? (i = e.top)
+ : isObject(t)
+ ? (i = e.getPixelForValue(t.value))
+ : e.getBasePixel && (i = e.getBasePixel()),
+ i
+ );
+}
+function _getTargetValue(t, e, i) {
+ let a;
+ return (a =
+ "start" === t
+ ? i
+ : "end" === t
+ ? e.options.reverse
+ ? e.min
+ : e.max
+ : isObject(t)
+ ? t.value
+ : e.getBaseValue());
+}
+function parseFillOption(t) {
+ var t = t.options,
+ e = t.fill;
+ let i = valueOrDefault(e && e.target, e);
+ return (
+ !1 !== (i = void 0 === i ? !!t.backgroundColor : i) &&
+ null !== i &&
+ (!0 === i ? "origin" : i)
+ );
+}
+function _buildStackLine(t) {
+ var { scale: t, index: e, line: i } = t,
+ a = [],
+ s = i.segments,
+ n = i.points;
+ const r = getLinesBelow(t, e);
+ r.push(_createBoundaryLine({ x: null, y: t.bottom }, i));
+ for (let t = 0; t < s.length; t++) {
+ var o = s[t];
+ for (let t = o.start; t <= o.end; t++) addPointsBelow(a, n[t], r);
+ }
+ return new LineElement({ points: a, options: {} });
+}
+function getLinesBelow(t, e) {
+ const i = [];
+ var a = t.getMatchingVisibleMetas("line");
+ for (let t = 0; t < a.length; t++) {
+ var s = a[t];
+ if (s.index === e) break;
+ s.hidden || i.unshift(s.dataset);
+ }
+ return i;
+}
+function addPointsBelow(e, i, a) {
+ const s = [];
+ for (let t = 0; t < a.length; t++) {
+ var { first: n, last: r, point: o } = findPoint(a[t], i, "x");
+ if (!(!o || (n && r)))
+ if (n) s.unshift(o);
+ else if ((e.push(o), !r)) break;
+ }
+ e.push(...s);
+}
+function findPoint(t, e, i) {
+ e = t.interpolate(e, i);
+ if (!e) return {};
+ var a = e[i],
+ s = t.segments,
+ n = t.points;
+ let r = !1,
+ o = !1;
+ for (let t = 0; t < s.length; t++) {
+ var l = s[t],
+ h = n[l.start][i],
+ l = n[l.end][i];
+ if (_isBetween(a, h, l)) {
+ (r = a === h), (o = a === l);
+ break;
+ }
+ }
+ return { first: r, last: o, point: e };
+}
+class simpleArc {
+ constructor(t) {
+ (this.x = t.x), (this.y = t.y), (this.radius = t.radius);
+ }
+ pathSegment(t, e, i) {
+ var { x: a, y: s, radius: n } = this;
+ return (
+ t.arc(a, s, n, (e = e || { start: 0, end: TAU }).end, e.start, !0),
+ !i.bounds
+ );
+ }
+ interpolate(t) {
+ var { x: e, y: i, radius: a } = this,
+ t = t.angle;
+ return { x: e + Math.cos(t) * a, y: i + Math.sin(t) * a, angle: t };
+ }
+}
+function _getTarget(t) {
+ var { chart: e, fill: i, line: a } = t;
+ if (isNumberFinite(i)) return getLineByIndex(e, i);
+ if ("stack" === i) return _buildStackLine(t);
+ if ("shape" === i) return !0;
+ e = computeBoundary(t);
+ return e instanceof simpleArc ? e : _createBoundaryLine(e, a);
+}
+function getLineByIndex(t, e) {
+ var i = t.getDatasetMeta(e);
+ return i && t.isDatasetVisible(e) ? i.dataset : null;
+}
+function computeBoundary(t) {
+ return (
+ (t.scale || {}).getPointPositionForValue
+ ? computeCircularBoundary
+ : computeLinearBoundary
+ )(t);
+}
+function computeLinearBoundary(t) {
+ const { scale: e = {}, fill: i } = t;
+ var a,
+ t = _getTargetPixel(i, e);
+ return isNumberFinite(t)
+ ? { x: (a = e.isHorizontal()) ? t : null, y: a ? null : t }
+ : null;
+}
+function computeCircularBoundary(t) {
+ const { scale: e, fill: i } = t;
+ var t = e.options,
+ a = e.getLabels().length,
+ s = t.reverse ? e.max : e.min,
+ n = _getTargetValue(i, e, s);
+ const r = [];
+ if (t.grid.circular)
+ return (
+ (t = e.getPointPositionForValue(0, s)),
+ new simpleArc({
+ x: t.x,
+ y: t.y,
+ radius: e.getDistanceFromCenterForValue(n),
+ })
+ );
+ for (let t = 0; t < a; ++t) r.push(e.getPointPositionForValue(t, n));
+ return r;
+}
+function _drawfill(t, e, i) {
+ var a = _getTarget(e),
+ { line: e, scale: s, axis: n } = e,
+ r = e.options,
+ o = r.fill,
+ r = r.backgroundColor,
+ { above: o = r, below: r = r } = o || {};
+ a &&
+ e.points.length &&
+ (clipArea(t, i),
+ doFill(t, {
+ line: e,
+ target: a,
+ above: o,
+ below: r,
+ area: i,
+ scale: s,
+ axis: n,
+ }),
+ unclipArea(t));
+}
+function doFill(t, e) {
+ var { line: i, target: a, above: s, below: n, area: r, scale: o } = e,
+ e = i._loop ? "angle" : e.axis;
+ t.save(),
+ "x" === e &&
+ n !== s &&
+ (clipVertical(t, a, r.top),
+ fill(t, { line: i, target: a, color: s, scale: o, property: e }),
+ t.restore(),
+ t.save(),
+ clipVertical(t, a, r.bottom)),
+ fill(t, { line: i, target: a, color: n, scale: o, property: e }),
+ t.restore();
+}
+function clipVertical(t, e, i) {
+ var { segments: a, points: s } = e;
+ let n = !0,
+ r = !1;
+ t.beginPath();
+ for (const d of a) {
+ var { start: o, end: l } = d,
+ h = s[o],
+ o = s[_findSegmentEnd(o, l, s)];
+ n ? (t.moveTo(h.x, h.y), (n = !1)) : (t.lineTo(h.x, i), t.lineTo(h.x, h.y)),
+ (r = !!e.pathSegment(t, d, { move: r }))
+ ? t.closePath()
+ : t.lineTo(o.x, i);
+ }
+ t.lineTo(e.first().x, i), t.closePath(), t.clip();
+}
+function fill(e, t) {
+ const { line: i, target: a, property: s, color: n, scale: r } = t;
+ var o, l, h, d;
+ for ({ source: o, target: l, start: h, end: d } of _segments(i, a, s)) {
+ var { style: { backgroundColor: c = n } = {} } = o,
+ u = !0 !== a,
+ c =
+ (e.save(),
+ (e.fillStyle = c),
+ clipBounds(e, r, u && _getBounds(s, h, d)),
+ e.beginPath(),
+ !!i.pathSegment(e, o));
+ let t;
+ u &&
+ (c ? e.closePath() : interpolatedLineTo(e, a, d, s),
+ (u = !!a.pathSegment(e, l, { move: c, reverse: !0 })),
+ (t = c && u) || interpolatedLineTo(e, a, h, s)),
+ e.closePath(),
+ e.fill(t ? "evenodd" : "nonzero"),
+ e.restore();
+ }
+}
+function clipBounds(t, e, i) {
+ var { top: e, bottom: a } = e.chart.chartArea,
+ { property: i, start: s, end: n } = i || {};
+ "x" === i && (t.beginPath(), t.rect(s, e, n - s, a - e), t.clip());
+}
+function interpolatedLineTo(t, e, i, a) {
+ e = e.interpolate(i, a);
+ e && t.lineTo(e.x, e.y);
+}
+var index = {
+ id: "filler",
+ afterDatasetsUpdate(t, e, i) {
+ var a = (t.data.datasets || []).length;
+ const s = [];
+ let n, r, o, l;
+ for (r = 0; r < a; ++r)
+ (o = (n = t.getDatasetMeta(r)).dataset),
+ (l = null),
+ o &&
+ o.options &&
+ o instanceof LineElement &&
+ (l = {
+ visible: t.isDatasetVisible(r),
+ index: r,
+ fill: _decodeFill(o, r, a),
+ chart: t,
+ axis: n.controller.options.indexAxis,
+ scale: n.vScale,
+ line: o,
+ }),
+ (n.$filler = l),
+ s.push(l);
+ for (r = 0; r < a; ++r)
+ (l = s[r]) &&
+ !1 !== l.fill &&
+ (l.fill = _resolveTarget(s, r, i.propagate));
+ },
+ beforeDraw(e, t, i) {
+ var a = "beforeDraw" === i.drawTime,
+ s = e.getSortedVisibleDatasetMetas(),
+ n = e.chartArea;
+ for (let t = s.length - 1; 0 <= t; --t) {
+ const r = s[t].$filler;
+ r &&
+ (r.line.updateControlPoints(n, r.axis),
+ a && r.fill && _drawfill(e.ctx, r, n));
+ }
+ },
+ beforeDatasetsDraw(e, t, i) {
+ if ("beforeDatasetsDraw" === i.drawTime) {
+ var a = e.getSortedVisibleDatasetMetas();
+ for (let t = a.length - 1; 0 <= t; --t) {
+ var s = a[t].$filler;
+ _shouldApplyFill(s) && _drawfill(e.ctx, s, e.chartArea);
+ }
+ }
+ },
+ beforeDatasetDraw(t, e, i) {
+ e = e.meta.$filler;
+ _shouldApplyFill(e) &&
+ "beforeDatasetDraw" === i.drawTime &&
+ _drawfill(t.ctx, e, t.chartArea);
+ },
+ defaults: { propagate: !0, drawTime: "beforeDatasetDraw" },
+};
+const getBoxSize = (t, e) => {
+ let { boxHeight: i = e, boxWidth: a = e } = t;
+ return (
+ t.usePointStyle &&
+ ((i = Math.min(i, e)), (a = t.pointStyleWidth || Math.min(a, e))),
+ { boxWidth: a, boxHeight: i, itemHeight: Math.max(e, i) }
+ );
+ },
+ itemsEqual = (t, e) =>
+ null !== t &&
+ null !== e &&
+ t.datasetIndex === e.datasetIndex &&
+ t.index === e.index;
+class Legend extends Element {
+ constructor(t) {
+ super(),
+ (this._added = !1),
+ (this.legendHitBoxes = []),
+ (this._hoveredItem = null),
+ (this.doughnutMode = !1),
+ (this.chart = t.chart),
+ (this.options = t.options),
+ (this.ctx = t.ctx),
+ (this.legendItems = void 0),
+ (this.columnSizes = void 0),
+ (this.lineWidths = void 0),
+ (this.maxHeight = void 0),
+ (this.maxWidth = void 0),
+ (this.top = void 0),
+ (this.bottom = void 0),
+ (this.left = void 0),
+ (this.right = void 0),
+ (this.height = void 0),
+ (this.width = void 0),
+ (this._margins = void 0),
+ (this.position = void 0),
+ (this.weight = void 0),
+ (this.fullSize = void 0);
+ }
+ update(t, e, i) {
+ (this.maxWidth = t),
+ (this.maxHeight = e),
+ (this._margins = i),
+ this.setDimensions(),
+ this.buildLabels(),
+ this.fit();
+ }
+ setDimensions() {
+ this.isHorizontal()
+ ? ((this.width = this.maxWidth),
+ (this.left = this._margins.left),
+ (this.right = this.width))
+ : ((this.height = this.maxHeight),
+ (this.top = this._margins.top),
+ (this.bottom = this.height));
+ }
+ buildLabels() {
+ const i = this.options.labels || {};
+ let t = callback(i.generateLabels, [this.chart], this) || [];
+ i.filter && (t = t.filter((t) => i.filter(t, this.chart.data))),
+ i.sort && (t = t.sort((t, e) => i.sort(t, e, this.chart.data))),
+ this.options.reverse && t.reverse(),
+ (this.legendItems = t);
+ }
+ fit() {
+ const { options: i, ctx: a } = this;
+ if (i.display) {
+ var s = i.labels,
+ n = toFont(s.font),
+ r = n.size,
+ o = this._computeTitleHeight(),
+ { boxWidth: s, itemHeight: l } = getBoxSize(s, r);
+ let t, e;
+ (a.font = n.string),
+ this.isHorizontal()
+ ? ((t = this.maxWidth), (e = this._fitRows(o, r, s, l) + 10))
+ : ((e = this.maxHeight), (t = this._fitCols(o, n, s, l) + 10)),
+ (this.width = Math.min(t, i.maxWidth || this.maxWidth)),
+ (this.height = Math.min(e, i.maxHeight || this.maxHeight));
+ } else this.width = this.height = 0;
+ }
+ _fitRows(t, i, a, s) {
+ const {
+ ctx: n,
+ maxWidth: r,
+ options: {
+ labels: { padding: o },
+ },
+ } = this,
+ l = (this.legendHitBoxes = []),
+ h = (this.lineWidths = [0]),
+ d = s + o;
+ let c = t,
+ u = ((n.textAlign = "left"), (n.textBaseline = "middle"), -1),
+ g = -d;
+ return (
+ this.legendItems.forEach((t, e) => {
+ t = a + i / 2 + n.measureText(t.text).width;
+ (0 === e || h[h.length - 1] + t + 2 * o > r) &&
+ ((c += d), (h[h.length - (0 < e ? 0 : 1)] = 0), (g += d), u++),
+ (l[e] = { left: 0, top: g, row: u, width: t, height: s }),
+ (h[h.length - 1] += t + o);
+ }),
+ c
+ );
+ }
+ _fitCols(t, a, s, n) {
+ const {
+ ctx: r,
+ maxHeight: e,
+ options: {
+ labels: { padding: o },
+ },
+ } = this,
+ l = (this.legendHitBoxes = []),
+ h = (this.columnSizes = []),
+ d = e - t;
+ let c = o,
+ u = 0,
+ g = 0,
+ p = 0,
+ f = 0;
+ return (
+ this.legendItems.forEach((t, e) => {
+ var { itemWidth: t, itemHeight: i } = calculateItemSize(s, a, r, t, n);
+ 0 < e &&
+ g + i + 2 * o > d &&
+ ((c += u + o),
+ h.push({ width: u, height: g }),
+ (p += u + o),
+ f++,
+ (u = g = 0)),
+ (l[e] = { left: p, top: g, col: f, width: t, height: i }),
+ (u = Math.max(u, t)),
+ (g += i + o);
+ }),
+ (c += u),
+ h.push({ width: u, height: g }),
+ c
+ );
+ }
+ adjustHitBoxes() {
+ if (this.options.display) {
+ var i = this._computeTitleHeight(),
+ {
+ legendHitBoxes: a,
+ options: {
+ align: s,
+ labels: { padding: n },
+ rtl: t,
+ },
+ } = this;
+ const r = getRtlAdapter(t, this.left, this.width);
+ if (this.isHorizontal()) {
+ let t = 0,
+ e = _alignStartEnd(s, this.left + n, this.right - this.lineWidths[t]);
+ for (const o of a)
+ t !== o.row &&
+ ((t = o.row),
+ (e = _alignStartEnd(
+ s,
+ this.left + n,
+ this.right - this.lineWidths[t]
+ ))),
+ (o.top += this.top + i + n),
+ (o.left = r.leftForLtr(r.x(e), o.width)),
+ (e += o.width + n);
+ } else {
+ let t = 0,
+ e = _alignStartEnd(
+ s,
+ this.top + i + n,
+ this.bottom - this.columnSizes[t].height
+ );
+ for (const l of a)
+ l.col !== t &&
+ ((t = l.col),
+ (e = _alignStartEnd(
+ s,
+ this.top + i + n,
+ this.bottom - this.columnSizes[t].height
+ ))),
+ (l.top = e),
+ (l.left += this.left + n),
+ (l.left = r.leftForLtr(r.x(l.left), l.width)),
+ (e += l.height + n);
+ }
+ }
+ }
+ isHorizontal() {
+ return (
+ "top" === this.options.position || "bottom" === this.options.position
+ );
+ }
+ draw() {
+ var t;
+ this.options.display &&
+ ((t = this.ctx), clipArea(t, this), this._draw(), unclipArea(t));
+ }
+ _draw() {
+ const { options: u, columnSizes: g, lineWidths: p, ctx: f } = this,
+ { align: m, labels: v } = u,
+ x = defaults.color,
+ b = getRtlAdapter(u.rtl, this.left, this.width),
+ _ = toFont(v.font),
+ y = v["padding"],
+ k = _.size,
+ S = k / 2;
+ let D;
+ this.drawTitle(),
+ (f.textAlign = b.textAlign("left")),
+ (f.textBaseline = "middle"),
+ (f.lineWidth = 0.5),
+ (f.font = _.string);
+ const { boxWidth: M, boxHeight: P, itemHeight: A } = getBoxSize(v, k),
+ w = this.isHorizontal(),
+ C = this._computeTitleHeight(),
+ O =
+ ((D = w
+ ? {
+ x: _alignStartEnd(m, this.left + y, this.right - p[0]),
+ y: this.top + y + C,
+ line: 0,
+ }
+ : {
+ x: this.left + y,
+ y: _alignStartEnd(m, this.top + C + y, this.bottom - g[0].height),
+ line: 0,
+ }),
+ overrideTextDirection(this.ctx, u.textDirection),
+ A + y);
+ this.legendItems.forEach((t, e) => {
+ (f.strokeStyle = t.fontColor), (f.fillStyle = t.fontColor);
+ var i = f.measureText(t.text).width,
+ a = b.textAlign(t.textAlign || (t.textAlign = v.textAlign)),
+ i = M + S + i;
+ let s = D.x,
+ n = D.y;
+ b.setWidth(this.width),
+ w
+ ? 0 < e &&
+ s + i + y > this.right &&
+ ((n = D.y += O),
+ D.line++,
+ (s = D.x =
+ _alignStartEnd(m, this.left + y, this.right - p[D.line])))
+ : 0 < e &&
+ n + O > this.bottom &&
+ ((s = D.x = s + g[D.line].width + y),
+ D.line++,
+ (n = D.y =
+ _alignStartEnd(
+ m,
+ this.top + C + y,
+ this.bottom - g[D.line].height
+ )));
+ var r,
+ o,
+ l,
+ h,
+ d,
+ c,
+ e = b.x(s);
+ (e = e),
+ (h = n),
+ (d = t),
+ isNaN(M) ||
+ M <= 0 ||
+ isNaN(P) ||
+ P < 0 ||
+ (f.save(),
+ (r = valueOrDefault(d.lineWidth, 1)),
+ (f.fillStyle = valueOrDefault(d.fillStyle, x)),
+ (f.lineCap = valueOrDefault(d.lineCap, "butt")),
+ (f.lineDashOffset = valueOrDefault(d.lineDashOffset, 0)),
+ (f.lineJoin = valueOrDefault(d.lineJoin, "miter")),
+ (f.lineWidth = r),
+ (f.strokeStyle = valueOrDefault(d.strokeStyle, x)),
+ f.setLineDash(valueOrDefault(d.lineDash, [])),
+ v.usePointStyle
+ ? ((o = {
+ radius: (P * Math.SQRT2) / 2,
+ pointStyle: d.pointStyle,
+ rotation: d.rotation,
+ borderWidth: r,
+ }),
+ (l = b.xPlus(e, M / 2)),
+ (c = h + S),
+ drawPointLegend(f, o, l, c, v.pointStyleWidth && M))
+ : ((o = h + Math.max((k - P) / 2, 0)),
+ (l = b.leftForLtr(e, M)),
+ (c = toTRBLCorners(d.borderRadius)),
+ f.beginPath(),
+ Object.values(c).some((t) => 0 !== t)
+ ? addRoundedRectPath(f, { x: l, y: o, w: M, h: P, radius: c })
+ : f.rect(l, o, M, P),
+ f.fill(),
+ 0 !== r && f.stroke()),
+ f.restore()),
+ (s = _textX(a, s + M + S, w ? s + i : this.right, u.rtl)),
+ (h = b.x(s)),
+ (e = n),
+ (d = t),
+ renderText(f, d.text, h, e + A / 2, _, {
+ strikethrough: d.hidden,
+ textAlign: b.textAlign(d.textAlign),
+ }),
+ w
+ ? (D.x += i + y)
+ : "string" != typeof t.text
+ ? ((c = _.lineHeight), (D.y += calculateLegendItemHeight(t, c) + y))
+ : (D.y += O);
+ }),
+ restoreTextDirection(this.ctx, u.textDirection);
+ }
+ drawTitle() {
+ var a = this.options,
+ s = a.title,
+ n = toFont(s.font),
+ r = toPadding(s.padding);
+ if (s.display) {
+ const h = getRtlAdapter(a.rtl, this.left, this.width),
+ d = this.ctx;
+ var o = s.position,
+ l = n.size / 2,
+ r = r.top + l;
+ let t,
+ e = this.left,
+ i = this.width;
+ this.isHorizontal()
+ ? ((i = Math.max(...this.lineWidths)),
+ (t = this.top + r),
+ (e = _alignStartEnd(a.align, e, this.right - i)))
+ : ((l = this.columnSizes.reduce((t, e) => Math.max(t, e.height), 0)),
+ (t =
+ r +
+ _alignStartEnd(
+ a.align,
+ this.top,
+ this.bottom - l - a.labels.padding - this._computeTitleHeight()
+ )));
+ r = _alignStartEnd(o, e, e + i);
+ (d.textAlign = h.textAlign(_toLeftRightCenter(o))),
+ (d.textBaseline = "middle"),
+ (d.strokeStyle = s.color),
+ (d.fillStyle = s.color),
+ (d.font = n.string),
+ renderText(d, s.text, r, t, n);
+ }
+ }
+ _computeTitleHeight() {
+ var t = this.options.title,
+ e = toFont(t.font),
+ i = toPadding(t.padding);
+ return t.display ? e.lineHeight + i.height : 0;
+ }
+ _getLegendItemAt(t, e) {
+ let i, a, s;
+ if (
+ _isBetween(t, this.left, this.right) &&
+ _isBetween(e, this.top, this.bottom)
+ )
+ for (s = this.legendHitBoxes, i = 0; i < s.length; ++i)
+ if (
+ ((a = s[i]),
+ _isBetween(t, a.left, a.left + a.width) &&
+ _isBetween(e, a.top, a.top + a.height))
+ )
+ return this.legendItems[i];
+ return null;
+ }
+ handleEvent(t) {
+ var e,
+ i,
+ a,
+ s = this.options;
+ isListened(t.type, s) &&
+ ((e = this._getLegendItemAt(t.x, t.y)),
+ "mousemove" === t.type || "mouseout" === t.type
+ ? ((i = this._hoveredItem),
+ (a = itemsEqual(i, e)),
+ i && !a && callback(s.onLeave, [t, i, this], this),
+ (this._hoveredItem = e) &&
+ !a &&
+ callback(s.onHover, [t, e, this], this))
+ : e && callback(s.onClick, [t, e, this], this));
+ }
+}
+function calculateItemSize(t, e, i, a, s) {
+ return {
+ itemWidth: calculateItemWidth(a, t, e, i),
+ itemHeight: calculateItemHeight(s, a, e.lineHeight),
+ };
+}
+function calculateItemWidth(t, e, i, a) {
+ let s = t.text;
+ return (
+ s &&
+ "string" != typeof s &&
+ (s = s.reduce((t, e) => (t.length > e.length ? t : e))),
+ e + i.size / 2 + a.measureText(s).width
+ );
+}
+function calculateItemHeight(t, e, i) {
+ let a = t;
+ return (a = "string" != typeof e.text ? calculateLegendItemHeight(e, i) : a);
+}
+function calculateLegendItemHeight(t, e) {
+ return e * (t.text ? t.text.length : 0);
+}
+function isListened(t, e) {
+ return (
+ !(("mousemove" !== t && "mouseout" !== t) || (!e.onHover && !e.onLeave)) ||
+ !(!e.onClick || ("click" !== t && "mouseup" !== t))
+ );
+}
+var plugin_legend = {
+ id: "legend",
+ _element: Legend,
+ start(t, e, i) {
+ var a = (t.legend = new Legend({ ctx: t.ctx, options: i, chart: t }));
+ layouts.configure(t, a, i), layouts.addBox(t, a);
+ },
+ stop(t) {
+ layouts.removeBox(t, t.legend), delete t.legend;
+ },
+ beforeUpdate(t, e, i) {
+ const a = t.legend;
+ layouts.configure(t, a, i), (a.options = i);
+ },
+ afterUpdate(t) {
+ const e = t.legend;
+ e.buildLabels(), e.adjustHitBoxes();
+ },
+ afterEvent(t, e) {
+ e.replay || t.legend.handleEvent(e.event);
+ },
+ defaults: {
+ display: !0,
+ position: "top",
+ align: "center",
+ fullSize: !0,
+ reverse: !1,
+ weight: 1e3,
+ onClick(t, e, i) {
+ var a = e.datasetIndex;
+ const s = i.chart;
+ s.isDatasetVisible(a)
+ ? (s.hide(a), (e.hidden = !0))
+ : (s.show(a), (e.hidden = !1));
+ },
+ onHover: null,
+ onLeave: null,
+ labels: {
+ color: (t) => t.chart.options.color,
+ boxWidth: 40,
+ padding: 10,
+ generateLabels(t) {
+ const a = t.data.datasets,
+ {
+ usePointStyle: s,
+ pointStyle: n,
+ textAlign: r,
+ color: o,
+ useBorderRadius: l,
+ borderRadius: h,
+ } = t.legend.options["labels"];
+ return t._getSortedDatasetMetas().map((t) => {
+ var e = t.controller.getStyle(s ? 0 : void 0),
+ i = toPadding(e.borderWidth);
+ return {
+ text: a[t.index].label,
+ fillStyle: e.backgroundColor,
+ fontColor: o,
+ hidden: !t.visible,
+ lineCap: e.borderCapStyle,
+ lineDash: e.borderDash,
+ lineDashOffset: e.borderDashOffset,
+ lineJoin: e.borderJoinStyle,
+ lineWidth: (i.width + i.height) / 4,
+ strokeStyle: e.borderColor,
+ pointStyle: n || e.pointStyle,
+ rotation: e.rotation,
+ textAlign: r || e.textAlign,
+ borderRadius: l && (h || e.borderRadius),
+ datasetIndex: t.index,
+ };
+ }, this);
+ },
+ },
+ title: {
+ color: (t) => t.chart.options.color,
+ display: !1,
+ position: "center",
+ text: "",
+ },
+ },
+ descriptors: {
+ _scriptable: (t) => !t.startsWith("on"),
+ labels: {
+ _scriptable: (t) => !["generateLabels", "filter", "sort"].includes(t),
+ },
+ },
+};
+class Title extends Element {
+ constructor(t) {
+ super(),
+ (this.chart = t.chart),
+ (this.options = t.options),
+ (this.ctx = t.ctx),
+ (this._padding = void 0),
+ (this.top = void 0),
+ (this.bottom = void 0),
+ (this.left = void 0),
+ (this.right = void 0),
+ (this.width = void 0),
+ (this.height = void 0),
+ (this.position = void 0),
+ (this.weight = void 0),
+ (this.fullSize = void 0);
+ }
+ update(t, e) {
+ var i = this.options;
+ (this.left = 0),
+ (this.top = 0),
+ i.display
+ ? ((this.width = this.right = t),
+ (this.height = this.bottom = e),
+ (t = isArray(i.text) ? i.text.length : 1),
+ (this._padding = toPadding(i.padding)),
+ (e = t * toFont(i.font).lineHeight + this._padding.height),
+ this.isHorizontal() ? (this.height = e) : (this.width = e))
+ : (this.width = this.height = this.right = this.bottom = 0);
+ }
+ isHorizontal() {
+ var t = this.options.position;
+ return "top" === t || "bottom" === t;
+ }
+ _drawArgs(t) {
+ var { top: e, left: i, bottom: a, right: s, options: n } = this,
+ r = n.align;
+ let o = 0,
+ l,
+ h,
+ d;
+ return (
+ (l = this.isHorizontal()
+ ? ((h = _alignStartEnd(r, i, s)), (d = e + t), s - i)
+ : ((o =
+ "left" === n.position
+ ? ((h = i + t), (d = _alignStartEnd(r, a, e)), -0.5 * PI)
+ : ((h = s - t), (d = _alignStartEnd(r, e, a)), 0.5 * PI)),
+ a - e)),
+ { titleX: h, titleY: d, maxWidth: l, rotation: o }
+ );
+ }
+ draw() {
+ var t,
+ e,
+ i,
+ a,
+ s,
+ n = this.ctx,
+ r = this.options;
+ r.display &&
+ ((e = (t = toFont(r.font)).lineHeight / 2 + this._padding.top),
+ ({ titleX: e, titleY: i, maxWidth: a, rotation: s } = this._drawArgs(e)),
+ renderText(n, r.text, 0, 0, t, {
+ color: r.color,
+ maxWidth: a,
+ rotation: s,
+ textAlign: _toLeftRightCenter(r.align),
+ textBaseline: "middle",
+ translation: [e, i],
+ }));
+ }
+}
+function createTitle(t, e) {
+ var i = new Title({ ctx: t.ctx, options: e, chart: t });
+ layouts.configure(t, i, e), layouts.addBox(t, i), (t.titleBlock = i);
+}
+var plugin_title = {
+ id: "title",
+ _element: Title,
+ start(t, e, i) {
+ createTitle(t, i);
+ },
+ stop(t) {
+ var e = t.titleBlock;
+ layouts.removeBox(t, e), delete t.titleBlock;
+ },
+ beforeUpdate(t, e, i) {
+ const a = t.titleBlock;
+ layouts.configure(t, a, i), (a.options = i);
+ },
+ defaults: {
+ align: "center",
+ display: !1,
+ font: { weight: "bold" },
+ fullSize: !0,
+ padding: 10,
+ position: "top",
+ text: "",
+ weight: 2e3,
+ },
+ defaultRoutes: { color: "color" },
+ descriptors: { _scriptable: !0, _indexable: !1 },
+};
+const map = new WeakMap();
+var plugin_subtitle = {
+ id: "subtitle",
+ start(t, e, i) {
+ var a = new Title({ ctx: t.ctx, options: i, chart: t });
+ layouts.configure(t, a, i), layouts.addBox(t, a), map.set(t, a);
+ },
+ stop(t) {
+ layouts.removeBox(t, map.get(t)), map.delete(t);
+ },
+ beforeUpdate(t, e, i) {
+ const a = map.get(t);
+ layouts.configure(t, a, i), (a.options = i);
+ },
+ defaults: {
+ align: "center",
+ display: !1,
+ font: { weight: "normal" },
+ fullSize: !0,
+ padding: 0,
+ position: "top",
+ text: "",
+ weight: 1500,
+ },
+ defaultRoutes: { color: "color" },
+ descriptors: { _scriptable: !0, _indexable: !1 },
+};
+const positioners = {
+ average(t) {
+ if (!t.length) return !1;
+ let e,
+ i,
+ a = 0,
+ s = 0,
+ n = 0;
+ for (e = 0, i = t.length; e < i; ++e) {
+ const o = t[e].element;
+ var r;
+ o &&
+ o.hasValue() &&
+ ((r = o.tooltipPosition()), (a += r.x), (s += r.y), ++n);
+ }
+ return { x: a / n, y: s / n };
+ },
+ nearest(t, e) {
+ if (!t.length) return !1;
+ let i = e.x,
+ a = e.y,
+ s = Number.POSITIVE_INFINITY,
+ n,
+ r,
+ o;
+ for (n = 0, r = t.length; n < r; ++n) {
+ const d = t[n].element;
+ var l;
+ d &&
+ d.hasValue() &&
+ ((l = d.getCenterPoint()),
+ (l = distanceBetweenPoints(e, l)) < s && ((s = l), (o = d)));
+ }
+ var h;
+ return (
+ o && ((h = o.tooltipPosition()), (i = h.x), (a = h.y)), { x: i, y: a }
+ );
+ },
+};
+function pushOrConcat(t, e) {
+ return e && (isArray(e) ? Array.prototype.push.apply(t, e) : t.push(e)), t;
+}
+function splitNewlines(t) {
+ return ("string" == typeof t || t instanceof String) && -1 < t.indexOf("\n")
+ ? t.split("\n")
+ : t;
+}
+function createTooltipItem(t, e) {
+ var { element: e, datasetIndex: i, index: a } = e;
+ const s = t.getDatasetMeta(i).controller;
+ var { label: n, value: r } = s.getLabelAndValue(a);
+ return {
+ chart: t,
+ label: n,
+ parsed: s.getParsed(a),
+ raw: t.data.datasets[i].data[a],
+ formattedValue: r,
+ dataset: s.getDataset(),
+ dataIndex: a,
+ datasetIndex: i,
+ element: e,
+ };
+}
+function getTooltipSize(t, e) {
+ const i = t.chart.ctx,
+ { body: a, footer: s, title: n } = t;
+ var { boxWidth: r, boxHeight: o } = e,
+ l = toFont(e.bodyFont),
+ h = toFont(e.titleFont),
+ d = toFont(e.footerFont),
+ c = n.length,
+ u = s.length,
+ g = a.length,
+ p = toPadding(e.padding);
+ let f = p.height,
+ m = 0;
+ var v = a.reduce(
+ (t, e) => t + e.before.length + e.lines.length + e.after.length,
+ 0
+ );
+ (v += t.beforeBody.length + t.afterBody.length),
+ c &&
+ (f += c * h.lineHeight + (c - 1) * e.titleSpacing + e.titleMarginBottom),
+ v &&
+ ((c = e.displayColors ? Math.max(o, l.lineHeight) : l.lineHeight),
+ (f += g * c + (v - g) * l.lineHeight + (v - 1) * e.bodySpacing)),
+ u &&
+ (f += e.footerMarginTop + u * d.lineHeight + (u - 1) * e.footerSpacing);
+ let x = 0;
+ function b(t) {
+ m = Math.max(m, i.measureText(t).width + x);
+ }
+ return (
+ i.save(),
+ (i.font = h.string),
+ each(t.title, b),
+ (i.font = l.string),
+ each(t.beforeBody.concat(t.afterBody), b),
+ (x = e.displayColors ? r + 2 + e.boxPadding : 0),
+ each(a, (t) => {
+ each(t.before, b), each(t.lines, b), each(t.after, b);
+ }),
+ (x = 0),
+ (i.font = d.string),
+ each(t.footer, b),
+ i.restore(),
+ { width: (m += p.width), height: f }
+ );
+}
+function determineYAlign(t, e) {
+ var { y: e, height: i } = e;
+ return e < i / 2 ? "top" : e > t.height - i / 2 ? "bottom" : "center";
+}
+function doesNotFitWithAlign(t, e, i, a) {
+ var { x: a, width: s } = a,
+ i = i.caretSize + i.caretPadding;
+ return (
+ ("left" === t && a + s + i > e.width) ||
+ ("right" === t && a - s - i < 0) ||
+ void 0
+ );
+}
+function determineXAlign(t, e, i, a) {
+ var { x: s, width: n } = i,
+ {
+ width: r,
+ chartArea: { left: o, right: l },
+ } = t;
+ let h = "center";
+ return (
+ "center" === a
+ ? (h = s <= (o + l) / 2 ? "left" : "right")
+ : s <= n / 2
+ ? (h = "left")
+ : r - n / 2 <= s && (h = "right"),
+ (h = doesNotFitWithAlign(h, t, e, i) ? "center" : h)
+ );
+}
+function determineAlignment(t, e, i) {
+ var a = i.yAlign || e.yAlign || determineYAlign(t, i);
+ return {
+ xAlign: i.xAlign || e.xAlign || determineXAlign(t, e, i, a),
+ yAlign: a,
+ };
+}
+function alignX(t, e) {
+ let { x: i, width: a } = t;
+ return "right" === e ? (i -= a) : "center" === e && (i -= a / 2), i;
+}
+function alignY(t, e, i) {
+ let { y: a, height: s } = t;
+ return "top" === e ? (a += i) : (a -= "bottom" === e ? s + i : s / 2), a;
+}
+function getBackgroundPoint(t, e, i, a) {
+ var { caretSize: t, caretPadding: s, cornerRadius: n } = t,
+ { xAlign: i, yAlign: r } = i,
+ s = t + s,
+ {
+ topLeft: n,
+ topRight: o,
+ bottomLeft: l,
+ bottomRight: h,
+ } = toTRBLCorners(n);
+ let d = alignX(e, i);
+ var c = alignY(e, r, s);
+ return (
+ "center" === r
+ ? "left" === i
+ ? (d += s)
+ : "right" === i && (d -= s)
+ : "left" === i
+ ? (d -= Math.max(n, l) + t)
+ : "right" === i && (d += Math.max(o, h) + t),
+ {
+ x: _limitValue(d, 0, a.width - e.width),
+ y: _limitValue(c, 0, a.height - e.height),
+ }
+ );
+}
+function getAlignedX(t, e, i) {
+ i = toPadding(i.padding);
+ return "center" === e
+ ? t.x + t.width / 2
+ : "right" === e
+ ? t.x + t.width - i.right
+ : t.x + i.left;
+}
+function getBeforeAfterBodyLines(t) {
+ return pushOrConcat([], splitNewlines(t));
+}
+function createTooltipContext(t, e, i) {
+ return createContext(t, { tooltip: e, tooltipItems: i, type: "tooltip" });
+}
+function overrideCallbacks(t, e) {
+ e = e && e.dataset && e.dataset.tooltip && e.dataset.tooltip.callbacks;
+ return e ? t.override(e) : t;
+}
+const defaultCallbacks = {
+ beforeTitle: noop,
+ title(t) {
+ if (0 < t.length) {
+ var t = t[0],
+ e = t.chart.data.labels,
+ i = e ? e.length : 0;
+ if (this && this.options && "dataset" === this.options.mode)
+ return t.dataset.label || "";
+ if (t.label) return t.label;
+ if (0 < i && t.dataIndex < i) return e[t.dataIndex];
+ }
+ return "";
+ },
+ afterTitle: noop,
+ beforeBody: noop,
+ beforeLabel: noop,
+ label(t) {
+ if (this && this.options && "dataset" === this.options.mode)
+ return t.label + ": " + t.formattedValue || t.formattedValue;
+ let e = t.dataset.label || "";
+ e && (e += ": ");
+ t = t.formattedValue;
+ return isNullOrUndef(t) || (e += t), e;
+ },
+ labelColor(t) {
+ const e = t.chart.getDatasetMeta(t.datasetIndex);
+ t = e.controller.getStyle(t.dataIndex);
+ return {
+ borderColor: t.borderColor,
+ backgroundColor: t.backgroundColor,
+ borderWidth: t.borderWidth,
+ borderDash: t.borderDash,
+ borderDashOffset: t.borderDashOffset,
+ borderRadius: 0,
+ };
+ },
+ labelTextColor() {
+ return this.options.bodyColor;
+ },
+ labelPointStyle(t) {
+ const e = t.chart.getDatasetMeta(t.datasetIndex);
+ t = e.controller.getStyle(t.dataIndex);
+ return { pointStyle: t.pointStyle, rotation: t.rotation };
+ },
+ afterLabel: noop,
+ afterBody: noop,
+ beforeFooter: noop,
+ footer: noop,
+ afterFooter: noop,
+};
+function invokeCallbackWithFallback(t, e, i, a) {
+ t = t[e].call(i, a);
+ return void 0 === t ? defaultCallbacks[e].call(i, a) : t;
+}
+class Tooltip extends Element {
+ static positioners = positioners;
+ constructor(t) {
+ super(),
+ (this.opacity = 0),
+ (this._active = []),
+ (this._eventPosition = void 0),
+ (this._size = void 0),
+ (this._cachedAnimations = void 0),
+ (this._tooltipItems = []),
+ (this.$animations = void 0),
+ (this.$context = void 0),
+ (this.chart = t.chart),
+ (this.options = t.options),
+ (this.dataPoints = void 0),
+ (this.title = void 0),
+ (this.beforeBody = void 0),
+ (this.body = void 0),
+ (this.afterBody = void 0),
+ (this.footer = void 0),
+ (this.xAlign = void 0),
+ (this.yAlign = void 0),
+ (this.x = void 0),
+ (this.y = void 0),
+ (this.height = void 0),
+ (this.width = void 0),
+ (this.caretX = void 0),
+ (this.caretY = void 0),
+ (this.labelColors = void 0),
+ (this.labelPointStyles = void 0),
+ (this.labelTextColors = void 0);
+ }
+ initialize(t) {
+ (this.options = t),
+ (this._cachedAnimations = void 0),
+ (this.$context = void 0);
+ }
+ _resolveAnimations() {
+ var t = this._cachedAnimations;
+ if (t) return t;
+ var t = this.chart,
+ e = this.options.setContext(this.getContext()),
+ t = e.enabled && t.options.animation && e.animations,
+ e = new Animations(this.chart, t);
+ return t._cacheable && (this._cachedAnimations = Object.freeze(e)), e;
+ }
+ getContext() {
+ return (
+ this.$context ||
+ (this.$context = createTooltipContext(
+ this.chart.getContext(),
+ this,
+ this._tooltipItems
+ ))
+ );
+ }
+ getTitle(t, e) {
+ var e = e["callbacks"],
+ i = invokeCallbackWithFallback(e, "beforeTitle", this, t),
+ a = invokeCallbackWithFallback(e, "title", this, t),
+ e = invokeCallbackWithFallback(e, "afterTitle", this, t),
+ t = pushOrConcat([], splitNewlines(i));
+ return (
+ (t = pushOrConcat(t, splitNewlines(a))), pushOrConcat(t, splitNewlines(e))
+ );
+ }
+ getBeforeBody(t, e) {
+ return getBeforeAfterBodyLines(
+ invokeCallbackWithFallback(e.callbacks, "beforeBody", this, t)
+ );
+ }
+ getBody(t, e) {
+ const a = e["callbacks"],
+ s = [];
+ return (
+ each(t, (t) => {
+ var e = { before: [], lines: [], after: [] },
+ i = overrideCallbacks(a, t);
+ pushOrConcat(
+ e.before,
+ splitNewlines(invokeCallbackWithFallback(i, "beforeLabel", this, t))
+ ),
+ pushOrConcat(
+ e.lines,
+ invokeCallbackWithFallback(i, "label", this, t)
+ ),
+ pushOrConcat(
+ e.after,
+ splitNewlines(invokeCallbackWithFallback(i, "afterLabel", this, t))
+ ),
+ s.push(e);
+ }),
+ s
+ );
+ }
+ getAfterBody(t, e) {
+ return getBeforeAfterBodyLines(
+ invokeCallbackWithFallback(e.callbacks, "afterBody", this, t)
+ );
+ }
+ getFooter(t, e) {
+ var e = e["callbacks"],
+ i = invokeCallbackWithFallback(e, "beforeFooter", this, t),
+ a = invokeCallbackWithFallback(e, "footer", this, t),
+ e = invokeCallbackWithFallback(e, "afterFooter", this, t),
+ t = pushOrConcat([], splitNewlines(i));
+ return (
+ (t = pushOrConcat(t, splitNewlines(a))), pushOrConcat(t, splitNewlines(e))
+ );
+ }
+ _createItems(a) {
+ var t = this._active;
+ const s = this.chart.data,
+ i = [],
+ n = [],
+ r = [];
+ let e = [],
+ o,
+ l;
+ for (o = 0, l = t.length; o < l; ++o)
+ e.push(createTooltipItem(this.chart, t[o]));
+ return (
+ a.filter && (e = e.filter((t, e, i) => a.filter(t, e, i, s))),
+ a.itemSort && (e = e.sort((t, e) => a.itemSort(t, e, s))),
+ each(e, (t) => {
+ var e = overrideCallbacks(a.callbacks, t);
+ i.push(invokeCallbackWithFallback(e, "labelColor", this, t)),
+ n.push(invokeCallbackWithFallback(e, "labelPointStyle", this, t)),
+ r.push(invokeCallbackWithFallback(e, "labelTextColor", this, t));
+ }),
+ (this.labelColors = i),
+ (this.labelPointStyles = n),
+ (this.labelTextColors = r),
+ (this.dataPoints = e)
+ );
+ }
+ update(t, e) {
+ const i = this.options.setContext(this.getContext());
+ var a,
+ s,
+ n,
+ r = this._active;
+ let o,
+ l = [];
+ r.length
+ ? ((r = positioners[i.position].call(this, r, this._eventPosition)),
+ (l = this._createItems(i)),
+ (this.title = this.getTitle(l, i)),
+ (this.beforeBody = this.getBeforeBody(l, i)),
+ (this.body = this.getBody(l, i)),
+ (this.afterBody = this.getAfterBody(l, i)),
+ (this.footer = this.getFooter(l, i)),
+ (a = this._size = getTooltipSize(this, i)),
+ (n = Object.assign({}, r, a)),
+ (s = determineAlignment(this.chart, i, n)),
+ (n = getBackgroundPoint(i, n, s, this.chart)),
+ (this.xAlign = s.xAlign),
+ (this.yAlign = s.yAlign),
+ (o = {
+ opacity: 1,
+ x: n.x,
+ y: n.y,
+ width: a.width,
+ height: a.height,
+ caretX: r.x,
+ caretY: r.y,
+ }))
+ : 0 !== this.opacity && (o = { opacity: 0 }),
+ (this._tooltipItems = l),
+ (this.$context = void 0),
+ o && this._resolveAnimations().update(this, o),
+ t &&
+ i.external &&
+ i.external.call(this, { chart: this.chart, tooltip: this, replay: e });
+ }
+ drawCaret(t, e, i, a) {
+ t = this.getCaretPosition(t, i, a);
+ e.lineTo(t.x1, t.y1), e.lineTo(t.x2, t.y2), e.lineTo(t.x3, t.y3);
+ }
+ getCaretPosition(t, e, i) {
+ var { xAlign: a, yAlign: s } = this,
+ { caretSize: i, cornerRadius: n } = i,
+ {
+ topLeft: n,
+ topRight: r,
+ bottomLeft: o,
+ bottomRight: l,
+ } = toTRBLCorners(n),
+ { x: t, y: h } = t,
+ { width: e, height: d } = e;
+ let c, u, g, p, f, m;
+ return (
+ "center" === s
+ ? ((f = h + d / 2),
+ (m =
+ "left" === a
+ ? ((c = t), (u = c - i), (p = f + i), f - i)
+ : ((c = t + e), (u = c + i), (p = f - i), f + i)),
+ (g = c))
+ : ((u =
+ "left" === a
+ ? t + Math.max(n, o) + i
+ : "right" === a
+ ? t + e - Math.max(r, l) - i
+ : this.caretX),
+ (g =
+ "top" === s
+ ? ((p = h), (f = p - i), (c = u - i), u + i)
+ : ((p = h + d), (f = p + i), (c = u + i), u - i)),
+ (m = p)),
+ { x1: c, x2: u, x3: g, y1: p, y2: f, y3: m }
+ );
+ }
+ drawTitle(t, e, i) {
+ var a = this.title,
+ s = a.length;
+ let n, r, o;
+ if (s) {
+ const l = getRtlAdapter(i.rtl, this.x, this.width);
+ for (
+ t.x = getAlignedX(this, i.titleAlign, i),
+ e.textAlign = l.textAlign(i.titleAlign),
+ e.textBaseline = "middle",
+ n = toFont(i.titleFont),
+ r = i.titleSpacing,
+ e.fillStyle = i.titleColor,
+ e.font = n.string,
+ o = 0;
+ o < s;
+ ++o
+ )
+ e.fillText(a[o], l.x(t.x), t.y + n.lineHeight / 2),
+ (t.y += n.lineHeight + r),
+ o + 1 === s && (t.y += i.titleMarginBottom - r);
+ }
+ }
+ _drawColorBox(t, e, i, a, s) {
+ var n,
+ r = this.labelColors[i],
+ o = this.labelPointStyles[i],
+ { boxHeight: l, boxWidth: h } = s,
+ d = toFont(s.bodyFont),
+ c = getAlignedX(this, "left", s),
+ c = a.x(c),
+ d = l < d.lineHeight ? (d.lineHeight - l) / 2 : 0,
+ e = e.y + d;
+ s.usePointStyle
+ ? ((d = {
+ radius: Math.min(h, l) / 2,
+ pointStyle: o.pointStyle,
+ rotation: o.rotation,
+ borderWidth: 1,
+ }),
+ (o = a.leftForLtr(c, h) + h / 2),
+ (n = e + l / 2),
+ (t.strokeStyle = s.multiKeyBackground),
+ (t.fillStyle = s.multiKeyBackground),
+ drawPoint(t, d, o, n),
+ (t.strokeStyle = r.borderColor),
+ (t.fillStyle = r.backgroundColor),
+ drawPoint(t, d, o, n))
+ : ((t.lineWidth = isObject(r.borderWidth)
+ ? Math.max(...Object.values(r.borderWidth))
+ : r.borderWidth || 1),
+ (t.strokeStyle = r.borderColor),
+ t.setLineDash(r.borderDash || []),
+ (t.lineDashOffset = r.borderDashOffset || 0),
+ (d = a.leftForLtr(c, h)),
+ (o = a.leftForLtr(a.xPlus(c, 1), h - 2)),
+ (n = toTRBLCorners(r.borderRadius)),
+ Object.values(n).some((t) => 0 !== t)
+ ? (t.beginPath(),
+ (t.fillStyle = s.multiKeyBackground),
+ addRoundedRectPath(t, { x: d, y: e, w: h, h: l, radius: n }),
+ t.fill(),
+ t.stroke(),
+ (t.fillStyle = r.backgroundColor),
+ t.beginPath(),
+ addRoundedRectPath(t, {
+ x: o,
+ y: e + 1,
+ w: h - 2,
+ h: l - 2,
+ radius: n,
+ }),
+ t.fill())
+ : ((t.fillStyle = s.multiKeyBackground),
+ t.fillRect(d, e, h, l),
+ t.strokeRect(d, e, h, l),
+ (t.fillStyle = r.backgroundColor),
+ t.fillRect(o, e + 1, h - 2, l - 2))),
+ (t.fillStyle = this.labelTextColors[i]);
+ }
+ drawBody(e, i, t) {
+ var a = this["body"];
+ const {
+ bodySpacing: s,
+ bodyAlign: n,
+ displayColors: r,
+ boxHeight: o,
+ boxWidth: l,
+ boxPadding: h,
+ } = t;
+ var d = toFont(t.bodyFont);
+ let c = d.lineHeight,
+ u = 0;
+ const g = getRtlAdapter(t.rtl, this.x, this.width);
+ function p(t) {
+ i.fillText(t, g.x(e.x + u), e.y + c / 2), (e.y += c + s);
+ }
+ var f = g.textAlign(n);
+ let m, v, x, b, _, y, k;
+ for (
+ i.textAlign = n,
+ i.textBaseline = "middle",
+ i.font = d.string,
+ e.x = getAlignedX(this, f, t),
+ i.fillStyle = t.bodyColor,
+ each(this.beforeBody, p),
+ u = r && "right" !== f ? ("center" === n ? l / 2 + h : l + 2 + h) : 0,
+ b = 0,
+ y = a.length;
+ b < y;
+ ++b
+ ) {
+ for (
+ m = a[b],
+ v = this.labelTextColors[b],
+ i.fillStyle = v,
+ each(m.before, p),
+ x = m.lines,
+ r &&
+ x.length &&
+ (this._drawColorBox(i, e, b, g, t),
+ (c = Math.max(d.lineHeight, o))),
+ _ = 0,
+ k = x.length;
+ _ < k;
+ ++_
+ )
+ p(x[_]), (c = d.lineHeight);
+ each(m.after, p);
+ }
+ (u = 0), (c = d.lineHeight), each(this.afterBody, p), (e.y -= s);
+ }
+ drawFooter(t, e, i) {
+ var a = this.footer,
+ s = a.length;
+ let n, r;
+ if (s) {
+ const o = getRtlAdapter(i.rtl, this.x, this.width);
+ for (
+ t.x = getAlignedX(this, i.footerAlign, i),
+ t.y += i.footerMarginTop,
+ e.textAlign = o.textAlign(i.footerAlign),
+ e.textBaseline = "middle",
+ n = toFont(i.footerFont),
+ e.fillStyle = i.footerColor,
+ e.font = n.string,
+ r = 0;
+ r < s;
+ ++r
+ )
+ e.fillText(a[r], o.x(t.x), t.y + n.lineHeight / 2),
+ (t.y += n.lineHeight + i.footerSpacing);
+ }
+ }
+ drawBackground(t, e, i, a) {
+ var { xAlign: s, yAlign: n } = this,
+ { x: r, y: o } = t,
+ { width: l, height: h } = i,
+ {
+ topLeft: d,
+ topRight: c,
+ bottomLeft: u,
+ bottomRight: g,
+ } = toTRBLCorners(a.cornerRadius);
+ (e.fillStyle = a.backgroundColor),
+ (e.strokeStyle = a.borderColor),
+ (e.lineWidth = a.borderWidth),
+ e.beginPath(),
+ e.moveTo(r + d, o),
+ "top" === n && this.drawCaret(t, e, i, a),
+ e.lineTo(r + l - c, o),
+ e.quadraticCurveTo(r + l, o, r + l, o + c),
+ "center" === n && "right" === s && this.drawCaret(t, e, i, a),
+ e.lineTo(r + l, o + h - g),
+ e.quadraticCurveTo(r + l, o + h, r + l - g, o + h),
+ "bottom" === n && this.drawCaret(t, e, i, a),
+ e.lineTo(r + u, o + h),
+ e.quadraticCurveTo(r, o + h, r, o + h - u),
+ "center" === n && "left" === s && this.drawCaret(t, e, i, a),
+ e.lineTo(r, o + d),
+ e.quadraticCurveTo(r, o, r + d, o),
+ e.closePath(),
+ e.fill(),
+ 0 < a.borderWidth && e.stroke();
+ }
+ _updateAnimationTarget(t) {
+ var e,
+ i,
+ a,
+ s = this.chart,
+ n = this.$animations,
+ r = n && n.x,
+ n = n && n.y;
+ (r || n) &&
+ (e = positioners[t.position].call(
+ this,
+ this._active,
+ this._eventPosition
+ )) &&
+ ((i = this._size = getTooltipSize(this, t)),
+ (a = getBackgroundPoint(
+ t,
+ (a = Object.assign({}, e, this._size)),
+ (t = determineAlignment(s, t, a)),
+ s
+ )),
+ (r._to === a.x && n._to === a.y) ||
+ ((this.xAlign = t.xAlign),
+ (this.yAlign = t.yAlign),
+ (this.width = i.width),
+ (this.height = i.height),
+ (this.caretX = e.x),
+ (this.caretY = e.y),
+ this._resolveAnimations().update(this, a)));
+ }
+ _willRender() {
+ return !!this.opacity;
+ }
+ draw(t) {
+ var e = this.options.setContext(this.getContext());
+ let i = this.opacity;
+ if (i) {
+ this._updateAnimationTarget(e);
+ var a = { width: this.width, height: this.height };
+ const r = { x: this.x, y: this.y };
+ i = Math.abs(i) < 0.001 ? 0 : i;
+ var s = toPadding(e.padding),
+ n =
+ this.title.length ||
+ this.beforeBody.length ||
+ this.body.length ||
+ this.afterBody.length ||
+ this.footer.length;
+ e.enabled &&
+ n &&
+ (t.save(),
+ (t.globalAlpha = i),
+ this.drawBackground(r, t, a, e),
+ overrideTextDirection(t, e.textDirection),
+ (r.y += s.top),
+ this.drawTitle(r, t, e),
+ this.drawBody(r, t, e),
+ this.drawFooter(r, t, e),
+ restoreTextDirection(t, e.textDirection),
+ t.restore());
+ }
+ }
+ getActiveElements() {
+ return this._active || [];
+ }
+ setActiveElements(t, e) {
+ var i = this._active,
+ t = t.map(({ datasetIndex: t, index: e }) => {
+ var i = this.chart.getDatasetMeta(t);
+ if (i) return { datasetIndex: t, element: i.data[e], index: e };
+ throw new Error("Cannot find a dataset at index " + t);
+ }),
+ i = !_elementsEqual(i, t),
+ a = this._positionChanged(t, e);
+ (i || a) &&
+ ((this._active = t),
+ (this._eventPosition = e),
+ (this._ignoreReplayEvents = !0),
+ this.update(!0));
+ }
+ handleEvent(t, e, i = !0) {
+ if (e && this._ignoreReplayEvents) return !1;
+ this._ignoreReplayEvents = !1;
+ var a = this.options,
+ s = this._active || [],
+ i = this._getActiveElements(t, s, e, i),
+ n = this._positionChanged(i, t),
+ s = e || !_elementsEqual(i, s) || n;
+ return (
+ s &&
+ ((this._active = i),
+ (a.enabled || a.external) &&
+ ((this._eventPosition = { x: t.x, y: t.y }), this.update(!0, e))),
+ s
+ );
+ }
+ _getActiveElements(t, e, i, a) {
+ var s = this.options;
+ if ("mouseout" === t.type) return [];
+ if (!a)
+ return e.filter(
+ (t) =>
+ this.chart.data.datasets[t.datasetIndex] &&
+ void 0 !==
+ this.chart
+ .getDatasetMeta(t.datasetIndex)
+ .controller.getParsed(t.index)
+ );
+ const n = this.chart.getElementsAtEventForMode(t, s.mode, s, i);
+ return s.reverse && n.reverse(), n;
+ }
+ _positionChanged(t, e) {
+ var { caretX: i, caretY: a, options: s } = this,
+ s = positioners[s.position].call(this, t, e);
+ return !1 !== s && (i !== s.x || a !== s.y);
+ }
+}
+var plugin_tooltip = {
+ id: "tooltip",
+ _element: Tooltip,
+ positioners: positioners,
+ afterInit(t, e, i) {
+ i && (t.tooltip = new Tooltip({ chart: t, options: i }));
+ },
+ beforeUpdate(t, e, i) {
+ t.tooltip && t.tooltip.initialize(i);
+ },
+ reset(t, e, i) {
+ t.tooltip && t.tooltip.initialize(i);
+ },
+ afterDraw(t) {
+ const e = t.tooltip;
+ var i;
+ e &&
+ e._willRender() &&
+ !(i = { tooltip: e }) !==
+ t.notifyPlugins("beforeTooltipDraw", { ...i, cancelable: !0 }) &&
+ (e.draw(t.ctx), t.notifyPlugins("afterTooltipDraw", i));
+ },
+ afterEvent(t, e) {
+ var i;
+ t.tooltip &&
+ ((i = e.replay),
+ t.tooltip.handleEvent(e.event, i, e.inChartArea) && (e.changed = !0));
+ },
+ defaults: {
+ enabled: !0,
+ external: null,
+ position: "average",
+ backgroundColor: "rgba(0,0,0,0.8)",
+ titleColor: "#fff",
+ titleFont: { weight: "bold" },
+ titleSpacing: 2,
+ titleMarginBottom: 6,
+ titleAlign: "left",
+ bodyColor: "#fff",
+ bodySpacing: 2,
+ bodyFont: {},
+ bodyAlign: "left",
+ footerColor: "#fff",
+ footerSpacing: 2,
+ footerMarginTop: 6,
+ footerFont: { weight: "bold" },
+ footerAlign: "left",
+ padding: 6,
+ caretPadding: 2,
+ caretSize: 5,
+ cornerRadius: 6,
+ boxHeight: (t, e) => e.bodyFont.size,
+ boxWidth: (t, e) => e.bodyFont.size,
+ multiKeyBackground: "#fff",
+ displayColors: !0,
+ boxPadding: 0,
+ borderColor: "rgba(0,0,0,0)",
+ borderWidth: 0,
+ animation: { duration: 400, easing: "easeOutQuart" },
+ animations: {
+ numbers: {
+ type: "number",
+ properties: ["x", "y", "width", "height", "caretX", "caretY"],
+ },
+ opacity: { easing: "linear", duration: 200 },
+ },
+ callbacks: defaultCallbacks,
+ },
+ defaultRoutes: { bodyFont: "font", footerFont: "font", titleFont: "font" },
+ descriptors: {
+ _scriptable: (t) =>
+ "filter" !== t && "itemSort" !== t && "external" !== t,
+ _indexable: !1,
+ callbacks: { _scriptable: !1, _indexable: !1 },
+ animation: { _fallback: !1 },
+ animations: { _fallback: "animation" },
+ },
+ additionalOptionScopes: ["interaction"],
+ },
+ plugins = Object.freeze({
+ __proto__: null,
+ Colors: plugin_colors,
+ Decimation: plugin_decimation,
+ Filler: index,
+ Legend: plugin_legend,
+ SubTitle: plugin_subtitle,
+ Title: plugin_title,
+ Tooltip: plugin_tooltip,
+ });
+const addIfString = (t, e, i, a) => (
+ "string" == typeof e
+ ? ((i = t.push(e) - 1), a.unshift({ index: i, label: e }))
+ : isNaN(e) && (i = null),
+ i
+);
+function findOrAddLabel(t, e, i, a) {
+ var s = t.indexOf(e);
+ return -1 === s ? addIfString(t, e, i, a) : s !== t.lastIndexOf(e) ? i : s;
+}
+const validIndex = (t, e) =>
+ null === t ? null : _limitValue(Math.round(t), 0, e);
+function _getLabelForValue(t) {
+ var e = this.getLabels();
+ return 0 <= t && t < e.length ? e[t] : t;
+}
+class CategoryScale extends Scale {
+ static id = "category";
+ static defaults = { ticks: { callback: _getLabelForValue } };
+ constructor(t) {
+ super(t),
+ (this._startValue = void 0),
+ (this._valueRange = 0),
+ (this._addedLabels = []);
+ }
+ init(t) {
+ var e = this._addedLabels;
+ if (e.length) {
+ const s = this.getLabels();
+ for (var { index: i, label: a } of e) s[i] === a && s.splice(i, 1);
+ this._addedLabels = [];
+ }
+ super.init(t);
+ }
+ parse(t, e) {
+ if (isNullOrUndef(t)) return null;
+ var i = this.getLabels();
+ return (
+ (e =
+ isFinite(e) && i[e] === t
+ ? e
+ : findOrAddLabel(i, t, valueOrDefault(e, t), this._addedLabels)),
+ validIndex(e, i.length - 1)
+ );
+ }
+ determineDataLimits() {
+ var { minDefined: t, maxDefined: e } = this.getUserBounds();
+ let { min: i, max: a } = this.getMinMax(!0);
+ "ticks" === this.options.bounds &&
+ (t || (i = 0), e || (a = this.getLabels().length - 1)),
+ (this.min = i),
+ (this.max = a);
+ }
+ buildTicks() {
+ var e = this.min,
+ i = this.max,
+ t = this.options.offset;
+ const a = [];
+ let s = this.getLabels();
+ (s = 0 === e && i === s.length - 1 ? s : s.slice(e, i + 1)),
+ (this._valueRange = Math.max(s.length - (t ? 0 : 1), 1)),
+ (this._startValue = this.min - (t ? 0.5 : 0));
+ for (let t = e; t <= i; t++) a.push({ value: t });
+ return a;
+ }
+ getLabelForValue(t) {
+ return _getLabelForValue.call(this, t);
+ }
+ configure() {
+ super.configure(),
+ this.isHorizontal() || (this._reversePixels = !this._reversePixels);
+ }
+ getPixelForValue(t) {
+ return null === (t = "number" != typeof t ? this.parse(t) : t)
+ ? NaN
+ : this.getPixelForDecimal((t - this._startValue) / this._valueRange);
+ }
+ getPixelForTick(t) {
+ var e = this.ticks;
+ return t < 0 || t > e.length - 1 ? null : this.getPixelForValue(e[t].value);
+ }
+ getValueForPixel(t) {
+ return Math.round(
+ this._startValue + this.getDecimalForPixel(t) * this._valueRange
+ );
+ }
+ getBasePixel() {
+ return this.bottom;
+ }
+}
+function generateTicks$1(t, e) {
+ const i = [];
+ var {
+ bounds: a,
+ step: s,
+ min: n,
+ max: r,
+ precision: o,
+ count: l,
+ maxTicks: h,
+ maxDigits: d,
+ includeBounds: c,
+ } = t,
+ u = s || 1,
+ g = h - 1,
+ { min: e, max: p } = e,
+ f = !isNullOrUndef(n),
+ m = !isNullOrUndef(r),
+ v = !isNullOrUndef(l),
+ d = (p - e) / (d + 1);
+ let x = niceNum((p - e) / g / u) * u,
+ b,
+ _,
+ y,
+ k;
+ if (x < 1e-14 && !f && !m) return [{ value: e }, { value: p }];
+ (k = Math.ceil(p / x) - Math.floor(e / x)) > g &&
+ (x = niceNum((k * x) / g / u) * u),
+ isNullOrUndef(o) || ((b = Math.pow(10, o)), (x = Math.ceil(x * b) / b)),
+ (y =
+ "ticks" === a
+ ? ((_ = Math.floor(e / x) * x), Math.ceil(p / x) * x)
+ : ((_ = e), p)),
+ f && m && s && almostWhole((r - n) / s, x / 1e3)
+ ? ((k = Math.round(Math.min((r - n) / x, h))),
+ (x = (r - n) / k),
+ (_ = n),
+ (y = r))
+ : v
+ ? ((_ = f ? n : _), (y = m ? r : y), (k = l - 1), (x = (y - _) / k))
+ : ((k = (y - _) / x),
+ (k = almostEquals(k, Math.round(k), x / 1e3)
+ ? Math.round(k)
+ : Math.ceil(k)));
+ g = Math.max(_decimalPlaces(x), _decimalPlaces(_));
+ (b = Math.pow(10, isNullOrUndef(o) ? g : o)),
+ (_ = Math.round(_ * b) / b),
+ (y = Math.round(y * b) / b);
+ let S = 0;
+ for (
+ f &&
+ (c && _ !== n
+ ? (i.push({ value: n }),
+ _ < n && S++,
+ almostEquals(
+ Math.round((_ + S * x) * b) / b,
+ n,
+ relativeLabelSize(n, d, t)
+ ) && S++)
+ : _ < n && S++);
+ S < k;
+ ++S
+ ) {
+ var D = Math.round((_ + S * x) * b) / b;
+ if (m && r < D) break;
+ i.push({ value: D });
+ }
+ return (
+ m && c && y !== r
+ ? i.length &&
+ almostEquals(i[i.length - 1].value, r, relativeLabelSize(r, d, t))
+ ? (i[i.length - 1].value = r)
+ : i.push({ value: r })
+ : (m && y !== r) || i.push({ value: y }),
+ i
+ );
+}
+function relativeLabelSize(t, e, { horizontal: i, minRotation: a }) {
+ (a = toRadians(a)), (i = (i ? Math.sin(a) : Math.cos(a)) || 0.001);
+ return Math.min(e / i, 0.75 * e * ("" + t).length);
+}
+class LinearScaleBase extends Scale {
+ constructor(t) {
+ super(t),
+ (this.start = void 0),
+ (this.end = void 0),
+ (this._startValue = void 0),
+ (this._endValue = void 0),
+ (this._valueRange = 0);
+ }
+ parse(t, e) {
+ return isNullOrUndef(t) ||
+ (("number" == typeof t || t instanceof Number) && !isFinite(+t))
+ ? null
+ : +t;
+ }
+ handleTickRangeOptions() {
+ var t = this.options["beginAtZero"];
+ const { minDefined: e, maxDefined: i } = this.getUserBounds();
+ let { min: a, max: s } = this;
+ var n,
+ r,
+ o = (t) => (a = e ? a : t),
+ l = (t) => (s = i ? s : t);
+ t &&
+ ((r = sign(a)),
+ (n = sign(s)),
+ r < 0 && n < 0 ? l(0) : 0 < r && 0 < n && o(0)),
+ a === s &&
+ ((r = 0 === s ? 1 : Math.abs(0.05 * s)), l(s + r), t || o(a - r)),
+ (this.min = a),
+ (this.max = s);
+ }
+ getTickLimit() {
+ let { maxTicksLimit: t, stepSize: e } = this.options.ticks,
+ i;
+ return (
+ e
+ ? 1e3 < (i = Math.ceil(this.max / e) - Math.floor(this.min / e) + 1) &&
+ (console.warn(
+ `scales.${this.id}.ticks.stepSize: ${e} would result generating up to ${i} ticks. Limiting to 1000.`
+ ),
+ (i = 1e3))
+ : ((i = this.computeTickLimit()), (t = t || 11)),
+ (i = t ? Math.min(t, i) : i)
+ );
+ }
+ computeTickLimit() {
+ return Number.POSITIVE_INFINITY;
+ }
+ buildTicks() {
+ var t = this.options,
+ e = t.ticks,
+ i = this.getTickLimit();
+ const a = generateTicks$1(
+ {
+ maxTicks: Math.max(2, i),
+ bounds: t.bounds,
+ min: t.min,
+ max: t.max,
+ precision: e.precision,
+ step: e.stepSize,
+ count: e.count,
+ maxDigits: this._maxDigits(),
+ horizontal: this.isHorizontal(),
+ minRotation: e.minRotation || 0,
+ includeBounds: !1 !== e.includeBounds,
+ },
+ this._range || this
+ );
+ return (
+ "ticks" === t.bounds && _setMinAndMaxByKey(a, this, "value"),
+ t.reverse
+ ? (a.reverse(), (this.start = this.max), (this.end = this.min))
+ : ((this.start = this.min), (this.end = this.max)),
+ a
+ );
+ }
+ configure() {
+ var t = this.ticks;
+ let e = this.min,
+ i = this.max;
+ super.configure(),
+ this.options.offset &&
+ t.length &&
+ ((t = (i - e) / Math.max(t.length - 1, 1) / 2), (e -= t), (i += t)),
+ (this._startValue = e),
+ (this._endValue = i),
+ (this._valueRange = i - e);
+ }
+ getLabelForValue(t) {
+ return formatNumber(
+ t,
+ this.chart.options.locale,
+ this.options.ticks.format
+ );
+ }
+}
+class LinearScale extends LinearScaleBase {
+ static id = "linear";
+ static defaults = { ticks: { callback: Ticks.formatters.numeric } };
+ determineDataLimits() {
+ var { min: t, max: e } = this.getMinMax(!0);
+ (this.min = isNumberFinite(t) ? t : 0),
+ (this.max = isNumberFinite(e) ? e : 1),
+ this.handleTickRangeOptions();
+ }
+ computeTickLimit() {
+ var t = this.isHorizontal(),
+ e = t ? this.width : this.height,
+ i = toRadians(this.options.ticks.minRotation),
+ t = (t ? Math.sin(i) : Math.cos(i)) || 0.001,
+ i = this._resolveTickFontOptions(0);
+ return Math.ceil(e / Math.min(40, i.lineHeight / t));
+ }
+ getPixelForValue(t) {
+ return null === t
+ ? NaN
+ : this.getPixelForDecimal((t - this._startValue) / this._valueRange);
+ }
+ getValueForPixel(t) {
+ return this._startValue + this.getDecimalForPixel(t) * this._valueRange;
+ }
+}
+const log10Floor = (t) => Math.floor(log10(t)),
+ changeExponent = (t, e) => Math.pow(10, log10Floor(t) + e);
+function isMajor(t) {
+ return 1 == t / Math.pow(10, log10Floor(t));
+}
+function steps(t, e, i) {
+ (i = Math.pow(10, i)), (t = Math.floor(t / i));
+ return Math.ceil(e / i) - t;
+}
+function startExp(t, e) {
+ var i = e - t;
+ let a = log10Floor(i);
+ for (; 10 < steps(t, e, a); ) a++;
+ for (; steps(t, e, a) < 10; ) a--;
+ return Math.min(a, log10Floor(t));
+}
+function generateTicks(t, { min: e, max: i }) {
+ e = finiteOrDefault(t.min, e);
+ const a = [];
+ var s = log10Floor(e);
+ let n = startExp(e, i),
+ r = n < 0 ? Math.pow(10, Math.abs(n)) : 1;
+ var o = Math.pow(10, n),
+ l = s > n ? Math.pow(10, s) : 0,
+ s = Math.round((e - l) * r) / r,
+ h = Math.floor((e - l) / o / 10) * o * 10;
+ let d = Math.floor((s - h) / Math.pow(10, n)),
+ c = finiteOrDefault(
+ t.min,
+ Math.round((l + h + d * Math.pow(10, n)) * r) / r
+ );
+ for (; c < i; )
+ a.push({ value: c, major: isMajor(c), significand: d }),
+ 10 <= d ? (d = d < 15 ? 15 : 20) : d++,
+ 20 <= d && (n++, (d = 2), (r = 0 <= n ? 1 : r)),
+ (c = Math.round((l + h + d * Math.pow(10, n)) * r) / r);
+ e = finiteOrDefault(t.max, c);
+ return a.push({ value: e, major: isMajor(e), significand: d }), a;
+}
+class LogarithmicScale extends Scale {
+ static id = "logarithmic";
+ static defaults = {
+ ticks: { callback: Ticks.formatters.logarithmic, major: { enabled: !0 } },
+ };
+ constructor(t) {
+ super(t),
+ (this.start = void 0),
+ (this.end = void 0),
+ (this._startValue = void 0),
+ (this._valueRange = 0);
+ }
+ parse(t, e) {
+ t = LinearScaleBase.prototype.parse.apply(this, [t, e]);
+ if (0 !== t) return isNumberFinite(t) && 0 < t ? t : null;
+ this._zero = !0;
+ }
+ determineDataLimits() {
+ var { min: t, max: e } = this.getMinMax(!0);
+ (this.min = isNumberFinite(t) ? Math.max(0, t) : null),
+ (this.max = isNumberFinite(e) ? Math.max(0, e) : null),
+ this.options.beginAtZero && (this._zero = !0),
+ this._zero &&
+ this.min !== this._suggestedMin &&
+ !isNumberFinite(this._userMin) &&
+ (this.min =
+ t === changeExponent(this.min, 0)
+ ? changeExponent(this.min, -1)
+ : changeExponent(this.min, 0)),
+ this.handleTickRangeOptions();
+ }
+ handleTickRangeOptions() {
+ const { minDefined: e, maxDefined: i } = this.getUserBounds();
+ let a = this.min,
+ s = this.max;
+ var t = (t) => (a = e ? a : t),
+ n = (t) => (s = i ? s : t);
+ a === s &&
+ (a <= 0
+ ? (t(1), n(10))
+ : (t(changeExponent(a, -1)), n(changeExponent(s, 1)))),
+ a <= 0 && t(changeExponent(s, -1)),
+ s <= 0 && n(changeExponent(a, 1)),
+ (this.min = a),
+ (this.max = s);
+ }
+ buildTicks() {
+ var t = this.options;
+ const e = generateTicks({ min: this._userMin, max: this._userMax }, this);
+ return (
+ "ticks" === t.bounds && _setMinAndMaxByKey(e, this, "value"),
+ t.reverse
+ ? (e.reverse(), (this.start = this.max), (this.end = this.min))
+ : ((this.start = this.min), (this.end = this.max)),
+ e
+ );
+ }
+ getLabelForValue(t) {
+ return void 0 === t
+ ? "0"
+ : formatNumber(t, this.chart.options.locale, this.options.ticks.format);
+ }
+ configure() {
+ var t = this.min;
+ super.configure(),
+ (this._startValue = log10(t)),
+ (this._valueRange = log10(this.max) - log10(t));
+ }
+ getPixelForValue(t) {
+ return null === (t = void 0 !== t && 0 !== t ? t : this.min) || isNaN(t)
+ ? NaN
+ : this.getPixelForDecimal(
+ t === this.min ? 0 : (log10(t) - this._startValue) / this._valueRange
+ );
+ }
+ getValueForPixel(t) {
+ t = this.getDecimalForPixel(t);
+ return Math.pow(10, this._startValue + t * this._valueRange);
+ }
+}
+function getTickBackdropHeight(t) {
+ var e = t.ticks;
+ return e.display && t.display
+ ? ((t = toPadding(e.backdropPadding)),
+ valueOrDefault(e.font && e.font.size, defaults.font.size) + t.height)
+ : 0;
+}
+function measureLabelSize(t, e, i) {
+ return (
+ (i = isArray(i) ? i : [i]),
+ { w: _longestText(t, e.string, i), h: i.length * e.lineHeight }
+ );
+}
+function determineLimits(t, e, i, a, s) {
+ return t === a || t === s
+ ? { start: e - i / 2, end: e + i / 2 }
+ : t < a || s < t
+ ? { start: e - i, end: e }
+ : { start: e, end: e + i };
+}
+function fitWithPointLabels(e) {
+ var i = {
+ l: e.left + e._padding.left,
+ r: e.right - e._padding.right,
+ t: e.top + e._padding.top,
+ b: e.bottom - e._padding.bottom,
+ },
+ a = Object.assign({}, i);
+ const s = [],
+ n = [];
+ var r = e._pointLabels.length;
+ const o = e.options.pointLabels;
+ var l = o.centerPointLabels ? PI / r : 0;
+ for (let t = 0; t < r; t++) {
+ var h = o.setContext(e.getPointLabelContext(t)),
+ d = ((n[t] = h.padding), e.getPointPosition(t, e.drawingArea + n[t], l)),
+ h = toFont(h.font),
+ h = measureLabelSize(e.ctx, h, e._pointLabels[t]),
+ c = ((s[t] = h), _normalizeAngle(e.getIndexAngle(t) + l)),
+ u = Math.round(toDegrees(c));
+ updateLimits(
+ a,
+ i,
+ c,
+ determineLimits(u, d.x, h.w, 0, 180),
+ determineLimits(u, d.y, h.h, 90, 270)
+ );
+ }
+ e.setCenterPoint(i.l - a.l, a.r - i.r, i.t - a.t, a.b - i.b),
+ (e._pointLabelItems = buildPointLabelItems(e, s, n));
+}
+function updateLimits(t, e, i, a, s) {
+ var n = Math.abs(Math.sin(i)),
+ i = Math.abs(Math.cos(i));
+ let r = 0,
+ o = 0;
+ a.start < e.l
+ ? ((r = (e.l - a.start) / n), (t.l = Math.min(t.l, e.l - r)))
+ : a.end > e.r && ((r = (a.end - e.r) / n), (t.r = Math.max(t.r, e.r + r))),
+ s.start < e.t
+ ? ((o = (e.t - s.start) / i), (t.t = Math.min(t.t, e.t - o)))
+ : s.end > e.b &&
+ ((o = (s.end - e.b) / i), (t.b = Math.max(t.b, e.b + o)));
+}
+function createPointLabelItem(t, e, i) {
+ var a = t.drawingArea,
+ { extra: i, additionalAngle: s, padding: n, size: r } = i,
+ t = t.getPointPosition(e, a + i + n, s),
+ e = Math.round(toDegrees(_normalizeAngle(t.angle + HALF_PI))),
+ a = yForAngle(t.y, r.h, e),
+ i = getTextAlignForAngle(e),
+ n = leftForTextAlign(t.x, r.w, i);
+ return {
+ visible: !0,
+ x: t.x,
+ y: a,
+ textAlign: i,
+ left: n,
+ top: a,
+ right: n + r.w,
+ bottom: a + r.h,
+ };
+}
+function isNotOverlapped(t, e) {
+ if (!e) return !0;
+ var { left: t, top: i, right: a, bottom: s } = t;
+ return !(
+ _isPointInArea({ x: t, y: i }, e) ||
+ _isPointInArea({ x: t, y: s }, e) ||
+ _isPointInArea({ x: a, y: i }, e) ||
+ _isPointInArea({ x: a, y: s }, e)
+ );
+}
+function buildPointLabelItems(e, i, a) {
+ const s = [];
+ var n = e._pointLabels.length,
+ t = e.options,
+ { centerPointLabels: r, display: o } = t.pointLabels;
+ const l = {
+ extra: getTickBackdropHeight(t) / 2,
+ additionalAngle: r ? PI / n : 0,
+ };
+ let h;
+ for (let t = 0; t < n; t++) {
+ (l.padding = a[t]), (l.size = i[t]);
+ const d = createPointLabelItem(e, t, l);
+ s.push(d),
+ "auto" === o &&
+ ((d.visible = isNotOverlapped(d, h)), d.visible && (h = d));
+ }
+ return s;
+}
+function getTextAlignForAngle(t) {
+ return 0 === t || 180 === t ? "center" : t < 180 ? "left" : "right";
+}
+function leftForTextAlign(t, e, i) {
+ return "right" === i ? (t -= e) : "center" === i && (t -= e / 2), t;
+}
+function yForAngle(t, e, i) {
+ return (
+ 90 === i || 270 === i ? (t -= e / 2) : (270 < i || i < 90) && (t -= e), t
+ );
+}
+function drawPointLabelBox(t, e, i) {
+ var a,
+ s,
+ { left: i, top: n, right: r, bottom: o } = i,
+ l = e["backdropColor"];
+ isNullOrUndef(l) ||
+ ((a = toTRBLCorners(e.borderRadius)),
+ (e = toPadding(e.backdropPadding)),
+ (t.fillStyle = l),
+ (l = i - e.left),
+ (s = n - e.top),
+ (r = r - i + e.width),
+ (i = o - n + e.height),
+ Object.values(a).some((t) => 0 !== t)
+ ? (t.beginPath(),
+ addRoundedRectPath(t, { x: l, y: s, w: r, h: i, radius: a }),
+ t.fill())
+ : t.fillRect(l, s, r, i));
+}
+function drawPointLabels(e, i) {
+ const {
+ ctx: a,
+ options: { pointLabels: s },
+ } = e;
+ for (let t = i - 1; 0 <= t; t--) {
+ var n,
+ r,
+ o,
+ l,
+ h = e._pointLabelItems[t];
+ h.visible &&
+ (drawPointLabelBox(a, (n = s.setContext(e.getPointLabelContext(t))), h),
+ (r = toFont(n.font)),
+ ({ x: h, y: o, textAlign: l } = h),
+ renderText(a, e._pointLabels[t], h, o + r.lineHeight / 2, r, {
+ color: n.color,
+ textAlign: l,
+ textBaseline: "middle",
+ }));
+ }
+}
+function pathRadiusLine(e, i, t, a) {
+ const s = e["ctx"];
+ if (t) s.arc(e.xCenter, e.yCenter, i, 0, TAU);
+ else {
+ var n = e.getPointPosition(0, i);
+ s.moveTo(n.x, n.y);
+ for (let t = 1; t < a; t++)
+ (n = e.getPointPosition(t, i)), s.lineTo(n.x, n.y);
+ }
+}
+function drawRadiusLine(t, e, i, a, s) {
+ const n = t.ctx;
+ var r = e.circular,
+ { color: e, lineWidth: o } = e;
+ (!r && !a) ||
+ !e ||
+ !o ||
+ i < 0 ||
+ (n.save(),
+ (n.strokeStyle = e),
+ (n.lineWidth = o),
+ n.setLineDash(s.dash),
+ (n.lineDashOffset = s.dashOffset),
+ n.beginPath(),
+ pathRadiusLine(t, i, r, a),
+ n.closePath(),
+ n.stroke(),
+ n.restore());
+}
+function createPointLabelContext(t, e, i) {
+ return createContext(t, { label: i, index: e, type: "pointLabel" });
+}
+class RadialLinearScale extends LinearScaleBase {
+ static id = "radialLinear";
+ static defaults = {
+ display: !0,
+ animate: !0,
+ position: "chartArea",
+ angleLines: {
+ display: !0,
+ lineWidth: 1,
+ borderDash: [],
+ borderDashOffset: 0,
+ },
+ grid: { circular: !1 },
+ startAngle: 0,
+ ticks: { showLabelBackdrop: !0, callback: Ticks.formatters.numeric },
+ pointLabels: {
+ backdropColor: void 0,
+ backdropPadding: 2,
+ display: !0,
+ font: { size: 10 },
+ callback(t) {
+ return t;
+ },
+ padding: 5,
+ centerPointLabels: !1,
+ },
+ };
+ static defaultRoutes = {
+ "angleLines.color": "borderColor",
+ "pointLabels.color": "color",
+ "ticks.color": "color",
+ };
+ static descriptors = { angleLines: { _fallback: "grid" } };
+ constructor(t) {
+ super(t),
+ (this.xCenter = void 0),
+ (this.yCenter = void 0),
+ (this.drawingArea = void 0),
+ (this._pointLabels = []),
+ (this._pointLabelItems = []);
+ }
+ setDimensions() {
+ var t = (this._padding = toPadding(
+ getTickBackdropHeight(this.options) / 2
+ )),
+ e = (this.width = this.maxWidth - t.width),
+ i = (this.height = this.maxHeight - t.height);
+ (this.xCenter = Math.floor(this.left + e / 2 + t.left)),
+ (this.yCenter = Math.floor(this.top + i / 2 + t.top)),
+ (this.drawingArea = Math.floor(Math.min(e, i) / 2));
+ }
+ determineDataLimits() {
+ var { min: t, max: e } = this.getMinMax(!1);
+ (this.min = isNumberFinite(t) && !isNaN(t) ? t : 0),
+ (this.max = isNumberFinite(e) && !isNaN(e) ? e : 0),
+ this.handleTickRangeOptions();
+ }
+ computeTickLimit() {
+ return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));
+ }
+ generateTickLabels(t) {
+ LinearScaleBase.prototype.generateTickLabels.call(this, t),
+ (this._pointLabels = this.getLabels()
+ .map((t, e) => {
+ t = callback(this.options.pointLabels.callback, [t, e], this);
+ return t || 0 === t ? t : "";
+ })
+ .filter((t, e) => this.chart.getDataVisibility(e)));
+ }
+ fit() {
+ var t = this.options;
+ t.display && t.pointLabels.display
+ ? fitWithPointLabels(this)
+ : this.setCenterPoint(0, 0, 0, 0);
+ }
+ setCenterPoint(t, e, i, a) {
+ (this.xCenter += Math.floor((t - e) / 2)),
+ (this.yCenter += Math.floor((i - a) / 2)),
+ (this.drawingArea -= Math.min(
+ this.drawingArea / 2,
+ Math.max(t, e, i, a)
+ ));
+ }
+ getIndexAngle(t) {
+ var e = TAU / (this._pointLabels.length || 1),
+ i = this.options.startAngle || 0;
+ return _normalizeAngle(t * e + toRadians(i));
+ }
+ getDistanceFromCenterForValue(t) {
+ if (isNullOrUndef(t)) return NaN;
+ var e = this.drawingArea / (this.max - this.min);
+ return this.options.reverse ? (this.max - t) * e : (t - this.min) * e;
+ }
+ getValueForDistanceFromCenter(t) {
+ if (isNullOrUndef(t)) return NaN;
+ t /= this.drawingArea / (this.max - this.min);
+ return this.options.reverse ? this.max - t : this.min + t;
+ }
+ getPointLabelContext(t) {
+ var e = this._pointLabels || [];
+ if (0 <= t && t < e.length)
+ return (e = e[t]), createPointLabelContext(this.getContext(), t, e);
+ }
+ getPointPosition(t, e, i = 0) {
+ t = this.getIndexAngle(t) - HALF_PI + i;
+ return {
+ x: Math.cos(t) * e + this.xCenter,
+ y: Math.sin(t) * e + this.yCenter,
+ angle: t,
+ };
+ }
+ getPointPositionForValue(t, e) {
+ return this.getPointPosition(t, this.getDistanceFromCenterForValue(e));
+ }
+ getBasePosition(t) {
+ return this.getPointPositionForValue(t || 0, this.getBaseValue());
+ }
+ getPointLabelPosition(t) {
+ var { left: t, top: e, right: i, bottom: a } = this._pointLabelItems[t];
+ return { left: t, top: e, right: i, bottom: a };
+ }
+ drawBackground() {
+ var {
+ backgroundColor: t,
+ grid: { circular: e },
+ } = this.options;
+ if (t) {
+ const i = this.ctx;
+ i.save(),
+ i.beginPath(),
+ pathRadiusLine(
+ this,
+ this.getDistanceFromCenterForValue(this._endValue),
+ e,
+ this._pointLabels.length
+ ),
+ i.closePath(),
+ (i.fillStyle = t),
+ i.fill(),
+ i.restore();
+ }
+ }
+ drawGrid() {
+ const t = this.ctx;
+ var e = this.options;
+ const { angleLines: i, grid: a, border: s } = e,
+ n = this._pointLabels.length;
+ let r, o, l;
+ if (
+ (e.pointLabels.display && drawPointLabels(this, n),
+ a.display &&
+ this.ticks.forEach((t, e) => {
+ 0 !== e &&
+ ((o = this.getDistanceFromCenterForValue(t.value)),
+ (t = this.getContext(e)),
+ (e = a.setContext(t)),
+ (t = s.setContext(t)),
+ drawRadiusLine(this, e, o, n, t));
+ }),
+ i.display)
+ ) {
+ for (t.save(), r = n - 1; 0 <= r; r--) {
+ var h = i.setContext(this.getPointLabelContext(r)),
+ { color: d, lineWidth: c } = h;
+ c &&
+ d &&
+ ((t.lineWidth = c),
+ (t.strokeStyle = d),
+ t.setLineDash(h.borderDash),
+ (t.lineDashOffset = h.borderDashOffset),
+ (o = this.getDistanceFromCenterForValue(
+ e.ticks.reverse ? this.min : this.max
+ )),
+ (l = this.getPointPosition(r, o)),
+ t.beginPath(),
+ t.moveTo(this.xCenter, this.yCenter),
+ t.lineTo(l.x, l.y),
+ t.stroke());
+ }
+ t.restore();
+ }
+ }
+ drawBorder() {}
+ drawLabels() {
+ const r = this.ctx,
+ o = this.options,
+ l = o.ticks;
+ if (l.display) {
+ var t = this.getIndexAngle(0);
+ let s, n;
+ r.save(),
+ r.translate(this.xCenter, this.yCenter),
+ r.rotate(t),
+ (r.textAlign = "center"),
+ (r.textBaseline = "middle"),
+ this.ticks.forEach((t, e) => {
+ var i, a;
+ (0 === e && !o.reverse) ||
+ ((i = l.setContext(this.getContext(e))),
+ (a = toFont(i.font)),
+ (s = this.getDistanceFromCenterForValue(this.ticks[e].value)),
+ i.showLabelBackdrop &&
+ ((r.font = a.string),
+ (n = r.measureText(t.label).width),
+ (r.fillStyle = i.backdropColor),
+ (e = toPadding(i.backdropPadding)),
+ r.fillRect(
+ -n / 2 - e.left,
+ -s - a.size / 2 - e.top,
+ n + e.width,
+ a.size + e.height
+ )),
+ renderText(r, t.label, 0, -s, a, {
+ color: i.color,
+ strokeColor: i.textStrokeColor,
+ strokeWidth: i.textStrokeWidth,
+ }));
+ }),
+ r.restore();
+ }
+ }
+ drawTitle() {}
+}
+const INTERVALS = {
+ millisecond: { common: !0, size: 1, steps: 1e3 },
+ second: { common: !0, size: 1e3, steps: 60 },
+ minute: { common: !0, size: 6e4, steps: 60 },
+ hour: { common: !0, size: 36e5, steps: 24 },
+ day: { common: !0, size: 864e5, steps: 30 },
+ week: { common: !1, size: 6048e5, steps: 4 },
+ month: { common: !0, size: 2628e6, steps: 12 },
+ quarter: { common: !1, size: 7884e6, steps: 4 },
+ year: { common: !0, size: 3154e7 },
+ },
+ UNITS = Object.keys(INTERVALS);
+function sorter(t, e) {
+ return t - e;
+}
+function parse(t, e) {
+ if (isNullOrUndef(e)) return null;
+ const i = t._adapter,
+ { parser: a, round: s, isoWeekday: n } = t._parseOpts;
+ let r = e;
+ return (
+ "function" == typeof a && (r = a(r)),
+ null ===
+ (r = isNumberFinite(r)
+ ? r
+ : "string" == typeof a
+ ? i.parse(r, a)
+ : i.parse(r))
+ ? null
+ : +(r = s
+ ? "week" !== s || (!isNumber(n) && !0 !== n)
+ ? i.startOf(r, s)
+ : i.startOf(r, "isoWeek", n)
+ : r)
+ );
+}
+function determineUnitForAutoTicks(e, i, a, s) {
+ var n = UNITS.length;
+ for (let t = UNITS.indexOf(e); t < n - 1; ++t) {
+ var r = INTERVALS[UNITS[t]],
+ o = r.steps || Number.MAX_SAFE_INTEGER;
+ if (r.common && Math.ceil((a - i) / (o * r.size)) <= s) return UNITS[t];
+ }
+ return UNITS[n - 1];
+}
+function determineUnitForFormatting(e, i, a, s, n) {
+ for (let t = UNITS.length - 1; t >= UNITS.indexOf(a); t--) {
+ var r = UNITS[t];
+ if (INTERVALS[r].common && e._adapter.diff(n, s, r) >= i - 1) return r;
+ }
+ return UNITS[a ? UNITS.indexOf(a) : 0];
+}
+function determineMajorUnit(i) {
+ for (let t = UNITS.indexOf(i) + 1, e = UNITS.length; t < e; ++t)
+ if (INTERVALS[UNITS[t]].common) return UNITS[t];
+}
+function addTick(t, e, i) {
+ var a, s;
+ i
+ ? i.length &&
+ (({ lo: a, hi: s } = _lookup(i, e)), (t[i[a] >= e ? i[a] : i[s]] = !0))
+ : (t[e] = !0);
+}
+function setMajorTicks(t, e, i, a) {
+ const s = t._adapter;
+ var t = +s.startOf(e[0].value, a),
+ n = e[e.length - 1].value;
+ let r, o;
+ for (r = t; r <= n; r = +s.add(r, 1, a)) 0 <= (o = i[r]) && (e[o].major = !0);
+ return e;
+}
+function ticksFromTimestamps(t, e, i) {
+ const a = [],
+ s = {};
+ var n = e.length;
+ let r, o;
+ for (r = 0; r < n; ++r)
+ (o = e[r]), (s[o] = r), a.push({ value: o, major: !1 });
+ return 0 !== n && i ? setMajorTicks(t, a, s, i) : a;
+}
+class TimeScale extends Scale {
+ static id = "time";
+ static defaults = {
+ bounds: "data",
+ adapters: {},
+ time: {
+ parser: !1,
+ unit: !1,
+ round: !1,
+ isoWeekday: !1,
+ minUnit: "millisecond",
+ displayFormats: {},
+ },
+ ticks: { source: "auto", callback: !1, major: { enabled: !1 } },
+ };
+ constructor(t) {
+ super(t),
+ (this._cache = { data: [], labels: [], all: [] }),
+ (this._unit = "day"),
+ (this._majorUnit = void 0),
+ (this._offsets = {}),
+ (this._normalized = !1),
+ (this._parseOpts = void 0);
+ }
+ init(t, e = {}) {
+ var i = t.time || (t.time = {});
+ const a = (this._adapter = new adapters._date(t.adapters.date));
+ a.init(e),
+ mergeIf(i.displayFormats, a.formats()),
+ (this._parseOpts = {
+ parser: i.parser,
+ round: i.round,
+ isoWeekday: i.isoWeekday,
+ }),
+ super.init(t),
+ (this._normalized = e.normalized);
+ }
+ parse(t, e) {
+ return void 0 === t ? null : parse(this, t);
+ }
+ beforeLayout() {
+ super.beforeLayout(), (this._cache = { data: [], labels: [], all: [] });
+ }
+ determineDataLimits() {
+ var t = this.options;
+ const e = this._adapter;
+ var i = t.time.unit || "day";
+ let { min: a, max: s, minDefined: n, maxDefined: r } = this.getUserBounds();
+ function o(t) {
+ n || isNaN(t.min) || (a = Math.min(a, t.min)),
+ r || isNaN(t.max) || (s = Math.max(s, t.max));
+ }
+ (n && r) ||
+ (o(this._getLabelBounds()),
+ ("ticks" === t.bounds && "labels" === t.ticks.source) ||
+ o(this.getMinMax(!1))),
+ (a = isNumberFinite(a) && !isNaN(a) ? a : +e.startOf(Date.now(), i)),
+ (s = isNumberFinite(s) && !isNaN(s) ? s : +e.endOf(Date.now(), i) + 1),
+ (this.min = Math.min(a, s - 1)),
+ (this.max = Math.max(a + 1, s));
+ }
+ _getLabelBounds() {
+ var t = this.getLabelTimestamps();
+ let e = Number.POSITIVE_INFINITY,
+ i = Number.NEGATIVE_INFINITY;
+ return t.length && ((e = t[0]), (i = t[t.length - 1])), { min: e, max: i };
+ }
+ buildTicks() {
+ var t = this.options,
+ e = t.time,
+ i = t.ticks,
+ a = "labels" === i.source ? this.getLabelTimestamps() : this._generate(),
+ s =
+ ("ticks" === t.bounds &&
+ a.length &&
+ ((this.min = this._userMin || a[0]),
+ (this.max = this._userMax || a[a.length - 1])),
+ this.min),
+ n = this.max;
+ const r = _filterBetween(a, s, n);
+ return (
+ (this._unit =
+ e.unit ||
+ (i.autoSkip
+ ? determineUnitForAutoTicks(
+ e.minUnit,
+ this.min,
+ this.max,
+ this._getLabelCapacity(s)
+ )
+ : determineUnitForFormatting(
+ this,
+ r.length,
+ e.minUnit,
+ this.min,
+ this.max
+ ))),
+ (this._majorUnit =
+ i.major.enabled && "year" !== this._unit
+ ? determineMajorUnit(this._unit)
+ : void 0),
+ this.initOffsets(a),
+ t.reverse && r.reverse(),
+ ticksFromTimestamps(this, r, this._majorUnit)
+ );
+ }
+ afterAutoSkip() {
+ this.options.offsetAfterAutoskip &&
+ this.initOffsets(this.ticks.map((t) => +t.value));
+ }
+ initOffsets(t = []) {
+ let e = 0,
+ i = 0;
+ this.options.offset &&
+ t.length &&
+ ((a = this.getDecimalForValue(t[0])),
+ (e = 1 === t.length ? 1 - a : (this.getDecimalForValue(t[1]) - a) / 2),
+ (a = this.getDecimalForValue(t[t.length - 1])),
+ (i =
+ 1 === t.length
+ ? a
+ : (a - this.getDecimalForValue(t[t.length - 2])) / 2));
+ var a = t.length < 3 ? 0.5 : 0.25;
+ (e = _limitValue(e, 0, a)),
+ (i = _limitValue(i, 0, a)),
+ (this._offsets = { start: e, end: i, factor: 1 / (e + 1 + i) });
+ }
+ _generate() {
+ const t = this._adapter;
+ var e = this.min,
+ i = this.max,
+ a = this.options,
+ s = a.time,
+ n =
+ s.unit ||
+ determineUnitForAutoTicks(s.minUnit, e, i, this._getLabelCapacity(e)),
+ r = valueOrDefault(a.ticks.stepSize, 1),
+ s = "week" === n && s.isoWeekday,
+ o = isNumber(s) || !0 === s,
+ l = {};
+ let h = e,
+ d,
+ c;
+ if (
+ (o && (h = +t.startOf(h, "isoWeek", s)),
+ (h = +t.startOf(h, o ? "day" : n)),
+ t.diff(i, e, n) > 1e5 * r)
+ )
+ throw new Error(
+ e + " and " + i + " are too far apart with stepSize of " + r + " " + n
+ );
+ var u = "data" === a.ticks.source && this.getDataTimestamps();
+ for (d = h, c = 0; d < i; d = +t.add(d, r, n), c++) addTick(l, d, u);
+ return (
+ (d !== i && "ticks" !== a.bounds && 1 !== c) || addTick(l, d, u),
+ Object.keys(l)
+ .sort(sorter)
+ .map((t) => +t)
+ );
+ }
+ getLabelForValue(t) {
+ const e = this._adapter;
+ var i = this.options.time;
+ return i.tooltipFormat
+ ? e.format(t, i.tooltipFormat)
+ : e.format(t, i.displayFormats.datetime);
+ }
+ format(t, e) {
+ var i = this.options.time.displayFormats,
+ a = this._unit,
+ e = e || i[a];
+ return this._adapter.format(t, e);
+ }
+ _tickFormatFunction(t, e, i, a) {
+ var s = this.options,
+ n = s.ticks.callback;
+ if (n) return callback(n, [t, e, i], this);
+ var n = s.time.displayFormats,
+ s = this._unit,
+ r = this._majorUnit,
+ s = s && n[s],
+ n = r && n[r],
+ i = i[e],
+ e = r && n && i && i.major;
+ return this._adapter.format(t, a || (e ? n : s));
+ }
+ generateTickLabels(t) {
+ let e, i, a;
+ for (e = 0, i = t.length; e < i; ++e)
+ (a = t[e]).label = this._tickFormatFunction(a.value, e, t);
+ }
+ getDecimalForValue(t) {
+ return null === t ? NaN : (t - this.min) / (this.max - this.min);
+ }
+ getPixelForValue(t) {
+ var e = this._offsets,
+ t = this.getDecimalForValue(t);
+ return this.getPixelForDecimal((e.start + t) * e.factor);
+ }
+ getValueForPixel(t) {
+ var e = this._offsets,
+ t = this.getDecimalForPixel(t) / e.factor - e.end;
+ return this.min + t * (this.max - this.min);
+ }
+ _getLabelSize(t) {
+ var e = this.options.ticks,
+ t = this.ctx.measureText(t).width,
+ e = toRadians(this.isHorizontal() ? e.maxRotation : e.minRotation),
+ i = Math.cos(e),
+ e = Math.sin(e),
+ a = this._resolveTickFontOptions(0).size;
+ return { w: t * i + a * e, h: t * e + a * i };
+ }
+ _getLabelCapacity(t) {
+ var e = this.options.time,
+ i = e.displayFormats,
+ e = i[e.unit] || i.millisecond,
+ i = this._tickFormatFunction(
+ t,
+ 0,
+ ticksFromTimestamps(this, [t], this._majorUnit),
+ e
+ ),
+ t = this._getLabelSize(i),
+ e =
+ Math.floor(this.isHorizontal() ? this.width / t.w : this.height / t.h) -
+ 1;
+ return 0 < e ? e : 1;
+ }
+ getDataTimestamps() {
+ let t = this._cache.data || [],
+ e,
+ i;
+ if (t.length) return t;
+ const a = this.getMatchingVisibleMetas();
+ if (this._normalized && a.length)
+ return (this._cache.data = a[0].controller.getAllParsedValues(this));
+ for (e = 0, i = a.length; e < i; ++e)
+ t = t.concat(a[e].controller.getAllParsedValues(this));
+ return (this._cache.data = this.normalize(t));
+ }
+ getLabelTimestamps() {
+ const t = this._cache.labels || [];
+ let e, i;
+ if (t.length) return t;
+ var a = this.getLabels();
+ for (e = 0, i = a.length; e < i; ++e) t.push(parse(this, a[e]));
+ return (this._cache.labels = this._normalized ? t : this.normalize(t));
+ }
+ normalize(t) {
+ return _arrayUnique(t.sort(sorter));
+ }
+}
+function interpolate(t, e, i) {
+ let a = 0,
+ s = t.length - 1,
+ n,
+ r,
+ o,
+ l;
+ i
+ ? (e >= t[a].pos &&
+ e <= t[s].pos &&
+ ({ lo: a, hi: s } = _lookupByKey(t, "pos", e)),
+ ({ pos: n, time: o } = t[a]),
+ ({ pos: r, time: l } = t[s]))
+ : (e >= t[a].time &&
+ e <= t[s].time &&
+ ({ lo: a, hi: s } = _lookupByKey(t, "time", e)),
+ ({ time: n, pos: o } = t[a]),
+ ({ time: r, pos: l } = t[s]));
+ i = r - n;
+ return i ? o + ((l - o) * (e - n)) / i : o;
+}
+class TimeSeriesScale extends TimeScale {
+ static id = "timeseries";
+ static defaults = TimeScale.defaults;
+ constructor(t) {
+ super(t),
+ (this._table = []),
+ (this._minPos = void 0),
+ (this._tableRange = void 0);
+ }
+ initOffsets() {
+ var t = this._getTimestampsForTable(),
+ e = (this._table = this.buildLookupTable(t));
+ (this._minPos = interpolate(e, this.min)),
+ (this._tableRange = interpolate(e, this.max) - this._minPos),
+ super.initOffsets(t);
+ }
+ buildLookupTable(t) {
+ var { min: e, max: i } = this;
+ const a = [],
+ s = [];
+ let n, r, o, l, h;
+ for (n = 0, r = t.length; n < r; ++n)
+ (l = t[n]) >= e && l <= i && a.push(l);
+ if (a.length < 2)
+ return [
+ { time: e, pos: 0 },
+ { time: i, pos: 1 },
+ ];
+ for (n = 0, r = a.length; n < r; ++n)
+ (h = a[n + 1]),
+ (o = a[n - 1]),
+ (l = a[n]),
+ Math.round((h + o) / 2) !== l && s.push({ time: l, pos: n / (r - 1) });
+ return s;
+ }
+ _generate() {
+ var t = this.min,
+ e = this.max;
+ let i = super.getDataTimestamps();
+ return (
+ (i.includes(t) && i.length) || i.splice(0, 0, t),
+ (i.includes(e) && 1 !== i.length) || i.push(e),
+ i.sort((t, e) => t - e)
+ );
+ }
+ _getTimestampsForTable() {
+ let t = this._cache.all || [];
+ if (t.length) return t;
+ const e = this.getDataTimestamps();
+ var i = this.getLabelTimestamps();
+ return (
+ (t =
+ e.length && i.length ? this.normalize(e.concat(i)) : e.length ? e : i),
+ (t = this._cache.all = t)
+ );
+ }
+ getDecimalForValue(t) {
+ return (interpolate(this._table, t) - this._minPos) / this._tableRange;
+ }
+ getValueForPixel(t) {
+ var e = this._offsets,
+ t = this.getDecimalForPixel(t) / e.factor - e.end;
+ return interpolate(this._table, t * this._tableRange + this._minPos, !0);
+ }
+}
+var scales = Object.freeze({
+ __proto__: null,
+ CategoryScale: CategoryScale,
+ LinearScale: LinearScale,
+ LogarithmicScale: LogarithmicScale,
+ RadialLinearScale: RadialLinearScale,
+ TimeScale: TimeScale,
+ TimeSeriesScale: TimeSeriesScale,
+});
+const registerables = [controllers, elements, plugins, scales];
+export {
+ Animation,
+ Animations,
+ ArcElement,
+ BarController,
+ BarElement,
+ BasePlatform,
+ BasicPlatform,
+ BubbleController,
+ CategoryScale,
+ Chart,
+ plugin_colors as Colors,
+ DatasetController,
+ plugin_decimation as Decimation,
+ DomPlatform,
+ DoughnutController,
+ Element,
+ index as Filler,
+ Interaction,
+ plugin_legend as Legend,
+ LineController,
+ LineElement,
+ LinearScale,
+ LogarithmicScale,
+ PieController,
+ PointElement,
+ PolarAreaController,
+ RadarController,
+ RadialLinearScale,
+ Scale,
+ ScatterController,
+ plugin_subtitle as SubTitle,
+ Ticks,
+ TimeScale,
+ TimeSeriesScale,
+ plugin_title as Title,
+ plugin_tooltip as Tooltip,
+ adapters as _adapters,
+ _detectPlatform,
+ animator,
+ controllers,
+ defaults,
+ elements,
+ layouts,
+ plugins,
+ registerables,
+ registry,
+ scales,
+};
diff --git a/static/chess-charts.js b/static/chess-charts.js
new file mode 100644
index 0000000..2932b2a
--- /dev/null
+++ b/static/chess-charts.js
@@ -0,0 +1,46 @@
+const chessData = JSON.parse(document.getElementById("chessData").textContent);
+const bulletData = chessData[0];
+const blitzData = chessData[1];
+const rapidData = chessData[2];
+
+const rapidCtx = document.getElementById("rapidChart").getContext("2d");
+const rapidChart = new Chart(rapidCtx, {
+ type: "line",
+ data: {
+ datasets: [
+ {
+ borderColor: "#3273dc",
+ label: "rapid",
+ data: rapidData.data,
+ },
+ ],
+ },
+});
+
+const blitzCtx = document.getElementById("blitzChart").getContext("2d");
+const blitzChart = new Chart(blitzCtx, {
+ type: "line",
+ data: {
+ datasets: [
+ {
+ borderColor: "#EDAE49",
+ label: "blitz",
+ data: blitzData.data,
+ },
+ ],
+ },
+});
+
+const bulletCtx = document.getElementById("bulletChart").getContext("2d");
+const bulletChart = new Chart(bulletCtx, {
+ type: "line",
+ data: {
+ datasets: [
+ {
+ borderColor: "#D1495B",
+ label: "bullet",
+ data: bulletData.data,
+ },
+ ],
+ },
+});
diff --git a/static/style.css b/static/style.css
index 0e2aaa5..d8c928a 100644
--- a/static/style.css
+++ b/static/style.css
@@ -1,3 +1,9 @@
+/* helpers */
+
+.txt-right {
+ text-align: right;
+}
+
html {
--width: 800px;
--font-main: "DM Sans", sans-serif;
@@ -91,6 +97,10 @@ hr {
border-top: 1px dashed;
}
+small a {
+ text-transform: lowercase;
+}
+
img {
max-width: 100%;
}
@@ -151,3 +161,7 @@ ul.blog-posts li span {
ul.blog-posts li a:visited {
color: var(--visited-color);
}
+/* right now just used for chess charts*/
+canvas:not(:last-child) {
+ margin-bottom: 50px;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-04 16:12:47 +0000