diff --git a/addons_extensions/ftp_custom_dashboards/__init__.py b/addons_extensions/ftp_custom_dashboards/__init__.py
new file mode 100644
index 000000000..38718f084
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/__init__.py
@@ -0,0 +1,2 @@
+from . import models
+from . import controllers
\ No newline at end of file
diff --git a/addons_extensions/ftp_custom_dashboards/__manifest__.py b/addons_extensions/ftp_custom_dashboards/__manifest__.py
new file mode 100644
index 000000000..0d8c1e70d
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/__manifest__.py
@@ -0,0 +1,50 @@
+{
+ 'name': 'FTP Custom Dashboards',
+ 'summary': 'Advanced Dynamic Dashboards with 3D Views, Charts, and Real-time Data for Odoo 18 Community',
+ 'category': 'Reporting',
+ 'version': '1.0.0',
+ 'author': 'Your Name',
+ 'website': 'https://yourwebsite.com',
+ 'license': 'LGPL-3',
+ 'maintainers': ['yourgithubusername'],
+ 'sequence': -100,
+ 'depends': [
+ 'base', 'web', 'hr', 'hr_recruitment_extended',
+ 'website_hr_recruitment_extended', 'website_mail'
+ ],
+ 'data': [
+ 'views/dashboard_menu.xml',
+ ],
+ 'assets': {
+ 'web.assets_backend': [
+ # Ensure jQuery and Odoo dependencies are loaded first
+ 'web/static/lib/jquery/jquery.js',
+ 'web/static/src/legacy/js/public/public_widget.js',
+ 'web/static/src/legacy/js/public/minimal_dom.js',
+ 'web/static/src/legacy/js/core/*',
+ 'ftp_custom_dashboards/static/src/lib/Chart/Chart.js',
+ 'ftp_custom_dashboards/static/src/lib/d3/d3.min.js',
+ 'ftp_custom_dashboards/static/src/lib/three/three.min.js',
+ # 'ftp_custom_dashboards/static/src/lib/Chart/chartjs-plugin-datalabels.js',
+
+ # Local assets (Sortable.js and Select2)
+ 'website_hr_recruitment_extended/static/src/lib/select2/selecttwo.css',
+ 'website_hr_recruitment_extended/static/src/js/select2_init.js',
+ 'ftp_custom_dashboards/static/src/lib/sortable/Sortable.min.js',
+ 'ftp_custom_dashboards/static/src/lib/interact/interact.min.js',
+
+ # Custom module assets
+ 'ftp_custom_dashboards/static/src/js/customRecruitmentDashboard.js',
+ 'ftp_custom_dashboards/static/src/xml/customRecruitmentDashboard.xml',
+ 'ftp_custom_dashboards/static/src/css/customRecruitmentDashboard.css',
+ 'ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.js',
+ 'ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.xml',
+ ],
+ },
+ 'external_dependencies': {
+ 'python': ['numpy', 'pandas'],
+ },
+ 'installable': True,
+ 'application': True,
+ 'auto_install': False,
+}
diff --git a/addons_extensions/ftp_custom_dashboards/controllers/__init__.py b/addons_extensions/ftp_custom_dashboards/controllers/__init__.py
new file mode 100644
index 000000000..a03bfd097
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/controllers/__init__.py
@@ -0,0 +1 @@
+from . import controllers
\ No newline at end of file
diff --git a/addons_extensions/ftp_custom_dashboards/controllers/controllers.py b/addons_extensions/ftp_custom_dashboards/controllers/controllers.py
new file mode 100644
index 000000000..f3afc4a9c
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/controllers/controllers.py
@@ -0,0 +1,62 @@
+
+import warnings
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+from operator import itemgetter
+from werkzeug.urls import url_encode
+
+from odoo import http, _, fields
+from odoo.addons.website_hr_recruitment.controllers.main import WebsiteHrRecruitment
+from odoo.osv.expression import AND
+from odoo.http import request
+from datetime import timedelta
+from odoo.tools import email_normalize
+from odoo.tools.misc import groupby
+import base64
+from odoo.exceptions import UserError
+
+from PIL import Image
+from io import BytesIO
+import re
+import json
+
+
+
+class website_hr_recruitment_applications(http.Controller):
+
+ @http.route('/recruitment/get_assignees', type='json', auth='user', methods=['POST'])
+ def get_assignees(self):
+ """Fetch users who are in the 'Recruitment Interview Group'."""
+ group_id = request.env.ref("hr_recruitment.group_hr_recruitment_interviewer").id
+ assignees = request.env["res.users"].sudo().search([
+ ("groups_id", "in", [group_id])
+ ])
+
+ return [{"id": int(user.id), "name": user.name} for user in assignees]
+
+ @http.route('/custom_dashboard/recruitment_data', type='json', auth='user')
+ def recruitment_data(self, params=None):
+ domain = []
+ if params:
+ if params.get('date_range'):
+ date_range = params['date_range']
+ # Apply the date range filter in the domain
+ if date_range == "7":
+ domain.append(('create_date', '>=', fields.Date.today() - timedelta(days=7)))
+ elif date_range == "30":
+ domain.append(('create_date', '>=', fields.Date.today() - timedelta(days=30)))
+ # Add more conditions for different date ranges
+
+ if params.get('assignees'):
+ domain.append(('user_id', 'in', params['assignees']))
+
+ # Fetch data based on filtered domain
+ total_open_positions = request.env['hr.job.recruitment'].search_count(domain)
+ total_applications = request.env['hr.applicant'].search_count(domain)
+ # active_jobs = request.env['hr.job'].search_count(domain + [('state', '=', 'open')])
+
+ return {
+ 'total_open_positions': total_open_positions,
+ 'total_applications': total_applications,
+ 'active_jobs': 52,
+ }
diff --git a/addons_extensions/ftp_custom_dashboards/models/__init__.py b/addons_extensions/ftp_custom_dashboards/models/__init__.py
new file mode 100644
index 000000000..a549b2210
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/models/__init__.py
@@ -0,0 +1 @@
+from . import dashboard_menu
\ No newline at end of file
diff --git a/addons_extensions/ftp_custom_dashboards/models/dashboard_menu.py b/addons_extensions/ftp_custom_dashboards/models/dashboard_menu.py
new file mode 100644
index 000000000..deadad204
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/models/dashboard_menu.py
@@ -0,0 +1,8 @@
+# from odoo import models, fields
+#
+# class FTPDashboardMenu(models.Model):
+# _name = 'ftp.dashboard.menu'
+# _description = 'FTP Dashboard Menus'
+#
+# name = fields.Char(string="Menu Name", required=True)
+# active = fields.Boolean(string="Active", default=True)
diff --git a/addons_extensions/ftp_custom_dashboards/security/ir.model.access.csv b/addons_extensions/ftp_custom_dashboards/security/ir.model.access.csv
new file mode 100644
index 000000000..932030bc8
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/security/ir.model.access.csv
@@ -0,0 +1,3 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_ftp_dashboard_menu_manager,FTP Dashboard Menu Manager,model_ftp_dashboard_menu,base.group_user,1,1,1,1
+access_ftp_dashboard_menu_user,FTP Dashboard Menu User,model_ftp_dashboard_menu,,1,0,0,0
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/css/customRecruitmentDashboard.css b/addons_extensions/ftp_custom_dashboards/static/src/css/customRecruitmentDashboard.css
new file mode 100644
index 000000000..67a38286c
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/css/customRecruitmentDashboard.css
@@ -0,0 +1,241 @@
+/* General Styling */
+.custom_recruitment_dashboard {
+ display: flex;
+ flex-direction: column;
+ height: 100vh;
+ font-family: 'Poppins', sans-serif; /* Modern font */
+ background: #f4f7fc;
+ width: 100%;
+ overflow: hidden !important;
+}
+
+.custom_recruitment_dashboard .o_dashboard_title {
+ font-size: 40px;
+ color: #3b82f6;
+ font-weight: bold;
+ background: white;
+
+}
+
+.custom_recruitment_dashboard .custom_recruitment_layout {
+ overflow: hidden !important;
+}
+/* Filters */
+.custom_recruitment_dashboard .o_dashboard_filters {
+ display: flex;
+ align-items: center;
+ gap: 15px;
+ padding: 15px;
+ border-bottom: 2px solid #ddd;
+ background: white;
+ position: sticky;
+ top: 0;
+ z-index: 10;
+ box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1);
+ width: 100%;
+ overflow : hidden !important;
+}
+
+/* Dashboard Content */
+.custom_recruitment_dashboard .o_dashboard_content {
+ flex-grow: 1;
+ display: flex;
+ flex-direction: column;
+ background-color: #FAFAFA;
+ padding: 10px;
+ height: 90%;
+ width: 100%;
+ overflow: hidden !important;
+
+}
+
+/* Dashboard Items Container - Horizontal Scrolling */
+.custom_recruitment_dashboard #dashboard_items_container {
+ display: flex;
+ flex-wrap: nowrap; /* Prevents items from wrapping */
+ gap: 20px; /* Space between items */
+ padding: 10px;
+ overflow-x: auto; /* Enables horizontal scrolling */
+ overflow-y: hidden;
+ white-space: nowrap;
+ width: 100%;
+ height: 250px;
+ scroll-behavior: smooth; /* Smooth scrolling */
+}
+
+/* Dashboard Items */
+.custom_recruitment_dashboard .dashboard-item {
+ background: linear-gradient(145deg, #ffffff, #e3e6f0);
+ border-radius: 12px;
+ padding: 10px;
+ box-shadow: 5px 5px 15px rgba(0, 0, 0, 0.15);
+ cursor: pointer;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ min-width: 250px; /* Fixed width */
+ height: 150px; /* Fixed height */
+ transition: transform 0.2s ease-in-out, box-shadow 0.3s ease;
+ flex-shrink: 0; /* Prevents items from shrinking */
+}
+
+/* Add shadow when moving */
+.custom_recruitment_dashboard .dashboard-item:active {
+ transform: scale(1.05);
+ box-shadow: 6px 6px 20px rgba(0, 0, 0, 0.2);
+ cursor: grabbing;
+}
+
+/* Inner content */
+.custom_recruitment_dashboard .dashboard-content {
+ width: 100%;
+ height: 100%;
+ overflow: hidden;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ text-align: center;
+}
+
+/* Icons */
+.custom_recruitment_dashboard .dashboard-item i {
+ font-size: 40px;
+ color: #3b82f6;
+ margin-bottom: 10px;
+}
+
+/* Titles */
+.custom_recruitment_dashboard .dashboard-item h3 {
+ font-size: 1.2rem;
+ color: #333;
+ font-weight: 600;
+ margin: 5px 0;
+}
+
+/* Descriptions */
+.custom_recruitment_dashboard .dashboard-item p {
+ font-size: 0.9rem;
+ color: #777;
+ user-select: none; /* Prevents text selection while dragging */
+}
+
+/* Disable text selection */
+.custom_recruitment_dashboard .dashboard-item,
+.dashboard-item * {
+ user-select: none;
+}
+
+/* Resizing Effect */
+.custom_recruitment_dashboard .dashboard-item.resizing {
+ transition: none; /* Disable animation while resizing */
+}
+
+/* Scrollbar Styling */
+.custom_recruitment_dashboard #dashboard_items_container::-webkit-scrollbar {
+ height: 8px;
+}
+
+.custom_recruitment_dashboard #dashboard_items_container::-webkit-scrollbar-track {
+ background: #ddd;
+ border-radius: 4px;
+}
+
+.custom_recruitment_dashboard #dashboard_items_container::-webkit-scrollbar-thumb {
+ background: #888;
+ border-radius: 4px;
+}
+
+.custom_recruitment_dashboard #dashboard_items_container::-webkit-scrollbar-thumb:hover {
+ background: #555;
+}
+
+/* Dashboard Graph Container */
+.custom_recruitment_dashboard #dashboard_graph_container {
+ height: calc(100vh - 180px); /* Adjust based on the space taken by header and filters */
+ overflow-y: auto; /* Enable scrolling only on the graph container */
+ overflow-x: hidden !important;
+ padding: 10px;
+ display: flex;
+ justify-content: space-between; /* Ensure space between charts */
+ align-items: stretch; /* Make sure both charts stretch to fit container height */
+ gap: 10px; /* Reduced space between charts */
+ margin-bottom: 5%; /* Add margin to separate the charts vertically when stacked */
+
+}
+
+/* General Styling for Chart Section */
+.custom_recruitment_dashboard .submission_status_pie {
+ width: 39%; /* Slightly reduce width to ensure both charts fit properly side by side */
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ margin-bottom: 20px; /* Add margin to separate the charts vertically when stacked */
+ flex-grow: 1; /* Allow sections to grow and take up remaining space */
+}
+
+.custom_recruitment_dashboard .candidate_pipeline_dashboard {
+ width: 59%; /* Slightly reduce width to ensure both charts fit properly side by side */
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ margin-bottom: 20px; /* Add margin to separate the charts vertically when stacked */
+ flex-grow: 1; /* Allow sections to grow and take up remaining space */
+}
+
+.custom_recruitment_dashboard .job_applications_bar {
+ width: 89%; /* Slightly reduce width to ensure both charts fit properly side by side */
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ margin-bottom: 20px; /* Add margin to separate the charts vertically when stacked */
+ flex-grow: 1;
+}
+
+/* Ensure the charts fit well within the section */
+.custom_recruitment_dashboard .chart-container {
+ width: 100%; /* Take full width of the chart section */
+ padding: 10px;
+ box-sizing: border-box; /* Include padding in the width calculation */
+ display: flex;
+ justify-content: center;
+}
+
+/* Ensure charts fit properly in the container */
+.custom_recruitment_dashboard canvas#submissionStatusPieChart,
+.custom_recruitment_dashboard canvas#applicationsPerJobBarChart,
+.custom_recruitment_dashboard canvas#candidatePipelineBarChart {
+ width: 100% !important;
+ height: auto !important;
+ max-width: 100%; /* Prevent charts from overflowing */
+ max-height: 300px; /* Optional: set max height to avoid too large charts */
+}
+
+/* Ensure proper responsiveness for smaller screens */
+@media (max-width: 1024px) {
+ .custom_recruitment_dashboard #dashboard_graph_container {
+ padding: 10px;
+ flex-direction: column; /* Stack charts vertically on smaller screens */
+ align-items: center;
+ overflow-y: auto;
+ }
+
+ .custom_recruitment_dashboard .chart-section {
+ width: 100%; /* Full width on smaller screens */
+ margin-bottom: 20px; /* Space between charts */
+ }
+
+ .custom_recruitment_dashboard .chart-container {
+ width: 90%; /* Reduce width to prevent overflow on smaller screens */
+ }
+
+ /* Ensure charts don't overflow horizontally */
+ .custom_recruitment_dashboard canvas {
+ width: 100% !important;
+ height: auto !important;
+ }
+}
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.js b/addons_extensions/ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.js
new file mode 100644
index 000000000..43a0668b3
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.js
@@ -0,0 +1,17 @@
+import { Component } from "@odoo/owl";
+
+export class DashboardItem extends Component {
+ static template = "DashboardItemTemplate";
+ static props = {
+ icon: String,
+ name: String,
+ count: Number,
+ action: Function, // Ensure action is a function
+ };
+
+ onClick() {
+ if (this.props.action) {
+ this.props.action(); // Call the function when clicked
+ }
+ }
+}
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.xml b/addons_extensions/ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.xml
new file mode 100644
index 000000000..f18bba7ea
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/dashboard_item/dashboard_item.xml
@@ -0,0 +1,18 @@
+
+
+
+
+
+
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/js/customRecruitmentDashboard.js b/addons_extensions/ftp_custom_dashboards/static/src/js/customRecruitmentDashboard.js
new file mode 100644
index 000000000..17875d9ef
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/js/customRecruitmentDashboard.js
@@ -0,0 +1,954 @@
+/** @odoo-module **/
+/* global ChartDataLabels */
+
+import { Component, useState, onWillStart, onMounted, useRef } from "@odoo/owl";
+import { registry } from "@web/core/registry";
+import { useService } from "@web/core/utils/hooks";
+import { rpc } from "@web/core/network/rpc";
+import { Layout } from "@web/search/layout";
+import { DashboardItem } from "../dashboard_item/dashboard_item";
+//import Sortable from "../lib/sortable/Sortable.min.js";
+//import interact from "../lib/interact/interact.min.js";
+import Chart from "../lib/Chart/Chart.js";
+//import ChartDataLabels from "../lib/Chart/chartjs-plugin-datalabels.js";
+import d3 from "../lib/d3/d3.min.js";
+import THREE from "../lib/three/three.min.js";
+
+export class CreateRecruitmentDashboard extends Component {
+ static template = "Custom_Recruitment_Dashboard_Template";
+ static components = { Layout, DashboardItem };
+
+ static props = {
+ date_from: { type: String, optional: true },
+ date_to: { type: String, optional: true },
+ assignees: { type: Array, optional: true },
+ selectedRecruitmentType: { type: String, optional: true },
+ selectedAssignees: { type: Array, optional: true },
+ jobRequests: { type: Array, optional: true },
+ filteredJobRequests: { type: Array, optional: true },
+ applicantsData: { type: Array, optional: true },
+ filteredApplicantsData: { type: Array, optional: true },
+ dashboardItems: { type: Array, optional: true },
+ jobPositions: { type: Array, optional: true},
+ selectedPositions: { type: Array, optional: true },
+ action: { type: Object, optional: true },
+ actionId: { type: Number, optional: true },
+ updateActionState: { type: Function, optional: true },
+ className: { type: String, optional: true },
+ globalState: { type: Object, optional: true },
+ isPublished: { type: Boolean, optional: true },
+ recruitmentStages: { type: Object, optional: true },
+ };
+ setup() {
+ super.setup();
+ this.orm = useService("orm");
+ this.action = useService("action");
+ this.canvasRef = useRef("chartCanvas");
+ this.submissionChart = null;
+ this.jobApplicationsBarChart = null;
+ this.pipelineCandidateBarChart = null;
+
+ const storedFilters = JSON.parse(localStorage.getItem("recruitmentDashboardFilters")) || {};
+
+ this.state = useState({
+ date_from: storedFilters.date_from || this.props.date_from || null,
+ date_to: storedFilters.date_to || this.props.date_to || null,
+ assignees: this.props.assignees || [],
+ selectedRecruitmentType: storedFilters.selectedRecruitmentType || this.props.selectedRecruitmentType || 'external',
+ selectedAssignees: storedFilters.selectedAssignees || this.props.selectedAssignees || [],
+ jobRequests: this.props.jobRequests || [],
+ jobPositions: this.props.jobPositions || [],
+ selectedPositions: storedFilters.selectedPositions || this.props.selectedPositions || [],
+ filteredJobRequests: this.props.filteredJobRequests || [],
+ applicantsData: this.props.applicantsData || [],
+ filteredApplicantsData: this.props.filteredApplicantsData || [],
+ recruitmentStages: this.props.recruitmentStages || [],
+ isPublished: storedFilters.isPublished || this.props.isPublished || false,
+ dashboardItems: [],
+ });
+
+
+ this.display = { controlPanel: {} };
+
+ onWillStart(async () => {
+ await this.loadInitialData();
+// this.applyStoredFilters();
+ });
+
+ onMounted(async () => {
+ await this.initializeUI();
+ this.renderAllDashboards();
+ this.onDataFilterApply();
+ this.render();
+ console.log(this.state);
+ });
+
+ }
+
+ renderAllDashboards() {
+ this.renderSubmissionStatusPieChart();
+ this.renderSubmissionStatusBarChart();
+ this.renderCandidatePipeLineBarChart();
+ }
+
+ destroyCharts() {
+ if (this.submissionChart) {
+ this.submissionChart.destroy();
+ this.submissionChart = null;
+ }
+ if (this.jobApplicationsBarChart) {
+ this.jobApplicationsBarChart.destroy();
+ this.jobApplicationsBarChart = null;
+ }
+ if (this.pipelineCandidateBarChart) {
+ this.pipelineCandidateBarChart.destroy();
+ this.pipelineCandidateBarChart = null;
+ }
+ }
+
+
+ renderSubmissionStatusPieChart() {
+ const ctx = document.getElementById("submissionStatusPieChart");
+ if (!ctx) return;
+
+ // Ensure the old chart is destroyed before creating a new one
+ if (this.submissionChart) {
+ this.submissionChart.destroy();
+ this.submissionChart = null;
+ }
+
+ const jobRequests = this.state.filteredJobRequests;
+
+ // Categorize job requests
+ let filledSubmissions = [];
+ let partialSubmissions = [];
+ let zeroSubmissions = [];
+
+ jobRequests.forEach(jr => {
+ if (jr.no_of_submissions >= jr.no_of_recruitment) {
+ filledSubmissions.push(jr);
+ } else if (jr.no_of_submissions > 0 && jr.no_of_submissions < jr.no_of_recruitment) {
+ partialSubmissions.push(jr);
+ } else {
+ zeroSubmissions.push(jr);
+ }
+ });
+
+ // Define chart data
+ const labels = ["Zero Submissions", "Partial Submissions", "Filled Submissions"];
+ const data = [zeroSubmissions.length, partialSubmissions.length, filledSubmissions.length];
+ const colors = ["#E74C3C", "#F4C542", "#2ECC71"]; // Red, Yellow, Green
+
+ this.submissionChart = new window.Chart(ctx, {
+ type: "pie",
+ data: {
+ labels: labels,
+ datasets: [{
+ data: data,
+ backgroundColor: colors
+ }]
+ },
+ options: {
+ responsive: true,
+ plugins: {
+ tooltip: {
+ callbacks: {
+ label: (tooltipItem) => {
+ let category;
+ if (tooltipItem.dataIndex === 0) {
+ category = zeroSubmissions;
+ } else if (tooltipItem.dataIndex === 1) {
+ category = partialSubmissions;
+ } else {
+ category = filledSubmissions;
+ }
+
+ if (category.length === 0) return "No Data";
+
+ return category.map(jr =>
+ `Seq: ${jr.recruitment_sequence}, Job: ${jr.job_id[1]}, Req: ${jr.no_of_recruitment}, Sub: ${jr.no_of_submissions}`
+ );
+ }
+ }
+ },
+ },
+ elements: {
+ arc: {
+ borderWidth: 0, // Remove borders to enhance 3D effect
+ backgroundColor: function (context) {
+ var index = context.dataIndex;
+ return colors[index];
+ },
+ // Add shadow effect to give depth to the slices
+ shadowOffsetX: 4,
+ shadowOffsetY: 4,
+ shadowBlur: 10,
+ shadowColor: "rgba(0, 0, 0, 0.3)",
+ }
+ },
+ animation: {
+ animateScale: true, // Enable scaling for the 3D-like effect
+ animateRotate: true, // Enable rotation to make it more dynamic
+ },
+ cutoutPercentage: 0, // Create a fully filled pie chart without a hole in the middle (to look more like a globe)
+ rotation: 0.5 * Math.PI, // Rotate the pie chart slightly
+ responsive: true,
+ maintainAspectRatio: false,
+ onClick: (event, elements) => {
+ if (elements.length) {
+ const index = elements[0].index;
+ let name = null;
+ let categories = index === 0 ? zeroSubmissions : index === 1 ? partialSubmissions : filledSubmissions;
+ const categoryIds = categories.map(category => category.id);
+ if (index === 0 && categoryIds.length > 0) {
+ name = 'Zero Submissions';
+ }
+ else if (index === 1 && categoryIds.length > 0) {
+ name = 'Partial Submissions';
+ }
+ else {
+ name = 'Filled Submissions';
+ }
+ this.viewPieChartJobRequests(categoryIds, name);
+ }
+ }
+ }
+ });
+ }
+
+
+ viewPieChartJobRequests(jobIds, ActionName) {
+ this.destroyCharts();
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: ActionName,
+ res_model: "hr.job.recruitment",
+ domain: [["id", "in", jobIds]],
+ view_mode: "kanban,list,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+
+
+ renderCandidatePipeLineBarChart() {
+ const ctx = document.getElementById("candidatePipelineBarChart");
+ if (!ctx) return;
+
+ if (this.pipelineCandidateBarChart) {
+ this.pipelineCandidateBarChart.destroy();
+ this.pipelineCandidateBarChart = null;
+ }
+
+ const applicantsData = this.state.filteredApplicantsData;
+ const recruitmentStages = this.state.recruitmentStages || [];
+ const jobRequests = this.state.filteredJobRequests || [];
+
+ const stageDetails = {};
+ const stageCandidateCount = {};
+
+ // ➡️ Filtered data based on application_status
+ const filteredApplicants = applicantsData.filter(
+ applicant => applicant.application_status !== 'refused' &&
+ applicant.application_status !== 'archived'
+ );
+
+ // ➡️ Separate refused applicants for a new stage
+ const refusedApplicants = applicantsData.filter(
+ applicant => applicant.application_status === 'refused'
+ );
+
+ // Process accepted applicants
+ filteredApplicants.forEach(applicant => {
+ const stages = applicant.recruitment_stage_id;
+
+ if (Array.isArray(stages) && stages[1]) {
+ const stage = stages[1];
+
+ if (!stageDetails[stage]) {
+ stageDetails[stage] = {};
+ stageCandidateCount[stage] = 0;
+ }
+
+ stageCandidateCount[stage] += 1;
+
+ const jobId = applicant.hr_job_recruitment?.[0];
+ if (jobId) {
+ const jobRequest = jobRequests.find(jr => jr.id === jobId);
+ if (jobRequest) {
+ const jobKey = `${jobRequest.recruitment_sequence}_${jobRequest.job_id?.[1] || 'Unknown Job'}`;
+
+ if (!stageDetails[stage][jobKey]) {
+ stageDetails[stage][jobKey] = {
+ seq: jobRequest.recruitment_sequence,
+ job: jobRequest.job_id?.[1] || 'Unknown Job',
+ req: jobRequest.no_of_recruitment || 0,
+ sub: jobRequest.no_of_submissions || 0,
+ count: 0
+ };
+ }
+
+ stageDetails[stage][jobKey].count += 1;
+ }
+ }
+ }
+ });
+
+ // ➡️ Add Refused applicants as a separate stage
+ if (refusedApplicants.length > 0) {
+ stageCandidateCount['Refused'] = refusedApplicants.length;
+ stageDetails['Refused'] = refusedApplicants.map(applicant => ({
+ applicant: applicant.candidate_id?.[1] || 'N/A',
+ seq: applicant.hr_job_recruitment?.[1] ||'N/A',
+ job: applicant.job_id?.[1] || 'Unknown Job',
+ stage: applicant.recruitment_stage_id?.[1] || 'N/A' // ➡️ New Field to Indicate Refused Stage
+ }));
+ }
+
+ // Sorting stages
+ const sortedStages = recruitmentStages.sort((a, b) => a.sequence - b.sequence);
+
+ const datasets = [
+ ...sortedStages.map(stage => ({
+ label: stage.name,
+ stage_id: stage.id,
+ data: [stageCandidateCount[stage.name] || 0],
+ backgroundColor: stage.stage_color,
+ borderColor: stage.stage_color,
+ borderWidth: 1
+ })),
+ // ➡️ Add Refused stage dataset
+ {
+ label: 'Refused',
+ stage_id: null,
+ data: [stageCandidateCount['Refused'] || 0],
+ backgroundColor: '#E74C3C', // Red color for refused
+ borderColor: '#C0392B',
+ borderWidth: 1
+ }
+ ];
+
+ this.pipelineCandidateBarChart = new window.Chart(ctx, {
+ type: 'bar',
+ data: {
+ labels: ['Candidates'],
+ datasets: datasets
+ },
+ options: {
+ plugins: {
+ legend: { display: true, position: 'top' },
+ tooltip: {
+ callbacks: {
+ title: function (tooltipItems) {
+ const stageName = datasets[tooltipItems[0].datasetIndex].label;
+ const totalCount = stageCandidateCount[stageName] || 0;
+ return `Total Candidates: ${totalCount}`;
+ },
+ label: function (tooltipItem) {
+ const stageName = datasets[tooltipItem.datasetIndex].label;
+ const details = Object.values(stageDetails[stageName] || {});
+
+ if (details.length === 0) return "No Data";
+
+ let tooltipText;
+
+ if (stageName === 'Refused') {
+ tooltipText = details.map(detail =>
+ `Seq: ${detail.applicant}, Job: ${detail.job}, Stage: ${detail.stage}`
+ );
+ } else {
+ tooltipText = details.map(detail =>
+ `Seq: ${detail.seq}, Job: ${detail.job}, Req: ${detail.req}, Sub: ${detail.sub}, Count: ${detail.count}`
+ );
+ }
+
+ return tooltipText;
+ }
+ }
+ }
+ },
+ onClick: (event, elements) => {
+ if (elements.length > 0) {
+ const datasetIndex = elements[0].datasetIndex;
+ const stageName = datasets[datasetIndex].label;
+
+ const selectedStageDetails = Object.values(stageDetails[stageName] || {});
+
+ if (selectedStageDetails.length) {
+ const jobSeqs = selectedStageDetails.map(detail => detail.seq);
+ const jobIds = jobRequests
+ .filter(job => jobSeqs.includes(job.recruitment_sequence))
+ .map(details => details.id);
+
+// const refusedJobIds = jobRequests.filter(job=> job.id === details.seq).map(details => details.id);
+
+ debugger;
+
+ this.destroyCharts();
+
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: 'Applications',
+ res_model: "hr.applicant",
+ domain: stageName === 'Refused'
+ ? [["hr_job_recruitment", "in", jobIds],["application_status", "=", "refused"],'|', ['active','=',false],['active','=',true]]
+ : [["hr_job_recruitment", "in", jobIds], ['recruitment_stage_id', '=', datasets[datasetIndex].stage_id]],
+ view_mode: "kanban,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+ }
+ },
+ scales: {
+ y: {
+ beginAtZero: true,
+ ticks: { stepSize: 1 }
+ }
+ },
+ responsive: true,
+ maintainAspectRatio: false
+ }
+ });
+ }
+
+
+ renderSubmissionStatusBarChart() {
+ const ctx = document.getElementById("applicationsPerJobBarChart");
+ if (!ctx) return;
+
+ if (this.jobApplicationsBarChart) {
+ this.jobApplicationsBarChart.destroy();
+ this.jobApplicationsBarChart = null;
+ }
+
+ const jobRequests = this.state.filteredJobRequests;
+
+ // Group by user_id
+ const groupedByUser = {};
+ jobRequests.forEach(jr => {
+ const userId = jr.user_id[0];
+ const userName = jr.user_id[1];
+
+ if (!groupedByUser[userId]) {
+ groupedByUser[userId] = {
+ userName,
+ jobRequests: []
+ };
+ }
+ groupedByUser[userId].jobRequests.push(jr);
+ });
+
+ // Labels - Users
+ const userLabels = Object.values(groupedByUser).map(user => user.userName);
+
+ // Data arrays for each category
+ const requirementsData = [];
+ const applicationsData = [];
+ const submissionsData = [];
+ const rejectionsData = [];
+ const hiredData = [];
+ const tooltipsData = {};
+
+ userLabels.forEach(userName => {
+ const user = Object.values(groupedByUser).find(user => user.userName === userName);
+ let totalRequirements = 0, totalApplications = 0, totalSubmissions = 0, totalRejections = 0, totalHired = 0;
+ let jobDetails = [];
+
+ user.jobRequests.forEach(jr => {
+ totalRequirements += jr.no_of_recruitment;
+ totalApplications += jr.application_count;
+ totalSubmissions += jr.no_of_submissions;
+ totalRejections += jr.no_of_refused_submissions;
+ totalHired += jr.no_of_hired_employee;
+
+ jobDetails.push(`Seq: ${jr.recruitment_sequence}, Job: ${jr.job_id[1]}, Requirements: ${jr.no_of_recruitment}, Applications: ${jr.application_count}, submissions: ${jr.no_of_submissions}, Rejections: ${jr.no_of_refused_submissions}, Hired: ${jr.no_of_hired_employee}`);
+ });
+
+ requirementsData.push(totalRequirements);
+ applicationsData.push(totalApplications);
+ submissionsData.push(totalSubmissions);
+ rejectionsData.push(totalRejections);
+ hiredData.push(totalHired);
+ tooltipsData[userName] = jobDetails;
+ });
+
+ // Create Chart
+ this.jobApplicationsBarChart = new window.Chart(ctx, {
+ type: "bar",
+ data: {
+ labels: userLabels,
+ datasets: [
+ {
+ label: "Requirements",
+ data: requirementsData,
+ backgroundColor: "#9B59B6", // Purple
+ borderColor: "#8E44AD",
+ borderWidth: 1
+ },
+ {
+ label: "Applications",
+ data: applicationsData,
+ backgroundColor: "#3498DB", // Blue
+ borderColor: "#2980B9",
+ borderWidth: 1
+ },
+ {
+ label: "Submissions",
+ data: submissionsData,
+ backgroundColor: "#F4C542", // Yellow
+ borderColor: "#D4AC0D",
+ borderWidth: 1
+ },
+ {
+ label: "Rejections",
+ data: rejectionsData,
+ backgroundColor: "#E74C3C", // Red
+ borderColor: "#C0392B",
+ borderWidth: 1
+ },
+ {
+ label: "Hired",
+ data: hiredData,
+ backgroundColor: "#2ECC71", // Green
+ borderColor: "#27AE60",
+ borderWidth: 1
+ }
+ ]
+ },
+ options: {
+ responsive: true,
+ maintainAspectRatio: false,
+ scales: {
+ x: {
+ stacked: false,
+ title: { display: true, text: "Recruiters (User ID)" }
+ },
+ y: {
+ stacked: false,
+ title: { display: true, text: "Count" },
+ beginAtZero: true
+ }
+ },
+ plugins: {
+ tooltip: {
+ callbacks: {
+ label: (tooltipItem) => {
+ const datasetLabel = tooltipItem.dataset.label;
+ const value = tooltipItem.raw;
+ const userName = tooltipItem.label;
+ const jobDetails = tooltipsData[userName] || [];
+ if (jobDetails.length === 0) return "No Data";
+ let tooltipText = jobDetails.map(jr =>
+ `${jr}`
+ );
+ tooltipText.unshift(`${datasetLabel}: ${value}`);
+ return tooltipText;
+ }
+ }
+ }
+ }
+ }
+ });
+ }
+
+
+
+
+ async loadInitialData() {
+ try {
+ this.state.recruitmentStages = await this.fetchRecruitmentStages();
+ await this.fetchAssignees();
+ const jobRequestsData = await this.jobRequestsData();
+ this.state.jobRequests = jobRequestsData || [];
+ this.state.jobPositions = Object.values(jobRequestsData.reduce((acc, job) => {
+ const jobId = job.job_id[0]; // Extracting the job ID
+ const jobName = job.job_id[1]; // Extracting the job name
+ if (!acc[jobId]) {
+ acc[jobId] = {
+ id: jobId,
+ name: jobName,
+ jobs: [],
+ };
+ }
+ acc[jobId].jobs.push(job);
+ return acc;
+ }, {}));
+ this.state.filteredJobRequests = this.state.jobRequests.filter(job => job.recruitment_type === this.state.selectedRecruitmentType);
+
+ const jobApplicants = await this.jobApplicantsData();
+ this.state.applicantsData = jobApplicants || [];
+ debugger;
+ this.state.filteredApplicantsData = jobApplicants || [];
+
+ let dashboardData = await this.fetchDashboardData() || [];
+ this.state.dashboardItems = dashboardData;
+ this.onDataFilterApply();
+ } catch (error) {
+ console.error("Error loading initial data:", error);
+ }
+ }
+
+ async initializeUI() {
+ await this._renderAssigneesSelect2();
+ this._bindSelect2Event();
+ this._getSelectedData();
+ }
+
+ async jobApplicantsData() {
+ try {
+ const applicantsData = await this.orm.searchRead(
+ "hr.applicant",
+ ["|", ["active", "=", true], ["active", "=", false]],
+ ["id","recruitment_stage_id","candidate_id","hr_job_recruitment","job_id","refused_state","employee_id","submitted_to_client","stage_color","active","application_status"]
+ );
+ return applicantsData;
+ } catch (error) {
+ console.error("Error fetching Applicants data:", error);
+ return [];
+ }
+ }
+
+ async jobRequestsData() {
+ try {
+ const recruitmentData = await this.orm.searchRead(
+ "hr.job.recruitment",
+ [],
+ ["id","job_id","department_id","no_of_recruitment","application_count","no_of_hired_employee","no_of_submissions","no_of_refused_submissions","recruitment_sequence","recruitment_type","requested_by","user_id","is_published","target_from","target_to","application_ids"]
+ );
+ return recruitmentData;
+ } catch (error) {
+ console.error("Error fetching job Requests data:", error);
+ return [];
+ }
+ }
+
+ async fetchRecruitmentStages() {
+ try {
+ const recruitmentData = await this.orm.searchRead(
+ "hr.recruitment.stage",
+ [],
+ ["id","sequence","name","stage_color"]
+ );
+ return recruitmentData;
+ } catch (error) {
+ console.error("Error fetching job Requests data:", error);
+ return [];
+ }
+ }
+
+ async computedTotalPublishedRequirements() {
+ return this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_recruitment, 0); // Sum up no_of_recruitment
+ }
+
+ async computedTotalApplicants() {
+ return this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.application_count, 0); // Sum up no_of_recruitment
+ }
+
+ async computeActiveJobRequests() {
+ return this.state.filteredJobRequests
+ .reduce((sum, job) => sum + (job.is_published ? 1 : 0), 0); // Sum up no_of_recruitment
+ }
+
+ async computeTotalFilledRequests() {
+ return this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_hired_employee, 0);
+ }
+
+ async computeTotalSubmissions() {
+ return this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_submissions, 0);
+ }
+
+ async computeTotalRefusedSubmissions() {
+ return this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_refused_submissions, 0);
+ }
+
+ async computeOfferAcceptanceRate() {
+ const totalSubmissions = this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_submissions, 0);
+
+ const totalHired = this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_hired_employee, 0);
+
+ // Avoid division by zero
+ if (totalSubmissions === 0) {
+ return 0; // If there are no submissions, return 0% acceptance rate
+ }
+
+ return (totalHired / totalSubmissions) * 100;
+ }
+
+ async computeDropOutRate() {
+ const totalSubmissions = this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_submissions, 0);
+
+ const totalRefusals = this.state.filteredJobRequests
+ .reduce((sum, job) => sum + job.no_of_refused_submissions, 0);
+
+ // Avoid division by zero
+ if (totalSubmissions === 0) {
+ return 0; // If there are no submissions, return 0% acceptance rate
+ }
+
+ return (totalRefusals / totalSubmissions) * 100;
+ }
+
+ async fetchDashboardData() {
+ try {
+ return [
+ { icon: "fa fa fa-clock-o", name: "Total Positions", count: await this.computedTotalPublishedRequirements() || 0, action: () => this.viewOpenPositions() }, // Clipboard list for positions
+ { icon: "fa fa-users", name: "Total Applications", count: await this.computedTotalApplicants() || 0, action: () => this.viewApplications() }, // File icon for applications
+ { icon: "fa fa-briefcase", name: "Active Job Requests", count: await this.computeActiveJobRequests() || 0, action: () => this.viewActiveJobRequests() }, // Briefcase for active jobs
+ { icon: "fa fa-check-circle", name: "Positions Filled", count: await this.computeTotalFilledRequests() || 0, action: () => this.viewHiredApplications() }, // Users cog for filled positions
+ { icon: "fa fa-paper-plane", name: "Submitted Applications", count: await this.computeTotalSubmissions() || 0, action: () => this.viewSubmittedApplications() }, // User check for submitted applications
+ { icon: "fa fa-user-times", name: "Refused Submissions", count: await this.computeTotalRefusedSubmissions() || 0, action: () => this.viewRefusedSubmittedApplications() }, // User times for refused submissions
+ { icon: "fa fa-check-circle", name: "Offer Acceptance Rate", count: `${(await this.computeOfferAcceptanceRate()).toFixed(2)}%` || "0%", action: () => this.viewHiredApplications() }, // Check circle for offer acceptance
+ { icon: "fa fa-times-circle", name: "Refusal Rate", count: `${(await this.computeDropOutRate()).toFixed(2)}%` || "0%", action: () => this.viewRefusedSubmittedApplications() }, // Times circle for refusal rate
+ ];
+ } catch (error) {
+ console.error("Error fetching dashboard data:", error);
+ return []; // Return an empty array in case of failure
+ }
+ }
+
+ viewOpenPositions() {
+ const jobRequestIds = this.state.filteredJobRequests.map(job => job.id);
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: "Open Positions",
+ res_model: "hr.job.recruitment",
+ domain: [['id','in',jobRequestIds]],
+ view_mode: "kanban,list,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+
+ viewHiredApplications() {
+ const jobRequestIds = this.state.filteredJobRequests.map(job => job.id);
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: "Hired Applications",
+ res_model: "hr.applicant",
+ domain: ["|", ["active", "=", true], ["active", "=", false], ["hr_job_recruitment.id", "in", jobRequestIds], ["recruitment_stage_id.hired_stage", "=", true]],
+ view_mode: "kanban,list,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+
+ viewApplications() {
+ const jobRequestIds = this.state.filteredJobRequests.map(job => job.id);
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: "Applications",
+ res_model: "hr.applicant",
+ domain: ["|", ["active", "=", true], ["active", "=", false], ["hr_job_recruitment.id", "in", jobRequestIds]],
+ view_mode: "kanban,list,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+
+ viewSubmittedApplications() {
+ const jobRequestIds = this.state.filteredJobRequests.map(job => job.id);
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: "Submitted Applications",
+ res_model: "hr.applicant",
+ domain: ["|", ["active", "=", true], ["active", "=", false], ["hr_job_recruitment.id", "in", jobRequestIds], ["submitted_to_client", "=", true]],
+ view_mode: "kanban,list,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+
+ viewRefusedSubmittedApplications() {
+ const jobRequestIds = this.state.filteredJobRequests.map(job => job.id);
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: "Refused Submissions",
+ res_model: "hr.applicant",
+ domain: ["|", ["active", "=", true], ["active", "=", false], ["hr_job_recruitment.id", "in", jobRequestIds], ["submitted_to_client", "=", true] ,["application_status", "=", "refused"]],
+ view_mode: "kanban,list,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+
+ viewActiveJobRequests() {
+ const jobRequestIds = this.state.filteredJobRequests.map(job => job.id);
+ this.action.doAction({
+ type: "ir.actions.act_window",
+ name: "Active Jobs",
+ res_model: "hr.job.recruitment",
+ domain: [["is_published", "=", true],["id", "in", jobRequestIds]],
+ view_mode: "kanban,list,form",
+ views: [[false, "list"], [false, "form"]],
+ target: "current",
+ });
+ }
+
+ openJobRequisitionsPage() {
+ this.action.doAction("hr_recruitment_extended.action_hr_job_recruitment");
+ }
+
+ async _renderAssigneesSelect2() {
+ // Load Select2 manually if not already loaded
+ if (!$.fn.select2) {
+ console.warn("Select2 not found! Loading manually...");
+ $.getScript("/website_hr_recruitment_extended/static/src/lib/select2/select2.main.js", function() {
+ $("#assignees_select").select2();
+ $('#positions_select').select2();
+ });
+ } else {
+ $("#assignees_select").select2();
+ $("#positions_select").select2();
+
+ }
+ }
+
+ async fetchAssignees() {
+ try {
+ const assignees = await rpc("/recruitment/get_assignees");
+ this.state.assignees = assignees;
+ } catch (error) {
+ console.error("Error fetching assignees:", error);
+ }
+ }
+
+ async fetchApplicantData() {
+ try {
+ const assignees = await rpc("/recruitment/get_assignees");
+ this.state.assignees = assignees;
+ } catch (error) {
+ console.error("Error fetching assignees:", error);
+ }
+ }
+
+ onDateRangeChange(ev) {
+ this.state.selectedDateRange = ev.target.value;
+ this.fetchDashboardData(); // Refresh data
+ }
+
+ _bindSelect2Event() {
+ $("#assignees_select").on("change", (event) => {
+ const selectedValues = $("#assignees_select").val(); // Get selected values
+ this.state.selectedAssignees = selectedValues ? selectedValues.map(id => parseInt(id)) : [];
+ });
+
+ $("#positions_select").on("change", (event) => {
+ const selectedValues = $("#positions_select").val(); // Get selected values
+ this.state.selectedPositions = selectedValues ? selectedValues.map(id => parseInt(id)) : [];
+ });
+ }
+
+ _getSelectedData() {
+ $("#recruitment_type").on("change", (event) => {
+ this.state.selectedRecruitmentType = $("#recruitment_type").val();
+ })
+ }
+
+
+ async onDataFilterApply() {
+ if (this.state.date_from || this.state.date_to || this.state.selectedAssignees || this.state.selectedPositions) {
+ let filteredJobRequests = [...this.state.jobRequests];
+ const dateFrom = this.state.date_from ? new Date(this.state.date_from) : null;
+ const dateTo = this.state.date_to ? new Date(this.state.date_to) : null;
+ const assignees = this.state.selectedAssignees ? this.state.selectedAssignees : null;
+ const recruitmentType = this.state.selectedRecruitmentType ? this.state.selectedRecruitmentType : null;
+ const positions = this.state.selectedPositions ? this.state.selectedPositions: null;
+ const is_published = this.state.isPublished ? this.state.isPublished: false;
+ // Filter by date_from
+
+ if (is_published) {
+ filteredJobRequests = filteredJobRequests.filter(job => {
+ return job.is_published === true
+ });
+ }
+
+ if (dateFrom) {
+ filteredJobRequests = filteredJobRequests.filter(job => {
+ const targetFrom = job.target_from ? new Date(job.target_from) : null;
+ return targetFrom && targetFrom >= dateFrom; // Return boolean value for filtering
+ });
+ }
+
+ // Filter by date_to
+ if (dateTo) {
+ filteredJobRequests = filteredJobRequests.filter(job => {
+ const targetTo = job.target_to ? new Date(job.target_to) : null;
+ return targetTo && targetTo <= dateTo; // Return boolean value for filtering
+ });
+ }
+
+ // Filter by assignees
+ if (assignees && assignees.length > 0) {
+ filteredJobRequests = filteredJobRequests.filter(job => {
+ const assignedUser = job.user_id; // Assuming `job.user_id` is the user assigned to the job
+ return assignedUser && assignees.includes(assignedUser[0]); // Check if user is in the assignees list
+ });
+ }
+
+ if (recruitmentType) {
+ filteredJobRequests = filteredJobRequests.filter(job => {
+ return job.recruitment_type === recruitmentType
+ })
+ }
+
+ if (positions && positions.length > 0) {
+ filteredJobRequests = filteredJobRequests.filter(job => {
+ const jobPosition = job.job_id; // Assuming `job.user_id` is the user assigned to the job
+ return jobPosition && positions.includes(jobPosition[0]); // Check if user is in the assignees list
+ });
+ }
+ const filteredApplicantsData = this.state.applicantsData.filter(applicant => {
+ // Check if hr_job_recruitment[0] (the first element of the hr_job_recruitment array) exists in any job's ids
+ return filteredJobRequests.some(job => filteredJobRequests.map(job => job.id) && filteredJobRequests.map(job => job.id).includes(applicant.hr_job_recruitment[0]));
+ });
+
+
+ // Save filters to localStorage
+ localStorage.setItem("recruitmentDashboardFilters", JSON.stringify({
+ date_from: this.state.date_from || null,
+ date_to: this.state.date_to || null,
+ selectedAssignees: this.state.selectedAssignees || [],
+ selectedRecruitmentType: this.state.selectedRecruitmentType || null,
+ selectedPositions: this.state.selectedPositions || [],
+ isPublished: this.state.isPublished || false,
+ }));
+ // Update the state with the filtered job requests
+ Object.assign(this.state, {
+ filteredApplicantsData: filteredApplicantsData,
+ filteredJobRequests: filteredJobRequests,
+ dashboardItems: await this.fetchDashboardData() || [],
+
+ });
+ this.renderAllDashboards();
+ // ✅ Use `setState` to update state properly
+
+ this.render();
+ }
+ }
+
+
+ reorderDashboardItems(evt) {
+ const newOrder = Array.from(evt.from.children).map(el => el.getAttribute("data-item-name"));
+
+ // Update the state
+ this.state.dashboardItems.sort((a, b) => newOrder.indexOf(a.name) - newOrder.indexOf(b.name));
+ }
+
+ onTogglePublished() {
+ this.state.isPublished = !this.state.isPublished;
+ this.render()
+ }
+
+
+}
+
+registry.category("actions").add("createRecruitmentDashboard", CreateRecruitmentDashboard);
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/lib/Chart/Chart.js b/addons_extensions/ftp_custom_dashboards/static/src/lib/Chart/Chart.js
new file mode 100644
index 000000000..4659553ff
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/lib/Chart/Chart.js
@@ -0,0 +1,14921 @@
+/*!
+ * Chart.js v4.4.1
+ * https://www.chartjs.org
+ * (c) 2024 Chart.js Contributors
+ * Released under the MIT License
+ */
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Chart = factory());
+})(this, (function () { 'use strict';
+
+ var plugins = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ get Colors () { return plugin_colors; },
+ get Decimation () { return plugin_decimation; },
+ get Filler () { return index; },
+ get Legend () { return plugin_legend; },
+ get SubTitle () { return plugin_subtitle; },
+ get Title () { return plugin_title; },
+ get Tooltip () { return plugin_tooltip; }
+ });
+
+ /**
+ * @namespace Chart.helpers
+ */ /**
+ * An empty function that can be used, for example, for optional callback.
+ */ function noop() {
+ /* noop */ }
+ /**
+ * Returns a unique id, sequentially generated from a global variable.
+ */ const uid = (()=>{
+ let id = 0;
+ return ()=>id++;
+ })();
+ /**
+ * Returns true if `value` is neither null nor undefined, else returns false.
+ * @param value - The value to test.
+ * @since 2.7.0
+ */ function isNullOrUndef(value) {
+ return value === null || typeof value === 'undefined';
+ }
+ /**
+ * Returns true if `value` is an array (including typed arrays), else returns false.
+ * @param value - The value to test.
+ * @function
+ */ function isArray(value) {
+ if (Array.isArray && Array.isArray(value)) {
+ return true;
+ }
+ const type = Object.prototype.toString.call(value);
+ if (type.slice(0, 7) === '[object' && type.slice(-6) === 'Array]') {
+ return true;
+ }
+ return false;
+ }
+ /**
+ * Returns true if `value` is an object (excluding null), else returns false.
+ * @param value - The value to test.
+ * @since 2.7.0
+ */ function isObject(value) {
+ return value !== null && Object.prototype.toString.call(value) === '[object Object]';
+ }
+ /**
+ * Returns true if `value` is a finite number, else returns false
+ * @param value - The value to test.
+ */ function isNumberFinite(value) {
+ return (typeof value === 'number' || value instanceof Number) && isFinite(+value);
+ }
+ /**
+ * Returns `value` if finite, else returns `defaultValue`.
+ * @param value - The value to return if defined.
+ * @param defaultValue - The value to return if `value` is not finite.
+ */ function finiteOrDefault(value, defaultValue) {
+ return isNumberFinite(value) ? value : defaultValue;
+ }
+ /**
+ * Returns `value` if defined, else returns `defaultValue`.
+ * @param value - The value to return if defined.
+ * @param defaultValue - The value to return if `value` is undefined.
+ */ function valueOrDefault(value, defaultValue) {
+ return typeof value === 'undefined' ? defaultValue : value;
+ }
+ const toPercentage = (value, dimension)=>typeof value === 'string' && value.endsWith('%') ? parseFloat(value) / 100 : +value / dimension;
+ const toDimension = (value, dimension)=>typeof value === 'string' && value.endsWith('%') ? parseFloat(value) / 100 * dimension : +value;
+ /**
+ * Calls `fn` with the given `args` in the scope defined by `thisArg` and returns the
+ * value returned by `fn`. If `fn` is not a function, this method returns undefined.
+ * @param fn - The function to call.
+ * @param args - The arguments with which `fn` should be called.
+ * @param [thisArg] - The value of `this` provided for the call to `fn`.
+ */ function callback(fn, args, thisArg) {
+ if (fn && typeof fn.call === 'function') {
+ return fn.apply(thisArg, args);
+ }
+ }
+ function each(loopable, fn, thisArg, reverse) {
+ let i, len, keys;
+ if (isArray(loopable)) {
+ len = loopable.length;
+ if (reverse) {
+ for(i = len - 1; i >= 0; i--){
+ fn.call(thisArg, loopable[i], i);
+ }
+ } else {
+ for(i = 0; i < len; i++){
+ fn.call(thisArg, loopable[i], i);
+ }
+ }
+ } else if (isObject(loopable)) {
+ keys = Object.keys(loopable);
+ len = keys.length;
+ for(i = 0; i < len; i++){
+ fn.call(thisArg, loopable[keys[i]], keys[i]);
+ }
+ }
+ }
+ /**
+ * Returns true if the `a0` and `a1` arrays have the same content, else returns false.
+ * @param a0 - The array to compare
+ * @param a1 - The array to compare
+ * @private
+ */ function _elementsEqual(a0, a1) {
+ let i, ilen, v0, v1;
+ if (!a0 || !a1 || a0.length !== a1.length) {
+ return false;
+ }
+ for(i = 0, ilen = a0.length; i < ilen; ++i){
+ v0 = a0[i];
+ v1 = a1[i];
+ if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {
+ return false;
+ }
+ }
+ return true;
+ }
+ /**
+ * Returns a deep copy of `source` without keeping references on objects and arrays.
+ * @param source - The value to clone.
+ */ function clone$1(source) {
+ if (isArray(source)) {
+ return source.map(clone$1);
+ }
+ if (isObject(source)) {
+ const target = Object.create(null);
+ const keys = Object.keys(source);
+ const klen = keys.length;
+ let k = 0;
+ for(; k < klen; ++k){
+ target[keys[k]] = clone$1(source[keys[k]]);
+ }
+ return target;
+ }
+ return source;
+ }
+ function isValidKey(key) {
+ return [
+ '__proto__',
+ 'prototype',
+ 'constructor'
+ ].indexOf(key) === -1;
+ }
+ /**
+ * The default merger when Chart.helpers.merge is called without merger option.
+ * Note(SB): also used by mergeConfig and mergeScaleConfig as fallback.
+ * @private
+ */ function _merger(key, target, source, options) {
+ if (!isValidKey(key)) {
+ return;
+ }
+ const tval = target[key];
+ const sval = source[key];
+ if (isObject(tval) && isObject(sval)) {
+ // eslint-disable-next-line @typescript-eslint/no-use-before-define
+ merge(tval, sval, options);
+ } else {
+ target[key] = clone$1(sval);
+ }
+ }
+ function merge(target, source, options) {
+ const sources = isArray(source) ? source : [
+ source
+ ];
+ const ilen = sources.length;
+ if (!isObject(target)) {
+ return target;
+ }
+ options = options || {};
+ const merger = options.merger || _merger;
+ let current;
+ for(let i = 0; i < ilen; ++i){
+ current = sources[i];
+ if (!isObject(current)) {
+ continue;
+ }
+ const keys = Object.keys(current);
+ for(let k = 0, klen = keys.length; k < klen; ++k){
+ merger(keys[k], target, current, options);
+ }
+ }
+ return target;
+ }
+ function mergeIf(target, source) {
+ // eslint-disable-next-line @typescript-eslint/no-use-before-define
+ return merge(target, source, {
+ merger: _mergerIf
+ });
+ }
+ /**
+ * Merges source[key] in target[key] only if target[key] is undefined.
+ * @private
+ */ function _mergerIf(key, target, source) {
+ if (!isValidKey(key)) {
+ return;
+ }
+ const tval = target[key];
+ const sval = source[key];
+ if (isObject(tval) && isObject(sval)) {
+ mergeIf(tval, sval);
+ } else if (!Object.prototype.hasOwnProperty.call(target, key)) {
+ target[key] = clone$1(sval);
+ }
+ }
+ /**
+ * @private
+ */ function _deprecated(scope, value, previous, current) {
+ if (value !== undefined) {
+ console.warn(scope + ': "' + previous + '" is deprecated. Please use "' + current + '" instead');
+ }
+ }
+ // resolveObjectKey resolver cache
+ const keyResolvers = {
+ // Chart.helpers.core resolveObjectKey should resolve empty key to root object
+ '': (v)=>v,
+ // default resolvers
+ x: (o)=>o.x,
+ y: (o)=>o.y
+ };
+ /**
+ * @private
+ */ function _splitKey(key) {
+ const parts = key.split('.');
+ const keys = [];
+ let tmp = '';
+ for (const part of parts){
+ tmp += part;
+ if (tmp.endsWith('\\')) {
+ tmp = tmp.slice(0, -1) + '.';
+ } else {
+ keys.push(tmp);
+ tmp = '';
+ }
+ }
+ return keys;
+ }
+ function _getKeyResolver(key) {
+ const keys = _splitKey(key);
+ return (obj)=>{
+ for (const k of keys){
+ if (k === '') {
+ break;
+ }
+ obj = obj && obj[k];
+ }
+ return obj;
+ };
+ }
+ function resolveObjectKey(obj, key) {
+ const resolver = keyResolvers[key] || (keyResolvers[key] = _getKeyResolver(key));
+ return resolver(obj);
+ }
+ /**
+ * @private
+ */ function _capitalize(str) {
+ return str.charAt(0).toUpperCase() + str.slice(1);
+ }
+ const defined = (value)=>typeof value !== 'undefined';
+ const isFunction = (value)=>typeof value === 'function';
+ // Adapted from https://stackoverflow.com/questions/31128855/comparing-ecma6-sets-for-equality#31129384
+ const setsEqual = (a, b)=>{
+ if (a.size !== b.size) {
+ return false;
+ }
+ for (const item of a){
+ if (!b.has(item)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ /**
+ * @param e - The event
+ * @private
+ */ function _isClickEvent(e) {
+ return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu';
+ }
+
+ /**
+ * @alias Chart.helpers.math
+ * @namespace
+ */ const PI = Math.PI;
+ const TAU = 2 * PI;
+ const PITAU = TAU + PI;
+ const INFINITY = Number.POSITIVE_INFINITY;
+ const RAD_PER_DEG = PI / 180;
+ const HALF_PI = PI / 2;
+ const QUARTER_PI = PI / 4;
+ const TWO_THIRDS_PI = PI * 2 / 3;
+ const log10 = Math.log10;
+ const sign = Math.sign;
+ function almostEquals(x, y, epsilon) {
+ return Math.abs(x - y) < epsilon;
+ }
+ /**
+ * Implementation of the nice number algorithm used in determining where axis labels will go
+ */ function niceNum(range) {
+ const roundedRange = Math.round(range);
+ range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range;
+ const niceRange = Math.pow(10, Math.floor(log10(range)));
+ const fraction = range / niceRange;
+ const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;
+ return niceFraction * niceRange;
+ }
+ /**
+ * Returns an array of factors sorted from 1 to sqrt(value)
+ * @private
+ */ function _factorize(value) {
+ const result = [];
+ const sqrt = Math.sqrt(value);
+ let i;
+ for(i = 1; i < sqrt; i++){
+ if (value % i === 0) {
+ result.push(i);
+ result.push(value / i);
+ }
+ }
+ if (sqrt === (sqrt | 0)) {
+ result.push(sqrt);
+ }
+ result.sort((a, b)=>a - b).pop();
+ return result;
+ }
+ function isNumber(n) {
+ return !isNaN(parseFloat(n)) && isFinite(n);
+ }
+ function almostWhole(x, epsilon) {
+ const rounded = Math.round(x);
+ return rounded - epsilon <= x && rounded + epsilon >= x;
+ }
+ /**
+ * @private
+ */ function _setMinAndMaxByKey(array, target, property) {
+ let i, ilen, value;
+ for(i = 0, ilen = array.length; i < ilen; i++){
+ value = array[i][property];
+ if (!isNaN(value)) {
+ target.min = Math.min(target.min, value);
+ target.max = Math.max(target.max, value);
+ }
+ }
+ }
+ function toRadians(degrees) {
+ return degrees * (PI / 180);
+ }
+ function toDegrees(radians) {
+ return radians * (180 / PI);
+ }
+ /**
+ * Returns the number of decimal places
+ * i.e. the number of digits after the decimal point, of the value of this Number.
+ * @param x - A number.
+ * @returns The number of decimal places.
+ * @private
+ */ function _decimalPlaces(x) {
+ if (!isNumberFinite(x)) {
+ return;
+ }
+ let e = 1;
+ let p = 0;
+ while(Math.round(x * e) / e !== x){
+ e *= 10;
+ p++;
+ }
+ return p;
+ }
+ // Gets the angle from vertical upright to the point about a centre.
+ function getAngleFromPoint(centrePoint, anglePoint) {
+ const distanceFromXCenter = anglePoint.x - centrePoint.x;
+ const distanceFromYCenter = anglePoint.y - centrePoint.y;
+ const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
+ let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
+ if (angle < -0.5 * PI) {
+ angle += TAU; // make sure the returned angle is in the range of (-PI/2, 3PI/2]
+ }
+ return {
+ angle,
+ distance: radialDistanceFromCenter
+ };
+ }
+ function distanceBetweenPoints(pt1, pt2) {
+ return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
+ }
+ /**
+ * Shortest distance between angles, in either direction.
+ * @private
+ */ function _angleDiff(a, b) {
+ return (a - b + PITAU) % TAU - PI;
+ }
+ /**
+ * Normalize angle to be between 0 and 2*PI
+ * @private
+ */ function _normalizeAngle(a) {
+ return (a % TAU + TAU) % TAU;
+ }
+ /**
+ * @private
+ */ function _angleBetween(angle, start, end, sameAngleIsFullCircle) {
+ const a = _normalizeAngle(angle);
+ const s = _normalizeAngle(start);
+ const e = _normalizeAngle(end);
+ const angleToStart = _normalizeAngle(s - a);
+ const angleToEnd = _normalizeAngle(e - a);
+ const startToAngle = _normalizeAngle(a - s);
+ const endToAngle = _normalizeAngle(a - e);
+ return a === s || a === e || sameAngleIsFullCircle && s === e || angleToStart > angleToEnd && startToAngle < endToAngle;
+ }
+ /**
+ * Limit `value` between `min` and `max`
+ * @param value
+ * @param min
+ * @param max
+ * @private
+ */ function _limitValue(value, min, max) {
+ return Math.max(min, Math.min(max, value));
+ }
+ /**
+ * @param {number} value
+ * @private
+ */ function _int16Range(value) {
+ return _limitValue(value, -32768, 32767);
+ }
+ /**
+ * @param value
+ * @param start
+ * @param end
+ * @param [epsilon]
+ * @private
+ */ function _isBetween(value, start, end, epsilon = 1e-6) {
+ return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;
+ }
+
+ function _lookup(table, value, cmp) {
+ cmp = cmp || ((index)=>table[index] < value);
+ let hi = table.length - 1;
+ let lo = 0;
+ let mid;
+ while(hi - lo > 1){
+ mid = lo + hi >> 1;
+ if (cmp(mid)) {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+ return {
+ lo,
+ hi
+ };
+ }
+ /**
+ * Binary search
+ * @param table - the table search. must be sorted!
+ * @param key - property name for the value in each entry
+ * @param value - value to find
+ * @param last - lookup last index
+ * @private
+ */ const _lookupByKey = (table, key, value, last)=>_lookup(table, value, last ? (index)=>{
+ const ti = table[index][key];
+ return ti < value || ti === value && table[index + 1][key] === value;
+ } : (index)=>table[index][key] < value);
+ /**
+ * Reverse binary search
+ * @param table - the table search. must be sorted!
+ * @param key - property name for the value in each entry
+ * @param value - value to find
+ * @private
+ */ const _rlookupByKey = (table, key, value)=>_lookup(table, value, (index)=>table[index][key] >= value);
+ /**
+ * Return subset of `values` between `min` and `max` inclusive.
+ * Values are assumed to be in sorted order.
+ * @param values - sorted array of values
+ * @param min - min value
+ * @param max - max value
+ */ function _filterBetween(values, min, max) {
+ let start = 0;
+ let end = values.length;
+ while(start < end && values[start] < min){
+ start++;
+ }
+ while(end > start && values[end - 1] > max){
+ end--;
+ }
+ return start > 0 || end < values.length ? values.slice(start, end) : values;
+ }
+ const arrayEvents = [
+ 'push',
+ 'pop',
+ 'shift',
+ 'splice',
+ 'unshift'
+ ];
+ function listenArrayEvents(array, listener) {
+ if (array._chartjs) {
+ array._chartjs.listeners.push(listener);
+ return;
+ }
+ Object.defineProperty(array, '_chartjs', {
+ configurable: true,
+ enumerable: false,
+ value: {
+ listeners: [
+ listener
+ ]
+ }
+ });
+ arrayEvents.forEach((key)=>{
+ const method = '_onData' + _capitalize(key);
+ const base = array[key];
+ Object.defineProperty(array, key, {
+ configurable: true,
+ enumerable: false,
+ value (...args) {
+ const res = base.apply(this, args);
+ array._chartjs.listeners.forEach((object)=>{
+ if (typeof object[method] === 'function') {
+ object[method](...args);
+ }
+ });
+ return res;
+ }
+ });
+ });
+ }
+ function unlistenArrayEvents(array, listener) {
+ const stub = array._chartjs;
+ if (!stub) {
+ return;
+ }
+ const listeners = stub.listeners;
+ const index = listeners.indexOf(listener);
+ if (index !== -1) {
+ listeners.splice(index, 1);
+ }
+ if (listeners.length > 0) {
+ return;
+ }
+ arrayEvents.forEach((key)=>{
+ delete array[key];
+ });
+ delete array._chartjs;
+ }
+ /**
+ * @param items
+ */ function _arrayUnique(items) {
+ const set = new Set(items);
+ if (set.size === items.length) {
+ return items;
+ }
+ return Array.from(set);
+ }
+
+ function fontString(pixelSize, fontStyle, fontFamily) {
+ return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;
+ }
+ /**
+ * Request animation polyfill
+ */ const requestAnimFrame = function() {
+ if (typeof window === 'undefined') {
+ return function(callback) {
+ return callback();
+ };
+ }
+ return window.requestAnimationFrame;
+ }();
+ /**
+ * Throttles calling `fn` once per animation frame
+ * Latest arguments are used on the actual call
+ */ function throttled(fn, thisArg) {
+ let argsToUse = [];
+ let ticking = false;
+ return function(...args) {
+ // Save the args for use later
+ argsToUse = args;
+ if (!ticking) {
+ ticking = true;
+ requestAnimFrame.call(window, ()=>{
+ ticking = false;
+ fn.apply(thisArg, argsToUse);
+ });
+ }
+ };
+ }
+ /**
+ * Debounces calling `fn` for `delay` ms
+ */ function debounce(fn, delay) {
+ let timeout;
+ return function(...args) {
+ if (delay) {
+ clearTimeout(timeout);
+ timeout = setTimeout(fn, delay, args);
+ } else {
+ fn.apply(this, args);
+ }
+ return delay;
+ };
+ }
+ /**
+ * Converts 'start' to 'left', 'end' to 'right' and others to 'center'
+ * @private
+ */ const _toLeftRightCenter = (align)=>align === 'start' ? 'left' : align === 'end' ? 'right' : 'center';
+ /**
+ * Returns `start`, `end` or `(start + end) / 2` depending on `align`. Defaults to `center`
+ * @private
+ */ const _alignStartEnd = (align, start, end)=>align === 'start' ? start : align === 'end' ? end : (start + end) / 2;
+ /**
+ * Returns `left`, `right` or `(left + right) / 2` depending on `align`. Defaults to `left`
+ * @private
+ */ const _textX = (align, left, right, rtl)=>{
+ const check = rtl ? 'left' : 'right';
+ return align === check ? right : align === 'center' ? (left + right) / 2 : left;
+ };
+ /**
+ * Return start and count of visible points.
+ * @private
+ */ function _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) {
+ const pointCount = points.length;
+ let start = 0;
+ let count = pointCount;
+ if (meta._sorted) {
+ const { iScale , _parsed } = meta;
+ const axis = iScale.axis;
+ const { min , max , minDefined , maxDefined } = iScale.getUserBounds();
+ if (minDefined) {
+ start = _limitValue(Math.min(// @ts-expect-error Need to type _parsed
+ _lookupByKey(_parsed, axis, min).lo, // @ts-expect-error Need to fix types on _lookupByKey
+ animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo), 0, pointCount - 1);
+ }
+ if (maxDefined) {
+ count = _limitValue(Math.max(// @ts-expect-error Need to type _parsed
+ _lookupByKey(_parsed, iScale.axis, max, true).hi + 1, // @ts-expect-error Need to fix types on _lookupByKey
+ animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max), true).hi + 1), start, pointCount) - start;
+ } else {
+ count = pointCount - start;
+ }
+ }
+ return {
+ start,
+ count
+ };
+ }
+ /**
+ * Checks if the scale ranges have changed.
+ * @param {object} meta - dataset meta.
+ * @returns {boolean}
+ * @private
+ */ function _scaleRangesChanged(meta) {
+ const { xScale , yScale , _scaleRanges } = meta;
+ const newRanges = {
+ xmin: xScale.min,
+ xmax: xScale.max,
+ ymin: yScale.min,
+ ymax: yScale.max
+ };
+ if (!_scaleRanges) {
+ meta._scaleRanges = newRanges;
+ return true;
+ }
+ const changed = _scaleRanges.xmin !== xScale.min || _scaleRanges.xmax !== xScale.max || _scaleRanges.ymin !== yScale.min || _scaleRanges.ymax !== yScale.max;
+ Object.assign(_scaleRanges, newRanges);
+ return changed;
+ }
+
+ class Animator {
+ constructor(){
+ this._request = null;
+ this._charts = new Map();
+ this._running = false;
+ this._lastDate = undefined;
+ }
+ _notify(chart, anims, date, type) {
+ const callbacks = anims.listeners[type];
+ const numSteps = anims.duration;
+ callbacks.forEach((fn)=>fn({
+ chart,
+ initial: anims.initial,
+ numSteps,
+ currentStep: Math.min(date - anims.start, numSteps)
+ }));
+ }
+ _refresh() {
+ if (this._request) {
+ return;
+ }
+ this._running = true;
+ this._request = requestAnimFrame.call(window, ()=>{
+ this._update();
+ this._request = null;
+ if (this._running) {
+ this._refresh();
+ }
+ });
+ }
+ _update(date = Date.now()) {
+ let remaining = 0;
+ this._charts.forEach((anims, chart)=>{
+ if (!anims.running || !anims.items.length) {
+ return;
+ }
+ const items = anims.items;
+ let i = items.length - 1;
+ let draw = false;
+ let item;
+ for(; i >= 0; --i){
+ item = items[i];
+ if (item._active) {
+ if (item._total > anims.duration) {
+ anims.duration = item._total;
+ }
+ item.tick(date);
+ draw = true;
+ } else {
+ items[i] = items[items.length - 1];
+ items.pop();
+ }
+ }
+ if (draw) {
+ chart.draw();
+ this._notify(chart, anims, date, 'progress');
+ }
+ if (!items.length) {
+ anims.running = false;
+ this._notify(chart, anims, date, 'complete');
+ anims.initial = false;
+ }
+ remaining += items.length;
+ });
+ this._lastDate = date;
+ if (remaining === 0) {
+ this._running = false;
+ }
+ }
+ _getAnims(chart) {
+ const charts = this._charts;
+ let anims = charts.get(chart);
+ if (!anims) {
+ anims = {
+ running: false,
+ initial: true,
+ items: [],
+ listeners: {
+ complete: [],
+ progress: []
+ }
+ };
+ charts.set(chart, anims);
+ }
+ return anims;
+ }
+ listen(chart, event, cb) {
+ this._getAnims(chart).listeners[event].push(cb);
+ }
+ add(chart, items) {
+ if (!items || !items.length) {
+ return;
+ }
+ this._getAnims(chart).items.push(...items);
+ }
+ has(chart) {
+ return this._getAnims(chart).items.length > 0;
+ }
+ start(chart) {
+ const anims = this._charts.get(chart);
+ if (!anims) {
+ return;
+ }
+ anims.running = true;
+ anims.start = Date.now();
+ anims.duration = anims.items.reduce((acc, cur)=>Math.max(acc, cur._duration), 0);
+ this._refresh();
+ }
+ running(chart) {
+ if (!this._running) {
+ return false;
+ }
+ const anims = this._charts.get(chart);
+ if (!anims || !anims.running || !anims.items.length) {
+ return false;
+ }
+ return true;
+ }
+ stop(chart) {
+ const anims = this._charts.get(chart);
+ if (!anims || !anims.items.length) {
+ return;
+ }
+ const items = anims.items;
+ let i = items.length - 1;
+ for(; i >= 0; --i){
+ items[i].cancel();
+ }
+ anims.items = [];
+ this._notify(chart, anims, Date.now(), 'complete');
+ }
+ remove(chart) {
+ return this._charts.delete(chart);
+ }
+ }
+ var animator = /* #__PURE__ */ new Animator();
+
+ /*!
+ * @kurkle/color v0.3.2
+ * https://github.com/kurkle/color#readme
+ * (c) 2023 Jukka Kurkela
+ * Released under the MIT License
+ */
+ function round(v) {
+ return v + 0.5 | 0;
+ }
+ const lim = (v, l, h) => Math.max(Math.min(v, h), l);
+ function p2b(v) {
+ return lim(round(v * 2.55), 0, 255);
+ }
+ function n2b(v) {
+ return lim(round(v * 255), 0, 255);
+ }
+ function b2n(v) {
+ return lim(round(v / 2.55) / 100, 0, 1);
+ }
+ function n2p(v) {
+ return lim(round(v * 100), 0, 100);
+ }
+ const map$1 = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15};
+ const hex = [...'0123456789ABCDEF'];
+ const h1 = b => hex[b & 0xF];
+ const h2 = b => hex[(b & 0xF0) >> 4] + hex[b & 0xF];
+ const eq = b => ((b & 0xF0) >> 4) === (b & 0xF);
+ const isShort = v => eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a);
+ function hexParse(str) {
+ var len = str.length;
+ var ret;
+ if (str[0] === '#') {
+ if (len === 4 || len === 5) {
+ ret = {
+ r: 255 & map$1[str[1]] * 17,
+ g: 255 & map$1[str[2]] * 17,
+ b: 255 & map$1[str[3]] * 17,
+ a: len === 5 ? map$1[str[4]] * 17 : 255
+ };
+ } else if (len === 7 || len === 9) {
+ ret = {
+ r: map$1[str[1]] << 4 | map$1[str[2]],
+ g: map$1[str[3]] << 4 | map$1[str[4]],
+ b: map$1[str[5]] << 4 | map$1[str[6]],
+ a: len === 9 ? (map$1[str[7]] << 4 | map$1[str[8]]) : 255
+ };
+ }
+ }
+ return ret;
+ }
+ const alpha = (a, f) => a < 255 ? f(a) : '';
+ function hexString(v) {
+ var f = isShort(v) ? h1 : h2;
+ return v
+ ? '#' + f(v.r) + f(v.g) + f(v.b) + alpha(v.a, f)
+ : undefined;
+ }
+ const HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;
+ function hsl2rgbn(h, s, l) {
+ const a = s * Math.min(l, 1 - l);
+ const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+ return [f(0), f(8), f(4)];
+ }
+ function hsv2rgbn(h, s, v) {
+ const f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
+ return [f(5), f(3), f(1)];
+ }
+ function hwb2rgbn(h, w, b) {
+ const rgb = hsl2rgbn(h, 1, 0.5);
+ let i;
+ if (w + b > 1) {
+ i = 1 / (w + b);
+ w *= i;
+ b *= i;
+ }
+ for (i = 0; i < 3; i++) {
+ rgb[i] *= 1 - w - b;
+ rgb[i] += w;
+ }
+ return rgb;
+ }
+ function hueValue(r, g, b, d, max) {
+ if (r === max) {
+ return ((g - b) / d) + (g < b ? 6 : 0);
+ }
+ if (g === max) {
+ return (b - r) / d + 2;
+ }
+ return (r - g) / d + 4;
+ }
+ function rgb2hsl(v) {
+ const range = 255;
+ const r = v.r / range;
+ const g = v.g / range;
+ const b = v.b / range;
+ const max = Math.max(r, g, b);
+ const min = Math.min(r, g, b);
+ const l = (max + min) / 2;
+ let h, s, d;
+ if (max !== min) {
+ d = max - min;
+ s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+ h = hueValue(r, g, b, d, max);
+ h = h * 60 + 0.5;
+ }
+ return [h | 0, s || 0, l];
+ }
+ function calln(f, a, b, c) {
+ return (
+ Array.isArray(a)
+ ? f(a[0], a[1], a[2])
+ : f(a, b, c)
+ ).map(n2b);
+ }
+ function hsl2rgb(h, s, l) {
+ return calln(hsl2rgbn, h, s, l);
+ }
+ function hwb2rgb(h, w, b) {
+ return calln(hwb2rgbn, h, w, b);
+ }
+ function hsv2rgb(h, s, v) {
+ return calln(hsv2rgbn, h, s, v);
+ }
+ function hue(h) {
+ return (h % 360 + 360) % 360;
+ }
+ function hueParse(str) {
+ const m = HUE_RE.exec(str);
+ let a = 255;
+ let v;
+ if (!m) {
+ return;
+ }
+ if (m[5] !== v) {
+ a = m[6] ? p2b(+m[5]) : n2b(+m[5]);
+ }
+ const h = hue(+m[2]);
+ const p1 = +m[3] / 100;
+ const p2 = +m[4] / 100;
+ if (m[1] === 'hwb') {
+ v = hwb2rgb(h, p1, p2);
+ } else if (m[1] === 'hsv') {
+ v = hsv2rgb(h, p1, p2);
+ } else {
+ v = hsl2rgb(h, p1, p2);
+ }
+ return {
+ r: v[0],
+ g: v[1],
+ b: v[2],
+ a: a
+ };
+ }
+ function rotate(v, deg) {
+ var h = rgb2hsl(v);
+ h[0] = hue(h[0] + deg);
+ h = hsl2rgb(h);
+ v.r = h[0];
+ v.g = h[1];
+ v.b = h[2];
+ }
+ function hslString(v) {
+ if (!v) {
+ return;
+ }
+ const a = rgb2hsl(v);
+ const h = a[0];
+ const s = n2p(a[1]);
+ const l = n2p(a[2]);
+ return v.a < 255
+ ? `hsla(${h}, ${s}%, ${l}%, ${b2n(v.a)})`
+ : `hsl(${h}, ${s}%, ${l}%)`;
+ }
+ const map$2 = {
+ x: 'dark',
+ Z: 'light',
+ Y: 're',
+ X: 'blu',
+ W: 'gr',
+ V: 'medium',
+ U: 'slate',
+ A: 'ee',
+ T: 'ol',
+ S: 'or',
+ B: 'ra',
+ C: 'lateg',
+ D: 'ights',
+ R: 'in',
+ Q: 'turquois',
+ E: 'hi',
+ P: 'ro',
+ O: 'al',
+ N: 'le',
+ M: 'de',
+ L: 'yello',
+ F: 'en',
+ K: 'ch',
+ G: 'arks',
+ H: 'ea',
+ I: 'ightg',
+ J: 'wh'
+ };
+ const names$1 = {
+ OiceXe: 'f0f8ff',
+ antiquewEte: 'faebd7',
+ aqua: 'ffff',
+ aquamarRe: '7fffd4',
+ azuY: 'f0ffff',
+ beige: 'f5f5dc',
+ bisque: 'ffe4c4',
+ black: '0',
+ blanKedOmond: 'ffebcd',
+ Xe: 'ff',
+ XeviTet: '8a2be2',
+ bPwn: 'a52a2a',
+ burlywood: 'deb887',
+ caMtXe: '5f9ea0',
+ KartYuse: '7fff00',
+ KocTate: 'd2691e',
+ cSO: 'ff7f50',
+ cSnflowerXe: '6495ed',
+ cSnsilk: 'fff8dc',
+ crimson: 'dc143c',
+ cyan: 'ffff',
+ xXe: '8b',
+ xcyan: '8b8b',
+ xgTMnPd: 'b8860b',
+ xWay: 'a9a9a9',
+ xgYF: '6400',
+ xgYy: 'a9a9a9',
+ xkhaki: 'bdb76b',
+ xmagFta: '8b008b',
+ xTivegYF: '556b2f',
+ xSange: 'ff8c00',
+ xScEd: '9932cc',
+ xYd: '8b0000',
+ xsOmon: 'e9967a',
+ xsHgYF: '8fbc8f',
+ xUXe: '483d8b',
+ xUWay: '2f4f4f',
+ xUgYy: '2f4f4f',
+ xQe: 'ced1',
+ xviTet: '9400d3',
+ dAppRk: 'ff1493',
+ dApskyXe: 'bfff',
+ dimWay: '696969',
+ dimgYy: '696969',
+ dodgerXe: '1e90ff',
+ fiYbrick: 'b22222',
+ flSOwEte: 'fffaf0',
+ foYstWAn: '228b22',
+ fuKsia: 'ff00ff',
+ gaRsbSo: 'dcdcdc',
+ ghostwEte: 'f8f8ff',
+ gTd: 'ffd700',
+ gTMnPd: 'daa520',
+ Way: '808080',
+ gYF: '8000',
+ gYFLw: 'adff2f',
+ gYy: '808080',
+ honeyMw: 'f0fff0',
+ hotpRk: 'ff69b4',
+ RdianYd: 'cd5c5c',
+ Rdigo: '4b0082',
+ ivSy: 'fffff0',
+ khaki: 'f0e68c',
+ lavFMr: 'e6e6fa',
+ lavFMrXsh: 'fff0f5',
+ lawngYF: '7cfc00',
+ NmoncEffon: 'fffacd',
+ ZXe: 'add8e6',
+ ZcSO: 'f08080',
+ Zcyan: 'e0ffff',
+ ZgTMnPdLw: 'fafad2',
+ ZWay: 'd3d3d3',
+ ZgYF: '90ee90',
+ ZgYy: 'd3d3d3',
+ ZpRk: 'ffb6c1',
+ ZsOmon: 'ffa07a',
+ ZsHgYF: '20b2aa',
+ ZskyXe: '87cefa',
+ ZUWay: '778899',
+ ZUgYy: '778899',
+ ZstAlXe: 'b0c4de',
+ ZLw: 'ffffe0',
+ lime: 'ff00',
+ limegYF: '32cd32',
+ lRF: 'faf0e6',
+ magFta: 'ff00ff',
+ maPon: '800000',
+ VaquamarRe: '66cdaa',
+ VXe: 'cd',
+ VScEd: 'ba55d3',
+ VpurpN: '9370db',
+ VsHgYF: '3cb371',
+ VUXe: '7b68ee',
+ VsprRggYF: 'fa9a',
+ VQe: '48d1cc',
+ VviTetYd: 'c71585',
+ midnightXe: '191970',
+ mRtcYam: 'f5fffa',
+ mistyPse: 'ffe4e1',
+ moccasR: 'ffe4b5',
+ navajowEte: 'ffdead',
+ navy: '80',
+ Tdlace: 'fdf5e6',
+ Tive: '808000',
+ TivedBb: '6b8e23',
+ Sange: 'ffa500',
+ SangeYd: 'ff4500',
+ ScEd: 'da70d6',
+ pOegTMnPd: 'eee8aa',
+ pOegYF: '98fb98',
+ pOeQe: 'afeeee',
+ pOeviTetYd: 'db7093',
+ papayawEp: 'ffefd5',
+ pHKpuff: 'ffdab9',
+ peru: 'cd853f',
+ pRk: 'ffc0cb',
+ plum: 'dda0dd',
+ powMrXe: 'b0e0e6',
+ purpN: '800080',
+ YbeccapurpN: '663399',
+ Yd: 'ff0000',
+ Psybrown: 'bc8f8f',
+ PyOXe: '4169e1',
+ saddNbPwn: '8b4513',
+ sOmon: 'fa8072',
+ sandybPwn: 'f4a460',
+ sHgYF: '2e8b57',
+ sHshell: 'fff5ee',
+ siFna: 'a0522d',
+ silver: 'c0c0c0',
+ skyXe: '87ceeb',
+ UXe: '6a5acd',
+ UWay: '708090',
+ UgYy: '708090',
+ snow: 'fffafa',
+ sprRggYF: 'ff7f',
+ stAlXe: '4682b4',
+ tan: 'd2b48c',
+ teO: '8080',
+ tEstN: 'd8bfd8',
+ tomato: 'ff6347',
+ Qe: '40e0d0',
+ viTet: 'ee82ee',
+ JHt: 'f5deb3',
+ wEte: 'ffffff',
+ wEtesmoke: 'f5f5f5',
+ Lw: 'ffff00',
+ LwgYF: '9acd32'
+ };
+ function unpack() {
+ const unpacked = {};
+ const keys = Object.keys(names$1);
+ const tkeys = Object.keys(map$2);
+ let i, j, k, ok, nk;
+ for (i = 0; i < keys.length; i++) {
+ ok = nk = keys[i];
+ for (j = 0; j < tkeys.length; j++) {
+ k = tkeys[j];
+ nk = nk.replace(k, map$2[k]);
+ }
+ k = parseInt(names$1[ok], 16);
+ unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF];
+ }
+ return unpacked;
+ }
+ let names;
+ function nameParse(str) {
+ if (!names) {
+ names = unpack();
+ names.transparent = [0, 0, 0, 0];
+ }
+ const a = names[str.toLowerCase()];
+ return a && {
+ r: a[0],
+ g: a[1],
+ b: a[2],
+ a: a.length === 4 ? a[3] : 255
+ };
+ }
+ const RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;
+ function rgbParse(str) {
+ const m = RGB_RE.exec(str);
+ let a = 255;
+ let r, g, b;
+ if (!m) {
+ return;
+ }
+ if (m[7] !== r) {
+ const v = +m[7];
+ a = m[8] ? p2b(v) : lim(v * 255, 0, 255);
+ }
+ r = +m[1];
+ g = +m[3];
+ b = +m[5];
+ r = 255 & (m[2] ? p2b(r) : lim(r, 0, 255));
+ g = 255 & (m[4] ? p2b(g) : lim(g, 0, 255));
+ b = 255 & (m[6] ? p2b(b) : lim(b, 0, 255));
+ return {
+ r: r,
+ g: g,
+ b: b,
+ a: a
+ };
+ }
+ function rgbString(v) {
+ return v && (
+ v.a < 255
+ ? `rgba(${v.r}, ${v.g}, ${v.b}, ${b2n(v.a)})`
+ : `rgb(${v.r}, ${v.g}, ${v.b})`
+ );
+ }
+ const to = v => v <= 0.0031308 ? v * 12.92 : Math.pow(v, 1.0 / 2.4) * 1.055 - 0.055;
+ const from = v => v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+ function interpolate$1(rgb1, rgb2, t) {
+ const r = from(b2n(rgb1.r));
+ const g = from(b2n(rgb1.g));
+ const b = from(b2n(rgb1.b));
+ return {
+ r: n2b(to(r + t * (from(b2n(rgb2.r)) - r))),
+ g: n2b(to(g + t * (from(b2n(rgb2.g)) - g))),
+ b: n2b(to(b + t * (from(b2n(rgb2.b)) - b))),
+ a: rgb1.a + t * (rgb2.a - rgb1.a)
+ };
+ }
+ function modHSL(v, i, ratio) {
+ if (v) {
+ let tmp = rgb2hsl(v);
+ tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1));
+ tmp = hsl2rgb(tmp);
+ v.r = tmp[0];
+ v.g = tmp[1];
+ v.b = tmp[2];
+ }
+ }
+ function clone(v, proto) {
+ return v ? Object.assign(proto || {}, v) : v;
+ }
+ function fromObject(input) {
+ var v = {r: 0, g: 0, b: 0, a: 255};
+ if (Array.isArray(input)) {
+ if (input.length >= 3) {
+ v = {r: input[0], g: input[1], b: input[2], a: 255};
+ if (input.length > 3) {
+ v.a = n2b(input[3]);
+ }
+ }
+ } else {
+ v = clone(input, {r: 0, g: 0, b: 0, a: 1});
+ v.a = n2b(v.a);
+ }
+ return v;
+ }
+ function functionParse(str) {
+ if (str.charAt(0) === 'r') {
+ return rgbParse(str);
+ }
+ return hueParse(str);
+ }
+ class Color {
+ constructor(input) {
+ if (input instanceof Color) {
+ return input;
+ }
+ const type = typeof input;
+ let v;
+ if (type === 'object') {
+ v = fromObject(input);
+ } else if (type === 'string') {
+ v = hexParse(input) || nameParse(input) || functionParse(input);
+ }
+ this._rgb = v;
+ this._valid = !!v;
+ }
+ get valid() {
+ return this._valid;
+ }
+ get rgb() {
+ var v = clone(this._rgb);
+ if (v) {
+ v.a = b2n(v.a);
+ }
+ return v;
+ }
+ set rgb(obj) {
+ this._rgb = fromObject(obj);
+ }
+ rgbString() {
+ return this._valid ? rgbString(this._rgb) : undefined;
+ }
+ hexString() {
+ return this._valid ? hexString(this._rgb) : undefined;
+ }
+ hslString() {
+ return this._valid ? hslString(this._rgb) : undefined;
+ }
+ mix(color, weight) {
+ if (color) {
+ const c1 = this.rgb;
+ const c2 = color.rgb;
+ let w2;
+ const p = weight === w2 ? 0.5 : weight;
+ const w = 2 * p - 1;
+ const a = c1.a - c2.a;
+ const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
+ w2 = 1 - w1;
+ c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5;
+ c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5;
+ c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5;
+ c1.a = p * c1.a + (1 - p) * c2.a;
+ this.rgb = c1;
+ }
+ return this;
+ }
+ interpolate(color, t) {
+ if (color) {
+ this._rgb = interpolate$1(this._rgb, color._rgb, t);
+ }
+ return this;
+ }
+ clone() {
+ return new Color(this.rgb);
+ }
+ alpha(a) {
+ this._rgb.a = n2b(a);
+ return this;
+ }
+ clearer(ratio) {
+ const rgb = this._rgb;
+ rgb.a *= 1 - ratio;
+ return this;
+ }
+ greyscale() {
+ const rgb = this._rgb;
+ const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);
+ rgb.r = rgb.g = rgb.b = val;
+ return this;
+ }
+ opaquer(ratio) {
+ const rgb = this._rgb;
+ rgb.a *= 1 + ratio;
+ return this;
+ }
+ negate() {
+ const v = this._rgb;
+ v.r = 255 - v.r;
+ v.g = 255 - v.g;
+ v.b = 255 - v.b;
+ return this;
+ }
+ lighten(ratio) {
+ modHSL(this._rgb, 2, ratio);
+ return this;
+ }
+ darken(ratio) {
+ modHSL(this._rgb, 2, -ratio);
+ return this;
+ }
+ saturate(ratio) {
+ modHSL(this._rgb, 1, ratio);
+ return this;
+ }
+ desaturate(ratio) {
+ modHSL(this._rgb, 1, -ratio);
+ return this;
+ }
+ rotate(deg) {
+ rotate(this._rgb, deg);
+ return this;
+ }
+ }
+
+ function isPatternOrGradient(value) {
+ if (value && typeof value === 'object') {
+ const type = value.toString();
+ return type === '[object CanvasPattern]' || type === '[object CanvasGradient]';
+ }
+ return false;
+ }
+ function color(value) {
+ return isPatternOrGradient(value) ? value : new Color(value);
+ }
+ function getHoverColor(value) {
+ return isPatternOrGradient(value) ? value : new Color(value).saturate(0.5).darken(0.1).hexString();
+ }
+
+ const numbers = [
+ 'x',
+ 'y',
+ 'borderWidth',
+ 'radius',
+ 'tension'
+ ];
+ const colors = [
+ 'color',
+ 'borderColor',
+ 'backgroundColor'
+ ];
+ function applyAnimationsDefaults(defaults) {
+ defaults.set('animation', {
+ delay: undefined,
+ duration: 1000,
+ easing: 'easeOutQuart',
+ fn: undefined,
+ from: undefined,
+ loop: undefined,
+ to: undefined,
+ type: undefined
+ });
+ defaults.describe('animation', {
+ _fallback: false,
+ _indexable: false,
+ _scriptable: (name)=>name !== 'onProgress' && name !== 'onComplete' && name !== 'fn'
+ });
+ defaults.set('animations', {
+ colors: {
+ type: 'color',
+ properties: colors
+ },
+ numbers: {
+ type: 'number',
+ properties: numbers
+ }
+ });
+ defaults.describe('animations', {
+ _fallback: 'animation'
+ });
+ defaults.set('transitions', {
+ active: {
+ animation: {
+ duration: 400
+ }
+ },
+ resize: {
+ animation: {
+ duration: 0
+ }
+ },
+ show: {
+ animations: {
+ colors: {
+ from: 'transparent'
+ },
+ visible: {
+ type: 'boolean',
+ duration: 0
+ }
+ }
+ },
+ hide: {
+ animations: {
+ colors: {
+ to: 'transparent'
+ },
+ visible: {
+ type: 'boolean',
+ easing: 'linear',
+ fn: (v)=>v | 0
+ }
+ }
+ }
+ });
+ }
+
+ function applyLayoutsDefaults(defaults) {
+ defaults.set('layout', {
+ autoPadding: true,
+ padding: {
+ top: 0,
+ right: 0,
+ bottom: 0,
+ left: 0
+ }
+ });
+ }
+
+ const intlCache = new Map();
+ function getNumberFormat(locale, options) {
+ options = options || {};
+ const cacheKey = locale + JSON.stringify(options);
+ let formatter = intlCache.get(cacheKey);
+ if (!formatter) {
+ formatter = new Intl.NumberFormat(locale, options);
+ intlCache.set(cacheKey, formatter);
+ }
+ return formatter;
+ }
+ function formatNumber(num, locale, options) {
+ return getNumberFormat(locale, options).format(num);
+ }
+
+ const formatters = {
+ values (value) {
+ return isArray(value) ? value : '' + value;
+ },
+ numeric (tickValue, index, ticks) {
+ if (tickValue === 0) {
+ return '0';
+ }
+ const locale = this.chart.options.locale;
+ let notation;
+ let delta = tickValue;
+ if (ticks.length > 1) {
+ const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));
+ if (maxTick < 1e-4 || maxTick > 1e+15) {
+ notation = 'scientific';
+ }
+ delta = calculateDelta(tickValue, ticks);
+ }
+ const logDelta = log10(Math.abs(delta));
+ const numDecimal = isNaN(logDelta) ? 1 : Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);
+ const options = {
+ notation,
+ minimumFractionDigits: numDecimal,
+ maximumFractionDigits: numDecimal
+ };
+ Object.assign(options, this.options.ticks.format);
+ return formatNumber(tickValue, locale, options);
+ },
+ logarithmic (tickValue, index, ticks) {
+ if (tickValue === 0) {
+ return '0';
+ }
+ const remain = ticks[index].significand || tickValue / Math.pow(10, Math.floor(log10(tickValue)));
+ if ([
+ 1,
+ 2,
+ 3,
+ 5,
+ 10,
+ 15
+ ].includes(remain) || index > 0.8 * ticks.length) {
+ return formatters.numeric.call(this, tickValue, index, ticks);
+ }
+ return '';
+ }
+ };
+ function calculateDelta(tickValue, ticks) {
+ let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;
+ if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {
+ delta = tickValue - Math.floor(tickValue);
+ }
+ return delta;
+ }
+ var Ticks = {
+ formatters
+ };
+
+ function applyScaleDefaults(defaults) {
+ defaults.set('scale', {
+ display: true,
+ offset: false,
+ reverse: false,
+ beginAtZero: false,
+ bounds: 'ticks',
+ clip: true,
+ grace: 0,
+ grid: {
+ display: true,
+ lineWidth: 1,
+ drawOnChartArea: true,
+ drawTicks: true,
+ tickLength: 8,
+ tickWidth: (_ctx, options)=>options.lineWidth,
+ tickColor: (_ctx, options)=>options.color,
+ offset: false
+ },
+ border: {
+ display: true,
+ dash: [],
+ dashOffset: 0.0,
+ width: 1
+ },
+ title: {
+ display: false,
+ text: '',
+ padding: {
+ top: 4,
+ bottom: 4
+ }
+ },
+ ticks: {
+ minRotation: 0,
+ maxRotation: 50,
+ mirror: false,
+ textStrokeWidth: 0,
+ textStrokeColor: '',
+ padding: 3,
+ display: true,
+ autoSkip: true,
+ autoSkipPadding: 3,
+ labelOffset: 0,
+ callback: Ticks.formatters.values,
+ minor: {},
+ major: {},
+ align: 'center',
+ crossAlign: 'near',
+ showLabelBackdrop: false,
+ backdropColor: 'rgba(255, 255, 255, 0.75)',
+ backdropPadding: 2
+ }
+ });
+ defaults.route('scale.ticks', 'color', '', 'color');
+ defaults.route('scale.grid', 'color', '', 'borderColor');
+ defaults.route('scale.border', 'color', '', 'borderColor');
+ defaults.route('scale.title', 'color', '', 'color');
+ defaults.describe('scale', {
+ _fallback: false,
+ _scriptable: (name)=>!name.startsWith('before') && !name.startsWith('after') && name !== 'callback' && name !== 'parser',
+ _indexable: (name)=>name !== 'borderDash' && name !== 'tickBorderDash' && name !== 'dash'
+ });
+ defaults.describe('scales', {
+ _fallback: 'scale'
+ });
+ defaults.describe('scale.ticks', {
+ _scriptable: (name)=>name !== 'backdropPadding' && name !== 'callback',
+ _indexable: (name)=>name !== 'backdropPadding'
+ });
+ }
+
+ const overrides = Object.create(null);
+ const descriptors = Object.create(null);
+ function getScope$1(node, key) {
+ if (!key) {
+ return node;
+ }
+ const keys = key.split('.');
+ for(let i = 0, n = keys.length; i < n; ++i){
+ const k = keys[i];
+ node = node[k] || (node[k] = Object.create(null));
+ }
+ return node;
+ }
+ function set(root, scope, values) {
+ if (typeof scope === 'string') {
+ return merge(getScope$1(root, scope), values);
+ }
+ return merge(getScope$1(root, ''), scope);
+ }
+ class Defaults {
+ constructor(_descriptors, _appliers){
+ this.animation = undefined;
+ this.backgroundColor = 'rgba(0,0,0,0.1)';
+ this.borderColor = 'rgba(0,0,0,0.1)';
+ this.color = '#666';
+ this.datasets = {};
+ this.devicePixelRatio = (context)=>context.chart.platform.getDevicePixelRatio();
+ this.elements = {};
+ this.events = [
+ 'mousemove',
+ 'mouseout',
+ 'click',
+ 'touchstart',
+ 'touchmove'
+ ];
+ this.font = {
+ family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
+ size: 12,
+ style: 'normal',
+ lineHeight: 1.2,
+ weight: null
+ };
+ this.hover = {};
+ this.hoverBackgroundColor = (ctx, options)=>getHoverColor(options.backgroundColor);
+ this.hoverBorderColor = (ctx, options)=>getHoverColor(options.borderColor);
+ this.hoverColor = (ctx, options)=>getHoverColor(options.color);
+ this.indexAxis = 'x';
+ this.interaction = {
+ mode: 'nearest',
+ intersect: true,
+ includeInvisible: false
+ };
+ this.maintainAspectRatio = true;
+ this.onHover = null;
+ this.onClick = null;
+ this.parsing = true;
+ this.plugins = {};
+ this.responsive = true;
+ this.scale = undefined;
+ this.scales = {};
+ this.showLine = true;
+ this.drawActiveElementsOnTop = true;
+ this.describe(_descriptors);
+ this.apply(_appliers);
+ }
+ set(scope, values) {
+ return set(this, scope, values);
+ }
+ get(scope) {
+ return getScope$1(this, scope);
+ }
+ describe(scope, values) {
+ return set(descriptors, scope, values);
+ }
+ override(scope, values) {
+ return set(overrides, scope, values);
+ }
+ route(scope, name, targetScope, targetName) {
+ const scopeObject = getScope$1(this, scope);
+ const targetScopeObject = getScope$1(this, targetScope);
+ const privateName = '_' + name;
+ Object.defineProperties(scopeObject, {
+ [privateName]: {
+ value: scopeObject[name],
+ writable: true
+ },
+ [name]: {
+ enumerable: true,
+ get () {
+ const local = this[privateName];
+ const target = targetScopeObject[targetName];
+ if (isObject(local)) {
+ return Object.assign({}, target, local);
+ }
+ return valueOrDefault(local, target);
+ },
+ set (value) {
+ this[privateName] = value;
+ }
+ }
+ });
+ }
+ apply(appliers) {
+ appliers.forEach((apply)=>apply(this));
+ }
+ }
+ var defaults = /* #__PURE__ */ new Defaults({
+ _scriptable: (name)=>!name.startsWith('on'),
+ _indexable: (name)=>name !== 'events',
+ hover: {
+ _fallback: 'interaction'
+ },
+ interaction: {
+ _scriptable: false,
+ _indexable: false
+ }
+ }, [
+ applyAnimationsDefaults,
+ applyLayoutsDefaults,
+ applyScaleDefaults
+ ]);
+
+ /**
+ * Note: typedefs are auto-exported, so use a made-up `dom` namespace where
+ * necessary to avoid duplicates with `export * from './helpers`; see
+ * https://github.com/microsoft/TypeScript/issues/46011
+ * @typedef { import('../core/core.controller.js').default } dom.Chart
+ * @typedef { import('../../types').ChartEvent } ChartEvent
+ */ /**
+ * @private
+ */ function _isDomSupported() {
+ return typeof window !== 'undefined' && typeof document !== 'undefined';
+ }
+ /**
+ * @private
+ */ function _getParentNode(domNode) {
+ let parent = domNode.parentNode;
+ if (parent && parent.toString() === '[object ShadowRoot]') {
+ parent = parent.host;
+ }
+ return parent;
+ }
+ /**
+ * convert max-width/max-height values that may be percentages into a number
+ * @private
+ */ function parseMaxStyle(styleValue, node, parentProperty) {
+ let valueInPixels;
+ if (typeof styleValue === 'string') {
+ valueInPixels = parseInt(styleValue, 10);
+ if (styleValue.indexOf('%') !== -1) {
+ // percentage * size in dimension
+ valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
+ }
+ } else {
+ valueInPixels = styleValue;
+ }
+ return valueInPixels;
+ }
+ const getComputedStyle = (element)=>element.ownerDocument.defaultView.getComputedStyle(element, null);
+ function getStyle(el, property) {
+ return getComputedStyle(el).getPropertyValue(property);
+ }
+ const positions = [
+ 'top',
+ 'right',
+ 'bottom',
+ 'left'
+ ];
+ function getPositionedStyle(styles, style, suffix) {
+ const result = {};
+ suffix = suffix ? '-' + suffix : '';
+ for(let i = 0; i < 4; i++){
+ const pos = positions[i];
+ result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0;
+ }
+ result.width = result.left + result.right;
+ result.height = result.top + result.bottom;
+ return result;
+ }
+ const useOffsetPos = (x, y, target)=>(x > 0 || y > 0) && (!target || !target.shadowRoot);
+ /**
+ * @param e
+ * @param canvas
+ * @returns Canvas position
+ */ function getCanvasPosition(e, canvas) {
+ const touches = e.touches;
+ const source = touches && touches.length ? touches[0] : e;
+ const { offsetX , offsetY } = source;
+ let box = false;
+ let x, y;
+ if (useOffsetPos(offsetX, offsetY, e.target)) {
+ x = offsetX;
+ y = offsetY;
+ } else {
+ const rect = canvas.getBoundingClientRect();
+ x = source.clientX - rect.left;
+ y = source.clientY - rect.top;
+ box = true;
+ }
+ return {
+ x,
+ y,
+ box
+ };
+ }
+ /**
+ * Gets an event's x, y coordinates, relative to the chart area
+ * @param event
+ * @param chart
+ * @returns x and y coordinates of the event
+ */ function getRelativePosition(event, chart) {
+ if ('native' in event) {
+ return event;
+ }
+ const { canvas , currentDevicePixelRatio } = chart;
+ const style = getComputedStyle(canvas);
+ const borderBox = style.boxSizing === 'border-box';
+ const paddings = getPositionedStyle(style, 'padding');
+ const borders = getPositionedStyle(style, 'border', 'width');
+ const { x , y , box } = getCanvasPosition(event, canvas);
+ const xOffset = paddings.left + (box && borders.left);
+ const yOffset = paddings.top + (box && borders.top);
+ let { width , height } = chart;
+ if (borderBox) {
+ width -= paddings.width + borders.width;
+ height -= paddings.height + borders.height;
+ }
+ return {
+ x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio),
+ y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio)
+ };
+ }
+ function getContainerSize(canvas, width, height) {
+ let maxWidth, maxHeight;
+ if (width === undefined || height === undefined) {
+ const container = _getParentNode(canvas);
+ if (!container) {
+ width = canvas.clientWidth;
+ height = canvas.clientHeight;
+ } else {
+ const rect = container.getBoundingClientRect(); // this is the border box of the container
+ const containerStyle = getComputedStyle(container);
+ const containerBorder = getPositionedStyle(containerStyle, 'border', 'width');
+ const containerPadding = getPositionedStyle(containerStyle, 'padding');
+ width = rect.width - containerPadding.width - containerBorder.width;
+ height = rect.height - containerPadding.height - containerBorder.height;
+ maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth');
+ maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight');
+ }
+ }
+ return {
+ width,
+ height,
+ maxWidth: maxWidth || INFINITY,
+ maxHeight: maxHeight || INFINITY
+ };
+ }
+ const round1 = (v)=>Math.round(v * 10) / 10;
+ // eslint-disable-next-line complexity
+ function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {
+ const style = getComputedStyle(canvas);
+ const margins = getPositionedStyle(style, 'margin');
+ const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY;
+ const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY;
+ const containerSize = getContainerSize(canvas, bbWidth, bbHeight);
+ let { width , height } = containerSize;
+ if (style.boxSizing === 'content-box') {
+ const borders = getPositionedStyle(style, 'border', 'width');
+ const paddings = getPositionedStyle(style, 'padding');
+ width -= paddings.width + borders.width;
+ height -= paddings.height + borders.height;
+ }
+ width = Math.max(0, width - margins.width);
+ height = Math.max(0, aspectRatio ? width / aspectRatio : height - margins.height);
+ width = round1(Math.min(width, maxWidth, containerSize.maxWidth));
+ height = round1(Math.min(height, maxHeight, containerSize.maxHeight));
+ if (width && !height) {
+ // https://github.com/chartjs/Chart.js/issues/4659
+ // If the canvas has width, but no height, default to aspectRatio of 2 (canvas default)
+ height = round1(width / 2);
+ }
+ const maintainHeight = bbWidth !== undefined || bbHeight !== undefined;
+ if (maintainHeight && aspectRatio && containerSize.height && height > containerSize.height) {
+ height = containerSize.height;
+ width = round1(Math.floor(height * aspectRatio));
+ }
+ return {
+ width,
+ height
+ };
+ }
+ /**
+ * @param chart
+ * @param forceRatio
+ * @param forceStyle
+ * @returns True if the canvas context size or transformation has changed.
+ */ function retinaScale(chart, forceRatio, forceStyle) {
+ const pixelRatio = forceRatio || 1;
+ const deviceHeight = Math.floor(chart.height * pixelRatio);
+ const deviceWidth = Math.floor(chart.width * pixelRatio);
+ chart.height = Math.floor(chart.height);
+ chart.width = Math.floor(chart.width);
+ const canvas = chart.canvas;
+ // If no style has been set on the canvas, the render size is used as display size,
+ // making the chart visually bigger, so let's enforce it to the "correct" values.
+ // See https://github.com/chartjs/Chart.js/issues/3575
+ if (canvas.style && (forceStyle || !canvas.style.height && !canvas.style.width)) {
+ canvas.style.height = `${chart.height}px`;
+ canvas.style.width = `${chart.width}px`;
+ }
+ if (chart.currentDevicePixelRatio !== pixelRatio || canvas.height !== deviceHeight || canvas.width !== deviceWidth) {
+ chart.currentDevicePixelRatio = pixelRatio;
+ canvas.height = deviceHeight;
+ canvas.width = deviceWidth;
+ chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+ return true;
+ }
+ return false;
+ }
+ /**
+ * Detects support for options object argument in addEventListener.
+ * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+ * @private
+ */ const supportsEventListenerOptions = function() {
+ let passiveSupported = false;
+ try {
+ const options = {
+ get passive () {
+ passiveSupported = true;
+ return false;
+ }
+ };
+ if (_isDomSupported()) {
+ window.addEventListener('test', null, options);
+ window.removeEventListener('test', null, options);
+ }
+ } catch (e) {
+ // continue regardless of error
+ }
+ return passiveSupported;
+ }();
+ /**
+ * The "used" size is the final value of a dimension property after all calculations have
+ * been performed. This method uses the computed style of `element` but returns undefined
+ * if the computed style is not expressed in pixels. That can happen in some cases where
+ * `element` has a size relative to its parent and this last one is not yet displayed,
+ * for example because of `display: none` on a parent node.
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
+ * @returns Size in pixels or undefined if unknown.
+ */ function readUsedSize(element, property) {
+ const value = getStyle(element, property);
+ const matches = value && value.match(/^(\d+)(\.\d+)?px$/);
+ return matches ? +matches[1] : undefined;
+ }
+
+ /**
+ * Converts the given font object into a CSS font string.
+ * @param font - A font object.
+ * @return The CSS font string. See https://developer.mozilla.org/en-US/docs/Web/CSS/font
+ * @private
+ */ function toFontString(font) {
+ if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {
+ return null;
+ }
+ return (font.style ? font.style + ' ' : '') + (font.weight ? font.weight + ' ' : '') + font.size + 'px ' + font.family;
+ }
+ /**
+ * @private
+ */ function _measureText(ctx, data, gc, longest, string) {
+ let textWidth = data[string];
+ if (!textWidth) {
+ textWidth = data[string] = ctx.measureText(string).width;
+ gc.push(string);
+ }
+ if (textWidth > longest) {
+ longest = textWidth;
+ }
+ return longest;
+ }
+ /**
+ * @private
+ */ // eslint-disable-next-line complexity
+ function _longestText(ctx, font, arrayOfThings, cache) {
+ cache = cache || {};
+ let data = cache.data = cache.data || {};
+ let gc = cache.garbageCollect = cache.garbageCollect || [];
+ if (cache.font !== font) {
+ data = cache.data = {};
+ gc = cache.garbageCollect = [];
+ cache.font = font;
+ }
+ ctx.save();
+ ctx.font = font;
+ let longest = 0;
+ const ilen = arrayOfThings.length;
+ let i, j, jlen, thing, nestedThing;
+ for(i = 0; i < ilen; i++){
+ thing = arrayOfThings[i];
+ // Undefined strings and arrays should not be measured
+ if (thing !== undefined && thing !== null && !isArray(thing)) {
+ longest = _measureText(ctx, data, gc, longest, thing);
+ } else if (isArray(thing)) {
+ // if it is an array lets measure each element
+ // to do maybe simplify this function a bit so we can do this more recursively?
+ for(j = 0, jlen = thing.length; j < jlen; j++){
+ nestedThing = thing[j];
+ // Undefined strings and arrays should not be measured
+ if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) {
+ longest = _measureText(ctx, data, gc, longest, nestedThing);
+ }
+ }
+ }
+ }
+ ctx.restore();
+ const gcLen = gc.length / 2;
+ if (gcLen > arrayOfThings.length) {
+ for(i = 0; i < gcLen; i++){
+ delete data[gc[i]];
+ }
+ gc.splice(0, gcLen);
+ }
+ return longest;
+ }
+ /**
+ * Returns the aligned pixel value to avoid anti-aliasing blur
+ * @param chart - The chart instance.
+ * @param pixel - A pixel value.
+ * @param width - The width of the element.
+ * @returns The aligned pixel value.
+ * @private
+ */ function _alignPixel(chart, pixel, width) {
+ const devicePixelRatio = chart.currentDevicePixelRatio;
+ const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;
+ return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
+ }
+ /**
+ * Clears the entire canvas.
+ */ function clearCanvas(canvas, ctx) {
+ ctx = ctx || canvas.getContext('2d');
+ ctx.save();
+ // canvas.width and canvas.height do not consider the canvas transform,
+ // while clearRect does
+ ctx.resetTransform();
+ ctx.clearRect(0, 0, canvas.width, canvas.height);
+ ctx.restore();
+ }
+ function drawPoint(ctx, options, x, y) {
+ // eslint-disable-next-line @typescript-eslint/no-use-before-define
+ drawPointLegend(ctx, options, x, y, null);
+ }
+ // eslint-disable-next-line complexity
+ function drawPointLegend(ctx, options, x, y, w) {
+ let type, xOffset, yOffset, size, cornerRadius, width, xOffsetW, yOffsetW;
+ const style = options.pointStyle;
+ const rotation = options.rotation;
+ const radius = options.radius;
+ let rad = (rotation || 0) * RAD_PER_DEG;
+ if (style && typeof style === 'object') {
+ type = style.toString();
+ if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {
+ ctx.save();
+ ctx.translate(x, y);
+ ctx.rotate(rad);
+ ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);
+ ctx.restore();
+ return;
+ }
+ }
+ if (isNaN(radius) || radius <= 0) {
+ return;
+ }
+ ctx.beginPath();
+ switch(style){
+ // Default includes circle
+ default:
+ if (w) {
+ ctx.ellipse(x, y, w / 2, radius, 0, 0, TAU);
+ } else {
+ ctx.arc(x, y, radius, 0, TAU);
+ }
+ ctx.closePath();
+ break;
+ case 'triangle':
+ width = w ? w / 2 : radius;
+ ctx.moveTo(x + Math.sin(rad) * width, y - Math.cos(rad) * radius);
+ rad += TWO_THIRDS_PI;
+ ctx.lineTo(x + Math.sin(rad) * width, y - Math.cos(rad) * radius);
+ rad += TWO_THIRDS_PI;
+ ctx.lineTo(x + Math.sin(rad) * width, y - Math.cos(rad) * radius);
+ ctx.closePath();
+ break;
+ case 'rectRounded':
+ // NOTE: the rounded rect implementation changed to use `arc` instead of
+ // `quadraticCurveTo` since it generates better results when rect is
+ // almost a circle. 0.516 (instead of 0.5) produces results with visually
+ // closer proportion to the previous impl and it is inscribed in the
+ // circle with `radius`. For more details, see the following PRs:
+ // https://github.com/chartjs/Chart.js/issues/5597
+ // https://github.com/chartjs/Chart.js/issues/5858
+ cornerRadius = radius * 0.516;
+ size = radius - cornerRadius;
+ xOffset = Math.cos(rad + QUARTER_PI) * size;
+ xOffsetW = Math.cos(rad + QUARTER_PI) * (w ? w / 2 - cornerRadius : size);
+ yOffset = Math.sin(rad + QUARTER_PI) * size;
+ yOffsetW = Math.sin(rad + QUARTER_PI) * (w ? w / 2 - cornerRadius : size);
+ ctx.arc(x - xOffsetW, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI);
+ ctx.arc(x + yOffsetW, y - xOffset, cornerRadius, rad - HALF_PI, rad);
+ ctx.arc(x + xOffsetW, y + yOffset, cornerRadius, rad, rad + HALF_PI);
+ ctx.arc(x - yOffsetW, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI);
+ ctx.closePath();
+ break;
+ case 'rect':
+ if (!rotation) {
+ size = Math.SQRT1_2 * radius;
+ width = w ? w / 2 : size;
+ ctx.rect(x - width, y - size, 2 * width, 2 * size);
+ break;
+ }
+ rad += QUARTER_PI;
+ /* falls through */ case 'rectRot':
+ xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);
+ ctx.moveTo(x - xOffsetW, y - yOffset);
+ ctx.lineTo(x + yOffsetW, y - xOffset);
+ ctx.lineTo(x + xOffsetW, y + yOffset);
+ ctx.lineTo(x - yOffsetW, y + xOffset);
+ ctx.closePath();
+ break;
+ case 'crossRot':
+ rad += QUARTER_PI;
+ /* falls through */ case 'cross':
+ xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);
+ ctx.moveTo(x - xOffsetW, y - yOffset);
+ ctx.lineTo(x + xOffsetW, y + yOffset);
+ ctx.moveTo(x + yOffsetW, y - xOffset);
+ ctx.lineTo(x - yOffsetW, y + xOffset);
+ break;
+ case 'star':
+ xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);
+ ctx.moveTo(x - xOffsetW, y - yOffset);
+ ctx.lineTo(x + xOffsetW, y + yOffset);
+ ctx.moveTo(x + yOffsetW, y - xOffset);
+ ctx.lineTo(x - yOffsetW, y + xOffset);
+ rad += QUARTER_PI;
+ xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);
+ ctx.moveTo(x - xOffsetW, y - yOffset);
+ ctx.lineTo(x + xOffsetW, y + yOffset);
+ ctx.moveTo(x + yOffsetW, y - xOffset);
+ ctx.lineTo(x - yOffsetW, y + xOffset);
+ break;
+ case 'line':
+ xOffset = w ? w / 2 : Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ ctx.moveTo(x - xOffset, y - yOffset);
+ ctx.lineTo(x + xOffset, y + yOffset);
+ break;
+ case 'dash':
+ ctx.moveTo(x, y);
+ ctx.lineTo(x + Math.cos(rad) * (w ? w / 2 : radius), y + Math.sin(rad) * radius);
+ break;
+ case false:
+ ctx.closePath();
+ break;
+ }
+ ctx.fill();
+ if (options.borderWidth > 0) {
+ ctx.stroke();
+ }
+ }
+ /**
+ * Returns true if the point is inside the rectangle
+ * @param point - The point to test
+ * @param area - The rectangle
+ * @param margin - allowed margin
+ * @private
+ */ function _isPointInArea(point, area, margin) {
+ margin = margin || 0.5; // margin - default is to match rounded decimals
+ return !area || point && point.x > area.left - margin && point.x < area.right + margin && point.y > area.top - margin && point.y < area.bottom + margin;
+ }
+ function clipArea(ctx, area) {
+ ctx.save();
+ ctx.beginPath();
+ ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
+ ctx.clip();
+ }
+ function unclipArea(ctx) {
+ ctx.restore();
+ }
+ /**
+ * @private
+ */ function _steppedLineTo(ctx, previous, target, flip, mode) {
+ if (!previous) {
+ return ctx.lineTo(target.x, target.y);
+ }
+ if (mode === 'middle') {
+ const midpoint = (previous.x + target.x) / 2.0;
+ ctx.lineTo(midpoint, previous.y);
+ ctx.lineTo(midpoint, target.y);
+ } else if (mode === 'after' !== !!flip) {
+ ctx.lineTo(previous.x, target.y);
+ } else {
+ ctx.lineTo(target.x, previous.y);
+ }
+ ctx.lineTo(target.x, target.y);
+ }
+ /**
+ * @private
+ */ function _bezierCurveTo(ctx, previous, target, flip) {
+ if (!previous) {
+ return ctx.lineTo(target.x, target.y);
+ }
+ ctx.bezierCurveTo(flip ? previous.cp1x : previous.cp2x, flip ? previous.cp1y : previous.cp2y, flip ? target.cp2x : target.cp1x, flip ? target.cp2y : target.cp1y, target.x, target.y);
+ }
+ function setRenderOpts(ctx, opts) {
+ if (opts.translation) {
+ ctx.translate(opts.translation[0], opts.translation[1]);
+ }
+ if (!isNullOrUndef(opts.rotation)) {
+ ctx.rotate(opts.rotation);
+ }
+ if (opts.color) {
+ ctx.fillStyle = opts.color;
+ }
+ if (opts.textAlign) {
+ ctx.textAlign = opts.textAlign;
+ }
+ if (opts.textBaseline) {
+ ctx.textBaseline = opts.textBaseline;
+ }
+ }
+ function decorateText(ctx, x, y, line, opts) {
+ if (opts.strikethrough || opts.underline) {
+ /**
+ * Now that IE11 support has been dropped, we can use more
+ * of the TextMetrics object. The actual bounding boxes
+ * are unflagged in Chrome, Firefox, Edge, and Safari so they
+ * can be safely used.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/TextMetrics#Browser_compatibility
+ */ const metrics = ctx.measureText(line);
+ const left = x - metrics.actualBoundingBoxLeft;
+ const right = x + metrics.actualBoundingBoxRight;
+ const top = y - metrics.actualBoundingBoxAscent;
+ const bottom = y + metrics.actualBoundingBoxDescent;
+ const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;
+ ctx.strokeStyle = ctx.fillStyle;
+ ctx.beginPath();
+ ctx.lineWidth = opts.decorationWidth || 2;
+ ctx.moveTo(left, yDecoration);
+ ctx.lineTo(right, yDecoration);
+ ctx.stroke();
+ }
+ }
+ function drawBackdrop(ctx, opts) {
+ const oldColor = ctx.fillStyle;
+ ctx.fillStyle = opts.color;
+ ctx.fillRect(opts.left, opts.top, opts.width, opts.height);
+ ctx.fillStyle = oldColor;
+ }
+ /**
+ * Render text onto the canvas
+ */ function renderText(ctx, text, x, y, font, opts = {}) {
+ const lines = isArray(text) ? text : [
+ text
+ ];
+ const stroke = opts.strokeWidth > 0 && opts.strokeColor !== '';
+ let i, line;
+ ctx.save();
+ ctx.font = font.string;
+ setRenderOpts(ctx, opts);
+ for(i = 0; i < lines.length; ++i){
+ line = lines[i];
+ if (opts.backdrop) {
+ drawBackdrop(ctx, opts.backdrop);
+ }
+ if (stroke) {
+ if (opts.strokeColor) {
+ ctx.strokeStyle = opts.strokeColor;
+ }
+ if (!isNullOrUndef(opts.strokeWidth)) {
+ ctx.lineWidth = opts.strokeWidth;
+ }
+ ctx.strokeText(line, x, y, opts.maxWidth);
+ }
+ ctx.fillText(line, x, y, opts.maxWidth);
+ decorateText(ctx, x, y, line, opts);
+ y += Number(font.lineHeight);
+ }
+ ctx.restore();
+ }
+ /**
+ * Add a path of a rectangle with rounded corners to the current sub-path
+ * @param ctx - Context
+ * @param rect - Bounding rect
+ */ function addRoundedRectPath(ctx, rect) {
+ const { x , y , w , h , radius } = rect;
+ // top left arc
+ ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, 1.5 * PI, PI, true);
+ // line from top left to bottom left
+ ctx.lineTo(x, y + h - radius.bottomLeft);
+ // bottom left arc
+ ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);
+ // line from bottom left to bottom right
+ ctx.lineTo(x + w - radius.bottomRight, y + h);
+ // bottom right arc
+ ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);
+ // line from bottom right to top right
+ ctx.lineTo(x + w, y + radius.topRight);
+ // top right arc
+ ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true);
+ // line from top right to top left
+ ctx.lineTo(x + radius.topLeft, y);
+ }
+
+ /**
+ * Creates a Proxy for resolving raw values for options.
+ * @param scopes - The option scopes to look for values, in resolution order
+ * @param prefixes - The prefixes for values, in resolution order.
+ * @param rootScopes - The root option scopes
+ * @param fallback - Parent scopes fallback
+ * @param getTarget - callback for getting the target for changed values
+ * @returns Proxy
+ * @private
+ */ function _createResolver(scopes, prefixes = [
+ ''
+ ], rootScopes, fallback, getTarget = ()=>scopes[0]) {
+ const finalRootScopes = rootScopes || scopes;
+ if (typeof fallback === 'undefined') {
+ fallback = _resolve('_fallback', scopes);
+ }
+ const cache = {
+ [Symbol.toStringTag]: 'Object',
+ _cacheable: true,
+ _scopes: scopes,
+ _rootScopes: finalRootScopes,
+ _fallback: fallback,
+ _getTarget: getTarget,
+ override: (scope)=>_createResolver([
+ scope,
+ ...scopes
+ ], prefixes, finalRootScopes, fallback)
+ };
+ return new Proxy(cache, {
+ /**
+ * A trap for the delete operator.
+ */ deleteProperty (target, prop) {
+ delete target[prop]; // remove from cache
+ delete target._keys; // remove cached keys
+ delete scopes[0][prop]; // remove from top level scope
+ return true;
+ },
+ /**
+ * A trap for getting property values.
+ */ get (target, prop) {
+ return _cached(target, prop, ()=>_resolveWithPrefixes(prop, prefixes, scopes, target));
+ },
+ /**
+ * A trap for Object.getOwnPropertyDescriptor.
+ * Also used by Object.hasOwnProperty.
+ */ getOwnPropertyDescriptor (target, prop) {
+ return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);
+ },
+ /**
+ * A trap for Object.getPrototypeOf.
+ */ getPrototypeOf () {
+ return Reflect.getPrototypeOf(scopes[0]);
+ },
+ /**
+ * A trap for the in operator.
+ */ has (target, prop) {
+ return getKeysFromAllScopes(target).includes(prop);
+ },
+ /**
+ * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
+ */ ownKeys (target) {
+ return getKeysFromAllScopes(target);
+ },
+ /**
+ * A trap for setting property values.
+ */ set (target, prop, value) {
+ const storage = target._storage || (target._storage = getTarget());
+ target[prop] = storage[prop] = value; // set to top level scope + cache
+ delete target._keys; // remove cached keys
+ return true;
+ }
+ });
+ }
+ /**
+ * Returns an Proxy for resolving option values with context.
+ * @param proxy - The Proxy returned by `_createResolver`
+ * @param context - Context object for scriptable/indexable options
+ * @param subProxy - The proxy provided for scriptable options
+ * @param descriptorDefaults - Defaults for descriptors
+ * @private
+ */ function _attachContext(proxy, context, subProxy, descriptorDefaults) {
+ const cache = {
+ _cacheable: false,
+ _proxy: proxy,
+ _context: context,
+ _subProxy: subProxy,
+ _stack: new Set(),
+ _descriptors: _descriptors(proxy, descriptorDefaults),
+ setContext: (ctx)=>_attachContext(proxy, ctx, subProxy, descriptorDefaults),
+ override: (scope)=>_attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)
+ };
+ return new Proxy(cache, {
+ /**
+ * A trap for the delete operator.
+ */ deleteProperty (target, prop) {
+ delete target[prop]; // remove from cache
+ delete proxy[prop]; // remove from proxy
+ return true;
+ },
+ /**
+ * A trap for getting property values.
+ */ get (target, prop, receiver) {
+ return _cached(target, prop, ()=>_resolveWithContext(target, prop, receiver));
+ },
+ /**
+ * A trap for Object.getOwnPropertyDescriptor.
+ * Also used by Object.hasOwnProperty.
+ */ getOwnPropertyDescriptor (target, prop) {
+ return target._descriptors.allKeys ? Reflect.has(proxy, prop) ? {
+ enumerable: true,
+ configurable: true
+ } : undefined : Reflect.getOwnPropertyDescriptor(proxy, prop);
+ },
+ /**
+ * A trap for Object.getPrototypeOf.
+ */ getPrototypeOf () {
+ return Reflect.getPrototypeOf(proxy);
+ },
+ /**
+ * A trap for the in operator.
+ */ has (target, prop) {
+ return Reflect.has(proxy, prop);
+ },
+ /**
+ * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
+ */ ownKeys () {
+ return Reflect.ownKeys(proxy);
+ },
+ /**
+ * A trap for setting property values.
+ */ set (target, prop, value) {
+ proxy[prop] = value; // set to proxy
+ delete target[prop]; // remove from cache
+ return true;
+ }
+ });
+ }
+ /**
+ * @private
+ */ function _descriptors(proxy, defaults = {
+ scriptable: true,
+ indexable: true
+ }) {
+ const { _scriptable =defaults.scriptable , _indexable =defaults.indexable , _allKeys =defaults.allKeys } = proxy;
+ return {
+ allKeys: _allKeys,
+ scriptable: _scriptable,
+ indexable: _indexable,
+ isScriptable: isFunction(_scriptable) ? _scriptable : ()=>_scriptable,
+ isIndexable: isFunction(_indexable) ? _indexable : ()=>_indexable
+ };
+ }
+ const readKey = (prefix, name)=>prefix ? prefix + _capitalize(name) : name;
+ const needsSubResolver = (prop, value)=>isObject(value) && prop !== 'adapters' && (Object.getPrototypeOf(value) === null || value.constructor === Object);
+ function _cached(target, prop, resolve) {
+ if (Object.prototype.hasOwnProperty.call(target, prop)) {
+ return target[prop];
+ }
+ const value = resolve();
+ // cache the resolved value
+ target[prop] = value;
+ return value;
+ }
+ function _resolveWithContext(target, prop, receiver) {
+ const { _proxy , _context , _subProxy , _descriptors: descriptors } = target;
+ let value = _proxy[prop]; // resolve from proxy
+ // resolve with context
+ if (isFunction(value) && descriptors.isScriptable(prop)) {
+ value = _resolveScriptable(prop, value, target, receiver);
+ }
+ if (isArray(value) && value.length) {
+ value = _resolveArray(prop, value, target, descriptors.isIndexable);
+ }
+ if (needsSubResolver(prop, value)) {
+ // if the resolved value is an object, create a sub resolver for it
+ value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors);
+ }
+ return value;
+ }
+ function _resolveScriptable(prop, getValue, target, receiver) {
+ const { _proxy , _context , _subProxy , _stack } = target;
+ if (_stack.has(prop)) {
+ throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop);
+ }
+ _stack.add(prop);
+ let value = getValue(_context, _subProxy || receiver);
+ _stack.delete(prop);
+ if (needsSubResolver(prop, value)) {
+ // When scriptable option returns an object, create a resolver on that.
+ value = createSubResolver(_proxy._scopes, _proxy, prop, value);
+ }
+ return value;
+ }
+ function _resolveArray(prop, value, target, isIndexable) {
+ const { _proxy , _context , _subProxy , _descriptors: descriptors } = target;
+ if (typeof _context.index !== 'undefined' && isIndexable(prop)) {
+ return value[_context.index % value.length];
+ } else if (isObject(value[0])) {
+ // Array of objects, return array or resolvers
+ const arr = value;
+ const scopes = _proxy._scopes.filter((s)=>s !== arr);
+ value = [];
+ for (const item of arr){
+ const resolver = createSubResolver(scopes, _proxy, prop, item);
+ value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors));
+ }
+ }
+ return value;
+ }
+ function resolveFallback(fallback, prop, value) {
+ return isFunction(fallback) ? fallback(prop, value) : fallback;
+ }
+ const getScope = (key, parent)=>key === true ? parent : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;
+ function addScopes(set, parentScopes, key, parentFallback, value) {
+ for (const parent of parentScopes){
+ const scope = getScope(key, parent);
+ if (scope) {
+ set.add(scope);
+ const fallback = resolveFallback(scope._fallback, key, value);
+ if (typeof fallback !== 'undefined' && fallback !== key && fallback !== parentFallback) {
+ // When we reach the descriptor that defines a new _fallback, return that.
+ // The fallback will resume to that new scope.
+ return fallback;
+ }
+ } else if (scope === false && typeof parentFallback !== 'undefined' && key !== parentFallback) {
+ // Fallback to `false` results to `false`, when falling back to different key.
+ // For example `interaction` from `hover` or `plugins.tooltip` and `animation` from `animations`
+ return null;
+ }
+ }
+ return false;
+ }
+ function createSubResolver(parentScopes, resolver, prop, value) {
+ const rootScopes = resolver._rootScopes;
+ const fallback = resolveFallback(resolver._fallback, prop, value);
+ const allScopes = [
+ ...parentScopes,
+ ...rootScopes
+ ];
+ const set = new Set();
+ set.add(value);
+ let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value);
+ if (key === null) {
+ return false;
+ }
+ if (typeof fallback !== 'undefined' && fallback !== prop) {
+ key = addScopesFromKey(set, allScopes, fallback, key, value);
+ if (key === null) {
+ return false;
+ }
+ }
+ return _createResolver(Array.from(set), [
+ ''
+ ], rootScopes, fallback, ()=>subGetTarget(resolver, prop, value));
+ }
+ function addScopesFromKey(set, allScopes, key, fallback, item) {
+ while(key){
+ key = addScopes(set, allScopes, key, fallback, item);
+ }
+ return key;
+ }
+ function subGetTarget(resolver, prop, value) {
+ const parent = resolver._getTarget();
+ if (!(prop in parent)) {
+ parent[prop] = {};
+ }
+ const target = parent[prop];
+ if (isArray(target) && isObject(value)) {
+ // For array of objects, the object is used to store updated values
+ return value;
+ }
+ return target || {};
+ }
+ function _resolveWithPrefixes(prop, prefixes, scopes, proxy) {
+ let value;
+ for (const prefix of prefixes){
+ value = _resolve(readKey(prefix, prop), scopes);
+ if (typeof value !== 'undefined') {
+ return needsSubResolver(prop, value) ? createSubResolver(scopes, proxy, prop, value) : value;
+ }
+ }
+ }
+ function _resolve(key, scopes) {
+ for (const scope of scopes){
+ if (!scope) {
+ continue;
+ }
+ const value = scope[key];
+ if (typeof value !== 'undefined') {
+ return value;
+ }
+ }
+ }
+ function getKeysFromAllScopes(target) {
+ let keys = target._keys;
+ if (!keys) {
+ keys = target._keys = resolveKeysFromAllScopes(target._scopes);
+ }
+ return keys;
+ }
+ function resolveKeysFromAllScopes(scopes) {
+ const set = new Set();
+ for (const scope of scopes){
+ for (const key of Object.keys(scope).filter((k)=>!k.startsWith('_'))){
+ set.add(key);
+ }
+ }
+ return Array.from(set);
+ }
+ function _parseObjectDataRadialScale(meta, data, start, count) {
+ const { iScale } = meta;
+ const { key ='r' } = this._parsing;
+ const parsed = new Array(count);
+ let i, ilen, index, item;
+ for(i = 0, ilen = count; i < ilen; ++i){
+ index = i + start;
+ item = data[index];
+ parsed[i] = {
+ r: iScale.parse(resolveObjectKey(item, key), index)
+ };
+ }
+ return parsed;
+ }
+
+ const EPSILON = Number.EPSILON || 1e-14;
+ const getPoint = (points, i)=>i < points.length && !points[i].skip && points[i];
+ const getValueAxis = (indexAxis)=>indexAxis === 'x' ? 'y' : 'x';
+ function splineCurve(firstPoint, middlePoint, afterPoint, t) {
+ // Props to Rob Spencer at scaled innovation for his post on splining between points
+ // http://scaledinnovation.com/analytics/splines/aboutSplines.html
+ // This function must also respect "skipped" points
+ const previous = firstPoint.skip ? middlePoint : firstPoint;
+ const current = middlePoint;
+ const next = afterPoint.skip ? middlePoint : afterPoint;
+ const d01 = distanceBetweenPoints(current, previous);
+ const d12 = distanceBetweenPoints(next, current);
+ let s01 = d01 / (d01 + d12);
+ let s12 = d12 / (d01 + d12);
+ // If all points are the same, s01 & s02 will be inf
+ s01 = isNaN(s01) ? 0 : s01;
+ s12 = isNaN(s12) ? 0 : s12;
+ const fa = t * s01; // scaling factor for triangle Ta
+ const fb = t * s12;
+ return {
+ previous: {
+ x: current.x - fa * (next.x - previous.x),
+ y: current.y - fa * (next.y - previous.y)
+ },
+ next: {
+ x: current.x + fb * (next.x - previous.x),
+ y: current.y + fb * (next.y - previous.y)
+ }
+ };
+ }
+ /**
+ * Adjust tangents to ensure monotonic properties
+ */ function monotoneAdjust(points, deltaK, mK) {
+ const pointsLen = points.length;
+ let alphaK, betaK, tauK, squaredMagnitude, pointCurrent;
+ let pointAfter = getPoint(points, 0);
+ for(let i = 0; i < pointsLen - 1; ++i){
+ pointCurrent = pointAfter;
+ pointAfter = getPoint(points, i + 1);
+ if (!pointCurrent || !pointAfter) {
+ continue;
+ }
+ if (almostEquals(deltaK[i], 0, EPSILON)) {
+ mK[i] = mK[i + 1] = 0;
+ continue;
+ }
+ alphaK = mK[i] / deltaK[i];
+ betaK = mK[i + 1] / deltaK[i];
+ squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);
+ if (squaredMagnitude <= 9) {
+ continue;
+ }
+ tauK = 3 / Math.sqrt(squaredMagnitude);
+ mK[i] = alphaK * tauK * deltaK[i];
+ mK[i + 1] = betaK * tauK * deltaK[i];
+ }
+ }
+ function monotoneCompute(points, mK, indexAxis = 'x') {
+ const valueAxis = getValueAxis(indexAxis);
+ const pointsLen = points.length;
+ let delta, pointBefore, pointCurrent;
+ let pointAfter = getPoint(points, 0);
+ for(let i = 0; i < pointsLen; ++i){
+ pointBefore = pointCurrent;
+ pointCurrent = pointAfter;
+ pointAfter = getPoint(points, i + 1);
+ if (!pointCurrent) {
+ continue;
+ }
+ const iPixel = pointCurrent[indexAxis];
+ const vPixel = pointCurrent[valueAxis];
+ if (pointBefore) {
+ delta = (iPixel - pointBefore[indexAxis]) / 3;
+ pointCurrent[`cp1${indexAxis}`] = iPixel - delta;
+ pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i];
+ }
+ if (pointAfter) {
+ delta = (pointAfter[indexAxis] - iPixel) / 3;
+ pointCurrent[`cp2${indexAxis}`] = iPixel + delta;
+ pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i];
+ }
+ }
+ }
+ /**
+ * This function calculates Bézier control points in a similar way than |splineCurve|,
+ * but preserves monotonicity of the provided data and ensures no local extremums are added
+ * between the dataset discrete points due to the interpolation.
+ * See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation
+ */ function splineCurveMonotone(points, indexAxis = 'x') {
+ const valueAxis = getValueAxis(indexAxis);
+ const pointsLen = points.length;
+ const deltaK = Array(pointsLen).fill(0);
+ const mK = Array(pointsLen);
+ // Calculate slopes (deltaK) and initialize tangents (mK)
+ let i, pointBefore, pointCurrent;
+ let pointAfter = getPoint(points, 0);
+ for(i = 0; i < pointsLen; ++i){
+ pointBefore = pointCurrent;
+ pointCurrent = pointAfter;
+ pointAfter = getPoint(points, i + 1);
+ if (!pointCurrent) {
+ continue;
+ }
+ if (pointAfter) {
+ const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis];
+ // In the case of two points that appear at the same x pixel, slopeDeltaX is 0
+ deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0;
+ }
+ mK[i] = !pointBefore ? deltaK[i] : !pointAfter ? deltaK[i - 1] : sign(deltaK[i - 1]) !== sign(deltaK[i]) ? 0 : (deltaK[i - 1] + deltaK[i]) / 2;
+ }
+ monotoneAdjust(points, deltaK, mK);
+ monotoneCompute(points, mK, indexAxis);
+ }
+ function capControlPoint(pt, min, max) {
+ return Math.max(Math.min(pt, max), min);
+ }
+ function capBezierPoints(points, area) {
+ let i, ilen, point, inArea, inAreaPrev;
+ let inAreaNext = _isPointInArea(points[0], area);
+ for(i = 0, ilen = points.length; i < ilen; ++i){
+ inAreaPrev = inArea;
+ inArea = inAreaNext;
+ inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area);
+ if (!inArea) {
+ continue;
+ }
+ point = points[i];
+ if (inAreaPrev) {
+ point.cp1x = capControlPoint(point.cp1x, area.left, area.right);
+ point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom);
+ }
+ if (inAreaNext) {
+ point.cp2x = capControlPoint(point.cp2x, area.left, area.right);
+ point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom);
+ }
+ }
+ }
+ /**
+ * @private
+ */ function _updateBezierControlPoints(points, options, area, loop, indexAxis) {
+ let i, ilen, point, controlPoints;
+ // Only consider points that are drawn in case the spanGaps option is used
+ if (options.spanGaps) {
+ points = points.filter((pt)=>!pt.skip);
+ }
+ if (options.cubicInterpolationMode === 'monotone') {
+ splineCurveMonotone(points, indexAxis);
+ } else {
+ let prev = loop ? points[points.length - 1] : points[0];
+ for(i = 0, ilen = points.length; i < ilen; ++i){
+ point = points[i];
+ controlPoints = splineCurve(prev, point, points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen], options.tension);
+ point.cp1x = controlPoints.previous.x;
+ point.cp1y = controlPoints.previous.y;
+ point.cp2x = controlPoints.next.x;
+ point.cp2y = controlPoints.next.y;
+ prev = point;
+ }
+ }
+ if (options.capBezierPoints) {
+ capBezierPoints(points, area);
+ }
+ }
+
+ const atEdge = (t)=>t === 0 || t === 1;
+ const elasticIn = (t, s, p)=>-(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));
+ const elasticOut = (t, s, p)=>Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1;
+ /**
+ * Easing functions adapted from Robert Penner's easing equations.
+ * @namespace Chart.helpers.easing.effects
+ * @see http://www.robertpenner.com/easing/
+ */ const effects = {
+ linear: (t)=>t,
+ easeInQuad: (t)=>t * t,
+ easeOutQuad: (t)=>-t * (t - 2),
+ easeInOutQuad: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t : -0.5 * (--t * (t - 2) - 1),
+ easeInCubic: (t)=>t * t * t,
+ easeOutCubic: (t)=>(t -= 1) * t * t + 1,
+ easeInOutCubic: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t * t : 0.5 * ((t -= 2) * t * t + 2),
+ easeInQuart: (t)=>t * t * t * t,
+ easeOutQuart: (t)=>-((t -= 1) * t * t * t - 1),
+ easeInOutQuart: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t * t * t : -0.5 * ((t -= 2) * t * t * t - 2),
+ easeInQuint: (t)=>t * t * t * t * t,
+ easeOutQuint: (t)=>(t -= 1) * t * t * t * t + 1,
+ easeInOutQuint: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t * t * t * t : 0.5 * ((t -= 2) * t * t * t * t + 2),
+ easeInSine: (t)=>-Math.cos(t * HALF_PI) + 1,
+ easeOutSine: (t)=>Math.sin(t * HALF_PI),
+ easeInOutSine: (t)=>-0.5 * (Math.cos(PI * t) - 1),
+ easeInExpo: (t)=>t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),
+ easeOutExpo: (t)=>t === 1 ? 1 : -Math.pow(2, -10 * t) + 1,
+ easeInOutExpo: (t)=>atEdge(t) ? t : t < 0.5 ? 0.5 * Math.pow(2, 10 * (t * 2 - 1)) : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2),
+ easeInCirc: (t)=>t >= 1 ? t : -(Math.sqrt(1 - t * t) - 1),
+ easeOutCirc: (t)=>Math.sqrt(1 - (t -= 1) * t),
+ easeInOutCirc: (t)=>(t /= 0.5) < 1 ? -0.5 * (Math.sqrt(1 - t * t) - 1) : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1),
+ easeInElastic: (t)=>atEdge(t) ? t : elasticIn(t, 0.075, 0.3),
+ easeOutElastic: (t)=>atEdge(t) ? t : elasticOut(t, 0.075, 0.3),
+ easeInOutElastic (t) {
+ const s = 0.1125;
+ const p = 0.45;
+ return atEdge(t) ? t : t < 0.5 ? 0.5 * elasticIn(t * 2, s, p) : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p);
+ },
+ easeInBack (t) {
+ const s = 1.70158;
+ return t * t * ((s + 1) * t - s);
+ },
+ easeOutBack (t) {
+ const s = 1.70158;
+ return (t -= 1) * t * ((s + 1) * t + s) + 1;
+ },
+ easeInOutBack (t) {
+ let s = 1.70158;
+ if ((t /= 0.5) < 1) {
+ return 0.5 * (t * t * (((s *= 1.525) + 1) * t - s));
+ }
+ return 0.5 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2);
+ },
+ easeInBounce: (t)=>1 - effects.easeOutBounce(1 - t),
+ easeOutBounce (t) {
+ const m = 7.5625;
+ const d = 2.75;
+ if (t < 1 / d) {
+ return m * t * t;
+ }
+ if (t < 2 / d) {
+ return m * (t -= 1.5 / d) * t + 0.75;
+ }
+ if (t < 2.5 / d) {
+ return m * (t -= 2.25 / d) * t + 0.9375;
+ }
+ return m * (t -= 2.625 / d) * t + 0.984375;
+ },
+ easeInOutBounce: (t)=>t < 0.5 ? effects.easeInBounce(t * 2) * 0.5 : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5
+ };
+
+ /**
+ * @private
+ */ function _pointInLine(p1, p2, t, mode) {
+ return {
+ x: p1.x + t * (p2.x - p1.x),
+ y: p1.y + t * (p2.y - p1.y)
+ };
+ }
+ /**
+ * @private
+ */ function _steppedInterpolation(p1, p2, t, mode) {
+ return {
+ x: p1.x + t * (p2.x - p1.x),
+ y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y : mode === 'after' ? t < 1 ? p1.y : p2.y : t > 0 ? p2.y : p1.y
+ };
+ }
+ /**
+ * @private
+ */ function _bezierInterpolation(p1, p2, t, mode) {
+ const cp1 = {
+ x: p1.cp2x,
+ y: p1.cp2y
+ };
+ const cp2 = {
+ x: p2.cp1x,
+ y: p2.cp1y
+ };
+ const a = _pointInLine(p1, cp1, t);
+ const b = _pointInLine(cp1, cp2, t);
+ const c = _pointInLine(cp2, p2, t);
+ const d = _pointInLine(a, b, t);
+ const e = _pointInLine(b, c, t);
+ return _pointInLine(d, e, t);
+ }
+
+ const LINE_HEIGHT = /^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/;
+ const FONT_STYLE = /^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;
+ /**
+ * @alias Chart.helpers.options
+ * @namespace
+ */ /**
+ * Converts the given line height `value` in pixels for a specific font `size`.
+ * @param value - The lineHeight to parse (eg. 1.6, '14px', '75%', '1.6em').
+ * @param size - The font size (in pixels) used to resolve relative `value`.
+ * @returns The effective line height in pixels (size * 1.2 if value is invalid).
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-height
+ * @since 2.7.0
+ */ function toLineHeight(value, size) {
+ const matches = ('' + value).match(LINE_HEIGHT);
+ if (!matches || matches[1] === 'normal') {
+ return size * 1.2;
+ }
+ value = +matches[2];
+ switch(matches[3]){
+ case 'px':
+ return value;
+ case '%':
+ value /= 100;
+ break;
+ }
+ return size * value;
+ }
+ const numberOrZero = (v)=>+v || 0;
+ function _readValueToProps(value, props) {
+ const ret = {};
+ const objProps = isObject(props);
+ const keys = objProps ? Object.keys(props) : props;
+ const read = isObject(value) ? objProps ? (prop)=>valueOrDefault(value[prop], value[props[prop]]) : (prop)=>value[prop] : ()=>value;
+ for (const prop of keys){
+ ret[prop] = numberOrZero(read(prop));
+ }
+ return ret;
+ }
+ /**
+ * Converts the given value into a TRBL object.
+ * @param value - If a number, set the value to all TRBL component,
+ * else, if an object, use defined properties and sets undefined ones to 0.
+ * x / y are shorthands for same value for left/right and top/bottom.
+ * @returns The padding values (top, right, bottom, left)
+ * @since 3.0.0
+ */ function toTRBL(value) {
+ return _readValueToProps(value, {
+ top: 'y',
+ right: 'x',
+ bottom: 'y',
+ left: 'x'
+ });
+ }
+ /**
+ * Converts the given value into a TRBL corners object (similar with css border-radius).
+ * @param value - If a number, set the value to all TRBL corner components,
+ * else, if an object, use defined properties and sets undefined ones to 0.
+ * @returns The TRBL corner values (topLeft, topRight, bottomLeft, bottomRight)
+ * @since 3.0.0
+ */ function toTRBLCorners(value) {
+ return _readValueToProps(value, [
+ 'topLeft',
+ 'topRight',
+ 'bottomLeft',
+ 'bottomRight'
+ ]);
+ }
+ /**
+ * Converts the given value into a padding object with pre-computed width/height.
+ * @param value - If a number, set the value to all TRBL component,
+ * else, if an object, use defined properties and sets undefined ones to 0.
+ * x / y are shorthands for same value for left/right and top/bottom.
+ * @returns The padding values (top, right, bottom, left, width, height)
+ * @since 2.7.0
+ */ function toPadding(value) {
+ const obj = toTRBL(value);
+ obj.width = obj.left + obj.right;
+ obj.height = obj.top + obj.bottom;
+ return obj;
+ }
+ /**
+ * Parses font options and returns the font object.
+ * @param options - A object that contains font options to be parsed.
+ * @param fallback - A object that contains fallback font options.
+ * @return The font object.
+ * @private
+ */ function toFont(options, fallback) {
+ options = options || {};
+ fallback = fallback || defaults.font;
+ let size = valueOrDefault(options.size, fallback.size);
+ if (typeof size === 'string') {
+ size = parseInt(size, 10);
+ }
+ let style = valueOrDefault(options.style, fallback.style);
+ if (style && !('' + style).match(FONT_STYLE)) {
+ console.warn('Invalid font style specified: "' + style + '"');
+ style = undefined;
+ }
+ const font = {
+ family: valueOrDefault(options.family, fallback.family),
+ lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),
+ size,
+ style,
+ weight: valueOrDefault(options.weight, fallback.weight),
+ string: ''
+ };
+ font.string = toFontString(font);
+ return font;
+ }
+ /**
+ * Evaluates the given `inputs` sequentially and returns the first defined value.
+ * @param inputs - An array of values, falling back to the last value.
+ * @param context - If defined and the current value is a function, the value
+ * is called with `context` as first argument and the result becomes the new input.
+ * @param index - If defined and the current value is an array, the value
+ * at `index` become the new input.
+ * @param info - object to return information about resolution in
+ * @param info.cacheable - Will be set to `false` if option is not cacheable.
+ * @since 2.7.0
+ */ function resolve(inputs, context, index, info) {
+ let cacheable = true;
+ let i, ilen, value;
+ for(i = 0, ilen = inputs.length; i < ilen; ++i){
+ value = inputs[i];
+ if (value === undefined) {
+ continue;
+ }
+ if (context !== undefined && typeof value === 'function') {
+ value = value(context);
+ cacheable = false;
+ }
+ if (index !== undefined && isArray(value)) {
+ value = value[index % value.length];
+ cacheable = false;
+ }
+ if (value !== undefined) {
+ if (info && !cacheable) {
+ info.cacheable = false;
+ }
+ return value;
+ }
+ }
+ }
+ /**
+ * @param minmax
+ * @param grace
+ * @param beginAtZero
+ * @private
+ */ function _addGrace(minmax, grace, beginAtZero) {
+ const { min , max } = minmax;
+ const change = toDimension(grace, (max - min) / 2);
+ const keepZero = (value, add)=>beginAtZero && value === 0 ? 0 : value + add;
+ return {
+ min: keepZero(min, -Math.abs(change)),
+ max: keepZero(max, change)
+ };
+ }
+ function createContext(parentContext, context) {
+ return Object.assign(Object.create(parentContext), context);
+ }
+
+ const getRightToLeftAdapter = function(rectX, width) {
+ return {
+ x (x) {
+ return rectX + rectX + width - x;
+ },
+ setWidth (w) {
+ width = w;
+ },
+ textAlign (align) {
+ if (align === 'center') {
+ return align;
+ }
+ return align === 'right' ? 'left' : 'right';
+ },
+ xPlus (x, value) {
+ return x - value;
+ },
+ leftForLtr (x, itemWidth) {
+ return x - itemWidth;
+ }
+ };
+ };
+ const getLeftToRightAdapter = function() {
+ return {
+ x (x) {
+ return x;
+ },
+ setWidth (w) {},
+ textAlign (align) {
+ return align;
+ },
+ xPlus (x, value) {
+ return x + value;
+ },
+ leftForLtr (x, _itemWidth) {
+ return x;
+ }
+ };
+ };
+ function getRtlAdapter(rtl, rectX, width) {
+ return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();
+ }
+ function overrideTextDirection(ctx, direction) {
+ let style, original;
+ if (direction === 'ltr' || direction === 'rtl') {
+ style = ctx.canvas.style;
+ original = [
+ style.getPropertyValue('direction'),
+ style.getPropertyPriority('direction')
+ ];
+ style.setProperty('direction', direction, 'important');
+ ctx.prevTextDirection = original;
+ }
+ }
+ function restoreTextDirection(ctx, original) {
+ if (original !== undefined) {
+ delete ctx.prevTextDirection;
+ ctx.canvas.style.setProperty('direction', original[0], original[1]);
+ }
+ }
+
+ function propertyFn(property) {
+ if (property === 'angle') {
+ return {
+ between: _angleBetween,
+ compare: _angleDiff,
+ normalize: _normalizeAngle
+ };
+ }
+ return {
+ between: _isBetween,
+ compare: (a, b)=>a - b,
+ normalize: (x)=>x
+ };
+ }
+ function normalizeSegment({ start , end , count , loop , style }) {
+ return {
+ start: start % count,
+ end: end % count,
+ loop: loop && (end - start + 1) % count === 0,
+ style
+ };
+ }
+ function getSegment(segment, points, bounds) {
+ const { property , start: startBound , end: endBound } = bounds;
+ const { between , normalize } = propertyFn(property);
+ const count = points.length;
+ let { start , end , loop } = segment;
+ let i, ilen;
+ if (loop) {
+ start += count;
+ end += count;
+ for(i = 0, ilen = count; i < ilen; ++i){
+ if (!between(normalize(points[start % count][property]), startBound, endBound)) {
+ break;
+ }
+ start--;
+ end--;
+ }
+ start %= count;
+ end %= count;
+ }
+ if (end < start) {
+ end += count;
+ }
+ return {
+ start,
+ end,
+ loop,
+ style: segment.style
+ };
+ }
+ function _boundSegment(segment, points, bounds) {
+ if (!bounds) {
+ return [
+ segment
+ ];
+ }
+ const { property , start: startBound , end: endBound } = bounds;
+ const count = points.length;
+ const { compare , between , normalize } = propertyFn(property);
+ const { start , end , loop , style } = getSegment(segment, points, bounds);
+ const result = [];
+ let inside = false;
+ let subStart = null;
+ let value, point, prevValue;
+ const startIsBefore = ()=>between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0;
+ const endIsBefore = ()=>compare(endBound, value) === 0 || between(endBound, prevValue, value);
+ const shouldStart = ()=>inside || startIsBefore();
+ const shouldStop = ()=>!inside || endIsBefore();
+ for(let i = start, prev = start; i <= end; ++i){
+ point = points[i % count];
+ if (point.skip) {
+ continue;
+ }
+ value = normalize(point[property]);
+ if (value === prevValue) {
+ continue;
+ }
+ inside = between(value, startBound, endBound);
+ if (subStart === null && shouldStart()) {
+ subStart = compare(value, startBound) === 0 ? i : prev;
+ }
+ if (subStart !== null && shouldStop()) {
+ result.push(normalizeSegment({
+ start: subStart,
+ end: i,
+ loop,
+ count,
+ style
+ }));
+ subStart = null;
+ }
+ prev = i;
+ prevValue = value;
+ }
+ if (subStart !== null) {
+ result.push(normalizeSegment({
+ start: subStart,
+ end,
+ loop,
+ count,
+ style
+ }));
+ }
+ return result;
+ }
+ function _boundSegments(line, bounds) {
+ const result = [];
+ const segments = line.segments;
+ for(let i = 0; i < segments.length; i++){
+ const sub = _boundSegment(segments[i], line.points, bounds);
+ if (sub.length) {
+ result.push(...sub);
+ }
+ }
+ return result;
+ }
+ function findStartAndEnd(points, count, loop, spanGaps) {
+ let start = 0;
+ let end = count - 1;
+ if (loop && !spanGaps) {
+ while(start < count && !points[start].skip){
+ start++;
+ }
+ }
+ while(start < count && points[start].skip){
+ start++;
+ }
+ start %= count;
+ if (loop) {
+ end += start;
+ }
+ while(end > start && points[end % count].skip){
+ end--;
+ }
+ end %= count;
+ return {
+ start,
+ end
+ };
+ }
+ function solidSegments(points, start, max, loop) {
+ const count = points.length;
+ const result = [];
+ let last = start;
+ let prev = points[start];
+ let end;
+ for(end = start + 1; end <= max; ++end){
+ const cur = points[end % count];
+ if (cur.skip || cur.stop) {
+ if (!prev.skip) {
+ loop = false;
+ result.push({
+ start: start % count,
+ end: (end - 1) % count,
+ loop
+ });
+ start = last = cur.stop ? end : null;
+ }
+ } else {
+ last = end;
+ if (prev.skip) {
+ start = end;
+ }
+ }
+ prev = cur;
+ }
+ if (last !== null) {
+ result.push({
+ start: start % count,
+ end: last % count,
+ loop
+ });
+ }
+ return result;
+ }
+ function _computeSegments(line, segmentOptions) {
+ const points = line.points;
+ const spanGaps = line.options.spanGaps;
+ const count = points.length;
+ if (!count) {
+ return [];
+ }
+ const loop = !!line._loop;
+ const { start , end } = findStartAndEnd(points, count, loop, spanGaps);
+ if (spanGaps === true) {
+ return splitByStyles(line, [
+ {
+ start,
+ end,
+ loop
+ }
+ ], points, segmentOptions);
+ }
+ const max = end < start ? end + count : end;
+ const completeLoop = !!line._fullLoop && start === 0 && end === count - 1;
+ return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions);
+ }
+ function splitByStyles(line, segments, points, segmentOptions) {
+ if (!segmentOptions || !segmentOptions.setContext || !points) {
+ return segments;
+ }
+ return doSplitByStyles(line, segments, points, segmentOptions);
+ }
+ function doSplitByStyles(line, segments, points, segmentOptions) {
+ const chartContext = line._chart.getContext();
+ const baseStyle = readStyle(line.options);
+ const { _datasetIndex: datasetIndex , options: { spanGaps } } = line;
+ const count = points.length;
+ const result = [];
+ let prevStyle = baseStyle;
+ let start = segments[0].start;
+ let i = start;
+ function addStyle(s, e, l, st) {
+ const dir = spanGaps ? -1 : 1;
+ if (s === e) {
+ return;
+ }
+ s += count;
+ while(points[s % count].skip){
+ s -= dir;
+ }
+ while(points[e % count].skip){
+ e += dir;
+ }
+ if (s % count !== e % count) {
+ result.push({
+ start: s % count,
+ end: e % count,
+ loop: l,
+ style: st
+ });
+ prevStyle = st;
+ start = e % count;
+ }
+ }
+ for (const segment of segments){
+ start = spanGaps ? start : segment.start;
+ let prev = points[start % count];
+ let style;
+ for(i = start + 1; i <= segment.end; i++){
+ const pt = points[i % count];
+ style = readStyle(segmentOptions.setContext(createContext(chartContext, {
+ type: 'segment',
+ p0: prev,
+ p1: pt,
+ p0DataIndex: (i - 1) % count,
+ p1DataIndex: i % count,
+ datasetIndex
+ })));
+ if (styleChanged(style, prevStyle)) {
+ addStyle(start, i - 1, segment.loop, prevStyle);
+ }
+ prev = pt;
+ prevStyle = style;
+ }
+ if (start < i - 1) {
+ addStyle(start, i - 1, segment.loop, prevStyle);
+ }
+ }
+ return result;
+ }
+ function readStyle(options) {
+ return {
+ backgroundColor: options.backgroundColor,
+ borderCapStyle: options.borderCapStyle,
+ borderDash: options.borderDash,
+ borderDashOffset: options.borderDashOffset,
+ borderJoinStyle: options.borderJoinStyle,
+ borderWidth: options.borderWidth,
+ borderColor: options.borderColor
+ };
+ }
+ function styleChanged(style, prevStyle) {
+ if (!prevStyle) {
+ return false;
+ }
+ const cache = [];
+ const replacer = function(key, value) {
+ if (!isPatternOrGradient(value)) {
+ return value;
+ }
+ if (!cache.includes(value)) {
+ cache.push(value);
+ }
+ return cache.indexOf(value);
+ };
+ return JSON.stringify(style, replacer) !== JSON.stringify(prevStyle, replacer);
+ }
+
+ var helpers = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ HALF_PI: HALF_PI,
+ INFINITY: INFINITY,
+ PI: PI,
+ PITAU: PITAU,
+ QUARTER_PI: QUARTER_PI,
+ RAD_PER_DEG: RAD_PER_DEG,
+ TAU: TAU,
+ TWO_THIRDS_PI: TWO_THIRDS_PI,
+ _addGrace: _addGrace,
+ _alignPixel: _alignPixel,
+ _alignStartEnd: _alignStartEnd,
+ _angleBetween: _angleBetween,
+ _angleDiff: _angleDiff,
+ _arrayUnique: _arrayUnique,
+ _attachContext: _attachContext,
+ _bezierCurveTo: _bezierCurveTo,
+ _bezierInterpolation: _bezierInterpolation,
+ _boundSegment: _boundSegment,
+ _boundSegments: _boundSegments,
+ _capitalize: _capitalize,
+ _computeSegments: _computeSegments,
+ _createResolver: _createResolver,
+ _decimalPlaces: _decimalPlaces,
+ _deprecated: _deprecated,
+ _descriptors: _descriptors,
+ _elementsEqual: _elementsEqual,
+ _factorize: _factorize,
+ _filterBetween: _filterBetween,
+ _getParentNode: _getParentNode,
+ _getStartAndCountOfVisiblePoints: _getStartAndCountOfVisiblePoints,
+ _int16Range: _int16Range,
+ _isBetween: _isBetween,
+ _isClickEvent: _isClickEvent,
+ _isDomSupported: _isDomSupported,
+ _isPointInArea: _isPointInArea,
+ _limitValue: _limitValue,
+ _longestText: _longestText,
+ _lookup: _lookup,
+ _lookupByKey: _lookupByKey,
+ _measureText: _measureText,
+ _merger: _merger,
+ _mergerIf: _mergerIf,
+ _normalizeAngle: _normalizeAngle,
+ _parseObjectDataRadialScale: _parseObjectDataRadialScale,
+ _pointInLine: _pointInLine,
+ _readValueToProps: _readValueToProps,
+ _rlookupByKey: _rlookupByKey,
+ _scaleRangesChanged: _scaleRangesChanged,
+ _setMinAndMaxByKey: _setMinAndMaxByKey,
+ _splitKey: _splitKey,
+ _steppedInterpolation: _steppedInterpolation,
+ _steppedLineTo: _steppedLineTo,
+ _textX: _textX,
+ _toLeftRightCenter: _toLeftRightCenter,
+ _updateBezierControlPoints: _updateBezierControlPoints,
+ addRoundedRectPath: addRoundedRectPath,
+ almostEquals: almostEquals,
+ almostWhole: almostWhole,
+ callback: callback,
+ clearCanvas: clearCanvas,
+ clipArea: clipArea,
+ clone: clone$1,
+ color: color,
+ createContext: createContext,
+ debounce: debounce,
+ defined: defined,
+ distanceBetweenPoints: distanceBetweenPoints,
+ drawPoint: drawPoint,
+ drawPointLegend: drawPointLegend,
+ each: each,
+ easingEffects: effects,
+ finiteOrDefault: finiteOrDefault,
+ fontString: fontString,
+ formatNumber: formatNumber,
+ getAngleFromPoint: getAngleFromPoint,
+ getHoverColor: getHoverColor,
+ getMaximumSize: getMaximumSize,
+ getRelativePosition: getRelativePosition,
+ getRtlAdapter: getRtlAdapter,
+ getStyle: getStyle,
+ isArray: isArray,
+ isFinite: isNumberFinite,
+ isFunction: isFunction,
+ isNullOrUndef: isNullOrUndef,
+ isNumber: isNumber,
+ isObject: isObject,
+ isPatternOrGradient: isPatternOrGradient,
+ listenArrayEvents: listenArrayEvents,
+ log10: log10,
+ merge: merge,
+ mergeIf: mergeIf,
+ niceNum: niceNum,
+ noop: noop,
+ overrideTextDirection: overrideTextDirection,
+ readUsedSize: readUsedSize,
+ renderText: renderText,
+ requestAnimFrame: requestAnimFrame,
+ resolve: resolve,
+ resolveObjectKey: resolveObjectKey,
+ restoreTextDirection: restoreTextDirection,
+ retinaScale: retinaScale,
+ setsEqual: setsEqual,
+ sign: sign,
+ splineCurve: splineCurve,
+ splineCurveMonotone: splineCurveMonotone,
+ supportsEventListenerOptions: supportsEventListenerOptions,
+ throttled: throttled,
+ toDegrees: toDegrees,
+ toDimension: toDimension,
+ toFont: toFont,
+ toFontString: toFontString,
+ toLineHeight: toLineHeight,
+ toPadding: toPadding,
+ toPercentage: toPercentage,
+ toRadians: toRadians,
+ toTRBL: toTRBL,
+ toTRBLCorners: toTRBLCorners,
+ uid: uid,
+ unclipArea: unclipArea,
+ unlistenArrayEvents: unlistenArrayEvents,
+ valueOrDefault: valueOrDefault
+ });
+
+ function binarySearch(metaset, axis, value, intersect) {
+ const { controller , data , _sorted } = metaset;
+ const iScale = controller._cachedMeta.iScale;
+ if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) {
+ const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;
+ if (!intersect) {
+ return lookupMethod(data, axis, value);
+ } else if (controller._sharedOptions) {
+ const el = data[0];
+ const range = typeof el.getRange === 'function' && el.getRange(axis);
+ if (range) {
+ const start = lookupMethod(data, axis, value - range);
+ const end = lookupMethod(data, axis, value + range);
+ return {
+ lo: start.lo,
+ hi: end.hi
+ };
+ }
+ }
+ }
+ return {
+ lo: 0,
+ hi: data.length - 1
+ };
+ }
+ function evaluateInteractionItems(chart, axis, position, handler, intersect) {
+ const metasets = chart.getSortedVisibleDatasetMetas();
+ const value = position[axis];
+ for(let i = 0, ilen = metasets.length; i < ilen; ++i){
+ const { index , data } = metasets[i];
+ const { lo , hi } = binarySearch(metasets[i], axis, value, intersect);
+ for(let j = lo; j <= hi; ++j){
+ const element = data[j];
+ if (!element.skip) {
+ handler(element, index, j);
+ }
+ }
+ }
+ }
+ function getDistanceMetricForAxis(axis) {
+ const useX = axis.indexOf('x') !== -1;
+ const useY = axis.indexOf('y') !== -1;
+ return function(pt1, pt2) {
+ const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;
+ const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;
+ return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
+ };
+ }
+ function getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {
+ const items = [];
+ if (!includeInvisible && !chart.isPointInArea(position)) {
+ return items;
+ }
+ const evaluationFunc = function(element, datasetIndex, index) {
+ if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {
+ return;
+ }
+ if (element.inRange(position.x, position.y, useFinalPosition)) {
+ items.push({
+ element,
+ datasetIndex,
+ index
+ });
+ }
+ };
+ evaluateInteractionItems(chart, axis, position, evaluationFunc, true);
+ return items;
+ }
+ function getNearestRadialItems(chart, position, axis, useFinalPosition) {
+ let items = [];
+ function evaluationFunc(element, datasetIndex, index) {
+ const { startAngle , endAngle } = element.getProps([
+ 'startAngle',
+ 'endAngle'
+ ], useFinalPosition);
+ const { angle } = getAngleFromPoint(element, {
+ x: position.x,
+ y: position.y
+ });
+ if (_angleBetween(angle, startAngle, endAngle)) {
+ items.push({
+ element,
+ datasetIndex,
+ index
+ });
+ }
+ }
+ evaluateInteractionItems(chart, axis, position, evaluationFunc);
+ return items;
+ }
+ function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
+ let items = [];
+ const distanceMetric = getDistanceMetricForAxis(axis);
+ let minDistance = Number.POSITIVE_INFINITY;
+ function evaluationFunc(element, datasetIndex, index) {
+ const inRange = element.inRange(position.x, position.y, useFinalPosition);
+ if (intersect && !inRange) {
+ return;
+ }
+ const center = element.getCenterPoint(useFinalPosition);
+ const pointInArea = !!includeInvisible || chart.isPointInArea(center);
+ if (!pointInArea && !inRange) {
+ return;
+ }
+ const distance = distanceMetric(position, center);
+ if (distance < minDistance) {
+ items = [
+ {
+ element,
+ datasetIndex,
+ index
+ }
+ ];
+ minDistance = distance;
+ } else if (distance === minDistance) {
+ items.push({
+ element,
+ datasetIndex,
+ index
+ });
+ }
+ }
+ evaluateInteractionItems(chart, axis, position, evaluationFunc);
+ return items;
+ }
+ function getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
+ if (!includeInvisible && !chart.isPointInArea(position)) {
+ return [];
+ }
+ return axis === 'r' && !intersect ? getNearestRadialItems(chart, position, axis, useFinalPosition) : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);
+ }
+ function getAxisItems(chart, position, axis, intersect, useFinalPosition) {
+ const items = [];
+ const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange';
+ let intersectsItem = false;
+ evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index)=>{
+ if (element[rangeMethod](position[axis], useFinalPosition)) {
+ items.push({
+ element,
+ datasetIndex,
+ index
+ });
+ intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);
+ }
+ });
+ if (intersect && !intersectsItem) {
+ return [];
+ }
+ return items;
+ }
+ var Interaction = {
+ evaluateInteractionItems,
+ modes: {
+ index (chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'x';
+ const includeInvisible = options.includeInvisible || false;
+ const items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
+ const elements = [];
+ if (!items.length) {
+ return [];
+ }
+ chart.getSortedVisibleDatasetMetas().forEach((meta)=>{
+ const index = items[0].index;
+ const element = meta.data[index];
+ if (element && !element.skip) {
+ elements.push({
+ element,
+ datasetIndex: meta.index,
+ index
+ });
+ }
+ });
+ return elements;
+ },
+ dataset (chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'xy';
+ const includeInvisible = options.includeInvisible || false;
+ let items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
+ if (items.length > 0) {
+ const datasetIndex = items[0].datasetIndex;
+ const data = chart.getDatasetMeta(datasetIndex).data;
+ items = [];
+ for(let i = 0; i < data.length; ++i){
+ items.push({
+ element: data[i],
+ datasetIndex,
+ index: i
+ });
+ }
+ }
+ return items;
+ },
+ point (chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'xy';
+ const includeInvisible = options.includeInvisible || false;
+ return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);
+ },
+ nearest (chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'xy';
+ const includeInvisible = options.includeInvisible || false;
+ return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);
+ },
+ x (chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ return getAxisItems(chart, position, 'x', options.intersect, useFinalPosition);
+ },
+ y (chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ return getAxisItems(chart, position, 'y', options.intersect, useFinalPosition);
+ }
+ }
+ };
+
+ const STATIC_POSITIONS = [
+ 'left',
+ 'top',
+ 'right',
+ 'bottom'
+ ];
+ function filterByPosition(array, position) {
+ return array.filter((v)=>v.pos === position);
+ }
+ function filterDynamicPositionByAxis(array, axis) {
+ return array.filter((v)=>STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis);
+ }
+ function sortByWeight(array, reverse) {
+ return array.sort((a, b)=>{
+ const v0 = reverse ? b : a;
+ const v1 = reverse ? a : b;
+ return v0.weight === v1.weight ? v0.index - v1.index : v0.weight - v1.weight;
+ });
+ }
+ function wrapBoxes(boxes) {
+ const layoutBoxes = [];
+ let i, ilen, box, pos, stack, stackWeight;
+ for(i = 0, ilen = (boxes || []).length; i < ilen; ++i){
+ box = boxes[i];
+ ({ position: pos , options: { stack , stackWeight =1 } } = box);
+ layoutBoxes.push({
+ index: i,
+ box,
+ pos,
+ horizontal: box.isHorizontal(),
+ weight: box.weight,
+ stack: stack && pos + stack,
+ stackWeight
+ });
+ }
+ return layoutBoxes;
+ }
+ function buildStacks(layouts) {
+ const stacks = {};
+ for (const wrap of layouts){
+ const { stack , pos , stackWeight } = wrap;
+ if (!stack || !STATIC_POSITIONS.includes(pos)) {
+ continue;
+ }
+ const _stack = stacks[stack] || (stacks[stack] = {
+ count: 0,
+ placed: 0,
+ weight: 0,
+ size: 0
+ });
+ _stack.count++;
+ _stack.weight += stackWeight;
+ }
+ return stacks;
+ }
+ function setLayoutDims(layouts, params) {
+ const stacks = buildStacks(layouts);
+ const { vBoxMaxWidth , hBoxMaxHeight } = params;
+ let i, ilen, layout;
+ for(i = 0, ilen = layouts.length; i < ilen; ++i){
+ layout = layouts[i];
+ const { fullSize } = layout.box;
+ const stack = stacks[layout.stack];
+ const factor = stack && layout.stackWeight / stack.weight;
+ if (layout.horizontal) {
+ layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;
+ layout.height = hBoxMaxHeight;
+ } else {
+ layout.width = vBoxMaxWidth;
+ layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;
+ }
+ }
+ return stacks;
+ }
+ function buildLayoutBoxes(boxes) {
+ const layoutBoxes = wrapBoxes(boxes);
+ const fullSize = sortByWeight(layoutBoxes.filter((wrap)=>wrap.box.fullSize), true);
+ const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true);
+ const right = sortByWeight(filterByPosition(layoutBoxes, 'right'));
+ const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true);
+ const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom'));
+ const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x');
+ const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y');
+ return {
+ fullSize,
+ leftAndTop: left.concat(top),
+ rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),
+ chartArea: filterByPosition(layoutBoxes, 'chartArea'),
+ vertical: left.concat(right).concat(centerVertical),
+ horizontal: top.concat(bottom).concat(centerHorizontal)
+ };
+ }
+ function getCombinedMax(maxPadding, chartArea, a, b) {
+ return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]);
+ }
+ function updateMaxPadding(maxPadding, boxPadding) {
+ maxPadding.top = Math.max(maxPadding.top, boxPadding.top);
+ maxPadding.left = Math.max(maxPadding.left, boxPadding.left);
+ maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);
+ maxPadding.right = Math.max(maxPadding.right, boxPadding.right);
+ }
+ function updateDims(chartArea, params, layout, stacks) {
+ const { pos , box } = layout;
+ const maxPadding = chartArea.maxPadding;
+ if (!isObject(pos)) {
+ if (layout.size) {
+ chartArea[pos] -= layout.size;
+ }
+ const stack = stacks[layout.stack] || {
+ size: 0,
+ count: 1
+ };
+ stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);
+ layout.size = stack.size / stack.count;
+ chartArea[pos] += layout.size;
+ }
+ if (box.getPadding) {
+ updateMaxPadding(maxPadding, box.getPadding());
+ }
+ const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right'));
+ const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom'));
+ const widthChanged = newWidth !== chartArea.w;
+ const heightChanged = newHeight !== chartArea.h;
+ chartArea.w = newWidth;
+ chartArea.h = newHeight;
+ return layout.horizontal ? {
+ same: widthChanged,
+ other: heightChanged
+ } : {
+ same: heightChanged,
+ other: widthChanged
+ };
+ }
+ function handleMaxPadding(chartArea) {
+ const maxPadding = chartArea.maxPadding;
+ function updatePos(pos) {
+ const change = Math.max(maxPadding[pos] - chartArea[pos], 0);
+ chartArea[pos] += change;
+ return change;
+ }
+ chartArea.y += updatePos('top');
+ chartArea.x += updatePos('left');
+ updatePos('right');
+ updatePos('bottom');
+ }
+ function getMargins(horizontal, chartArea) {
+ const maxPadding = chartArea.maxPadding;
+ function marginForPositions(positions) {
+ const margin = {
+ left: 0,
+ top: 0,
+ right: 0,
+ bottom: 0
+ };
+ positions.forEach((pos)=>{
+ margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);
+ });
+ return margin;
+ }
+ return horizontal ? marginForPositions([
+ 'left',
+ 'right'
+ ]) : marginForPositions([
+ 'top',
+ 'bottom'
+ ]);
+ }
+ function fitBoxes(boxes, chartArea, params, stacks) {
+ const refitBoxes = [];
+ let i, ilen, layout, box, refit, changed;
+ for(i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i){
+ layout = boxes[i];
+ box = layout.box;
+ box.update(layout.width || chartArea.w, layout.height || chartArea.h, getMargins(layout.horizontal, chartArea));
+ const { same , other } = updateDims(chartArea, params, layout, stacks);
+ refit |= same && refitBoxes.length;
+ changed = changed || other;
+ if (!box.fullSize) {
+ refitBoxes.push(layout);
+ }
+ }
+ return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;
+ }
+ function setBoxDims(box, left, top, width, height) {
+ box.top = top;
+ box.left = left;
+ box.right = left + width;
+ box.bottom = top + height;
+ box.width = width;
+ box.height = height;
+ }
+ function placeBoxes(boxes, chartArea, params, stacks) {
+ const userPadding = params.padding;
+ let { x , y } = chartArea;
+ for (const layout of boxes){
+ const box = layout.box;
+ const stack = stacks[layout.stack] || {
+ count: 1,
+ placed: 0,
+ weight: 1
+ };
+ const weight = layout.stackWeight / stack.weight || 1;
+ if (layout.horizontal) {
+ const width = chartArea.w * weight;
+ const height = stack.size || box.height;
+ if (defined(stack.start)) {
+ y = stack.start;
+ }
+ if (box.fullSize) {
+ setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height);
+ } else {
+ setBoxDims(box, chartArea.left + stack.placed, y, width, height);
+ }
+ stack.start = y;
+ stack.placed += width;
+ y = box.bottom;
+ } else {
+ const height = chartArea.h * weight;
+ const width = stack.size || box.width;
+ if (defined(stack.start)) {
+ x = stack.start;
+ }
+ if (box.fullSize) {
+ setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);
+ } else {
+ setBoxDims(box, x, chartArea.top + stack.placed, width, height);
+ }
+ stack.start = x;
+ stack.placed += height;
+ x = box.right;
+ }
+ }
+ chartArea.x = x;
+ chartArea.y = y;
+ }
+ var layouts = {
+ addBox (chart, item) {
+ if (!chart.boxes) {
+ chart.boxes = [];
+ }
+ item.fullSize = item.fullSize || false;
+ item.position = item.position || 'top';
+ item.weight = item.weight || 0;
+ item._layers = item._layers || function() {
+ return [
+ {
+ z: 0,
+ draw (chartArea) {
+ item.draw(chartArea);
+ }
+ }
+ ];
+ };
+ chart.boxes.push(item);
+ },
+ removeBox (chart, layoutItem) {
+ const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;
+ if (index !== -1) {
+ chart.boxes.splice(index, 1);
+ }
+ },
+ configure (chart, item, options) {
+ item.fullSize = options.fullSize;
+ item.position = options.position;
+ item.weight = options.weight;
+ },
+ update (chart, width, height, minPadding) {
+ if (!chart) {
+ return;
+ }
+ const padding = toPadding(chart.options.layout.padding);
+ const availableWidth = Math.max(width - padding.width, 0);
+ const availableHeight = Math.max(height - padding.height, 0);
+ const boxes = buildLayoutBoxes(chart.boxes);
+ const verticalBoxes = boxes.vertical;
+ const horizontalBoxes = boxes.horizontal;
+ each(chart.boxes, (box)=>{
+ if (typeof box.beforeLayout === 'function') {
+ box.beforeLayout();
+ }
+ });
+ const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap)=>wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;
+ const params = Object.freeze({
+ outerWidth: width,
+ outerHeight: height,
+ padding,
+ availableWidth,
+ availableHeight,
+ vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,
+ hBoxMaxHeight: availableHeight / 2
+ });
+ const maxPadding = Object.assign({}, padding);
+ updateMaxPadding(maxPadding, toPadding(minPadding));
+ const chartArea = Object.assign({
+ maxPadding,
+ w: availableWidth,
+ h: availableHeight,
+ x: padding.left,
+ y: padding.top
+ }, padding);
+ const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);
+ fitBoxes(boxes.fullSize, chartArea, params, stacks);
+ fitBoxes(verticalBoxes, chartArea, params, stacks);
+ if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {
+ fitBoxes(verticalBoxes, chartArea, params, stacks);
+ }
+ handleMaxPadding(chartArea);
+ placeBoxes(boxes.leftAndTop, chartArea, params, stacks);
+ chartArea.x += chartArea.w;
+ chartArea.y += chartArea.h;
+ placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);
+ chart.chartArea = {
+ left: chartArea.left,
+ top: chartArea.top,
+ right: chartArea.left + chartArea.w,
+ bottom: chartArea.top + chartArea.h,
+ height: chartArea.h,
+ width: chartArea.w
+ };
+ each(boxes.chartArea, (layout)=>{
+ const box = layout.box;
+ Object.assign(box, chart.chartArea);
+ box.update(chartArea.w, chartArea.h, {
+ left: 0,
+ top: 0,
+ right: 0,
+ bottom: 0
+ });
+ });
+ }
+ };
+
+ class BasePlatform {
+ acquireContext(canvas, aspectRatio) {}
+ releaseContext(context) {
+ return false;
+ }
+ addEventListener(chart, type, listener) {}
+ removeEventListener(chart, type, listener) {}
+ getDevicePixelRatio() {
+ return 1;
+ }
+ getMaximumSize(element, width, height, aspectRatio) {
+ width = Math.max(0, width || element.width);
+ height = height || element.height;
+ return {
+ width,
+ height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)
+ };
+ }
+ isAttached(canvas) {
+ return true;
+ }
+ updateConfig(config) {
+ }
+ }
+
+ class BasicPlatform extends BasePlatform {
+ acquireContext(item) {
+ return item && item.getContext && item.getContext('2d') || null;
+ }
+ updateConfig(config) {
+ config.options.animation = false;
+ }
+ }
+
+ const EXPANDO_KEY = '$chartjs';
+ const EVENT_TYPES = {
+ touchstart: 'mousedown',
+ touchmove: 'mousemove',
+ touchend: 'mouseup',
+ pointerenter: 'mouseenter',
+ pointerdown: 'mousedown',
+ pointermove: 'mousemove',
+ pointerup: 'mouseup',
+ pointerleave: 'mouseout',
+ pointerout: 'mouseout'
+ };
+ const isNullOrEmpty = (value)=>value === null || value === '';
+ function initCanvas(canvas, aspectRatio) {
+ const style = canvas.style;
+ const renderHeight = canvas.getAttribute('height');
+ const renderWidth = canvas.getAttribute('width');
+ canvas[EXPANDO_KEY] = {
+ initial: {
+ height: renderHeight,
+ width: renderWidth,
+ style: {
+ display: style.display,
+ height: style.height,
+ width: style.width
+ }
+ }
+ };
+ style.display = style.display || 'block';
+ style.boxSizing = style.boxSizing || 'border-box';
+ if (isNullOrEmpty(renderWidth)) {
+ const displayWidth = readUsedSize(canvas, 'width');
+ if (displayWidth !== undefined) {
+ canvas.width = displayWidth;
+ }
+ }
+ if (isNullOrEmpty(renderHeight)) {
+ if (canvas.style.height === '') {
+ canvas.height = canvas.width / (aspectRatio || 2);
+ } else {
+ const displayHeight = readUsedSize(canvas, 'height');
+ if (displayHeight !== undefined) {
+ canvas.height = displayHeight;
+ }
+ }
+ }
+ return canvas;
+ }
+ const eventListenerOptions = supportsEventListenerOptions ? {
+ passive: true
+ } : false;
+ function addListener(node, type, listener) {
+ node.addEventListener(type, listener, eventListenerOptions);
+ }
+ function removeListener(chart, type, listener) {
+ chart.canvas.removeEventListener(type, listener, eventListenerOptions);
+ }
+ function fromNativeEvent(event, chart) {
+ const type = EVENT_TYPES[event.type] || event.type;
+ const { x , y } = getRelativePosition(event, chart);
+ return {
+ type,
+ chart,
+ native: event,
+ x: x !== undefined ? x : null,
+ y: y !== undefined ? y : null
+ };
+ }
+ function nodeListContains(nodeList, canvas) {
+ for (const node of nodeList){
+ if (node === canvas || node.contains(canvas)) {
+ return true;
+ }
+ }
+ }
+ function createAttachObserver(chart, type, listener) {
+ const canvas = chart.canvas;
+ const observer = new MutationObserver((entries)=>{
+ let trigger = false;
+ for (const entry of entries){
+ trigger = trigger || nodeListContains(entry.addedNodes, canvas);
+ trigger = trigger && !nodeListContains(entry.removedNodes, canvas);
+ }
+ if (trigger) {
+ listener();
+ }
+ });
+ observer.observe(document, {
+ childList: true,
+ subtree: true
+ });
+ return observer;
+ }
+ function createDetachObserver(chart, type, listener) {
+ const canvas = chart.canvas;
+ const observer = new MutationObserver((entries)=>{
+ let trigger = false;
+ for (const entry of entries){
+ trigger = trigger || nodeListContains(entry.removedNodes, canvas);
+ trigger = trigger && !nodeListContains(entry.addedNodes, canvas);
+ }
+ if (trigger) {
+ listener();
+ }
+ });
+ observer.observe(document, {
+ childList: true,
+ subtree: true
+ });
+ return observer;
+ }
+ const drpListeningCharts = new Map();
+ let oldDevicePixelRatio = 0;
+ function onWindowResize() {
+ const dpr = window.devicePixelRatio;
+ if (dpr === oldDevicePixelRatio) {
+ return;
+ }
+ oldDevicePixelRatio = dpr;
+ drpListeningCharts.forEach((resize, chart)=>{
+ if (chart.currentDevicePixelRatio !== dpr) {
+ resize();
+ }
+ });
+ }
+ function listenDevicePixelRatioChanges(chart, resize) {
+ if (!drpListeningCharts.size) {
+ window.addEventListener('resize', onWindowResize);
+ }
+ drpListeningCharts.set(chart, resize);
+ }
+ function unlistenDevicePixelRatioChanges(chart) {
+ drpListeningCharts.delete(chart);
+ if (!drpListeningCharts.size) {
+ window.removeEventListener('resize', onWindowResize);
+ }
+ }
+ function createResizeObserver(chart, type, listener) {
+ const canvas = chart.canvas;
+ const container = canvas && _getParentNode(canvas);
+ if (!container) {
+ return;
+ }
+ const resize = throttled((width, height)=>{
+ const w = container.clientWidth;
+ listener(width, height);
+ if (w < container.clientWidth) {
+ listener();
+ }
+ }, window);
+ const observer = new ResizeObserver((entries)=>{
+ const entry = entries[0];
+ const width = entry.contentRect.width;
+ const height = entry.contentRect.height;
+ if (width === 0 && height === 0) {
+ return;
+ }
+ resize(width, height);
+ });
+ observer.observe(container);
+ listenDevicePixelRatioChanges(chart, resize);
+ return observer;
+ }
+ function releaseObserver(chart, type, observer) {
+ if (observer) {
+ observer.disconnect();
+ }
+ if (type === 'resize') {
+ unlistenDevicePixelRatioChanges(chart);
+ }
+ }
+ function createProxyAndListen(chart, type, listener) {
+ const canvas = chart.canvas;
+ const proxy = throttled((event)=>{
+ if (chart.ctx !== null) {
+ listener(fromNativeEvent(event, chart));
+ }
+ }, chart);
+ addListener(canvas, type, proxy);
+ return proxy;
+ }
+ class DomPlatform extends BasePlatform {
+ acquireContext(canvas, aspectRatio) {
+ const context = canvas && canvas.getContext && canvas.getContext('2d');
+ if (context && context.canvas === canvas) {
+ initCanvas(canvas, aspectRatio);
+ return context;
+ }
+ return null;
+ }
+ releaseContext(context) {
+ const canvas = context.canvas;
+ if (!canvas[EXPANDO_KEY]) {
+ return false;
+ }
+ const initial = canvas[EXPANDO_KEY].initial;
+ [
+ 'height',
+ 'width'
+ ].forEach((prop)=>{
+ const value = initial[prop];
+ if (isNullOrUndef(value)) {
+ canvas.removeAttribute(prop);
+ } else {
+ canvas.setAttribute(prop, value);
+ }
+ });
+ const style = initial.style || {};
+ Object.keys(style).forEach((key)=>{
+ canvas.style[key] = style[key];
+ });
+ canvas.width = canvas.width;
+ delete canvas[EXPANDO_KEY];
+ return true;
+ }
+ addEventListener(chart, type, listener) {
+ this.removeEventListener(chart, type);
+ const proxies = chart.$proxies || (chart.$proxies = {});
+ const handlers = {
+ attach: createAttachObserver,
+ detach: createDetachObserver,
+ resize: createResizeObserver
+ };
+ const handler = handlers[type] || createProxyAndListen;
+ proxies[type] = handler(chart, type, listener);
+ }
+ removeEventListener(chart, type) {
+ const proxies = chart.$proxies || (chart.$proxies = {});
+ const proxy = proxies[type];
+ if (!proxy) {
+ return;
+ }
+ const handlers = {
+ attach: releaseObserver,
+ detach: releaseObserver,
+ resize: releaseObserver
+ };
+ const handler = handlers[type] || removeListener;
+ handler(chart, type, proxy);
+ proxies[type] = undefined;
+ }
+ getDevicePixelRatio() {
+ return window.devicePixelRatio;
+ }
+ getMaximumSize(canvas, width, height, aspectRatio) {
+ return getMaximumSize(canvas, width, height, aspectRatio);
+ }
+ isAttached(canvas) {
+ const container = _getParentNode(canvas);
+ return !!(container && container.isConnected);
+ }
+ }
+
+ function _detectPlatform(canvas) {
+ if (!_isDomSupported() || typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas) {
+ return BasicPlatform;
+ }
+ return DomPlatform;
+ }
+
+ var platforms = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ BasePlatform: BasePlatform,
+ BasicPlatform: BasicPlatform,
+ DomPlatform: DomPlatform,
+ _detectPlatform: _detectPlatform
+ });
+
+ const transparent = 'transparent';
+ const interpolators = {
+ boolean (from, to, factor) {
+ return factor > 0.5 ? to : from;
+ },
+ color (from, to, factor) {
+ const c0 = color(from || transparent);
+ const c1 = c0.valid && color(to || transparent);
+ return c1 && c1.valid ? c1.mix(c0, factor).hexString() : to;
+ },
+ number (from, to, factor) {
+ return from + (to - from) * factor;
+ }
+ };
+ class Animation {
+ constructor(cfg, target, prop, to){
+ const currentValue = target[prop];
+ to = resolve([
+ cfg.to,
+ to,
+ currentValue,
+ cfg.from
+ ]);
+ const from = resolve([
+ cfg.from,
+ currentValue,
+ to
+ ]);
+ this._active = true;
+ this._fn = cfg.fn || interpolators[cfg.type || typeof from];
+ this._easing = effects[cfg.easing] || effects.linear;
+ this._start = Math.floor(Date.now() + (cfg.delay || 0));
+ this._duration = this._total = Math.floor(cfg.duration);
+ this._loop = !!cfg.loop;
+ this._target = target;
+ this._prop = prop;
+ this._from = from;
+ this._to = to;
+ this._promises = undefined;
+ }
+ active() {
+ return this._active;
+ }
+ update(cfg, to, date) {
+ if (this._active) {
+ this._notify(false);
+ const currentValue = this._target[this._prop];
+ const elapsed = date - this._start;
+ const remain = this._duration - elapsed;
+ this._start = date;
+ this._duration = Math.floor(Math.max(remain, cfg.duration));
+ this._total += elapsed;
+ this._loop = !!cfg.loop;
+ this._to = resolve([
+ cfg.to,
+ to,
+ currentValue,
+ cfg.from
+ ]);
+ this._from = resolve([
+ cfg.from,
+ currentValue,
+ to
+ ]);
+ }
+ }
+ cancel() {
+ if (this._active) {
+ this.tick(Date.now());
+ this._active = false;
+ this._notify(false);
+ }
+ }
+ tick(date) {
+ const elapsed = date - this._start;
+ const duration = this._duration;
+ const prop = this._prop;
+ const from = this._from;
+ const loop = this._loop;
+ const to = this._to;
+ let factor;
+ this._active = from !== to && (loop || elapsed < duration);
+ if (!this._active) {
+ this._target[prop] = to;
+ this._notify(true);
+ return;
+ }
+ if (elapsed < 0) {
+ this._target[prop] = from;
+ return;
+ }
+ factor = elapsed / duration % 2;
+ factor = loop && factor > 1 ? 2 - factor : factor;
+ factor = this._easing(Math.min(1, Math.max(0, factor)));
+ this._target[prop] = this._fn(from, to, factor);
+ }
+ wait() {
+ const promises = this._promises || (this._promises = []);
+ return new Promise((res, rej)=>{
+ promises.push({
+ res,
+ rej
+ });
+ });
+ }
+ _notify(resolved) {
+ const method = resolved ? 'res' : 'rej';
+ const promises = this._promises || [];
+ for(let i = 0; i < promises.length; i++){
+ promises[i][method]();
+ }
+ }
+ }
+
+ class Animations {
+ constructor(chart, config){
+ this._chart = chart;
+ this._properties = new Map();
+ this.configure(config);
+ }
+ configure(config) {
+ if (!isObject(config)) {
+ return;
+ }
+ const animationOptions = Object.keys(defaults.animation);
+ const animatedProps = this._properties;
+ Object.getOwnPropertyNames(config).forEach((key)=>{
+ const cfg = config[key];
+ if (!isObject(cfg)) {
+ return;
+ }
+ const resolved = {};
+ for (const option of animationOptions){
+ resolved[option] = cfg[option];
+ }
+ (isArray(cfg.properties) && cfg.properties || [
+ key
+ ]).forEach((prop)=>{
+ if (prop === key || !animatedProps.has(prop)) {
+ animatedProps.set(prop, resolved);
+ }
+ });
+ });
+ }
+ _animateOptions(target, values) {
+ const newOptions = values.options;
+ const options = resolveTargetOptions(target, newOptions);
+ if (!options) {
+ return [];
+ }
+ const animations = this._createAnimations(options, newOptions);
+ if (newOptions.$shared) {
+ awaitAll(target.options.$animations, newOptions).then(()=>{
+ target.options = newOptions;
+ }, ()=>{
+ });
+ }
+ return animations;
+ }
+ _createAnimations(target, values) {
+ const animatedProps = this._properties;
+ const animations = [];
+ const running = target.$animations || (target.$animations = {});
+ const props = Object.keys(values);
+ const date = Date.now();
+ let i;
+ for(i = props.length - 1; i >= 0; --i){
+ const prop = props[i];
+ if (prop.charAt(0) === '$') {
+ continue;
+ }
+ if (prop === 'options') {
+ animations.push(...this._animateOptions(target, values));
+ continue;
+ }
+ const value = values[prop];
+ let animation = running[prop];
+ const cfg = animatedProps.get(prop);
+ if (animation) {
+ if (cfg && animation.active()) {
+ animation.update(cfg, value, date);
+ continue;
+ } else {
+ animation.cancel();
+ }
+ }
+ if (!cfg || !cfg.duration) {
+ target[prop] = value;
+ continue;
+ }
+ running[prop] = animation = new Animation(cfg, target, prop, value);
+ animations.push(animation);
+ }
+ return animations;
+ }
+ update(target, values) {
+ if (this._properties.size === 0) {
+ Object.assign(target, values);
+ return;
+ }
+ const animations = this._createAnimations(target, values);
+ if (animations.length) {
+ animator.add(this._chart, animations);
+ return true;
+ }
+ }
+ }
+ function awaitAll(animations, properties) {
+ const running = [];
+ const keys = Object.keys(properties);
+ for(let i = 0; i < keys.length; i++){
+ const anim = animations[keys[i]];
+ if (anim && anim.active()) {
+ running.push(anim.wait());
+ }
+ }
+ return Promise.all(running);
+ }
+ function resolveTargetOptions(target, newOptions) {
+ if (!newOptions) {
+ return;
+ }
+ let options = target.options;
+ if (!options) {
+ target.options = newOptions;
+ return;
+ }
+ if (options.$shared) {
+ target.options = options = Object.assign({}, options, {
+ $shared: false,
+ $animations: {}
+ });
+ }
+ return options;
+ }
+
+ function scaleClip(scale, allowedOverflow) {
+ const opts = scale && scale.options || {};
+ const reverse = opts.reverse;
+ const min = opts.min === undefined ? allowedOverflow : 0;
+ const max = opts.max === undefined ? allowedOverflow : 0;
+ return {
+ start: reverse ? max : min,
+ end: reverse ? min : max
+ };
+ }
+ function defaultClip(xScale, yScale, allowedOverflow) {
+ if (allowedOverflow === false) {
+ return false;
+ }
+ const x = scaleClip(xScale, allowedOverflow);
+ const y = scaleClip(yScale, allowedOverflow);
+ return {
+ top: y.end,
+ right: x.end,
+ bottom: y.start,
+ left: x.start
+ };
+ }
+ function toClip(value) {
+ let t, r, b, l;
+ if (isObject(value)) {
+ t = value.top;
+ r = value.right;
+ b = value.bottom;
+ l = value.left;
+ } else {
+ t = r = b = l = value;
+ }
+ return {
+ top: t,
+ right: r,
+ bottom: b,
+ left: l,
+ disabled: value === false
+ };
+ }
+ function getSortedDatasetIndices(chart, filterVisible) {
+ const keys = [];
+ const metasets = chart._getSortedDatasetMetas(filterVisible);
+ let i, ilen;
+ for(i = 0, ilen = metasets.length; i < ilen; ++i){
+ keys.push(metasets[i].index);
+ }
+ return keys;
+ }
+ function applyStack(stack, value, dsIndex, options = {}) {
+ const keys = stack.keys;
+ const singleMode = options.mode === 'single';
+ let i, ilen, datasetIndex, otherValue;
+ if (value === null) {
+ return;
+ }
+ for(i = 0, ilen = keys.length; i < ilen; ++i){
+ datasetIndex = +keys[i];
+ if (datasetIndex === dsIndex) {
+ if (options.all) {
+ continue;
+ }
+ break;
+ }
+ otherValue = stack.values[datasetIndex];
+ if (isNumberFinite(otherValue) && (singleMode || value === 0 || sign(value) === sign(otherValue))) {
+ value += otherValue;
+ }
+ }
+ return value;
+ }
+ function convertObjectDataToArray(data) {
+ const keys = Object.keys(data);
+ const adata = new Array(keys.length);
+ let i, ilen, key;
+ for(i = 0, ilen = keys.length; i < ilen; ++i){
+ key = keys[i];
+ adata[i] = {
+ x: key,
+ y: data[key]
+ };
+ }
+ return adata;
+ }
+ function isStacked(scale, meta) {
+ const stacked = scale && scale.options.stacked;
+ return stacked || stacked === undefined && meta.stack !== undefined;
+ }
+ function getStackKey(indexScale, valueScale, meta) {
+ return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;
+ }
+ function getUserBounds(scale) {
+ const { min , max , minDefined , maxDefined } = scale.getUserBounds();
+ return {
+ min: minDefined ? min : Number.NEGATIVE_INFINITY,
+ max: maxDefined ? max : Number.POSITIVE_INFINITY
+ };
+ }
+ function getOrCreateStack(stacks, stackKey, indexValue) {
+ const subStack = stacks[stackKey] || (stacks[stackKey] = {});
+ return subStack[indexValue] || (subStack[indexValue] = {});
+ }
+ function getLastIndexInStack(stack, vScale, positive, type) {
+ for (const meta of vScale.getMatchingVisibleMetas(type).reverse()){
+ const value = stack[meta.index];
+ if (positive && value > 0 || !positive && value < 0) {
+ return meta.index;
+ }
+ }
+ return null;
+ }
+ function updateStacks(controller, parsed) {
+ const { chart , _cachedMeta: meta } = controller;
+ const stacks = chart._stacks || (chart._stacks = {});
+ const { iScale , vScale , index: datasetIndex } = meta;
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ const key = getStackKey(iScale, vScale, meta);
+ const ilen = parsed.length;
+ let stack;
+ for(let i = 0; i < ilen; ++i){
+ const item = parsed[i];
+ const { [iAxis]: index , [vAxis]: value } = item;
+ const itemStacks = item._stacks || (item._stacks = {});
+ stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);
+ stack[datasetIndex] = value;
+ stack._top = getLastIndexInStack(stack, vScale, true, meta.type);
+ stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);
+ const visualValues = stack._visualValues || (stack._visualValues = {});
+ visualValues[datasetIndex] = value;
+ }
+ }
+ function getFirstScaleId(chart, axis) {
+ const scales = chart.scales;
+ return Object.keys(scales).filter((key)=>scales[key].axis === axis).shift();
+ }
+ function createDatasetContext(parent, index) {
+ return createContext(parent, {
+ active: false,
+ dataset: undefined,
+ datasetIndex: index,
+ index,
+ mode: 'default',
+ type: 'dataset'
+ });
+ }
+ function createDataContext(parent, index, element) {
+ return createContext(parent, {
+ active: false,
+ dataIndex: index,
+ parsed: undefined,
+ raw: undefined,
+ element,
+ index,
+ mode: 'default',
+ type: 'data'
+ });
+ }
+ function clearStacks(meta, items) {
+ const datasetIndex = meta.controller.index;
+ const axis = meta.vScale && meta.vScale.axis;
+ if (!axis) {
+ return;
+ }
+ items = items || meta._parsed;
+ for (const parsed of items){
+ const stacks = parsed._stacks;
+ if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) {
+ return;
+ }
+ delete stacks[axis][datasetIndex];
+ if (stacks[axis]._visualValues !== undefined && stacks[axis]._visualValues[datasetIndex] !== undefined) {
+ delete stacks[axis]._visualValues[datasetIndex];
+ }
+ }
+ }
+ const isDirectUpdateMode = (mode)=>mode === 'reset' || mode === 'none';
+ const cloneIfNotShared = (cached, shared)=>shared ? cached : Object.assign({}, cached);
+ const createStack = (canStack, meta, chart)=>canStack && !meta.hidden && meta._stacked && {
+ keys: getSortedDatasetIndices(chart, true),
+ values: null
+ };
+ class DatasetController {
+ static defaults = {};
+ static datasetElementType = null;
+ static dataElementType = null;
+ constructor(chart, datasetIndex){
+ this.chart = chart;
+ this._ctx = chart.ctx;
+ this.index = datasetIndex;
+ this._cachedDataOpts = {};
+ this._cachedMeta = this.getMeta();
+ this._type = this._cachedMeta.type;
+ this.options = undefined;
+ this._parsing = false;
+ this._data = undefined;
+ this._objectData = undefined;
+ this._sharedOptions = undefined;
+ this._drawStart = undefined;
+ this._drawCount = undefined;
+ this.enableOptionSharing = false;
+ this.supportsDecimation = false;
+ this.$context = undefined;
+ this._syncList = [];
+ this.datasetElementType = new.target.datasetElementType;
+ this.dataElementType = new.target.dataElementType;
+ this.initialize();
+ }
+ initialize() {
+ const meta = this._cachedMeta;
+ this.configure();
+ this.linkScales();
+ meta._stacked = isStacked(meta.vScale, meta);
+ this.addElements();
+ if (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(datasetIndex) {
+ if (this.index !== datasetIndex) {
+ clearStacks(this._cachedMeta);
+ }
+ this.index = datasetIndex;
+ }
+ linkScales() {
+ const chart = this.chart;
+ const meta = this._cachedMeta;
+ const dataset = this.getDataset();
+ const chooseId = (axis, x, y, r)=>axis === 'x' ? x : axis === 'r' ? r : y;
+ const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x'));
+ const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y'));
+ const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r'));
+ const indexAxis = meta.indexAxis;
+ const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);
+ const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);
+ meta.xScale = this.getScaleForId(xid);
+ meta.yScale = this.getScaleForId(yid);
+ meta.rScale = this.getScaleForId(rid);
+ meta.iScale = this.getScaleForId(iid);
+ meta.vScale = this.getScaleForId(vid);
+ }
+ getDataset() {
+ return this.chart.data.datasets[this.index];
+ }
+ getMeta() {
+ return this.chart.getDatasetMeta(this.index);
+ }
+ getScaleForId(scaleID) {
+ return this.chart.scales[scaleID];
+ }
+ _getOtherScale(scale) {
+ const meta = this._cachedMeta;
+ return scale === meta.iScale ? meta.vScale : meta.iScale;
+ }
+ reset() {
+ this._update('reset');
+ }
+ _destroy() {
+ const meta = this._cachedMeta;
+ if (this._data) {
+ unlistenArrayEvents(this._data, this);
+ }
+ if (meta._stacked) {
+ clearStacks(meta);
+ }
+ }
+ _dataCheck() {
+ const dataset = this.getDataset();
+ const data = dataset.data || (dataset.data = []);
+ const _data = this._data;
+ if (isObject(data)) {
+ this._data = convertObjectDataToArray(data);
+ } else if (_data !== data) {
+ if (_data) {
+ unlistenArrayEvents(_data, this);
+ const meta = this._cachedMeta;
+ clearStacks(meta);
+ meta._parsed = [];
+ }
+ if (data && Object.isExtensible(data)) {
+ listenArrayEvents(data, this);
+ }
+ this._syncList = [];
+ this._data = data;
+ }
+ }
+ addElements() {
+ const meta = this._cachedMeta;
+ this._dataCheck();
+ if (this.datasetElementType) {
+ meta.dataset = new this.datasetElementType();
+ }
+ }
+ buildOrUpdateElements(resetNewElements) {
+ const meta = this._cachedMeta;
+ const dataset = this.getDataset();
+ let stackChanged = false;
+ this._dataCheck();
+ const oldStacked = meta._stacked;
+ meta._stacked = isStacked(meta.vScale, meta);
+ if (meta.stack !== dataset.stack) {
+ stackChanged = true;
+ clearStacks(meta);
+ meta.stack = dataset.stack;
+ }
+ this._resyncElements(resetNewElements);
+ if (stackChanged || oldStacked !== meta._stacked) {
+ updateStacks(this, meta._parsed);
+ }
+ }
+ configure() {
+ const config = this.chart.config;
+ const scopeKeys = config.datasetScopeKeys(this._type);
+ const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);
+ this.options = config.createResolver(scopes, this.getContext());
+ this._parsing = this.options.parsing;
+ this._cachedDataOpts = {};
+ }
+ parse(start, count) {
+ const { _cachedMeta: meta , _data: data } = this;
+ const { iScale , _stacked } = meta;
+ const iAxis = iScale.axis;
+ let sorted = start === 0 && count === data.length ? true : meta._sorted;
+ let prev = start > 0 && meta._parsed[start - 1];
+ let i, cur, parsed;
+ if (this._parsing === false) {
+ meta._parsed = data;
+ meta._sorted = true;
+ parsed = data;
+ } else {
+ if (isArray(data[start])) {
+ parsed = this.parseArrayData(meta, data, start, count);
+ } else if (isObject(data[start])) {
+ parsed = this.parseObjectData(meta, data, start, count);
+ } else {
+ parsed = this.parsePrimitiveData(meta, data, start, count);
+ }
+ const isNotInOrderComparedToPrev = ()=>cur[iAxis] === null || prev && cur[iAxis] < prev[iAxis];
+ for(i = 0; i < count; ++i){
+ meta._parsed[i + start] = cur = parsed[i];
+ if (sorted) {
+ if (isNotInOrderComparedToPrev()) {
+ sorted = false;
+ }
+ prev = cur;
+ }
+ }
+ meta._sorted = sorted;
+ }
+ if (_stacked) {
+ updateStacks(this, parsed);
+ }
+ }
+ parsePrimitiveData(meta, data, start, count) {
+ const { iScale , vScale } = meta;
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ const labels = iScale.getLabels();
+ const singleScale = iScale === vScale;
+ const parsed = new Array(count);
+ let i, ilen, index;
+ for(i = 0, ilen = count; i < ilen; ++i){
+ index = i + start;
+ parsed[i] = {
+ [iAxis]: singleScale || iScale.parse(labels[index], index),
+ [vAxis]: vScale.parse(data[index], index)
+ };
+ }
+ return parsed;
+ }
+ parseArrayData(meta, data, start, count) {
+ const { xScale , yScale } = meta;
+ const parsed = new Array(count);
+ let i, ilen, index, item;
+ for(i = 0, ilen = count; i < ilen; ++i){
+ index = i + start;
+ item = data[index];
+ parsed[i] = {
+ x: xScale.parse(item[0], index),
+ y: yScale.parse(item[1], index)
+ };
+ }
+ return parsed;
+ }
+ parseObjectData(meta, data, start, count) {
+ const { xScale , yScale } = meta;
+ const { xAxisKey ='x' , yAxisKey ='y' } = this._parsing;
+ const parsed = new Array(count);
+ let i, ilen, index, item;
+ for(i = 0, ilen = count; i < ilen; ++i){
+ index = i + start;
+ item = data[index];
+ parsed[i] = {
+ x: xScale.parse(resolveObjectKey(item, xAxisKey), index),
+ y: yScale.parse(resolveObjectKey(item, yAxisKey), index)
+ };
+ }
+ return parsed;
+ }
+ getParsed(index) {
+ return this._cachedMeta._parsed[index];
+ }
+ getDataElement(index) {
+ return this._cachedMeta.data[index];
+ }
+ applyStack(scale, parsed, mode) {
+ const chart = this.chart;
+ const meta = this._cachedMeta;
+ const value = parsed[scale.axis];
+ const stack = {
+ keys: getSortedDatasetIndices(chart, true),
+ values: parsed._stacks[scale.axis]._visualValues
+ };
+ return applyStack(stack, value, meta.index, {
+ mode
+ });
+ }
+ updateRangeFromParsed(range, scale, parsed, stack) {
+ const parsedValue = parsed[scale.axis];
+ let value = parsedValue === null ? NaN : parsedValue;
+ const values = stack && parsed._stacks[scale.axis];
+ if (stack && values) {
+ stack.values = values;
+ value = applyStack(stack, parsedValue, this._cachedMeta.index);
+ }
+ range.min = Math.min(range.min, value);
+ range.max = Math.max(range.max, value);
+ }
+ getMinMax(scale, canStack) {
+ const meta = this._cachedMeta;
+ const _parsed = meta._parsed;
+ const sorted = meta._sorted && scale === meta.iScale;
+ const ilen = _parsed.length;
+ const otherScale = this._getOtherScale(scale);
+ const stack = createStack(canStack, meta, this.chart);
+ const range = {
+ min: Number.POSITIVE_INFINITY,
+ max: Number.NEGATIVE_INFINITY
+ };
+ const { min: otherMin , max: otherMax } = getUserBounds(otherScale);
+ let i, parsed;
+ function _skip() {
+ parsed = _parsed[i];
+ const otherValue = parsed[otherScale.axis];
+ return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;
+ }
+ for(i = 0; i < ilen; ++i){
+ if (_skip()) {
+ continue;
+ }
+ this.updateRangeFromParsed(range, scale, parsed, stack);
+ if (sorted) {
+ break;
+ }
+ }
+ if (sorted) {
+ for(i = ilen - 1; i >= 0; --i){
+ if (_skip()) {
+ continue;
+ }
+ this.updateRangeFromParsed(range, scale, parsed, stack);
+ break;
+ }
+ }
+ return range;
+ }
+ getAllParsedValues(scale) {
+ const parsed = this._cachedMeta._parsed;
+ const values = [];
+ let i, ilen, value;
+ for(i = 0, ilen = parsed.length; i < ilen; ++i){
+ value = parsed[i][scale.axis];
+ if (isNumberFinite(value)) {
+ values.push(value);
+ }
+ }
+ return values;
+ }
+ getMaxOverflow() {
+ return false;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const iScale = meta.iScale;
+ const vScale = meta.vScale;
+ const parsed = this.getParsed(index);
+ return {
+ label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '',
+ value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : ''
+ };
+ }
+ _update(mode) {
+ const meta = this._cachedMeta;
+ this.update(mode || 'default');
+ meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));
+ }
+ update(mode) {}
+ draw() {
+ const ctx = this._ctx;
+ const chart = this.chart;
+ const meta = this._cachedMeta;
+ const elements = meta.data || [];
+ const area = chart.chartArea;
+ const active = [];
+ const start = this._drawStart || 0;
+ const count = this._drawCount || elements.length - start;
+ const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;
+ let i;
+ if (meta.dataset) {
+ meta.dataset.draw(ctx, area, start, count);
+ }
+ for(i = start; i < start + count; ++i){
+ const element = elements[i];
+ if (element.hidden) {
+ continue;
+ }
+ if (element.active && drawActiveElementsOnTop) {
+ active.push(element);
+ } else {
+ element.draw(ctx, area);
+ }
+ }
+ for(i = 0; i < active.length; ++i){
+ active[i].draw(ctx, area);
+ }
+ }
+ getStyle(index, active) {
+ const mode = active ? 'active' : 'default';
+ return index === undefined && this._cachedMeta.dataset ? this.resolveDatasetElementOptions(mode) : this.resolveDataElementOptions(index || 0, mode);
+ }
+ getContext(index, active, mode) {
+ const dataset = this.getDataset();
+ let context;
+ if (index >= 0 && index < this._cachedMeta.data.length) {
+ const element = this._cachedMeta.data[index];
+ context = element.$context || (element.$context = createDataContext(this.getContext(), index, element));
+ context.parsed = this.getParsed(index);
+ context.raw = dataset.data[index];
+ context.index = context.dataIndex = index;
+ } else {
+ context = this.$context || (this.$context = createDatasetContext(this.chart.getContext(), this.index));
+ context.dataset = dataset;
+ context.index = context.datasetIndex = this.index;
+ }
+ context.active = !!active;
+ context.mode = mode;
+ return context;
+ }
+ resolveDatasetElementOptions(mode) {
+ return this._resolveElementOptions(this.datasetElementType.id, mode);
+ }
+ resolveDataElementOptions(index, mode) {
+ return this._resolveElementOptions(this.dataElementType.id, mode, index);
+ }
+ _resolveElementOptions(elementType, mode = 'default', index) {
+ const active = mode === 'active';
+ const cache = this._cachedDataOpts;
+ const cacheKey = elementType + '-' + mode;
+ const cached = cache[cacheKey];
+ const sharing = this.enableOptionSharing && defined(index);
+ if (cached) {
+ return cloneIfNotShared(cached, sharing);
+ }
+ const config = this.chart.config;
+ const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);
+ const prefixes = active ? [
+ `${elementType}Hover`,
+ 'hover',
+ elementType,
+ ''
+ ] : [
+ elementType,
+ ''
+ ];
+ const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
+ const names = Object.keys(defaults.elements[elementType]);
+ const context = ()=>this.getContext(index, active, mode);
+ const values = config.resolveNamedOptions(scopes, names, context, prefixes);
+ if (values.$shared) {
+ values.$shared = sharing;
+ cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));
+ }
+ return values;
+ }
+ _resolveAnimations(index, transition, active) {
+ const chart = this.chart;
+ const cache = this._cachedDataOpts;
+ const cacheKey = `animation-${transition}`;
+ const cached = cache[cacheKey];
+ if (cached) {
+ return cached;
+ }
+ let options;
+ if (chart.options.animation !== false) {
+ const config = this.chart.config;
+ const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);
+ const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
+ options = config.createResolver(scopes, this.getContext(index, active, transition));
+ }
+ const animations = new Animations(chart, options && options.animations);
+ if (options && options._cacheable) {
+ cache[cacheKey] = Object.freeze(animations);
+ }
+ return animations;
+ }
+ getSharedOptions(options) {
+ if (!options.$shared) {
+ return;
+ }
+ return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));
+ }
+ includeOptions(mode, sharedOptions) {
+ return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;
+ }
+ _getSharedOptions(start, mode) {
+ const firstOpts = this.resolveDataElementOptions(start, mode);
+ const previouslySharedOptions = this._sharedOptions;
+ const sharedOptions = this.getSharedOptions(firstOpts);
+ const includeOptions = this.includeOptions(mode, sharedOptions) || sharedOptions !== previouslySharedOptions;
+ this.updateSharedOptions(sharedOptions, mode, firstOpts);
+ return {
+ sharedOptions,
+ includeOptions
+ };
+ }
+ updateElement(element, index, properties, mode) {
+ if (isDirectUpdateMode(mode)) {
+ Object.assign(element, properties);
+ } else {
+ this._resolveAnimations(index, mode).update(element, properties);
+ }
+ }
+ updateSharedOptions(sharedOptions, mode, newOptions) {
+ if (sharedOptions && !isDirectUpdateMode(mode)) {
+ this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions);
+ }
+ }
+ _setStyle(element, index, mode, active) {
+ element.active = active;
+ const options = this.getStyle(index, active);
+ this._resolveAnimations(index, mode, active).update(element, {
+ options: !active && this.getSharedOptions(options) || options
+ });
+ }
+ removeHoverStyle(element, datasetIndex, index) {
+ this._setStyle(element, index, 'active', false);
+ }
+ setHoverStyle(element, datasetIndex, index) {
+ this._setStyle(element, index, 'active', true);
+ }
+ _removeDatasetHoverStyle() {
+ const element = this._cachedMeta.dataset;
+ if (element) {
+ this._setStyle(element, undefined, 'active', false);
+ }
+ }
+ _setDatasetHoverStyle() {
+ const element = this._cachedMeta.dataset;
+ if (element) {
+ this._setStyle(element, undefined, 'active', true);
+ }
+ }
+ _resyncElements(resetNewElements) {
+ const data = this._data;
+ const elements = this._cachedMeta.data;
+ for (const [method, arg1, arg2] of this._syncList){
+ this[method](arg1, arg2);
+ }
+ this._syncList = [];
+ const numMeta = elements.length;
+ const numData = data.length;
+ const count = Math.min(numData, numMeta);
+ if (count) {
+ this.parse(0, count);
+ }
+ if (numData > numMeta) {
+ this._insertElements(numMeta, numData - numMeta, resetNewElements);
+ } else if (numData < numMeta) {
+ this._removeElements(numData, numMeta - numData);
+ }
+ }
+ _insertElements(start, count, resetNewElements = true) {
+ const meta = this._cachedMeta;
+ const data = meta.data;
+ const end = start + count;
+ let i;
+ const move = (arr)=>{
+ arr.length += count;
+ for(i = arr.length - 1; i >= end; i--){
+ arr[i] = arr[i - count];
+ }
+ };
+ move(data);
+ for(i = start; i < end; ++i){
+ data[i] = new this.dataElementType();
+ }
+ if (this._parsing) {
+ move(meta._parsed);
+ }
+ this.parse(start, count);
+ if (resetNewElements) {
+ this.updateElements(data, start, count, 'reset');
+ }
+ }
+ updateElements(element, start, count, mode) {}
+ _removeElements(start, count) {
+ const meta = this._cachedMeta;
+ if (this._parsing) {
+ const removed = meta._parsed.splice(start, count);
+ if (meta._stacked) {
+ clearStacks(meta, removed);
+ }
+ }
+ meta.data.splice(start, count);
+ }
+ _sync(args) {
+ if (this._parsing) {
+ this._syncList.push(args);
+ } else {
+ const [method, arg1, arg2] = args;
+ this[method](arg1, arg2);
+ }
+ this.chart._dataChanges.push([
+ this.index,
+ ...args
+ ]);
+ }
+ _onDataPush() {
+ const count = arguments.length;
+ this._sync([
+ '_insertElements',
+ this.getDataset().data.length - count,
+ count
+ ]);
+ }
+ _onDataPop() {
+ this._sync([
+ '_removeElements',
+ this._cachedMeta.data.length - 1,
+ 1
+ ]);
+ }
+ _onDataShift() {
+ this._sync([
+ '_removeElements',
+ 0,
+ 1
+ ]);
+ }
+ _onDataSplice(start, count) {
+ if (count) {
+ this._sync([
+ '_removeElements',
+ start,
+ count
+ ]);
+ }
+ const newCount = arguments.length - 2;
+ if (newCount) {
+ this._sync([
+ '_insertElements',
+ start,
+ newCount
+ ]);
+ }
+ }
+ _onDataUnshift() {
+ this._sync([
+ '_insertElements',
+ 0,
+ arguments.length
+ ]);
+ }
+ }
+
+ class Element {
+ static defaults = {};
+ static defaultRoutes = undefined;
+ x;
+ y;
+ active = false;
+ options;
+ $animations;
+ tooltipPosition(useFinalPosition) {
+ const { x , y } = this.getProps([
+ 'x',
+ 'y'
+ ], useFinalPosition);
+ return {
+ x,
+ y
+ };
+ }
+ hasValue() {
+ return isNumber(this.x) && isNumber(this.y);
+ }
+ getProps(props, final) {
+ const anims = this.$animations;
+ if (!final || !anims) {
+ // let's not create an object, if not needed
+ return this;
+ }
+ const ret = {};
+ props.forEach((prop)=>{
+ ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop];
+ });
+ return ret;
+ }
+ }
+
+ function autoSkip(scale, ticks) {
+ const tickOpts = scale.options.ticks;
+ const determinedMaxTicks = determineMaxTicks(scale);
+ const ticksLimit = Math.min(tickOpts.maxTicksLimit || determinedMaxTicks, determinedMaxTicks);
+ const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];
+ const numMajorIndices = majorIndices.length;
+ const first = majorIndices[0];
+ const last = majorIndices[numMajorIndices - 1];
+ const newTicks = [];
+ if (numMajorIndices > ticksLimit) {
+ skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);
+ return newTicks;
+ }
+ const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);
+ if (numMajorIndices > 0) {
+ let i, ilen;
+ const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;
+ skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);
+ for(i = 0, ilen = numMajorIndices - 1; i < ilen; i++){
+ skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);
+ }
+ skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);
+ return newTicks;
+ }
+ skip(ticks, newTicks, spacing);
+ return newTicks;
+ }
+ function determineMaxTicks(scale) {
+ const offset = scale.options.offset;
+ const tickLength = scale._tickSize();
+ const maxScale = scale._length / tickLength + (offset ? 0 : 1);
+ const maxChart = scale._maxLength / tickLength;
+ return Math.floor(Math.min(maxScale, maxChart));
+ }
+ function calculateSpacing(majorIndices, ticks, ticksLimit) {
+ const evenMajorSpacing = getEvenSpacing(majorIndices);
+ const spacing = ticks.length / ticksLimit;
+ if (!evenMajorSpacing) {
+ return Math.max(spacing, 1);
+ }
+ const factors = _factorize(evenMajorSpacing);
+ for(let i = 0, ilen = factors.length - 1; i < ilen; i++){
+ const factor = factors[i];
+ if (factor > spacing) {
+ return factor;
+ }
+ }
+ return Math.max(spacing, 1);
+ }
+ function getMajorIndices(ticks) {
+ const result = [];
+ let i, ilen;
+ for(i = 0, ilen = ticks.length; i < ilen; i++){
+ if (ticks[i].major) {
+ result.push(i);
+ }
+ }
+ return result;
+ }
+ function skipMajors(ticks, newTicks, majorIndices, spacing) {
+ let count = 0;
+ let next = majorIndices[0];
+ let i;
+ spacing = Math.ceil(spacing);
+ for(i = 0; i < ticks.length; i++){
+ if (i === next) {
+ newTicks.push(ticks[i]);
+ count++;
+ next = majorIndices[count * spacing];
+ }
+ }
+ }
+ function skip(ticks, newTicks, spacing, majorStart, majorEnd) {
+ const start = valueOrDefault(majorStart, 0);
+ const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);
+ let count = 0;
+ let length, i, next;
+ spacing = Math.ceil(spacing);
+ if (majorEnd) {
+ length = majorEnd - majorStart;
+ spacing = length / Math.floor(length / spacing);
+ }
+ next = start;
+ while(next < 0){
+ count++;
+ next = Math.round(start + count * spacing);
+ }
+ for(i = Math.max(start, 0); i < end; i++){
+ if (i === next) {
+ newTicks.push(ticks[i]);
+ count++;
+ next = Math.round(start + count * spacing);
+ }
+ }
+ }
+ function getEvenSpacing(arr) {
+ const len = arr.length;
+ let i, diff;
+ if (len < 2) {
+ return false;
+ }
+ for(diff = arr[0], i = 1; i < len; ++i){
+ if (arr[i] - arr[i - 1] !== diff) {
+ return false;
+ }
+ }
+ return diff;
+ }
+
+ const reverseAlign = (align)=>align === 'left' ? 'right' : align === 'right' ? 'left' : align;
+ const offsetFromEdge = (scale, edge, offset)=>edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset;
+ const getTicksLimit = (ticksLength, maxTicksLimit)=>Math.min(maxTicksLimit || ticksLength, ticksLength);
+ function sample(arr, numItems) {
+ const result = [];
+ const increment = arr.length / numItems;
+ const len = arr.length;
+ let i = 0;
+ for(; i < len; i += increment){
+ result.push(arr[Math.floor(i)]);
+ }
+ return result;
+ }
+ function getPixelForGridLine(scale, index, offsetGridLines) {
+ const length = scale.ticks.length;
+ const validIndex = Math.min(index, length - 1);
+ const start = scale._startPixel;
+ const end = scale._endPixel;
+ const epsilon = 1e-6;
+ let lineValue = scale.getPixelForTick(validIndex);
+ let offset;
+ if (offsetGridLines) {
+ if (length === 1) {
+ offset = Math.max(lineValue - start, end - lineValue);
+ } else if (index === 0) {
+ offset = (scale.getPixelForTick(1) - lineValue) / 2;
+ } else {
+ offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2;
+ }
+ lineValue += validIndex < index ? offset : -offset;
+ if (lineValue < start - epsilon || lineValue > end + epsilon) {
+ return;
+ }
+ }
+ return lineValue;
+ }
+ function garbageCollect(caches, length) {
+ each(caches, (cache)=>{
+ const gc = cache.gc;
+ const gcLen = gc.length / 2;
+ let i;
+ if (gcLen > length) {
+ for(i = 0; i < gcLen; ++i){
+ delete cache.data[gc[i]];
+ }
+ gc.splice(0, gcLen);
+ }
+ });
+ }
+ function getTickMarkLength(options) {
+ return options.drawTicks ? options.tickLength : 0;
+ }
+ function getTitleHeight(options, fallback) {
+ if (!options.display) {
+ return 0;
+ }
+ const font = toFont(options.font, fallback);
+ const padding = toPadding(options.padding);
+ const lines = isArray(options.text) ? options.text.length : 1;
+ return lines * font.lineHeight + padding.height;
+ }
+ function createScaleContext(parent, scale) {
+ return createContext(parent, {
+ scale,
+ type: 'scale'
+ });
+ }
+ function createTickContext(parent, index, tick) {
+ return createContext(parent, {
+ tick,
+ index,
+ type: 'tick'
+ });
+ }
+ function titleAlign(align, position, reverse) {
+ let ret = _toLeftRightCenter(align);
+ if (reverse && position !== 'right' || !reverse && position === 'right') {
+ ret = reverseAlign(ret);
+ }
+ return ret;
+ }
+ function titleArgs(scale, offset, position, align) {
+ const { top , left , bottom , right , chart } = scale;
+ const { chartArea , scales } = chart;
+ let rotation = 0;
+ let maxWidth, titleX, titleY;
+ const height = bottom - top;
+ const width = right - left;
+ if (scale.isHorizontal()) {
+ titleX = _alignStartEnd(align, left, right);
+ if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;
+ } else if (position === 'center') {
+ titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;
+ } else {
+ titleY = offsetFromEdge(scale, position, offset);
+ }
+ maxWidth = right - left;
+ } else {
+ if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;
+ } else if (position === 'center') {
+ titleX = (chartArea.left + chartArea.right) / 2 - width + offset;
+ } else {
+ titleX = offsetFromEdge(scale, position, offset);
+ }
+ titleY = _alignStartEnd(align, bottom, top);
+ rotation = position === 'left' ? -HALF_PI : HALF_PI;
+ }
+ return {
+ titleX,
+ titleY,
+ maxWidth,
+ rotation
+ };
+ }
+ class Scale extends Element {
+ constructor(cfg){
+ super();
+ this.id = cfg.id;
+ this.type = cfg.type;
+ this.options = undefined;
+ this.ctx = cfg.ctx;
+ this.chart = cfg.chart;
+ this.top = undefined;
+ this.bottom = undefined;
+ this.left = undefined;
+ this.right = undefined;
+ this.width = undefined;
+ this.height = undefined;
+ this._margins = {
+ left: 0,
+ right: 0,
+ top: 0,
+ bottom: 0
+ };
+ this.maxWidth = undefined;
+ this.maxHeight = undefined;
+ this.paddingTop = undefined;
+ this.paddingBottom = undefined;
+ this.paddingLeft = undefined;
+ this.paddingRight = undefined;
+ this.axis = undefined;
+ this.labelRotation = undefined;
+ this.min = undefined;
+ this.max = undefined;
+ this._range = undefined;
+ this.ticks = [];
+ this._gridLineItems = null;
+ this._labelItems = null;
+ this._labelSizes = null;
+ this._length = 0;
+ this._maxLength = 0;
+ this._longestTextCache = {};
+ this._startPixel = undefined;
+ this._endPixel = undefined;
+ this._reversePixels = false;
+ this._userMax = undefined;
+ this._userMin = undefined;
+ this._suggestedMax = undefined;
+ this._suggestedMin = undefined;
+ this._ticksLength = 0;
+ this._borderValue = 0;
+ this._cache = {};
+ this._dataLimitsCached = false;
+ this.$context = undefined;
+ }
+ init(options) {
+ this.options = options.setContext(this.getContext());
+ this.axis = options.axis;
+ this._userMin = this.parse(options.min);
+ this._userMax = this.parse(options.max);
+ this._suggestedMin = this.parse(options.suggestedMin);
+ this._suggestedMax = this.parse(options.suggestedMax);
+ }
+ parse(raw, index) {
+ return raw;
+ }
+ getUserBounds() {
+ let { _userMin , _userMax , _suggestedMin , _suggestedMax } = this;
+ _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);
+ _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);
+ _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);
+ _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);
+ return {
+ min: finiteOrDefault(_userMin, _suggestedMin),
+ max: finiteOrDefault(_userMax, _suggestedMax),
+ minDefined: isNumberFinite(_userMin),
+ maxDefined: isNumberFinite(_userMax)
+ };
+ }
+ getMinMax(canStack) {
+ let { min , max , minDefined , maxDefined } = this.getUserBounds();
+ let range;
+ if (minDefined && maxDefined) {
+ return {
+ min,
+ max
+ };
+ }
+ const metas = this.getMatchingVisibleMetas();
+ for(let i = 0, ilen = metas.length; i < ilen; ++i){
+ range = metas[i].controller.getMinMax(this, canStack);
+ if (!minDefined) {
+ min = Math.min(min, range.min);
+ }
+ if (!maxDefined) {
+ max = Math.max(max, range.max);
+ }
+ }
+ min = maxDefined && min > max ? max : min;
+ max = minDefined && min > max ? min : max;
+ return {
+ min: finiteOrDefault(min, finiteOrDefault(max, min)),
+ max: finiteOrDefault(max, finiteOrDefault(min, max))
+ };
+ }
+ getPadding() {
+ return {
+ left: this.paddingLeft || 0,
+ top: this.paddingTop || 0,
+ right: this.paddingRight || 0,
+ bottom: this.paddingBottom || 0
+ };
+ }
+ getTicks() {
+ return this.ticks;
+ }
+ getLabels() {
+ const data = this.chart.data;
+ return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];
+ }
+ getLabelItems(chartArea = this.chart.chartArea) {
+ const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));
+ return items;
+ }
+ beforeLayout() {
+ this._cache = {};
+ this._dataLimitsCached = false;
+ }
+ beforeUpdate() {
+ callback(this.options.beforeUpdate, [
+ this
+ ]);
+ }
+ update(maxWidth, maxHeight, margins) {
+ const { beginAtZero , grace , ticks: tickOpts } = this.options;
+ const sampleSize = tickOpts.sampleSize;
+ this.beforeUpdate();
+ this.maxWidth = maxWidth;
+ this.maxHeight = maxHeight;
+ this._margins = margins = Object.assign({
+ left: 0,
+ right: 0,
+ top: 0,
+ bottom: 0
+ }, margins);
+ this.ticks = null;
+ this._labelSizes = null;
+ this._gridLineItems = null;
+ this._labelItems = null;
+ this.beforeSetDimensions();
+ this.setDimensions();
+ this.afterSetDimensions();
+ this._maxLength = this.isHorizontal() ? this.width + margins.left + margins.right : this.height + margins.top + margins.bottom;
+ if (!this._dataLimitsCached) {
+ this.beforeDataLimits();
+ this.determineDataLimits();
+ this.afterDataLimits();
+ this._range = _addGrace(this, grace, beginAtZero);
+ this._dataLimitsCached = true;
+ }
+ this.beforeBuildTicks();
+ this.ticks = this.buildTicks() || [];
+ this.afterBuildTicks();
+ const samplingEnabled = sampleSize < this.ticks.length;
+ this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);
+ this.configure();
+ this.beforeCalculateLabelRotation();
+ this.calculateLabelRotation();
+ this.afterCalculateLabelRotation();
+ if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) {
+ this.ticks = autoSkip(this, this.ticks);
+ this._labelSizes = null;
+ this.afterAutoSkip();
+ }
+ if (samplingEnabled) {
+ this._convertTicksToLabels(this.ticks);
+ }
+ this.beforeFit();
+ this.fit();
+ this.afterFit();
+ this.afterUpdate();
+ }
+ configure() {
+ let reversePixels = this.options.reverse;
+ let startPixel, endPixel;
+ if (this.isHorizontal()) {
+ startPixel = this.left;
+ endPixel = this.right;
+ } else {
+ startPixel = this.top;
+ endPixel = this.bottom;
+ reversePixels = !reversePixels;
+ }
+ this._startPixel = startPixel;
+ this._endPixel = endPixel;
+ this._reversePixels = reversePixels;
+ this._length = endPixel - startPixel;
+ this._alignToPixels = this.options.alignToPixels;
+ }
+ afterUpdate() {
+ callback(this.options.afterUpdate, [
+ this
+ ]);
+ }
+ beforeSetDimensions() {
+ callback(this.options.beforeSetDimensions, [
+ this
+ ]);
+ }
+ setDimensions() {
+ if (this.isHorizontal()) {
+ this.width = this.maxWidth;
+ this.left = 0;
+ this.right = this.width;
+ } else {
+ this.height = this.maxHeight;
+ this.top = 0;
+ this.bottom = this.height;
+ }
+ this.paddingLeft = 0;
+ this.paddingTop = 0;
+ this.paddingRight = 0;
+ this.paddingBottom = 0;
+ }
+ afterSetDimensions() {
+ callback(this.options.afterSetDimensions, [
+ this
+ ]);
+ }
+ _callHooks(name) {
+ this.chart.notifyPlugins(name, this.getContext());
+ callback(this.options[name], [
+ this
+ ]);
+ }
+ beforeDataLimits() {
+ this._callHooks('beforeDataLimits');
+ }
+ determineDataLimits() {}
+ afterDataLimits() {
+ this._callHooks('afterDataLimits');
+ }
+ beforeBuildTicks() {
+ this._callHooks('beforeBuildTicks');
+ }
+ buildTicks() {
+ return [];
+ }
+ afterBuildTicks() {
+ this._callHooks('afterBuildTicks');
+ }
+ beforeTickToLabelConversion() {
+ callback(this.options.beforeTickToLabelConversion, [
+ this
+ ]);
+ }
+ generateTickLabels(ticks) {
+ const tickOpts = this.options.ticks;
+ let i, ilen, tick;
+ for(i = 0, ilen = ticks.length; i < ilen; i++){
+ tick = ticks[i];
+ tick.label = callback(tickOpts.callback, [
+ tick.value,
+ i,
+ ticks
+ ], this);
+ }
+ }
+ afterTickToLabelConversion() {
+ callback(this.options.afterTickToLabelConversion, [
+ this
+ ]);
+ }
+ beforeCalculateLabelRotation() {
+ callback(this.options.beforeCalculateLabelRotation, [
+ this
+ ]);
+ }
+ calculateLabelRotation() {
+ const options = this.options;
+ const tickOpts = options.ticks;
+ const numTicks = getTicksLimit(this.ticks.length, options.ticks.maxTicksLimit);
+ const minRotation = tickOpts.minRotation || 0;
+ const maxRotation = tickOpts.maxRotation;
+ let labelRotation = minRotation;
+ let tickWidth, maxHeight, maxLabelDiagonal;
+ if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {
+ this.labelRotation = minRotation;
+ return;
+ }
+ const labelSizes = this._getLabelSizes();
+ const maxLabelWidth = labelSizes.widest.width;
+ const maxLabelHeight = labelSizes.highest.height;
+ const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);
+ tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);
+ if (maxLabelWidth + 6 > tickWidth) {
+ tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));
+ maxHeight = this.maxHeight - getTickMarkLength(options.grid) - tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);
+ maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);
+ labelRotation = toDegrees(Math.min(Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)), Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))));
+ labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));
+ }
+ this.labelRotation = labelRotation;
+ }
+ afterCalculateLabelRotation() {
+ callback(this.options.afterCalculateLabelRotation, [
+ this
+ ]);
+ }
+ afterAutoSkip() {}
+ beforeFit() {
+ callback(this.options.beforeFit, [
+ this
+ ]);
+ }
+ fit() {
+ const minSize = {
+ width: 0,
+ height: 0
+ };
+ const { chart , options: { ticks: tickOpts , title: titleOpts , grid: gridOpts } } = this;
+ const display = this._isVisible();
+ const isHorizontal = this.isHorizontal();
+ if (display) {
+ const titleHeight = getTitleHeight(titleOpts, chart.options.font);
+ if (isHorizontal) {
+ minSize.width = this.maxWidth;
+ minSize.height = getTickMarkLength(gridOpts) + titleHeight;
+ } else {
+ minSize.height = this.maxHeight;
+ minSize.width = getTickMarkLength(gridOpts) + titleHeight;
+ }
+ if (tickOpts.display && this.ticks.length) {
+ const { first , last , widest , highest } = this._getLabelSizes();
+ const tickPadding = tickOpts.padding * 2;
+ const angleRadians = toRadians(this.labelRotation);
+ const cos = Math.cos(angleRadians);
+ const sin = Math.sin(angleRadians);
+ if (isHorizontal) {
+ const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;
+ minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);
+ } else {
+ const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;
+ minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);
+ }
+ this._calculatePadding(first, last, sin, cos);
+ }
+ }
+ this._handleMargins();
+ if (isHorizontal) {
+ this.width = this._length = chart.width - this._margins.left - this._margins.right;
+ this.height = minSize.height;
+ } else {
+ this.width = minSize.width;
+ this.height = this._length = chart.height - this._margins.top - this._margins.bottom;
+ }
+ }
+ _calculatePadding(first, last, sin, cos) {
+ const { ticks: { align , padding } , position } = this.options;
+ const isRotated = this.labelRotation !== 0;
+ const labelsBelowTicks = position !== 'top' && this.axis === 'x';
+ if (this.isHorizontal()) {
+ const offsetLeft = this.getPixelForTick(0) - this.left;
+ const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);
+ let paddingLeft = 0;
+ let paddingRight = 0;
+ if (isRotated) {
+ if (labelsBelowTicks) {
+ paddingLeft = cos * first.width;
+ paddingRight = sin * last.height;
+ } else {
+ paddingLeft = sin * first.height;
+ paddingRight = cos * last.width;
+ }
+ } else if (align === 'start') {
+ paddingRight = last.width;
+ } else if (align === 'end') {
+ paddingLeft = first.width;
+ } else if (align !== 'inner') {
+ paddingLeft = first.width / 2;
+ paddingRight = last.width / 2;
+ }
+ this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);
+ this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);
+ } else {
+ let paddingTop = last.height / 2;
+ let paddingBottom = first.height / 2;
+ if (align === 'start') {
+ paddingTop = 0;
+ paddingBottom = first.height;
+ } else if (align === 'end') {
+ paddingTop = last.height;
+ paddingBottom = 0;
+ }
+ this.paddingTop = paddingTop + padding;
+ this.paddingBottom = paddingBottom + padding;
+ }
+ }
+ _handleMargins() {
+ if (this._margins) {
+ this._margins.left = Math.max(this.paddingLeft, this._margins.left);
+ this._margins.top = Math.max(this.paddingTop, this._margins.top);
+ this._margins.right = Math.max(this.paddingRight, this._margins.right);
+ this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);
+ }
+ }
+ afterFit() {
+ callback(this.options.afterFit, [
+ this
+ ]);
+ }
+ isHorizontal() {
+ const { axis , position } = this.options;
+ return position === 'top' || position === 'bottom' || axis === 'x';
+ }
+ isFullSize() {
+ return this.options.fullSize;
+ }
+ _convertTicksToLabels(ticks) {
+ this.beforeTickToLabelConversion();
+ this.generateTickLabels(ticks);
+ let i, ilen;
+ for(i = 0, ilen = ticks.length; i < ilen; i++){
+ if (isNullOrUndef(ticks[i].label)) {
+ ticks.splice(i, 1);
+ ilen--;
+ i--;
+ }
+ }
+ this.afterTickToLabelConversion();
+ }
+ _getLabelSizes() {
+ let labelSizes = this._labelSizes;
+ if (!labelSizes) {
+ const sampleSize = this.options.ticks.sampleSize;
+ let ticks = this.ticks;
+ if (sampleSize < ticks.length) {
+ ticks = sample(ticks, sampleSize);
+ }
+ this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length, this.options.ticks.maxTicksLimit);
+ }
+ return labelSizes;
+ }
+ _computeLabelSizes(ticks, length, maxTicksLimit) {
+ const { ctx , _longestTextCache: caches } = this;
+ const widths = [];
+ const heights = [];
+ const increment = Math.floor(length / getTicksLimit(length, maxTicksLimit));
+ let widestLabelSize = 0;
+ let highestLabelSize = 0;
+ let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;
+ for(i = 0; i < length; i += increment){
+ label = ticks[i].label;
+ tickFont = this._resolveTickFontOptions(i);
+ ctx.font = fontString = tickFont.string;
+ cache = caches[fontString] = caches[fontString] || {
+ data: {},
+ gc: []
+ };
+ lineHeight = tickFont.lineHeight;
+ width = height = 0;
+ if (!isNullOrUndef(label) && !isArray(label)) {
+ width = _measureText(ctx, cache.data, cache.gc, width, label);
+ height = lineHeight;
+ } else if (isArray(label)) {
+ for(j = 0, jlen = label.length; j < jlen; ++j){
+ nestedLabel = label[j];
+ if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {
+ width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);
+ height += lineHeight;
+ }
+ }
+ }
+ widths.push(width);
+ heights.push(height);
+ widestLabelSize = Math.max(width, widestLabelSize);
+ highestLabelSize = Math.max(height, highestLabelSize);
+ }
+ garbageCollect(caches, length);
+ const widest = widths.indexOf(widestLabelSize);
+ const highest = heights.indexOf(highestLabelSize);
+ const valueAt = (idx)=>({
+ width: widths[idx] || 0,
+ height: heights[idx] || 0
+ });
+ return {
+ first: valueAt(0),
+ last: valueAt(length - 1),
+ widest: valueAt(widest),
+ highest: valueAt(highest),
+ widths,
+ heights
+ };
+ }
+ getLabelForValue(value) {
+ return value;
+ }
+ getPixelForValue(value, index) {
+ return NaN;
+ }
+ getValueForPixel(pixel) {}
+ getPixelForTick(index) {
+ const ticks = this.ticks;
+ if (index < 0 || index > ticks.length - 1) {
+ return null;
+ }
+ return this.getPixelForValue(ticks[index].value);
+ }
+ getPixelForDecimal(decimal) {
+ if (this._reversePixels) {
+ decimal = 1 - decimal;
+ }
+ const pixel = this._startPixel + decimal * this._length;
+ return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);
+ }
+ getDecimalForPixel(pixel) {
+ const decimal = (pixel - this._startPixel) / this._length;
+ return this._reversePixels ? 1 - decimal : decimal;
+ }
+ getBasePixel() {
+ return this.getPixelForValue(this.getBaseValue());
+ }
+ getBaseValue() {
+ const { min , max } = this;
+ return min < 0 && max < 0 ? max : min > 0 && max > 0 ? min : 0;
+ }
+ getContext(index) {
+ const ticks = this.ticks || [];
+ if (index >= 0 && index < ticks.length) {
+ const tick = ticks[index];
+ return tick.$context || (tick.$context = createTickContext(this.getContext(), index, tick));
+ }
+ return this.$context || (this.$context = createScaleContext(this.chart.getContext(), this));
+ }
+ _tickSize() {
+ const optionTicks = this.options.ticks;
+ const rot = toRadians(this.labelRotation);
+ const cos = Math.abs(Math.cos(rot));
+ const sin = Math.abs(Math.sin(rot));
+ const labelSizes = this._getLabelSizes();
+ const padding = optionTicks.autoSkipPadding || 0;
+ const w = labelSizes ? labelSizes.widest.width + padding : 0;
+ const h = labelSizes ? labelSizes.highest.height + padding : 0;
+ return this.isHorizontal() ? h * cos > w * sin ? w / cos : h / sin : h * sin < w * cos ? h / cos : w / sin;
+ }
+ _isVisible() {
+ const display = this.options.display;
+ if (display !== 'auto') {
+ return !!display;
+ }
+ return this.getMatchingVisibleMetas().length > 0;
+ }
+ _computeGridLineItems(chartArea) {
+ const axis = this.axis;
+ const chart = this.chart;
+ const options = this.options;
+ const { grid , position , border } = options;
+ const offset = grid.offset;
+ const isHorizontal = this.isHorizontal();
+ const ticks = this.ticks;
+ const ticksLength = ticks.length + (offset ? 1 : 0);
+ const tl = getTickMarkLength(grid);
+ const items = [];
+ const borderOpts = border.setContext(this.getContext());
+ const axisWidth = borderOpts.display ? borderOpts.width : 0;
+ const axisHalfWidth = axisWidth / 2;
+ const alignBorderValue = function(pixel) {
+ return _alignPixel(chart, pixel, axisWidth);
+ };
+ let borderValue, i, lineValue, alignedLineValue;
+ let tx1, ty1, tx2, ty2, x1, y1, x2, y2;
+ if (position === 'top') {
+ borderValue = alignBorderValue(this.bottom);
+ ty1 = this.bottom - tl;
+ ty2 = borderValue - axisHalfWidth;
+ y1 = alignBorderValue(chartArea.top) + axisHalfWidth;
+ y2 = chartArea.bottom;
+ } else if (position === 'bottom') {
+ borderValue = alignBorderValue(this.top);
+ y1 = chartArea.top;
+ y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;
+ ty1 = borderValue + axisHalfWidth;
+ ty2 = this.top + tl;
+ } else if (position === 'left') {
+ borderValue = alignBorderValue(this.right);
+ tx1 = this.right - tl;
+ tx2 = borderValue - axisHalfWidth;
+ x1 = alignBorderValue(chartArea.left) + axisHalfWidth;
+ x2 = chartArea.right;
+ } else if (position === 'right') {
+ borderValue = alignBorderValue(this.left);
+ x1 = chartArea.left;
+ x2 = alignBorderValue(chartArea.right) - axisHalfWidth;
+ tx1 = borderValue + axisHalfWidth;
+ tx2 = this.left + tl;
+ } else if (axis === 'x') {
+ if (position === 'center') {
+ borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
+ }
+ y1 = chartArea.top;
+ y2 = chartArea.bottom;
+ ty1 = borderValue + axisHalfWidth;
+ ty2 = ty1 + tl;
+ } else if (axis === 'y') {
+ if (position === 'center') {
+ borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
+ }
+ tx1 = borderValue - axisHalfWidth;
+ tx2 = tx1 - tl;
+ x1 = chartArea.left;
+ x2 = chartArea.right;
+ }
+ const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);
+ const step = Math.max(1, Math.ceil(ticksLength / limit));
+ for(i = 0; i < ticksLength; i += step){
+ const context = this.getContext(i);
+ const optsAtIndex = grid.setContext(context);
+ const optsAtIndexBorder = border.setContext(context);
+ const lineWidth = optsAtIndex.lineWidth;
+ const lineColor = optsAtIndex.color;
+ const borderDash = optsAtIndexBorder.dash || [];
+ const borderDashOffset = optsAtIndexBorder.dashOffset;
+ const tickWidth = optsAtIndex.tickWidth;
+ const tickColor = optsAtIndex.tickColor;
+ const tickBorderDash = optsAtIndex.tickBorderDash || [];
+ const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;
+ lineValue = getPixelForGridLine(this, i, offset);
+ if (lineValue === undefined) {
+ continue;
+ }
+ alignedLineValue = _alignPixel(chart, lineValue, lineWidth);
+ if (isHorizontal) {
+ tx1 = tx2 = x1 = x2 = alignedLineValue;
+ } else {
+ ty1 = ty2 = y1 = y2 = alignedLineValue;
+ }
+ items.push({
+ tx1,
+ ty1,
+ tx2,
+ ty2,
+ x1,
+ y1,
+ x2,
+ y2,
+ width: lineWidth,
+ color: lineColor,
+ borderDash,
+ borderDashOffset,
+ tickWidth,
+ tickColor,
+ tickBorderDash,
+ tickBorderDashOffset
+ });
+ }
+ this._ticksLength = ticksLength;
+ this._borderValue = borderValue;
+ return items;
+ }
+ _computeLabelItems(chartArea) {
+ const axis = this.axis;
+ const options = this.options;
+ const { position , ticks: optionTicks } = options;
+ const isHorizontal = this.isHorizontal();
+ const ticks = this.ticks;
+ const { align , crossAlign , padding , mirror } = optionTicks;
+ const tl = getTickMarkLength(options.grid);
+ const tickAndPadding = tl + padding;
+ const hTickAndPadding = mirror ? -padding : tickAndPadding;
+ const rotation = -toRadians(this.labelRotation);
+ const items = [];
+ let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;
+ let textBaseline = 'middle';
+ if (position === 'top') {
+ y = this.bottom - hTickAndPadding;
+ textAlign = this._getXAxisLabelAlignment();
+ } else if (position === 'bottom') {
+ y = this.top + hTickAndPadding;
+ textAlign = this._getXAxisLabelAlignment();
+ } else if (position === 'left') {
+ const ret = this._getYAxisLabelAlignment(tl);
+ textAlign = ret.textAlign;
+ x = ret.x;
+ } else if (position === 'right') {
+ const ret = this._getYAxisLabelAlignment(tl);
+ textAlign = ret.textAlign;
+ x = ret.x;
+ } else if (axis === 'x') {
+ if (position === 'center') {
+ y = (chartArea.top + chartArea.bottom) / 2 + tickAndPadding;
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;
+ }
+ textAlign = this._getXAxisLabelAlignment();
+ } else if (axis === 'y') {
+ if (position === 'center') {
+ x = (chartArea.left + chartArea.right) / 2 - tickAndPadding;
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ x = this.chart.scales[positionAxisID].getPixelForValue(value);
+ }
+ textAlign = this._getYAxisLabelAlignment(tl).textAlign;
+ }
+ if (axis === 'y') {
+ if (align === 'start') {
+ textBaseline = 'top';
+ } else if (align === 'end') {
+ textBaseline = 'bottom';
+ }
+ }
+ const labelSizes = this._getLabelSizes();
+ for(i = 0, ilen = ticks.length; i < ilen; ++i){
+ tick = ticks[i];
+ label = tick.label;
+ const optsAtIndex = optionTicks.setContext(this.getContext(i));
+ pixel = this.getPixelForTick(i) + optionTicks.labelOffset;
+ font = this._resolveTickFontOptions(i);
+ lineHeight = font.lineHeight;
+ lineCount = isArray(label) ? label.length : 1;
+ const halfCount = lineCount / 2;
+ const color = optsAtIndex.color;
+ const strokeColor = optsAtIndex.textStrokeColor;
+ const strokeWidth = optsAtIndex.textStrokeWidth;
+ let tickTextAlign = textAlign;
+ if (isHorizontal) {
+ x = pixel;
+ if (textAlign === 'inner') {
+ if (i === ilen - 1) {
+ tickTextAlign = !this.options.reverse ? 'right' : 'left';
+ } else if (i === 0) {
+ tickTextAlign = !this.options.reverse ? 'left' : 'right';
+ } else {
+ tickTextAlign = 'center';
+ }
+ }
+ if (position === 'top') {
+ if (crossAlign === 'near' || rotation !== 0) {
+ textOffset = -lineCount * lineHeight + lineHeight / 2;
+ } else if (crossAlign === 'center') {
+ textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;
+ } else {
+ textOffset = -labelSizes.highest.height + lineHeight / 2;
+ }
+ } else {
+ if (crossAlign === 'near' || rotation !== 0) {
+ textOffset = lineHeight / 2;
+ } else if (crossAlign === 'center') {
+ textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;
+ } else {
+ textOffset = labelSizes.highest.height - lineCount * lineHeight;
+ }
+ }
+ if (mirror) {
+ textOffset *= -1;
+ }
+ if (rotation !== 0 && !optsAtIndex.showLabelBackdrop) {
+ x += lineHeight / 2 * Math.sin(rotation);
+ }
+ } else {
+ y = pixel;
+ textOffset = (1 - lineCount) * lineHeight / 2;
+ }
+ let backdrop;
+ if (optsAtIndex.showLabelBackdrop) {
+ const labelPadding = toPadding(optsAtIndex.backdropPadding);
+ const height = labelSizes.heights[i];
+ const width = labelSizes.widths[i];
+ let top = textOffset - labelPadding.top;
+ let left = 0 - labelPadding.left;
+ switch(textBaseline){
+ case 'middle':
+ top -= height / 2;
+ break;
+ case 'bottom':
+ top -= height;
+ break;
+ }
+ switch(textAlign){
+ case 'center':
+ left -= width / 2;
+ break;
+ case 'right':
+ left -= width;
+ break;
+ case 'inner':
+ if (i === ilen - 1) {
+ left -= width;
+ } else if (i > 0) {
+ left -= width / 2;
+ }
+ break;
+ }
+ backdrop = {
+ left,
+ top,
+ width: width + labelPadding.width,
+ height: height + labelPadding.height,
+ color: optsAtIndex.backdropColor
+ };
+ }
+ items.push({
+ label,
+ font,
+ textOffset,
+ options: {
+ rotation,
+ color,
+ strokeColor,
+ strokeWidth,
+ textAlign: tickTextAlign,
+ textBaseline,
+ translation: [
+ x,
+ y
+ ],
+ backdrop
+ }
+ });
+ }
+ return items;
+ }
+ _getXAxisLabelAlignment() {
+ const { position , ticks } = this.options;
+ const rotation = -toRadians(this.labelRotation);
+ if (rotation) {
+ return position === 'top' ? 'left' : 'right';
+ }
+ let align = 'center';
+ if (ticks.align === 'start') {
+ align = 'left';
+ } else if (ticks.align === 'end') {
+ align = 'right';
+ } else if (ticks.align === 'inner') {
+ align = 'inner';
+ }
+ return align;
+ }
+ _getYAxisLabelAlignment(tl) {
+ const { position , ticks: { crossAlign , mirror , padding } } = this.options;
+ const labelSizes = this._getLabelSizes();
+ const tickAndPadding = tl + padding;
+ const widest = labelSizes.widest.width;
+ let textAlign;
+ let x;
+ if (position === 'left') {
+ if (mirror) {
+ x = this.right + padding;
+ if (crossAlign === 'near') {
+ textAlign = 'left';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x += widest / 2;
+ } else {
+ textAlign = 'right';
+ x += widest;
+ }
+ } else {
+ x = this.right - tickAndPadding;
+ if (crossAlign === 'near') {
+ textAlign = 'right';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x -= widest / 2;
+ } else {
+ textAlign = 'left';
+ x = this.left;
+ }
+ }
+ } else if (position === 'right') {
+ if (mirror) {
+ x = this.left + padding;
+ if (crossAlign === 'near') {
+ textAlign = 'right';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x -= widest / 2;
+ } else {
+ textAlign = 'left';
+ x -= widest;
+ }
+ } else {
+ x = this.left + tickAndPadding;
+ if (crossAlign === 'near') {
+ textAlign = 'left';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x += widest / 2;
+ } else {
+ textAlign = 'right';
+ x = this.right;
+ }
+ }
+ } else {
+ textAlign = 'right';
+ }
+ return {
+ textAlign,
+ x
+ };
+ }
+ _computeLabelArea() {
+ if (this.options.ticks.mirror) {
+ return;
+ }
+ const chart = this.chart;
+ const position = this.options.position;
+ if (position === 'left' || position === 'right') {
+ return {
+ top: 0,
+ left: this.left,
+ bottom: chart.height,
+ right: this.right
+ };
+ }
+ if (position === 'top' || position === 'bottom') {
+ return {
+ top: this.top,
+ left: 0,
+ bottom: this.bottom,
+ right: chart.width
+ };
+ }
+ }
+ drawBackground() {
+ const { ctx , options: { backgroundColor } , left , top , width , height } = this;
+ if (backgroundColor) {
+ ctx.save();
+ ctx.fillStyle = backgroundColor;
+ ctx.fillRect(left, top, width, height);
+ ctx.restore();
+ }
+ }
+ getLineWidthForValue(value) {
+ const grid = this.options.grid;
+ if (!this._isVisible() || !grid.display) {
+ return 0;
+ }
+ const ticks = this.ticks;
+ const index = ticks.findIndex((t)=>t.value === value);
+ if (index >= 0) {
+ const opts = grid.setContext(this.getContext(index));
+ return opts.lineWidth;
+ }
+ return 0;
+ }
+ drawGrid(chartArea) {
+ const grid = this.options.grid;
+ const ctx = this.ctx;
+ const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));
+ let i, ilen;
+ const drawLine = (p1, p2, style)=>{
+ if (!style.width || !style.color) {
+ return;
+ }
+ ctx.save();
+ ctx.lineWidth = style.width;
+ ctx.strokeStyle = style.color;
+ ctx.setLineDash(style.borderDash || []);
+ ctx.lineDashOffset = style.borderDashOffset;
+ ctx.beginPath();
+ ctx.moveTo(p1.x, p1.y);
+ ctx.lineTo(p2.x, p2.y);
+ ctx.stroke();
+ ctx.restore();
+ };
+ if (grid.display) {
+ for(i = 0, ilen = items.length; i < ilen; ++i){
+ const item = items[i];
+ if (grid.drawOnChartArea) {
+ drawLine({
+ x: item.x1,
+ y: item.y1
+ }, {
+ x: item.x2,
+ y: item.y2
+ }, item);
+ }
+ if (grid.drawTicks) {
+ drawLine({
+ x: item.tx1,
+ y: item.ty1
+ }, {
+ x: item.tx2,
+ y: item.ty2
+ }, {
+ color: item.tickColor,
+ width: item.tickWidth,
+ borderDash: item.tickBorderDash,
+ borderDashOffset: item.tickBorderDashOffset
+ });
+ }
+ }
+ }
+ }
+ drawBorder() {
+ const { chart , ctx , options: { border , grid } } = this;
+ const borderOpts = border.setContext(this.getContext());
+ const axisWidth = border.display ? borderOpts.width : 0;
+ if (!axisWidth) {
+ return;
+ }
+ const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;
+ const borderValue = this._borderValue;
+ let x1, x2, y1, y2;
+ if (this.isHorizontal()) {
+ x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;
+ x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;
+ y1 = y2 = borderValue;
+ } else {
+ y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;
+ y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;
+ x1 = x2 = borderValue;
+ }
+ ctx.save();
+ ctx.lineWidth = borderOpts.width;
+ ctx.strokeStyle = borderOpts.color;
+ ctx.beginPath();
+ ctx.moveTo(x1, y1);
+ ctx.lineTo(x2, y2);
+ ctx.stroke();
+ ctx.restore();
+ }
+ drawLabels(chartArea) {
+ const optionTicks = this.options.ticks;
+ if (!optionTicks.display) {
+ return;
+ }
+ const ctx = this.ctx;
+ const area = this._computeLabelArea();
+ if (area) {
+ clipArea(ctx, area);
+ }
+ const items = this.getLabelItems(chartArea);
+ for (const item of items){
+ const renderTextOptions = item.options;
+ const tickFont = item.font;
+ const label = item.label;
+ const y = item.textOffset;
+ renderText(ctx, label, 0, y, tickFont, renderTextOptions);
+ }
+ if (area) {
+ unclipArea(ctx);
+ }
+ }
+ drawTitle() {
+ const { ctx , options: { position , title , reverse } } = this;
+ if (!title.display) {
+ return;
+ }
+ const font = toFont(title.font);
+ const padding = toPadding(title.padding);
+ const align = title.align;
+ let offset = font.lineHeight / 2;
+ if (position === 'bottom' || position === 'center' || isObject(position)) {
+ offset += padding.bottom;
+ if (isArray(title.text)) {
+ offset += font.lineHeight * (title.text.length - 1);
+ }
+ } else {
+ offset += padding.top;
+ }
+ const { titleX , titleY , maxWidth , rotation } = titleArgs(this, offset, position, align);
+ renderText(ctx, title.text, 0, 0, font, {
+ color: title.color,
+ maxWidth,
+ rotation,
+ textAlign: titleAlign(align, position, reverse),
+ textBaseline: 'middle',
+ translation: [
+ titleX,
+ titleY
+ ]
+ });
+ }
+ draw(chartArea) {
+ if (!this._isVisible()) {
+ return;
+ }
+ this.drawBackground();
+ this.drawGrid(chartArea);
+ this.drawBorder();
+ this.drawTitle();
+ this.drawLabels(chartArea);
+ }
+ _layers() {
+ const opts = this.options;
+ const tz = opts.ticks && opts.ticks.z || 0;
+ const gz = valueOrDefault(opts.grid && opts.grid.z, -1);
+ const bz = valueOrDefault(opts.border && opts.border.z, 0);
+ if (!this._isVisible() || this.draw !== Scale.prototype.draw) {
+ return [
+ {
+ z: tz,
+ draw: (chartArea)=>{
+ this.draw(chartArea);
+ }
+ }
+ ];
+ }
+ return [
+ {
+ z: gz,
+ draw: (chartArea)=>{
+ this.drawBackground();
+ this.drawGrid(chartArea);
+ this.drawTitle();
+ }
+ },
+ {
+ z: bz,
+ draw: ()=>{
+ this.drawBorder();
+ }
+ },
+ {
+ z: tz,
+ draw: (chartArea)=>{
+ this.drawLabels(chartArea);
+ }
+ }
+ ];
+ }
+ getMatchingVisibleMetas(type) {
+ const metas = this.chart.getSortedVisibleDatasetMetas();
+ const axisID = this.axis + 'AxisID';
+ const result = [];
+ let i, ilen;
+ for(i = 0, ilen = metas.length; i < ilen; ++i){
+ const meta = metas[i];
+ if (meta[axisID] === this.id && (!type || meta.type === type)) {
+ result.push(meta);
+ }
+ }
+ return result;
+ }
+ _resolveTickFontOptions(index) {
+ const opts = this.options.ticks.setContext(this.getContext(index));
+ return toFont(opts.font);
+ }
+ _maxDigits() {
+ const fontSize = this._resolveTickFontOptions(0).lineHeight;
+ return (this.isHorizontal() ? this.width : this.height) / fontSize;
+ }
+ }
+
+ class TypedRegistry {
+ constructor(type, scope, override){
+ this.type = type;
+ this.scope = scope;
+ this.override = override;
+ this.items = Object.create(null);
+ }
+ isForType(type) {
+ return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);
+ }
+ register(item) {
+ const proto = Object.getPrototypeOf(item);
+ let parentScope;
+ if (isIChartComponent(proto)) {
+ parentScope = this.register(proto);
+ }
+ const items = this.items;
+ const id = item.id;
+ const scope = this.scope + '.' + id;
+ if (!id) {
+ throw new Error('class does not have id: ' + item);
+ }
+ if (id in items) {
+ return scope;
+ }
+ items[id] = item;
+ registerDefaults(item, scope, parentScope);
+ if (this.override) {
+ defaults.override(item.id, item.overrides);
+ }
+ return scope;
+ }
+ get(id) {
+ return this.items[id];
+ }
+ unregister(item) {
+ const items = this.items;
+ const id = item.id;
+ const scope = this.scope;
+ if (id in items) {
+ delete items[id];
+ }
+ if (scope && id in defaults[scope]) {
+ delete defaults[scope][id];
+ if (this.override) {
+ delete overrides[id];
+ }
+ }
+ }
+ }
+ function registerDefaults(item, scope, parentScope) {
+ const itemDefaults = merge(Object.create(null), [
+ parentScope ? defaults.get(parentScope) : {},
+ defaults.get(scope),
+ item.defaults
+ ]);
+ defaults.set(scope, itemDefaults);
+ if (item.defaultRoutes) {
+ routeDefaults(scope, item.defaultRoutes);
+ }
+ if (item.descriptors) {
+ defaults.describe(scope, item.descriptors);
+ }
+ }
+ function routeDefaults(scope, routes) {
+ Object.keys(routes).forEach((property)=>{
+ const propertyParts = property.split('.');
+ const sourceName = propertyParts.pop();
+ const sourceScope = [
+ scope
+ ].concat(propertyParts).join('.');
+ const parts = routes[property].split('.');
+ const targetName = parts.pop();
+ const targetScope = parts.join('.');
+ defaults.route(sourceScope, sourceName, targetScope, targetName);
+ });
+ }
+ function isIChartComponent(proto) {
+ return 'id' in proto && 'defaults' in proto;
+ }
+
+ class Registry {
+ constructor(){
+ this.controllers = new TypedRegistry(DatasetController, 'datasets', true);
+ this.elements = new TypedRegistry(Element, 'elements');
+ this.plugins = new TypedRegistry(Object, 'plugins');
+ this.scales = new TypedRegistry(Scale, 'scales');
+ this._typedRegistries = [
+ this.controllers,
+ this.scales,
+ this.elements
+ ];
+ }
+ add(...args) {
+ this._each('register', args);
+ }
+ remove(...args) {
+ this._each('unregister', args);
+ }
+ addControllers(...args) {
+ this._each('register', args, this.controllers);
+ }
+ addElements(...args) {
+ this._each('register', args, this.elements);
+ }
+ addPlugins(...args) {
+ this._each('register', args, this.plugins);
+ }
+ addScales(...args) {
+ this._each('register', args, this.scales);
+ }
+ getController(id) {
+ return this._get(id, this.controllers, 'controller');
+ }
+ getElement(id) {
+ return this._get(id, this.elements, 'element');
+ }
+ getPlugin(id) {
+ return this._get(id, this.plugins, 'plugin');
+ }
+ getScale(id) {
+ return this._get(id, this.scales, 'scale');
+ }
+ removeControllers(...args) {
+ this._each('unregister', args, this.controllers);
+ }
+ removeElements(...args) {
+ this._each('unregister', args, this.elements);
+ }
+ removePlugins(...args) {
+ this._each('unregister', args, this.plugins);
+ }
+ removeScales(...args) {
+ this._each('unregister', args, this.scales);
+ }
+ _each(method, args, typedRegistry) {
+ [
+ ...args
+ ].forEach((arg)=>{
+ const reg = typedRegistry || this._getRegistryForType(arg);
+ if (typedRegistry || reg.isForType(arg) || reg === this.plugins && arg.id) {
+ this._exec(method, reg, arg);
+ } else {
+ each(arg, (item)=>{
+ const itemReg = typedRegistry || this._getRegistryForType(item);
+ this._exec(method, itemReg, item);
+ });
+ }
+ });
+ }
+ _exec(method, registry, component) {
+ const camelMethod = _capitalize(method);
+ callback(component['before' + camelMethod], [], component);
+ registry[method](component);
+ callback(component['after' + camelMethod], [], component);
+ }
+ _getRegistryForType(type) {
+ for(let i = 0; i < this._typedRegistries.length; i++){
+ const reg = this._typedRegistries[i];
+ if (reg.isForType(type)) {
+ return reg;
+ }
+ }
+ return this.plugins;
+ }
+ _get(id, typedRegistry, type) {
+ const item = typedRegistry.get(id);
+ if (item === undefined) {
+ throw new Error('"' + id + '" is not a registered ' + type + '.');
+ }
+ return item;
+ }
+ }
+ var registry = /* #__PURE__ */ new Registry();
+
+ class PluginService {
+ constructor(){
+ this._init = [];
+ }
+ notify(chart, hook, args, filter) {
+ if (hook === 'beforeInit') {
+ this._init = this._createDescriptors(chart, true);
+ this._notify(this._init, chart, 'install');
+ }
+ const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);
+ const result = this._notify(descriptors, chart, hook, args);
+ if (hook === 'afterDestroy') {
+ this._notify(descriptors, chart, 'stop');
+ this._notify(this._init, chart, 'uninstall');
+ }
+ return result;
+ }
+ _notify(descriptors, chart, hook, args) {
+ args = args || {};
+ for (const descriptor of descriptors){
+ const plugin = descriptor.plugin;
+ const method = plugin[hook];
+ const params = [
+ chart,
+ args,
+ descriptor.options
+ ];
+ if (callback(method, params, plugin) === false && args.cancelable) {
+ return false;
+ }
+ }
+ return true;
+ }
+ invalidate() {
+ if (!isNullOrUndef(this._cache)) {
+ this._oldCache = this._cache;
+ this._cache = undefined;
+ }
+ }
+ _descriptors(chart) {
+ if (this._cache) {
+ return this._cache;
+ }
+ const descriptors = this._cache = this._createDescriptors(chart);
+ this._notifyStateChanges(chart);
+ return descriptors;
+ }
+ _createDescriptors(chart, all) {
+ const config = chart && chart.config;
+ const options = valueOrDefault(config.options && config.options.plugins, {});
+ const plugins = allPlugins(config);
+ return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);
+ }
+ _notifyStateChanges(chart) {
+ const previousDescriptors = this._oldCache || [];
+ const descriptors = this._cache;
+ const diff = (a, b)=>a.filter((x)=>!b.some((y)=>x.plugin.id === y.plugin.id));
+ this._notify(diff(previousDescriptors, descriptors), chart, 'stop');
+ this._notify(diff(descriptors, previousDescriptors), chart, 'start');
+ }
+ }
+ function allPlugins(config) {
+ const localIds = {};
+ const plugins = [];
+ const keys = Object.keys(registry.plugins.items);
+ for(let i = 0; i < keys.length; i++){
+ plugins.push(registry.getPlugin(keys[i]));
+ }
+ const local = config.plugins || [];
+ for(let i = 0; i < local.length; i++){
+ const plugin = local[i];
+ if (plugins.indexOf(plugin) === -1) {
+ plugins.push(plugin);
+ localIds[plugin.id] = true;
+ }
+ }
+ return {
+ plugins,
+ localIds
+ };
+ }
+ function getOpts(options, all) {
+ if (!all && options === false) {
+ return null;
+ }
+ if (options === true) {
+ return {};
+ }
+ return options;
+ }
+ function createDescriptors(chart, { plugins , localIds }, options, all) {
+ const result = [];
+ const context = chart.getContext();
+ for (const plugin of plugins){
+ const id = plugin.id;
+ const opts = getOpts(options[id], all);
+ if (opts === null) {
+ continue;
+ }
+ result.push({
+ plugin,
+ options: pluginOpts(chart.config, {
+ plugin,
+ local: localIds[id]
+ }, opts, context)
+ });
+ }
+ return result;
+ }
+ function pluginOpts(config, { plugin , local }, opts, context) {
+ const keys = config.pluginScopeKeys(plugin);
+ const scopes = config.getOptionScopes(opts, keys);
+ if (local && plugin.defaults) {
+ scopes.push(plugin.defaults);
+ }
+ return config.createResolver(scopes, context, [
+ ''
+ ], {
+ scriptable: false,
+ indexable: false,
+ allKeys: true
+ });
+ }
+
+ function getIndexAxis(type, options) {
+ const datasetDefaults = defaults.datasets[type] || {};
+ const datasetOptions = (options.datasets || {})[type] || {};
+ return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x';
+ }
+ function getAxisFromDefaultScaleID(id, indexAxis) {
+ let axis = id;
+ if (id === '_index_') {
+ axis = indexAxis;
+ } else if (id === '_value_') {
+ axis = indexAxis === 'x' ? 'y' : 'x';
+ }
+ return axis;
+ }
+ function getDefaultScaleIDFromAxis(axis, indexAxis) {
+ return axis === indexAxis ? '_index_' : '_value_';
+ }
+ function idMatchesAxis(id) {
+ if (id === 'x' || id === 'y' || id === 'r') {
+ return id;
+ }
+ }
+ function axisFromPosition(position) {
+ if (position === 'top' || position === 'bottom') {
+ return 'x';
+ }
+ if (position === 'left' || position === 'right') {
+ return 'y';
+ }
+ }
+ function determineAxis(id, ...scaleOptions) {
+ if (idMatchesAxis(id)) {
+ return id;
+ }
+ for (const opts of scaleOptions){
+ const axis = opts.axis || axisFromPosition(opts.position) || id.length > 1 && idMatchesAxis(id[0].toLowerCase());
+ if (axis) {
+ return axis;
+ }
+ }
+ throw new Error(`Cannot determine type of '${id}' axis. Please provide 'axis' or 'position' option.`);
+ }
+ function getAxisFromDataset(id, axis, dataset) {
+ if (dataset[axis + 'AxisID'] === id) {
+ return {
+ axis
+ };
+ }
+ }
+ function retrieveAxisFromDatasets(id, config) {
+ if (config.data && config.data.datasets) {
+ const boundDs = config.data.datasets.filter((d)=>d.xAxisID === id || d.yAxisID === id);
+ if (boundDs.length) {
+ return getAxisFromDataset(id, 'x', boundDs[0]) || getAxisFromDataset(id, 'y', boundDs[0]);
+ }
+ }
+ return {};
+ }
+ function mergeScaleConfig(config, options) {
+ const chartDefaults = overrides[config.type] || {
+ scales: {}
+ };
+ const configScales = options.scales || {};
+ const chartIndexAxis = getIndexAxis(config.type, options);
+ const scales = Object.create(null);
+ Object.keys(configScales).forEach((id)=>{
+ const scaleConf = configScales[id];
+ if (!isObject(scaleConf)) {
+ return console.error(`Invalid scale configuration for scale: ${id}`);
+ }
+ if (scaleConf._proxy) {
+ return console.warn(`Ignoring resolver passed as options for scale: ${id}`);
+ }
+ const axis = determineAxis(id, scaleConf, retrieveAxisFromDatasets(id, config), defaults.scales[scaleConf.type]);
+ const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);
+ const defaultScaleOptions = chartDefaults.scales || {};
+ scales[id] = mergeIf(Object.create(null), [
+ {
+ axis
+ },
+ scaleConf,
+ defaultScaleOptions[axis],
+ defaultScaleOptions[defaultId]
+ ]);
+ });
+ config.data.datasets.forEach((dataset)=>{
+ const type = dataset.type || config.type;
+ const indexAxis = dataset.indexAxis || getIndexAxis(type, options);
+ const datasetDefaults = overrides[type] || {};
+ const defaultScaleOptions = datasetDefaults.scales || {};
+ Object.keys(defaultScaleOptions).forEach((defaultID)=>{
+ const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);
+ const id = dataset[axis + 'AxisID'] || axis;
+ scales[id] = scales[id] || Object.create(null);
+ mergeIf(scales[id], [
+ {
+ axis
+ },
+ configScales[id],
+ defaultScaleOptions[defaultID]
+ ]);
+ });
+ });
+ Object.keys(scales).forEach((key)=>{
+ const scale = scales[key];
+ mergeIf(scale, [
+ defaults.scales[scale.type],
+ defaults.scale
+ ]);
+ });
+ return scales;
+ }
+ function initOptions(config) {
+ const options = config.options || (config.options = {});
+ options.plugins = valueOrDefault(options.plugins, {});
+ options.scales = mergeScaleConfig(config, options);
+ }
+ function initData(data) {
+ data = data || {};
+ data.datasets = data.datasets || [];
+ data.labels = data.labels || [];
+ return data;
+ }
+ function initConfig(config) {
+ config = config || {};
+ config.data = initData(config.data);
+ initOptions(config);
+ return config;
+ }
+ const keyCache = new Map();
+ const keysCached = new Set();
+ function cachedKeys(cacheKey, generate) {
+ let keys = keyCache.get(cacheKey);
+ if (!keys) {
+ keys = generate();
+ keyCache.set(cacheKey, keys);
+ keysCached.add(keys);
+ }
+ return keys;
+ }
+ const addIfFound = (set, obj, key)=>{
+ const opts = resolveObjectKey(obj, key);
+ if (opts !== undefined) {
+ set.add(opts);
+ }
+ };
+ class Config {
+ constructor(config){
+ this._config = initConfig(config);
+ this._scopeCache = new Map();
+ this._resolverCache = new Map();
+ }
+ get platform() {
+ return this._config.platform;
+ }
+ get type() {
+ return this._config.type;
+ }
+ set type(type) {
+ this._config.type = type;
+ }
+ get data() {
+ return this._config.data;
+ }
+ set data(data) {
+ this._config.data = initData(data);
+ }
+ get options() {
+ return this._config.options;
+ }
+ set options(options) {
+ this._config.options = options;
+ }
+ get plugins() {
+ return this._config.plugins;
+ }
+ update() {
+ const config = this._config;
+ this.clearCache();
+ initOptions(config);
+ }
+ clearCache() {
+ this._scopeCache.clear();
+ this._resolverCache.clear();
+ }
+ datasetScopeKeys(datasetType) {
+ return cachedKeys(datasetType, ()=>[
+ [
+ `datasets.${datasetType}`,
+ ''
+ ]
+ ]);
+ }
+ datasetAnimationScopeKeys(datasetType, transition) {
+ return cachedKeys(`${datasetType}.transition.${transition}`, ()=>[
+ [
+ `datasets.${datasetType}.transitions.${transition}`,
+ `transitions.${transition}`
+ ],
+ [
+ `datasets.${datasetType}`,
+ ''
+ ]
+ ]);
+ }
+ datasetElementScopeKeys(datasetType, elementType) {
+ return cachedKeys(`${datasetType}-${elementType}`, ()=>[
+ [
+ `datasets.${datasetType}.elements.${elementType}`,
+ `datasets.${datasetType}`,
+ `elements.${elementType}`,
+ ''
+ ]
+ ]);
+ }
+ pluginScopeKeys(plugin) {
+ const id = plugin.id;
+ const type = this.type;
+ return cachedKeys(`${type}-plugin-${id}`, ()=>[
+ [
+ `plugins.${id}`,
+ ...plugin.additionalOptionScopes || []
+ ]
+ ]);
+ }
+ _cachedScopes(mainScope, resetCache) {
+ const _scopeCache = this._scopeCache;
+ let cache = _scopeCache.get(mainScope);
+ if (!cache || resetCache) {
+ cache = new Map();
+ _scopeCache.set(mainScope, cache);
+ }
+ return cache;
+ }
+ getOptionScopes(mainScope, keyLists, resetCache) {
+ const { options , type } = this;
+ const cache = this._cachedScopes(mainScope, resetCache);
+ const cached = cache.get(keyLists);
+ if (cached) {
+ return cached;
+ }
+ const scopes = new Set();
+ keyLists.forEach((keys)=>{
+ if (mainScope) {
+ scopes.add(mainScope);
+ keys.forEach((key)=>addIfFound(scopes, mainScope, key));
+ }
+ keys.forEach((key)=>addIfFound(scopes, options, key));
+ keys.forEach((key)=>addIfFound(scopes, overrides[type] || {}, key));
+ keys.forEach((key)=>addIfFound(scopes, defaults, key));
+ keys.forEach((key)=>addIfFound(scopes, descriptors, key));
+ });
+ const array = Array.from(scopes);
+ if (array.length === 0) {
+ array.push(Object.create(null));
+ }
+ if (keysCached.has(keyLists)) {
+ cache.set(keyLists, array);
+ }
+ return array;
+ }
+ chartOptionScopes() {
+ const { options , type } = this;
+ return [
+ options,
+ overrides[type] || {},
+ defaults.datasets[type] || {},
+ {
+ type
+ },
+ defaults,
+ descriptors
+ ];
+ }
+ resolveNamedOptions(scopes, names, context, prefixes = [
+ ''
+ ]) {
+ const result = {
+ $shared: true
+ };
+ const { resolver , subPrefixes } = getResolver(this._resolverCache, scopes, prefixes);
+ let options = resolver;
+ if (needContext(resolver, names)) {
+ result.$shared = false;
+ context = isFunction(context) ? context() : context;
+ const subResolver = this.createResolver(scopes, context, subPrefixes);
+ options = _attachContext(resolver, context, subResolver);
+ }
+ for (const prop of names){
+ result[prop] = options[prop];
+ }
+ return result;
+ }
+ createResolver(scopes, context, prefixes = [
+ ''
+ ], descriptorDefaults) {
+ const { resolver } = getResolver(this._resolverCache, scopes, prefixes);
+ return isObject(context) ? _attachContext(resolver, context, undefined, descriptorDefaults) : resolver;
+ }
+ }
+ function getResolver(resolverCache, scopes, prefixes) {
+ let cache = resolverCache.get(scopes);
+ if (!cache) {
+ cache = new Map();
+ resolverCache.set(scopes, cache);
+ }
+ const cacheKey = prefixes.join();
+ let cached = cache.get(cacheKey);
+ if (!cached) {
+ const resolver = _createResolver(scopes, prefixes);
+ cached = {
+ resolver,
+ subPrefixes: prefixes.filter((p)=>!p.toLowerCase().includes('hover'))
+ };
+ cache.set(cacheKey, cached);
+ }
+ return cached;
+ }
+ const hasFunction = (value)=>isObject(value) && Object.getOwnPropertyNames(value).some((key)=>isFunction(value[key]));
+ function needContext(proxy, names) {
+ const { isScriptable , isIndexable } = _descriptors(proxy);
+ for (const prop of names){
+ const scriptable = isScriptable(prop);
+ const indexable = isIndexable(prop);
+ const value = (indexable || scriptable) && proxy[prop];
+ if (scriptable && (isFunction(value) || hasFunction(value)) || indexable && isArray(value)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ var version = "4.4.1";
+
+ const KNOWN_POSITIONS = [
+ 'top',
+ 'bottom',
+ 'left',
+ 'right',
+ 'chartArea'
+ ];
+ function positionIsHorizontal(position, axis) {
+ return position === 'top' || position === 'bottom' || KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x';
+ }
+ function compare2Level(l1, l2) {
+ return function(a, b) {
+ return a[l1] === b[l1] ? a[l2] - b[l2] : a[l1] - b[l1];
+ };
+ }
+ function onAnimationsComplete(context) {
+ const chart = context.chart;
+ const animationOptions = chart.options.animation;
+ chart.notifyPlugins('afterRender');
+ callback(animationOptions && animationOptions.onComplete, [
+ context
+ ], chart);
+ }
+ function onAnimationProgress(context) {
+ const chart = context.chart;
+ const animationOptions = chart.options.animation;
+ callback(animationOptions && animationOptions.onProgress, [
+ context
+ ], chart);
+ }
+ function getCanvas(item) {
+ if (_isDomSupported() && typeof item === 'string') {
+ item = document.getElementById(item);
+ } else if (item && item.length) {
+ item = item[0];
+ }
+ if (item && item.canvas) {
+ item = item.canvas;
+ }
+ return item;
+ }
+ const instances = {};
+ const getChart = (key)=>{
+ const canvas = getCanvas(key);
+ return Object.values(instances).filter((c)=>c.canvas === canvas).pop();
+ };
+ function moveNumericKeys(obj, start, move) {
+ const keys = Object.keys(obj);
+ for (const key of keys){
+ const intKey = +key;
+ if (intKey >= start) {
+ const value = obj[key];
+ delete obj[key];
+ if (move > 0 || intKey > start) {
+ obj[intKey + move] = value;
+ }
+ }
+ }
+ }
+ function determineLastEvent(e, lastEvent, inChartArea, isClick) {
+ if (!inChartArea || e.type === 'mouseout') {
+ return null;
+ }
+ if (isClick) {
+ return lastEvent;
+ }
+ return e;
+ }
+ function getSizeForArea(scale, chartArea, field) {
+ return scale.options.clip ? scale[field] : chartArea[field];
+ }
+ function getDatasetArea(meta, chartArea) {
+ const { xScale , yScale } = meta;
+ if (xScale && yScale) {
+ return {
+ left: getSizeForArea(xScale, chartArea, 'left'),
+ right: getSizeForArea(xScale, chartArea, 'right'),
+ top: getSizeForArea(yScale, chartArea, 'top'),
+ bottom: getSizeForArea(yScale, chartArea, 'bottom')
+ };
+ }
+ return chartArea;
+ }
+ class Chart {
+ static defaults = defaults;
+ static instances = instances;
+ static overrides = overrides;
+ static registry = registry;
+ static version = version;
+ static getChart = getChart;
+ static register(...items) {
+ registry.add(...items);
+ invalidatePlugins();
+ }
+ static unregister(...items) {
+ registry.remove(...items);
+ invalidatePlugins();
+ }
+ constructor(item, userConfig){
+ const config = this.config = new Config(userConfig);
+ const initialCanvas = getCanvas(item);
+ const existingChart = getChart(initialCanvas);
+ if (existingChart) {
+ throw new Error('Canvas is already in use. Chart with ID \'' + existingChart.id + '\'' + ' must be destroyed before the canvas with ID \'' + existingChart.canvas.id + '\' can be reused.');
+ }
+ const options = config.createResolver(config.chartOptionScopes(), this.getContext());
+ this.platform = new (config.platform || _detectPlatform(initialCanvas))();
+ this.platform.updateConfig(config);
+ const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);
+ const canvas = context && context.canvas;
+ const height = canvas && canvas.height;
+ const width = canvas && canvas.width;
+ this.id = uid();
+ this.ctx = context;
+ this.canvas = canvas;
+ this.width = width;
+ this.height = height;
+ this._options = options;
+ this._aspectRatio = this.aspectRatio;
+ this._layers = [];
+ this._metasets = [];
+ this._stacks = undefined;
+ this.boxes = [];
+ this.currentDevicePixelRatio = undefined;
+ this.chartArea = undefined;
+ this._active = [];
+ this._lastEvent = undefined;
+ this._listeners = {};
+ this._responsiveListeners = undefined;
+ this._sortedMetasets = [];
+ this.scales = {};
+ this._plugins = new PluginService();
+ this.$proxies = {};
+ this._hiddenIndices = {};
+ this.attached = false;
+ this._animationsDisabled = undefined;
+ this.$context = undefined;
+ this._doResize = debounce((mode)=>this.update(mode), options.resizeDelay || 0);
+ this._dataChanges = [];
+ instances[this.id] = this;
+ if (!context || !canvas) {
+ console.error("Failed to create chart: can't acquire context from the given item");
+ return;
+ }
+ animator.listen(this, 'complete', onAnimationsComplete);
+ animator.listen(this, 'progress', onAnimationProgress);
+ this._initialize();
+ if (this.attached) {
+ this.update();
+ }
+ }
+ get aspectRatio() {
+ const { options: { aspectRatio , maintainAspectRatio } , width , height , _aspectRatio } = this;
+ if (!isNullOrUndef(aspectRatio)) {
+ return aspectRatio;
+ }
+ if (maintainAspectRatio && _aspectRatio) {
+ return _aspectRatio;
+ }
+ return height ? width / height : null;
+ }
+ get data() {
+ return this.config.data;
+ }
+ set data(data) {
+ this.config.data = data;
+ }
+ get options() {
+ return this._options;
+ }
+ set options(options) {
+ this.config.options = options;
+ }
+ get registry() {
+ return registry;
+ }
+ _initialize() {
+ this.notifyPlugins('beforeInit');
+ if (this.options.responsive) {
+ this.resize();
+ } else {
+ retinaScale(this, this.options.devicePixelRatio);
+ }
+ this.bindEvents();
+ this.notifyPlugins('afterInit');
+ return this;
+ }
+ clear() {
+ clearCanvas(this.canvas, this.ctx);
+ return this;
+ }
+ stop() {
+ animator.stop(this);
+ return this;
+ }
+ resize(width, height) {
+ if (!animator.running(this)) {
+ this._resize(width, height);
+ } else {
+ this._resizeBeforeDraw = {
+ width,
+ height
+ };
+ }
+ }
+ _resize(width, height) {
+ const options = this.options;
+ const canvas = this.canvas;
+ const aspectRatio = options.maintainAspectRatio && this.aspectRatio;
+ const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);
+ const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();
+ const mode = this.width ? 'resize' : 'attach';
+ this.width = newSize.width;
+ this.height = newSize.height;
+ this._aspectRatio = this.aspectRatio;
+ if (!retinaScale(this, newRatio, true)) {
+ return;
+ }
+ this.notifyPlugins('resize', {
+ size: newSize
+ });
+ callback(options.onResize, [
+ this,
+ newSize
+ ], this);
+ if (this.attached) {
+ if (this._doResize(mode)) {
+ this.render();
+ }
+ }
+ }
+ ensureScalesHaveIDs() {
+ const options = this.options;
+ const scalesOptions = options.scales || {};
+ each(scalesOptions, (axisOptions, axisID)=>{
+ axisOptions.id = axisID;
+ });
+ }
+ buildOrUpdateScales() {
+ const options = this.options;
+ const scaleOpts = options.scales;
+ const scales = this.scales;
+ const updated = Object.keys(scales).reduce((obj, id)=>{
+ obj[id] = false;
+ return obj;
+ }, {});
+ let items = [];
+ if (scaleOpts) {
+ items = items.concat(Object.keys(scaleOpts).map((id)=>{
+ const scaleOptions = scaleOpts[id];
+ const axis = determineAxis(id, scaleOptions);
+ const isRadial = axis === 'r';
+ const isHorizontal = axis === 'x';
+ return {
+ options: scaleOptions,
+ dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left',
+ dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear'
+ };
+ }));
+ }
+ each(items, (item)=>{
+ const scaleOptions = item.options;
+ const id = scaleOptions.id;
+ const axis = determineAxis(id, scaleOptions);
+ const scaleType = valueOrDefault(scaleOptions.type, item.dtype);
+ if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {
+ scaleOptions.position = item.dposition;
+ }
+ updated[id] = true;
+ let scale = null;
+ if (id in scales && scales[id].type === scaleType) {
+ scale = scales[id];
+ } else {
+ const scaleClass = registry.getScale(scaleType);
+ scale = new scaleClass({
+ id,
+ type: scaleType,
+ ctx: this.ctx,
+ chart: this
+ });
+ scales[scale.id] = scale;
+ }
+ scale.init(scaleOptions, options);
+ });
+ each(updated, (hasUpdated, id)=>{
+ if (!hasUpdated) {
+ delete scales[id];
+ }
+ });
+ each(scales, (scale)=>{
+ layouts.configure(this, scale, scale.options);
+ layouts.addBox(this, scale);
+ });
+ }
+ _updateMetasets() {
+ const metasets = this._metasets;
+ const numData = this.data.datasets.length;
+ const numMeta = metasets.length;
+ metasets.sort((a, b)=>a.index - b.index);
+ if (numMeta > numData) {
+ for(let i = numData; i < numMeta; ++i){
+ this._destroyDatasetMeta(i);
+ }
+ metasets.splice(numData, numMeta - numData);
+ }
+ this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index'));
+ }
+ _removeUnreferencedMetasets() {
+ const { _metasets: metasets , data: { datasets } } = this;
+ if (metasets.length > datasets.length) {
+ delete this._stacks;
+ }
+ metasets.forEach((meta, index)=>{
+ if (datasets.filter((x)=>x === meta._dataset).length === 0) {
+ this._destroyDatasetMeta(index);
+ }
+ });
+ }
+ buildOrUpdateControllers() {
+ const newControllers = [];
+ const datasets = this.data.datasets;
+ let i, ilen;
+ this._removeUnreferencedMetasets();
+ for(i = 0, ilen = datasets.length; i < ilen; i++){
+ const dataset = datasets[i];
+ let meta = this.getDatasetMeta(i);
+ const type = dataset.type || this.config.type;
+ if (meta.type && meta.type !== type) {
+ this._destroyDatasetMeta(i);
+ meta = this.getDatasetMeta(i);
+ }
+ meta.type = type;
+ meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);
+ meta.order = dataset.order || 0;
+ meta.index = i;
+ meta.label = '' + dataset.label;
+ meta.visible = this.isDatasetVisible(i);
+ if (meta.controller) {
+ meta.controller.updateIndex(i);
+ meta.controller.linkScales();
+ } else {
+ const ControllerClass = registry.getController(type);
+ const { datasetElementType , dataElementType } = defaults.datasets[type];
+ Object.assign(ControllerClass, {
+ dataElementType: registry.getElement(dataElementType),
+ datasetElementType: datasetElementType && registry.getElement(datasetElementType)
+ });
+ meta.controller = new ControllerClass(this, i);
+ newControllers.push(meta.controller);
+ }
+ }
+ this._updateMetasets();
+ return newControllers;
+ }
+ _resetElements() {
+ each(this.data.datasets, (dataset, datasetIndex)=>{
+ this.getDatasetMeta(datasetIndex).controller.reset();
+ }, this);
+ }
+ reset() {
+ this._resetElements();
+ this.notifyPlugins('reset');
+ }
+ update(mode) {
+ const config = this.config;
+ config.update();
+ const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());
+ const animsDisabled = this._animationsDisabled = !options.animation;
+ this._updateScales();
+ this._checkEventBindings();
+ this._updateHiddenIndices();
+ this._plugins.invalidate();
+ if (this.notifyPlugins('beforeUpdate', {
+ mode,
+ cancelable: true
+ }) === false) {
+ return;
+ }
+ const newControllers = this.buildOrUpdateControllers();
+ this.notifyPlugins('beforeElementsUpdate');
+ let minPadding = 0;
+ for(let i = 0, ilen = this.data.datasets.length; i < ilen; i++){
+ const { controller } = this.getDatasetMeta(i);
+ const reset = !animsDisabled && newControllers.indexOf(controller) === -1;
+ controller.buildOrUpdateElements(reset);
+ minPadding = Math.max(+controller.getMaxOverflow(), minPadding);
+ }
+ minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;
+ this._updateLayout(minPadding);
+ if (!animsDisabled) {
+ each(newControllers, (controller)=>{
+ controller.reset();
+ });
+ }
+ this._updateDatasets(mode);
+ this.notifyPlugins('afterUpdate', {
+ mode
+ });
+ this._layers.sort(compare2Level('z', '_idx'));
+ const { _active , _lastEvent } = this;
+ if (_lastEvent) {
+ this._eventHandler(_lastEvent, true);
+ } else if (_active.length) {
+ this._updateHoverStyles(_active, _active, true);
+ }
+ this.render();
+ }
+ _updateScales() {
+ each(this.scales, (scale)=>{
+ layouts.removeBox(this, scale);
+ });
+ this.ensureScalesHaveIDs();
+ this.buildOrUpdateScales();
+ }
+ _checkEventBindings() {
+ const options = this.options;
+ const existingEvents = new Set(Object.keys(this._listeners));
+ const newEvents = new Set(options.events);
+ if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {
+ this.unbindEvents();
+ this.bindEvents();
+ }
+ }
+ _updateHiddenIndices() {
+ const { _hiddenIndices } = this;
+ const changes = this._getUniformDataChanges() || [];
+ for (const { method , start , count } of changes){
+ const move = method === '_removeElements' ? -count : count;
+ moveNumericKeys(_hiddenIndices, start, move);
+ }
+ }
+ _getUniformDataChanges() {
+ const _dataChanges = this._dataChanges;
+ if (!_dataChanges || !_dataChanges.length) {
+ return;
+ }
+ this._dataChanges = [];
+ const datasetCount = this.data.datasets.length;
+ const makeSet = (idx)=>new Set(_dataChanges.filter((c)=>c[0] === idx).map((c, i)=>i + ',' + c.splice(1).join(',')));
+ const changeSet = makeSet(0);
+ for(let i = 1; i < datasetCount; i++){
+ if (!setsEqual(changeSet, makeSet(i))) {
+ return;
+ }
+ }
+ return Array.from(changeSet).map((c)=>c.split(',')).map((a)=>({
+ method: a[1],
+ start: +a[2],
+ count: +a[3]
+ }));
+ }
+ _updateLayout(minPadding) {
+ if (this.notifyPlugins('beforeLayout', {
+ cancelable: true
+ }) === false) {
+ return;
+ }
+ layouts.update(this, this.width, this.height, minPadding);
+ const area = this.chartArea;
+ const noArea = area.width <= 0 || area.height <= 0;
+ this._layers = [];
+ each(this.boxes, (box)=>{
+ if (noArea && box.position === 'chartArea') {
+ return;
+ }
+ if (box.configure) {
+ box.configure();
+ }
+ this._layers.push(...box._layers());
+ }, this);
+ this._layers.forEach((item, index)=>{
+ item._idx = index;
+ });
+ this.notifyPlugins('afterLayout');
+ }
+ _updateDatasets(mode) {
+ if (this.notifyPlugins('beforeDatasetsUpdate', {
+ mode,
+ cancelable: true
+ }) === false) {
+ return;
+ }
+ for(let i = 0, ilen = this.data.datasets.length; i < ilen; ++i){
+ this.getDatasetMeta(i).controller.configure();
+ }
+ for(let i = 0, ilen = this.data.datasets.length; i < ilen; ++i){
+ this._updateDataset(i, isFunction(mode) ? mode({
+ datasetIndex: i
+ }) : mode);
+ }
+ this.notifyPlugins('afterDatasetsUpdate', {
+ mode
+ });
+ }
+ _updateDataset(index, mode) {
+ const meta = this.getDatasetMeta(index);
+ const args = {
+ meta,
+ index,
+ mode,
+ cancelable: true
+ };
+ if (this.notifyPlugins('beforeDatasetUpdate', args) === false) {
+ return;
+ }
+ meta.controller._update(mode);
+ args.cancelable = false;
+ this.notifyPlugins('afterDatasetUpdate', args);
+ }
+ render() {
+ if (this.notifyPlugins('beforeRender', {
+ cancelable: true
+ }) === false) {
+ return;
+ }
+ if (animator.has(this)) {
+ if (this.attached && !animator.running(this)) {
+ animator.start(this);
+ }
+ } else {
+ this.draw();
+ onAnimationsComplete({
+ chart: this
+ });
+ }
+ }
+ draw() {
+ let i;
+ if (this._resizeBeforeDraw) {
+ const { width , height } = this._resizeBeforeDraw;
+ this._resize(width, height);
+ this._resizeBeforeDraw = null;
+ }
+ this.clear();
+ if (this.width <= 0 || this.height <= 0) {
+ return;
+ }
+ if (this.notifyPlugins('beforeDraw', {
+ cancelable: true
+ }) === false) {
+ return;
+ }
+ const layers = this._layers;
+ for(i = 0; i < layers.length && layers[i].z <= 0; ++i){
+ layers[i].draw(this.chartArea);
+ }
+ this._drawDatasets();
+ for(; i < layers.length; ++i){
+ layers[i].draw(this.chartArea);
+ }
+ this.notifyPlugins('afterDraw');
+ }
+ _getSortedDatasetMetas(filterVisible) {
+ const metasets = this._sortedMetasets;
+ const result = [];
+ let i, ilen;
+ for(i = 0, ilen = metasets.length; i < ilen; ++i){
+ const meta = metasets[i];
+ if (!filterVisible || meta.visible) {
+ result.push(meta);
+ }
+ }
+ return result;
+ }
+ getSortedVisibleDatasetMetas() {
+ return this._getSortedDatasetMetas(true);
+ }
+ _drawDatasets() {
+ if (this.notifyPlugins('beforeDatasetsDraw', {
+ cancelable: true
+ }) === false) {
+ return;
+ }
+ const metasets = this.getSortedVisibleDatasetMetas();
+ for(let i = metasets.length - 1; i >= 0; --i){
+ this._drawDataset(metasets[i]);
+ }
+ this.notifyPlugins('afterDatasetsDraw');
+ }
+ _drawDataset(meta) {
+ const ctx = this.ctx;
+ const clip = meta._clip;
+ const useClip = !clip.disabled;
+ const area = getDatasetArea(meta, this.chartArea);
+ const args = {
+ meta,
+ index: meta.index,
+ cancelable: true
+ };
+ if (this.notifyPlugins('beforeDatasetDraw', args) === false) {
+ return;
+ }
+ if (useClip) {
+ clipArea(ctx, {
+ left: clip.left === false ? 0 : area.left - clip.left,
+ right: clip.right === false ? this.width : area.right + clip.right,
+ top: clip.top === false ? 0 : area.top - clip.top,
+ bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom
+ });
+ }
+ meta.controller.draw();
+ if (useClip) {
+ unclipArea(ctx);
+ }
+ args.cancelable = false;
+ this.notifyPlugins('afterDatasetDraw', args);
+ }
+ isPointInArea(point) {
+ return _isPointInArea(point, this.chartArea, this._minPadding);
+ }
+ getElementsAtEventForMode(e, mode, options, useFinalPosition) {
+ const method = Interaction.modes[mode];
+ if (typeof method === 'function') {
+ return method(this, e, options, useFinalPosition);
+ }
+ return [];
+ }
+ getDatasetMeta(datasetIndex) {
+ const dataset = this.data.datasets[datasetIndex];
+ const metasets = this._metasets;
+ let meta = metasets.filter((x)=>x && x._dataset === dataset).pop();
+ if (!meta) {
+ meta = {
+ type: null,
+ data: [],
+ dataset: null,
+ controller: null,
+ hidden: null,
+ xAxisID: null,
+ yAxisID: null,
+ order: dataset && dataset.order || 0,
+ index: datasetIndex,
+ _dataset: dataset,
+ _parsed: [],
+ _sorted: false
+ };
+ metasets.push(meta);
+ }
+ return meta;
+ }
+ getContext() {
+ return this.$context || (this.$context = createContext(null, {
+ chart: this,
+ type: 'chart'
+ }));
+ }
+ getVisibleDatasetCount() {
+ return this.getSortedVisibleDatasetMetas().length;
+ }
+ isDatasetVisible(datasetIndex) {
+ const dataset = this.data.datasets[datasetIndex];
+ if (!dataset) {
+ return false;
+ }
+ const meta = this.getDatasetMeta(datasetIndex);
+ return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden;
+ }
+ setDatasetVisibility(datasetIndex, visible) {
+ const meta = this.getDatasetMeta(datasetIndex);
+ meta.hidden = !visible;
+ }
+ toggleDataVisibility(index) {
+ this._hiddenIndices[index] = !this._hiddenIndices[index];
+ }
+ getDataVisibility(index) {
+ return !this._hiddenIndices[index];
+ }
+ _updateVisibility(datasetIndex, dataIndex, visible) {
+ const mode = visible ? 'show' : 'hide';
+ const meta = this.getDatasetMeta(datasetIndex);
+ const anims = meta.controller._resolveAnimations(undefined, mode);
+ if (defined(dataIndex)) {
+ meta.data[dataIndex].hidden = !visible;
+ this.update();
+ } else {
+ this.setDatasetVisibility(datasetIndex, visible);
+ anims.update(meta, {
+ visible
+ });
+ this.update((ctx)=>ctx.datasetIndex === datasetIndex ? mode : undefined);
+ }
+ }
+ hide(datasetIndex, dataIndex) {
+ this._updateVisibility(datasetIndex, dataIndex, false);
+ }
+ show(datasetIndex, dataIndex) {
+ this._updateVisibility(datasetIndex, dataIndex, true);
+ }
+ _destroyDatasetMeta(datasetIndex) {
+ const meta = this._metasets[datasetIndex];
+ if (meta && meta.controller) {
+ meta.controller._destroy();
+ }
+ delete this._metasets[datasetIndex];
+ }
+ _stop() {
+ let i, ilen;
+ this.stop();
+ animator.remove(this);
+ for(i = 0, ilen = this.data.datasets.length; i < ilen; ++i){
+ this._destroyDatasetMeta(i);
+ }
+ }
+ destroy() {
+ this.notifyPlugins('beforeDestroy');
+ const { canvas , ctx } = this;
+ this._stop();
+ this.config.clearCache();
+ if (canvas) {
+ this.unbindEvents();
+ clearCanvas(canvas, ctx);
+ this.platform.releaseContext(ctx);
+ this.canvas = null;
+ this.ctx = null;
+ }
+ delete instances[this.id];
+ this.notifyPlugins('afterDestroy');
+ }
+ toBase64Image(...args) {
+ return this.canvas.toDataURL(...args);
+ }
+ bindEvents() {
+ this.bindUserEvents();
+ if (this.options.responsive) {
+ this.bindResponsiveEvents();
+ } else {
+ this.attached = true;
+ }
+ }
+ bindUserEvents() {
+ const listeners = this._listeners;
+ const platform = this.platform;
+ const _add = (type, listener)=>{
+ platform.addEventListener(this, type, listener);
+ listeners[type] = listener;
+ };
+ const listener = (e, x, y)=>{
+ e.offsetX = x;
+ e.offsetY = y;
+ this._eventHandler(e);
+ };
+ each(this.options.events, (type)=>_add(type, listener));
+ }
+ bindResponsiveEvents() {
+ if (!this._responsiveListeners) {
+ this._responsiveListeners = {};
+ }
+ const listeners = this._responsiveListeners;
+ const platform = this.platform;
+ const _add = (type, listener)=>{
+ platform.addEventListener(this, type, listener);
+ listeners[type] = listener;
+ };
+ const _remove = (type, listener)=>{
+ if (listeners[type]) {
+ platform.removeEventListener(this, type, listener);
+ delete listeners[type];
+ }
+ };
+ const listener = (width, height)=>{
+ if (this.canvas) {
+ this.resize(width, height);
+ }
+ };
+ let detached;
+ const attached = ()=>{
+ _remove('attach', attached);
+ this.attached = true;
+ this.resize();
+ _add('resize', listener);
+ _add('detach', detached);
+ };
+ detached = ()=>{
+ this.attached = false;
+ _remove('resize', listener);
+ this._stop();
+ this._resize(0, 0);
+ _add('attach', attached);
+ };
+ if (platform.isAttached(this.canvas)) {
+ attached();
+ } else {
+ detached();
+ }
+ }
+ unbindEvents() {
+ each(this._listeners, (listener, type)=>{
+ this.platform.removeEventListener(this, type, listener);
+ });
+ this._listeners = {};
+ each(this._responsiveListeners, (listener, type)=>{
+ this.platform.removeEventListener(this, type, listener);
+ });
+ this._responsiveListeners = undefined;
+ }
+ updateHoverStyle(items, mode, enabled) {
+ const prefix = enabled ? 'set' : 'remove';
+ let meta, item, i, ilen;
+ if (mode === 'dataset') {
+ meta = this.getDatasetMeta(items[0].datasetIndex);
+ meta.controller['_' + prefix + 'DatasetHoverStyle']();
+ }
+ for(i = 0, ilen = items.length; i < ilen; ++i){
+ item = items[i];
+ const controller = item && this.getDatasetMeta(item.datasetIndex).controller;
+ if (controller) {
+ controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index);
+ }
+ }
+ }
+ getActiveElements() {
+ return this._active || [];
+ }
+ setActiveElements(activeElements) {
+ const lastActive = this._active || [];
+ const active = activeElements.map(({ datasetIndex , index })=>{
+ const meta = this.getDatasetMeta(datasetIndex);
+ if (!meta) {
+ throw new Error('No dataset found at index ' + datasetIndex);
+ }
+ return {
+ datasetIndex,
+ element: meta.data[index],
+ index
+ };
+ });
+ const changed = !_elementsEqual(active, lastActive);
+ if (changed) {
+ this._active = active;
+ this._lastEvent = null;
+ this._updateHoverStyles(active, lastActive);
+ }
+ }
+ notifyPlugins(hook, args, filter) {
+ return this._plugins.notify(this, hook, args, filter);
+ }
+ isPluginEnabled(pluginId) {
+ return this._plugins._cache.filter((p)=>p.plugin.id === pluginId).length === 1;
+ }
+ _updateHoverStyles(active, lastActive, replay) {
+ const hoverOptions = this.options.hover;
+ const diff = (a, b)=>a.filter((x)=>!b.some((y)=>x.datasetIndex === y.datasetIndex && x.index === y.index));
+ const deactivated = diff(lastActive, active);
+ const activated = replay ? active : diff(active, lastActive);
+ if (deactivated.length) {
+ this.updateHoverStyle(deactivated, hoverOptions.mode, false);
+ }
+ if (activated.length && hoverOptions.mode) {
+ this.updateHoverStyle(activated, hoverOptions.mode, true);
+ }
+ }
+ _eventHandler(e, replay) {
+ const args = {
+ event: e,
+ replay,
+ cancelable: true,
+ inChartArea: this.isPointInArea(e)
+ };
+ const eventFilter = (plugin)=>(plugin.options.events || this.options.events).includes(e.native.type);
+ if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) {
+ return;
+ }
+ const changed = this._handleEvent(e, replay, args.inChartArea);
+ args.cancelable = false;
+ this.notifyPlugins('afterEvent', args, eventFilter);
+ if (changed || args.changed) {
+ this.render();
+ }
+ return this;
+ }
+ _handleEvent(e, replay, inChartArea) {
+ const { _active: lastActive = [] , options } = this;
+ const useFinalPosition = replay;
+ const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);
+ const isClick = _isClickEvent(e);
+ const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);
+ if (inChartArea) {
+ this._lastEvent = null;
+ callback(options.onHover, [
+ e,
+ active,
+ this
+ ], this);
+ if (isClick) {
+ callback(options.onClick, [
+ e,
+ active,
+ this
+ ], this);
+ }
+ }
+ const changed = !_elementsEqual(active, lastActive);
+ if (changed || replay) {
+ this._active = active;
+ this._updateHoverStyles(active, lastActive, replay);
+ }
+ this._lastEvent = lastEvent;
+ return changed;
+ }
+ _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {
+ if (e.type === 'mouseout') {
+ return [];
+ }
+ if (!inChartArea) {
+ return lastActive;
+ }
+ const hoverOptions = this.options.hover;
+ return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);
+ }
+ }
+ function invalidatePlugins() {
+ return each(Chart.instances, (chart)=>chart._plugins.invalidate());
+ }
+
+ /**
+ * @namespace Chart._adapters
+ * @since 2.8.0
+ * @private
+ */ function abstract() {
+ throw new Error('This method is not implemented: Check that a complete date adapter is provided.');
+ }
+ /**
+ * Date adapter (current used by the time scale)
+ * @namespace Chart._adapters._date
+ * @memberof Chart._adapters
+ * @private
+ */ class DateAdapterBase {
+ /**
+ * Override default date adapter methods.
+ * Accepts type parameter to define options type.
+ * @example
+ * Chart._adapters._date.override<{myAdapterOption: string}>({
+ * init() {
+ * console.log(this.options.myAdapterOption);
+ * }
+ * })
+ */ static override(members) {
+ Object.assign(DateAdapterBase.prototype, members);
+ }
+ options;
+ constructor(options){
+ this.options = options || {};
+ }
+ // eslint-disable-next-line @typescript-eslint/no-empty-function
+ 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 getAllScaleValues(scale, type) {
+ if (!scale._cache.$bar) {
+ const visibleMetas = scale.getMatchingVisibleMetas(type);
+ let values = [];
+ for(let i = 0, ilen = visibleMetas.length; i < ilen; i++){
+ values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale));
+ }
+ scale._cache.$bar = _arrayUnique(values.sort((a, b)=>a - b));
+ }
+ return scale._cache.$bar;
+ }
+ function computeMinSampleSize(meta) {
+ const scale = meta.iScale;
+ const values = getAllScaleValues(scale, meta.type);
+ let min = scale._length;
+ let i, ilen, curr, prev;
+ const updateMinAndPrev = ()=>{
+ if (curr === 32767 || curr === -32768) {
+ return;
+ }
+ if (defined(prev)) {
+ min = Math.min(min, Math.abs(curr - prev) || min);
+ }
+ prev = curr;
+ };
+ for(i = 0, ilen = values.length; i < ilen; ++i){
+ curr = scale.getPixelForValue(values[i]);
+ updateMinAndPrev();
+ }
+ prev = undefined;
+ for(i = 0, ilen = scale.ticks.length; i < ilen; ++i){
+ curr = scale.getPixelForTick(i);
+ updateMinAndPrev();
+ }
+ return min;
+ }
+ function computeFitCategoryTraits(index, ruler, options, stackCount) {
+ const thickness = options.barThickness;
+ let size, ratio;
+ if (isNullOrUndef(thickness)) {
+ size = ruler.min * options.categoryPercentage;
+ ratio = options.barPercentage;
+ } else {
+ size = thickness * stackCount;
+ ratio = 1;
+ }
+ return {
+ chunk: size / stackCount,
+ ratio,
+ start: ruler.pixels[index] - size / 2
+ };
+ }
+ function computeFlexCategoryTraits(index, ruler, options, stackCount) {
+ const pixels = ruler.pixels;
+ const curr = pixels[index];
+ let prev = index > 0 ? pixels[index - 1] : null;
+ let next = index < pixels.length - 1 ? pixels[index + 1] : null;
+ const percent = options.categoryPercentage;
+ if (prev === null) {
+ prev = curr - (next === null ? ruler.end - ruler.start : next - curr);
+ }
+ if (next === null) {
+ next = curr + curr - prev;
+ }
+ const start = curr - (curr - Math.min(prev, next)) / 2 * percent;
+ const size = Math.abs(next - prev) / 2 * percent;
+ return {
+ chunk: size / stackCount,
+ ratio: options.barPercentage,
+ start
+ };
+ }
+ function parseFloatBar(entry, item, vScale, i) {
+ const startValue = vScale.parse(entry[0], i);
+ const endValue = vScale.parse(entry[1], i);
+ const min = Math.min(startValue, endValue);
+ const max = Math.max(startValue, endValue);
+ let barStart = min;
+ let barEnd = max;
+ if (Math.abs(min) > Math.abs(max)) {
+ barStart = max;
+ barEnd = min;
+ }
+ item[vScale.axis] = barEnd;
+ item._custom = {
+ barStart,
+ barEnd,
+ start: startValue,
+ end: endValue,
+ min,
+ max
+ };
+ }
+ function parseValue(entry, item, vScale, i) {
+ if (isArray(entry)) {
+ parseFloatBar(entry, item, vScale, i);
+ } else {
+ item[vScale.axis] = vScale.parse(entry, i);
+ }
+ return item;
+ }
+ function parseArrayOrPrimitive(meta, data, start, count) {
+ const iScale = meta.iScale;
+ const vScale = meta.vScale;
+ const labels = iScale.getLabels();
+ const singleScale = iScale === vScale;
+ const parsed = [];
+ let i, ilen, item, entry;
+ for(i = start, ilen = start + count; i < ilen; ++i){
+ entry = data[i];
+ item = {};
+ item[iScale.axis] = singleScale || iScale.parse(labels[i], i);
+ parsed.push(parseValue(entry, item, vScale, i));
+ }
+ return parsed;
+ }
+ function isFloatBar(custom) {
+ return custom && custom.barStart !== undefined && custom.barEnd !== undefined;
+ }
+ function barSign(size, vScale, actualBase) {
+ if (size !== 0) {
+ return sign(size);
+ }
+ return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);
+ }
+ function borderProps(properties) {
+ let reverse, start, end, top, bottom;
+ if (properties.horizontal) {
+ reverse = properties.base > properties.x;
+ start = 'left';
+ end = 'right';
+ } else {
+ reverse = properties.base < properties.y;
+ start = 'bottom';
+ end = 'top';
+ }
+ if (reverse) {
+ top = 'end';
+ bottom = 'start';
+ } else {
+ top = 'start';
+ bottom = 'end';
+ }
+ return {
+ start,
+ end,
+ reverse,
+ top,
+ bottom
+ };
+ }
+ function setBorderSkipped(properties, options, stack, index) {
+ let edge = options.borderSkipped;
+ const res = {};
+ if (!edge) {
+ properties.borderSkipped = res;
+ return;
+ }
+ if (edge === true) {
+ properties.borderSkipped = {
+ top: true,
+ right: true,
+ bottom: true,
+ left: true
+ };
+ return;
+ }
+ const { start , end , reverse , top , bottom } = borderProps(properties);
+ if (edge === 'middle' && stack) {
+ properties.enableBorderRadius = true;
+ if ((stack._top || 0) === index) {
+ edge = top;
+ } else if ((stack._bottom || 0) === index) {
+ edge = bottom;
+ } else {
+ res[parseEdge(bottom, start, end, reverse)] = true;
+ edge = top;
+ }
+ }
+ res[parseEdge(edge, start, end, reverse)] = true;
+ properties.borderSkipped = res;
+ }
+ function parseEdge(edge, a, b, reverse) {
+ if (reverse) {
+ edge = swap(edge, a, b);
+ edge = startEnd(edge, b, a);
+ } else {
+ edge = startEnd(edge, a, b);
+ }
+ return edge;
+ }
+ function swap(orig, v1, v2) {
+ return orig === v1 ? v2 : orig === v2 ? v1 : orig;
+ }
+ function startEnd(v, start, end) {
+ return v === 'start' ? start : v === 'end' ? end : v;
+ }
+ function setInflateAmount(properties, { inflateAmount }, ratio) {
+ properties.inflateAmount = inflateAmount === 'auto' ? ratio === 1 ? 0.33 : 0 : inflateAmount;
+ }
+ class BarController extends DatasetController {
+ static id = 'bar';
+ static defaults = {
+ datasetElementType: false,
+ dataElementType: 'bar',
+ categoryPercentage: 0.8,
+ barPercentage: 0.9,
+ grouped: true,
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: [
+ 'x',
+ 'y',
+ 'base',
+ 'width',
+ 'height'
+ ]
+ }
+ }
+ };
+ static overrides = {
+ scales: {
+ _index_: {
+ type: 'category',
+ offset: true,
+ grid: {
+ offset: true
+ }
+ },
+ _value_: {
+ type: 'linear',
+ beginAtZero: true
+ }
+ }
+ };
+ parsePrimitiveData(meta, data, start, count) {
+ return parseArrayOrPrimitive(meta, data, start, count);
+ }
+ parseArrayData(meta, data, start, count) {
+ return parseArrayOrPrimitive(meta, data, start, count);
+ }
+ parseObjectData(meta, data, start, count) {
+ const { iScale , vScale } = meta;
+ const { xAxisKey ='x' , yAxisKey ='y' } = this._parsing;
+ const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey;
+ const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey;
+ const parsed = [];
+ let i, ilen, item, obj;
+ for(i = start, ilen = start + count; i < ilen; ++i){
+ obj = data[i];
+ item = {};
+ item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i);
+ parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i));
+ }
+ return parsed;
+ }
+ updateRangeFromParsed(range, scale, parsed, stack) {
+ super.updateRangeFromParsed(range, scale, parsed, stack);
+ const custom = parsed._custom;
+ if (custom && scale === this._cachedMeta.vScale) {
+ range.min = Math.min(range.min, custom.min);
+ range.max = Math.max(range.max, custom.max);
+ }
+ }
+ getMaxOverflow() {
+ return 0;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const { iScale , vScale } = meta;
+ const parsed = this.getParsed(index);
+ const custom = parsed._custom;
+ const value = isFloatBar(custom) ? '[' + custom.start + ', ' + custom.end + ']' : '' + vScale.getLabelForValue(parsed[vScale.axis]);
+ return {
+ label: '' + iScale.getLabelForValue(parsed[iScale.axis]),
+ value
+ };
+ }
+ initialize() {
+ this.enableOptionSharing = true;
+ super.initialize();
+ const meta = this._cachedMeta;
+ meta.stack = this.getDataset().stack;
+ }
+ update(mode) {
+ const meta = this._cachedMeta;
+ this.updateElements(meta.data, 0, meta.data.length, mode);
+ }
+ updateElements(bars, start, count, mode) {
+ const reset = mode === 'reset';
+ const { index , _cachedMeta: { vScale } } = this;
+ const base = vScale.getBasePixel();
+ const horizontal = vScale.isHorizontal();
+ const ruler = this._getRuler();
+ const { sharedOptions , includeOptions } = this._getSharedOptions(start, mode);
+ for(let i = start; i < start + count; i++){
+ const parsed = this.getParsed(i);
+ const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {
+ base,
+ head: base
+ } : this._calculateBarValuePixels(i);
+ const ipixels = this._calculateBarIndexPixels(i, ruler);
+ const stack = (parsed._stacks || {})[vScale.axis];
+ const properties = {
+ horizontal,
+ base: vpixels.base,
+ enableBorderRadius: !stack || isFloatBar(parsed._custom) || index === stack._top || index === stack._bottom,
+ x: horizontal ? vpixels.head : ipixels.center,
+ y: horizontal ? ipixels.center : vpixels.head,
+ height: horizontal ? ipixels.size : Math.abs(vpixels.size),
+ width: horizontal ? Math.abs(vpixels.size) : ipixels.size
+ };
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode);
+ }
+ const options = properties.options || bars[i].options;
+ setBorderSkipped(properties, options, stack, index);
+ setInflateAmount(properties, options, ruler.ratio);
+ this.updateElement(bars[i], i, properties, mode);
+ }
+ }
+ _getStacks(last, dataIndex) {
+ const { iScale } = this._cachedMeta;
+ const metasets = iScale.getMatchingVisibleMetas(this._type).filter((meta)=>meta.controller.options.grouped);
+ const stacked = iScale.options.stacked;
+ const stacks = [];
+ const skipNull = (meta)=>{
+ const parsed = meta.controller.getParsed(dataIndex);
+ const val = parsed && parsed[meta.vScale.axis];
+ if (isNullOrUndef(val) || isNaN(val)) {
+ return true;
+ }
+ };
+ for (const meta of metasets){
+ if (dataIndex !== undefined && skipNull(meta)) {
+ continue;
+ }
+ if (stacked === false || stacks.indexOf(meta.stack) === -1 || stacked === undefined && meta.stack === undefined) {
+ stacks.push(meta.stack);
+ }
+ if (meta.index === last) {
+ break;
+ }
+ }
+ if (!stacks.length) {
+ stacks.push(undefined);
+ }
+ return stacks;
+ }
+ _getStackCount(index) {
+ return this._getStacks(undefined, index).length;
+ }
+ _getStackIndex(datasetIndex, name, dataIndex) {
+ const stacks = this._getStacks(datasetIndex, dataIndex);
+ const index = name !== undefined ? stacks.indexOf(name) : -1;
+ return index === -1 ? stacks.length - 1 : index;
+ }
+ _getRuler() {
+ const opts = this.options;
+ const meta = this._cachedMeta;
+ const iScale = meta.iScale;
+ const pixels = [];
+ let i, ilen;
+ for(i = 0, ilen = meta.data.length; i < ilen; ++i){
+ pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i));
+ }
+ const barThickness = opts.barThickness;
+ const min = barThickness || computeMinSampleSize(meta);
+ return {
+ min,
+ pixels,
+ start: iScale._startPixel,
+ end: iScale._endPixel,
+ stackCount: this._getStackCount(),
+ scale: iScale,
+ grouped: opts.grouped,
+ ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage
+ };
+ }
+ _calculateBarValuePixels(index) {
+ const { _cachedMeta: { vScale , _stacked , index: datasetIndex } , options: { base: baseValue , minBarLength } } = this;
+ const actualBase = baseValue || 0;
+ const parsed = this.getParsed(index);
+ const custom = parsed._custom;
+ const floating = isFloatBar(custom);
+ let value = parsed[vScale.axis];
+ let start = 0;
+ let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;
+ let head, size;
+ if (length !== value) {
+ start = length - value;
+ length = value;
+ }
+ if (floating) {
+ value = custom.barStart;
+ length = custom.barEnd - custom.barStart;
+ if (value !== 0 && sign(value) !== sign(custom.barEnd)) {
+ start = 0;
+ }
+ start += value;
+ }
+ const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;
+ let base = vScale.getPixelForValue(startValue);
+ if (this.chart.getDataVisibility(index)) {
+ head = vScale.getPixelForValue(start + length);
+ } else {
+ head = base;
+ }
+ size = head - base;
+ if (Math.abs(size) < minBarLength) {
+ size = barSign(size, vScale, actualBase) * minBarLength;
+ if (value === actualBase) {
+ base -= size / 2;
+ }
+ const startPixel = vScale.getPixelForDecimal(0);
+ const endPixel = vScale.getPixelForDecimal(1);
+ const min = Math.min(startPixel, endPixel);
+ const max = Math.max(startPixel, endPixel);
+ base = Math.max(Math.min(base, max), min);
+ head = base + size;
+ if (_stacked && !floating) {
+ parsed._stacks[vScale.axis]._visualValues[datasetIndex] = vScale.getValueForPixel(head) - vScale.getValueForPixel(base);
+ }
+ }
+ if (base === vScale.getPixelForValue(actualBase)) {
+ const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;
+ base += halfGrid;
+ size -= halfGrid;
+ }
+ return {
+ size,
+ base,
+ head,
+ center: head + size / 2
+ };
+ }
+ _calculateBarIndexPixels(index, ruler) {
+ const scale = ruler.scale;
+ const options = this.options;
+ const skipNull = options.skipNull;
+ const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);
+ let center, size;
+ if (ruler.grouped) {
+ const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;
+ const range = options.barThickness === 'flex' ? computeFlexCategoryTraits(index, ruler, options, stackCount) : computeFitCategoryTraits(index, ruler, options, stackCount);
+ const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined);
+ center = range.start + range.chunk * stackIndex + range.chunk / 2;
+ size = Math.min(maxBarThickness, range.chunk * range.ratio);
+ } else {
+ center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);
+ size = Math.min(maxBarThickness, ruler.min * ruler.ratio);
+ }
+ return {
+ base: center - size / 2,
+ head: center + size / 2,
+ center,
+ size
+ };
+ }
+ draw() {
+ const meta = this._cachedMeta;
+ const vScale = meta.vScale;
+ const rects = meta.data;
+ const ilen = rects.length;
+ let i = 0;
+ for(; i < ilen; ++i){
+ if (this.getParsed(i)[vScale.axis] !== null) {
+ rects[i].draw(this._ctx);
+ }
+ }
+ }
+ }
+
+ class BubbleController extends DatasetController {
+ static id = 'bubble';
+ static defaults = {
+ datasetElementType: false,
+ dataElementType: 'point',
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: [
+ 'x',
+ 'y',
+ 'borderWidth',
+ 'radius'
+ ]
+ }
+ }
+ };
+ static overrides = {
+ scales: {
+ x: {
+ type: 'linear'
+ },
+ y: {
+ type: 'linear'
+ }
+ }
+ };
+ initialize() {
+ this.enableOptionSharing = true;
+ super.initialize();
+ }
+ parsePrimitiveData(meta, data, start, count) {
+ const parsed = super.parsePrimitiveData(meta, data, start, count);
+ for(let i = 0; i < parsed.length; i++){
+ parsed[i]._custom = this.resolveDataElementOptions(i + start).radius;
+ }
+ return parsed;
+ }
+ parseArrayData(meta, data, start, count) {
+ const parsed = super.parseArrayData(meta, data, start, count);
+ for(let i = 0; i < parsed.length; i++){
+ const item = data[start + i];
+ parsed[i]._custom = valueOrDefault(item[2], this.resolveDataElementOptions(i + start).radius);
+ }
+ return parsed;
+ }
+ parseObjectData(meta, data, start, count) {
+ const parsed = super.parseObjectData(meta, data, start, count);
+ for(let i = 0; i < parsed.length; i++){
+ const item = data[start + i];
+ parsed[i]._custom = valueOrDefault(item && item.r && +item.r, this.resolveDataElementOptions(i + start).radius);
+ }
+ return parsed;
+ }
+ getMaxOverflow() {
+ const data = this._cachedMeta.data;
+ let max = 0;
+ for(let i = data.length - 1; i >= 0; --i){
+ max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2);
+ }
+ return max > 0 && max;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const labels = this.chart.data.labels || [];
+ const { xScale , yScale } = meta;
+ const parsed = this.getParsed(index);
+ const x = xScale.getLabelForValue(parsed.x);
+ const y = yScale.getLabelForValue(parsed.y);
+ const r = parsed._custom;
+ return {
+ label: labels[index] || '',
+ value: '(' + x + ', ' + y + (r ? ', ' + r : '') + ')'
+ };
+ }
+ update(mode) {
+ const points = this._cachedMeta.data;
+ this.updateElements(points, 0, points.length, mode);
+ }
+ updateElements(points, start, count, mode) {
+ const reset = mode === 'reset';
+ const { iScale , vScale } = this._cachedMeta;
+ const { sharedOptions , includeOptions } = this._getSharedOptions(start, mode);
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ for(let i = start; i < start + count; i++){
+ const point = points[i];
+ const parsed = !reset && this.getParsed(i);
+ const properties = {};
+ const iPixel = properties[iAxis] = reset ? iScale.getPixelForDecimal(0.5) : iScale.getPixelForValue(parsed[iAxis]);
+ const vPixel = properties[vAxis] = reset ? vScale.getBasePixel() : vScale.getPixelForValue(parsed[vAxis]);
+ properties.skip = isNaN(iPixel) || isNaN(vPixel);
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);
+ if (reset) {
+ properties.options.radius = 0;
+ }
+ }
+ this.updateElement(point, i, properties, mode);
+ }
+ }
+ resolveDataElementOptions(index, mode) {
+ const parsed = this.getParsed(index);
+ let values = super.resolveDataElementOptions(index, mode);
+ if (values.$shared) {
+ values = Object.assign({}, values, {
+ $shared: false
+ });
+ }
+ const radius = values.radius;
+ if (mode !== 'active') {
+ values.radius = 0;
+ }
+ values.radius += valueOrDefault(parsed && parsed._custom, radius);
+ return values;
+ }
+ }
+
+ function getRatioAndOffset(rotation, circumference, cutout) {
+ let ratioX = 1;
+ let ratioY = 1;
+ let offsetX = 0;
+ let offsetY = 0;
+ if (circumference < TAU) {
+ const startAngle = rotation;
+ const endAngle = startAngle + circumference;
+ const startX = Math.cos(startAngle);
+ const startY = Math.sin(startAngle);
+ const endX = Math.cos(endAngle);
+ const endY = Math.sin(endAngle);
+ const calcMax = (angle, a, b)=>_angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a, a * cutout, b, b * cutout);
+ const calcMin = (angle, a, b)=>_angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a, a * cutout, b, b * cutout);
+ const maxX = calcMax(0, startX, endX);
+ const maxY = calcMax(HALF_PI, startY, endY);
+ const minX = calcMin(PI, startX, endX);
+ const minY = calcMin(PI + HALF_PI, startY, endY);
+ ratioX = (maxX - minX) / 2;
+ ratioY = (maxY - minY) / 2;
+ offsetX = -(maxX + minX) / 2;
+ offsetY = -(maxY + minY) / 2;
+ }
+ return {
+ ratioX,
+ ratioY,
+ offsetX,
+ offsetY
+ };
+ }
+ class DoughnutController extends DatasetController {
+ static id = 'doughnut';
+ static defaults = {
+ datasetElementType: false,
+ dataElementType: 'arc',
+ animation: {
+ animateRotate: true,
+ animateScale: false
+ },
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: [
+ 'circumference',
+ 'endAngle',
+ 'innerRadius',
+ 'outerRadius',
+ 'startAngle',
+ 'x',
+ 'y',
+ 'offset',
+ 'borderWidth',
+ 'spacing'
+ ]
+ }
+ },
+ cutout: '50%',
+ rotation: 0,
+ circumference: 360,
+ radius: '100%',
+ spacing: 0,
+ indexAxis: 'r'
+ };
+ static descriptors = {
+ _scriptable: (name)=>name !== 'spacing',
+ _indexable: (name)=>name !== 'spacing' && !name.startsWith('borderDash') && !name.startsWith('hoverBorderDash')
+ };
+ static overrides = {
+ aspectRatio: 1,
+ plugins: {
+ legend: {
+ labels: {
+ generateLabels (chart) {
+ const data = chart.data;
+ if (data.labels.length && data.datasets.length) {
+ const { labels: { pointStyle , color } } = chart.legend.options;
+ return data.labels.map((label, i)=>{
+ const meta = chart.getDatasetMeta(0);
+ const style = meta.controller.getStyle(i);
+ return {
+ text: label,
+ fillStyle: style.backgroundColor,
+ strokeStyle: style.borderColor,
+ fontColor: color,
+ lineWidth: style.borderWidth,
+ pointStyle: pointStyle,
+ hidden: !chart.getDataVisibility(i),
+ index: i
+ };
+ });
+ }
+ return [];
+ }
+ },
+ onClick (e, legendItem, legend) {
+ legend.chart.toggleDataVisibility(legendItem.index);
+ legend.chart.update();
+ }
+ }
+ }
+ };
+ constructor(chart, datasetIndex){
+ super(chart, datasetIndex);
+ this.enableOptionSharing = true;
+ this.innerRadius = undefined;
+ this.outerRadius = undefined;
+ this.offsetX = undefined;
+ this.offsetY = undefined;
+ }
+ linkScales() {}
+ parse(start, count) {
+ const data = this.getDataset().data;
+ const meta = this._cachedMeta;
+ if (this._parsing === false) {
+ meta._parsed = data;
+ } else {
+ let getter = (i)=>+data[i];
+ if (isObject(data[start])) {
+ const { key ='value' } = this._parsing;
+ getter = (i)=>+resolveObjectKey(data[i], key);
+ }
+ let i, ilen;
+ for(i = start, ilen = start + count; i < ilen; ++i){
+ meta._parsed[i] = getter(i);
+ }
+ }
+ }
+ _getRotation() {
+ return toRadians(this.options.rotation - 90);
+ }
+ _getCircumference() {
+ return toRadians(this.options.circumference);
+ }
+ _getRotationExtents() {
+ let min = TAU;
+ let max = -TAU;
+ for(let i = 0; i < this.chart.data.datasets.length; ++i){
+ if (this.chart.isDatasetVisible(i) && this.chart.getDatasetMeta(i).type === this._type) {
+ const controller = this.chart.getDatasetMeta(i).controller;
+ const rotation = controller._getRotation();
+ const circumference = controller._getCircumference();
+ min = Math.min(min, rotation);
+ max = Math.max(max, rotation + circumference);
+ }
+ }
+ return {
+ rotation: min,
+ circumference: max - min
+ };
+ }
+ update(mode) {
+ const chart = this.chart;
+ const { chartArea } = chart;
+ const meta = this._cachedMeta;
+ const arcs = meta.data;
+ const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing;
+ const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0);
+ const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1);
+ const chartWeight = this._getRingWeight(this.index);
+ const { circumference , rotation } = this._getRotationExtents();
+ const { ratioX , ratioY , offsetX , offsetY } = getRatioAndOffset(rotation, circumference, cutout);
+ const maxWidth = (chartArea.width - spacing) / ratioX;
+ const maxHeight = (chartArea.height - spacing) / ratioY;
+ const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);
+ const outerRadius = toDimension(this.options.radius, maxRadius);
+ const innerRadius = Math.max(outerRadius * cutout, 0);
+ const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal();
+ this.offsetX = offsetX * outerRadius;
+ this.offsetY = offsetY * outerRadius;
+ meta.total = this.calculateTotal();
+ this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index);
+ this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0);
+ this.updateElements(arcs, 0, arcs.length, mode);
+ }
+ _circumference(i, reset) {
+ const opts = this.options;
+ const meta = this._cachedMeta;
+ const circumference = this._getCircumference();
+ if (reset && opts.animation.animateRotate || !this.chart.getDataVisibility(i) || meta._parsed[i] === null || meta.data[i].hidden) {
+ return 0;
+ }
+ return this.calculateCircumference(meta._parsed[i] * circumference / TAU);
+ }
+ updateElements(arcs, start, count, mode) {
+ const reset = mode === 'reset';
+ const chart = this.chart;
+ const chartArea = chart.chartArea;
+ const opts = chart.options;
+ const animationOpts = opts.animation;
+ const centerX = (chartArea.left + chartArea.right) / 2;
+ const centerY = (chartArea.top + chartArea.bottom) / 2;
+ const animateScale = reset && animationOpts.animateScale;
+ const innerRadius = animateScale ? 0 : this.innerRadius;
+ const outerRadius = animateScale ? 0 : this.outerRadius;
+ const { sharedOptions , includeOptions } = this._getSharedOptions(start, mode);
+ let startAngle = this._getRotation();
+ let i;
+ for(i = 0; i < start; ++i){
+ startAngle += this._circumference(i, reset);
+ }
+ for(i = start; i < start + count; ++i){
+ const circumference = this._circumference(i, reset);
+ const arc = arcs[i];
+ const properties = {
+ x: centerX + this.offsetX,
+ y: centerY + this.offsetY,
+ startAngle,
+ endAngle: startAngle + circumference,
+ circumference,
+ outerRadius,
+ innerRadius
+ };
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, arc.active ? 'active' : mode);
+ }
+ startAngle += circumference;
+ this.updateElement(arc, i, properties, mode);
+ }
+ }
+ calculateTotal() {
+ const meta = this._cachedMeta;
+ const metaData = meta.data;
+ let total = 0;
+ let i;
+ for(i = 0; i < metaData.length; i++){
+ const value = meta._parsed[i];
+ if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i) && !metaData[i].hidden) {
+ total += Math.abs(value);
+ }
+ }
+ return total;
+ }
+ calculateCircumference(value) {
+ const total = this._cachedMeta.total;
+ if (total > 0 && !isNaN(value)) {
+ return TAU * (Math.abs(value) / total);
+ }
+ return 0;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const chart = this.chart;
+ const labels = chart.data.labels || [];
+ const value = formatNumber(meta._parsed[index], chart.options.locale);
+ return {
+ label: labels[index] || '',
+ value
+ };
+ }
+ getMaxBorderWidth(arcs) {
+ let max = 0;
+ const chart = this.chart;
+ let i, ilen, meta, controller, options;
+ if (!arcs) {
+ for(i = 0, ilen = chart.data.datasets.length; i < ilen; ++i){
+ if (chart.isDatasetVisible(i)) {
+ meta = chart.getDatasetMeta(i);
+ arcs = meta.data;
+ controller = meta.controller;
+ break;
+ }
+ }
+ }
+ if (!arcs) {
+ return 0;
+ }
+ for(i = 0, ilen = arcs.length; i < ilen; ++i){
+ options = controller.resolveDataElementOptions(i);
+ if (options.borderAlign !== 'inner') {
+ max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0);
+ }
+ }
+ return max;
+ }
+ getMaxOffset(arcs) {
+ let max = 0;
+ for(let i = 0, ilen = arcs.length; i < ilen; ++i){
+ const options = this.resolveDataElementOptions(i);
+ max = Math.max(max, options.offset || 0, options.hoverOffset || 0);
+ }
+ return max;
+ }
+ _getRingWeightOffset(datasetIndex) {
+ let ringWeightOffset = 0;
+ for(let i = 0; i < datasetIndex; ++i){
+ if (this.chart.isDatasetVisible(i)) {
+ ringWeightOffset += this._getRingWeight(i);
+ }
+ }
+ return ringWeightOffset;
+ }
+ _getRingWeight(datasetIndex) {
+ return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);
+ }
+ _getVisibleDatasetWeightTotal() {
+ return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;
+ }
+ }
+
+ class LineController extends DatasetController {
+ static id = 'line';
+ static defaults = {
+ datasetElementType: 'line',
+ dataElementType: 'point',
+ showLine: true,
+ spanGaps: false
+ };
+ static overrides = {
+ scales: {
+ _index_: {
+ type: 'category'
+ },
+ _value_: {
+ type: 'linear'
+ }
+ }
+ };
+ initialize() {
+ this.enableOptionSharing = true;
+ this.supportsDecimation = true;
+ super.initialize();
+ }
+ update(mode) {
+ const meta = this._cachedMeta;
+ const { dataset: line , data: points = [] , _dataset } = meta;
+ const animationsDisabled = this.chart._animationsDisabled;
+ let { start , count } = _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);
+ this._drawStart = start;
+ this._drawCount = count;
+ if (_scaleRangesChanged(meta)) {
+ start = 0;
+ count = points.length;
+ }
+ line._chart = this.chart;
+ line._datasetIndex = this.index;
+ line._decimated = !!_dataset._decimated;
+ line.points = points;
+ const options = this.resolveDatasetElementOptions(mode);
+ if (!this.options.showLine) {
+ options.borderWidth = 0;
+ }
+ options.segment = this.options.segment;
+ this.updateElement(line, undefined, {
+ animated: !animationsDisabled,
+ options
+ }, mode);
+ this.updateElements(points, start, count, mode);
+ }
+ updateElements(points, start, count, mode) {
+ const reset = mode === 'reset';
+ const { iScale , vScale , _stacked , _dataset } = this._cachedMeta;
+ const { sharedOptions , includeOptions } = this._getSharedOptions(start, mode);
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ const { spanGaps , segment } = this.options;
+ const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;
+ const directUpdate = this.chart._animationsDisabled || reset || mode === 'none';
+ const end = start + count;
+ const pointsCount = points.length;
+ let prevParsed = start > 0 && this.getParsed(start - 1);
+ for(let i = 0; i < pointsCount; ++i){
+ const point = points[i];
+ const properties = directUpdate ? point : {};
+ if (i < start || i >= end) {
+ properties.skip = true;
+ continue;
+ }
+ const parsed = this.getParsed(i);
+ const nullData = isNullOrUndef(parsed[vAxis]);
+ const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);
+ const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);
+ properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;
+ properties.stop = i > 0 && Math.abs(parsed[iAxis] - prevParsed[iAxis]) > maxGapLength;
+ if (segment) {
+ properties.parsed = parsed;
+ properties.raw = _dataset.data[i];
+ }
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);
+ }
+ if (!directUpdate) {
+ this.updateElement(point, i, properties, mode);
+ }
+ prevParsed = parsed;
+ }
+ }
+ getMaxOverflow() {
+ const meta = this._cachedMeta;
+ const dataset = meta.dataset;
+ const border = dataset.options && dataset.options.borderWidth || 0;
+ const data = meta.data || [];
+ if (!data.length) {
+ return border;
+ }
+ const firstPoint = data[0].size(this.resolveDataElementOptions(0));
+ const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));
+ return Math.max(border, firstPoint, lastPoint) / 2;
+ }
+ draw() {
+ const meta = this._cachedMeta;
+ meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis);
+ super.draw();
+ }
+ }
+
+ class PolarAreaController extends DatasetController {
+ static id = 'polarArea';
+ static defaults = {
+ dataElementType: 'arc',
+ animation: {
+ animateRotate: true,
+ animateScale: true
+ },
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: [
+ 'x',
+ 'y',
+ 'startAngle',
+ 'endAngle',
+ 'innerRadius',
+ 'outerRadius'
+ ]
+ }
+ },
+ indexAxis: 'r',
+ startAngle: 0
+ };
+ static overrides = {
+ aspectRatio: 1,
+ plugins: {
+ legend: {
+ labels: {
+ generateLabels (chart) {
+ const data = chart.data;
+ if (data.labels.length && data.datasets.length) {
+ const { labels: { pointStyle , color } } = chart.legend.options;
+ return data.labels.map((label, i)=>{
+ const meta = chart.getDatasetMeta(0);
+ const style = meta.controller.getStyle(i);
+ return {
+ text: label,
+ fillStyle: style.backgroundColor,
+ strokeStyle: style.borderColor,
+ fontColor: color,
+ lineWidth: style.borderWidth,
+ pointStyle: pointStyle,
+ hidden: !chart.getDataVisibility(i),
+ index: i
+ };
+ });
+ }
+ return [];
+ }
+ },
+ onClick (e, legendItem, legend) {
+ legend.chart.toggleDataVisibility(legendItem.index);
+ legend.chart.update();
+ }
+ }
+ },
+ scales: {
+ r: {
+ type: 'radialLinear',
+ angleLines: {
+ display: false
+ },
+ beginAtZero: true,
+ grid: {
+ circular: true
+ },
+ pointLabels: {
+ display: false
+ },
+ startAngle: 0
+ }
+ }
+ };
+ constructor(chart, datasetIndex){
+ super(chart, datasetIndex);
+ this.innerRadius = undefined;
+ this.outerRadius = undefined;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const chart = this.chart;
+ const labels = chart.data.labels || [];
+ const value = formatNumber(meta._parsed[index].r, chart.options.locale);
+ return {
+ label: labels[index] || '',
+ value
+ };
+ }
+ parseObjectData(meta, data, start, count) {
+ return _parseObjectDataRadialScale.bind(this)(meta, data, start, count);
+ }
+ update(mode) {
+ const arcs = this._cachedMeta.data;
+ this._updateRadius();
+ this.updateElements(arcs, 0, arcs.length, mode);
+ }
+ getMinMax() {
+ const meta = this._cachedMeta;
+ const range = {
+ min: Number.POSITIVE_INFINITY,
+ max: Number.NEGATIVE_INFINITY
+ };
+ meta.data.forEach((element, index)=>{
+ const parsed = this.getParsed(index).r;
+ if (!isNaN(parsed) && this.chart.getDataVisibility(index)) {
+ if (parsed < range.min) {
+ range.min = parsed;
+ }
+ if (parsed > range.max) {
+ range.max = parsed;
+ }
+ }
+ });
+ return range;
+ }
+ _updateRadius() {
+ const chart = this.chart;
+ const chartArea = chart.chartArea;
+ const opts = chart.options;
+ const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);
+ const outerRadius = Math.max(minSize / 2, 0);
+ const innerRadius = Math.max(opts.cutoutPercentage ? outerRadius / 100 * opts.cutoutPercentage : 1, 0);
+ const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount();
+ this.outerRadius = outerRadius - radiusLength * this.index;
+ this.innerRadius = this.outerRadius - radiusLength;
+ }
+ updateElements(arcs, start, count, mode) {
+ const reset = mode === 'reset';
+ const chart = this.chart;
+ const opts = chart.options;
+ const animationOpts = opts.animation;
+ const scale = this._cachedMeta.rScale;
+ const centerX = scale.xCenter;
+ const centerY = scale.yCenter;
+ const datasetStartAngle = scale.getIndexAngle(0) - 0.5 * PI;
+ let angle = datasetStartAngle;
+ let i;
+ const defaultAngle = 360 / this.countVisibleElements();
+ for(i = 0; i < start; ++i){
+ angle += this._computeAngle(i, mode, defaultAngle);
+ }
+ for(i = start; i < start + count; i++){
+ const arc = arcs[i];
+ let startAngle = angle;
+ let endAngle = angle + this._computeAngle(i, mode, defaultAngle);
+ let outerRadius = chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(this.getParsed(i).r) : 0;
+ angle = endAngle;
+ if (reset) {
+ if (animationOpts.animateScale) {
+ outerRadius = 0;
+ }
+ if (animationOpts.animateRotate) {
+ startAngle = endAngle = datasetStartAngle;
+ }
+ }
+ const properties = {
+ x: centerX,
+ y: centerY,
+ innerRadius: 0,
+ outerRadius,
+ startAngle,
+ endAngle,
+ options: this.resolveDataElementOptions(i, arc.active ? 'active' : mode)
+ };
+ this.updateElement(arc, i, properties, mode);
+ }
+ }
+ countVisibleElements() {
+ const meta = this._cachedMeta;
+ let count = 0;
+ meta.data.forEach((element, index)=>{
+ if (!isNaN(this.getParsed(index).r) && this.chart.getDataVisibility(index)) {
+ count++;
+ }
+ });
+ return count;
+ }
+ _computeAngle(index, mode, defaultAngle) {
+ return this.chart.getDataVisibility(index) ? toRadians(this.resolveDataElementOptions(index, mode).angle || defaultAngle) : 0;
+ }
+ }
+
+ 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: true,
+ elements: {
+ line: {
+ fill: 'start'
+ }
+ }
+ };
+ static overrides = {
+ aspectRatio: 1,
+ scales: {
+ r: {
+ type: 'radialLinear'
+ }
+ }
+ };
+ getLabelAndValue(index) {
+ const vScale = this._cachedMeta.vScale;
+ const parsed = this.getParsed(index);
+ return {
+ label: vScale.getLabels()[index],
+ value: '' + vScale.getLabelForValue(parsed[vScale.axis])
+ };
+ }
+ parseObjectData(meta, data, start, count) {
+ return _parseObjectDataRadialScale.bind(this)(meta, data, start, count);
+ }
+ update(mode) {
+ const meta = this._cachedMeta;
+ const line = meta.dataset;
+ const points = meta.data || [];
+ const labels = meta.iScale.getLabels();
+ line.points = points;
+ if (mode !== 'resize') {
+ const options = this.resolveDatasetElementOptions(mode);
+ if (!this.options.showLine) {
+ options.borderWidth = 0;
+ }
+ const properties = {
+ _loop: true,
+ _fullLoop: labels.length === points.length,
+ options
+ };
+ this.updateElement(line, undefined, properties, mode);
+ }
+ this.updateElements(points, 0, points.length, mode);
+ }
+ updateElements(points, start, count, mode) {
+ const scale = this._cachedMeta.rScale;
+ const reset = mode === 'reset';
+ for(let i = start; i < start + count; i++){
+ const point = points[i];
+ const options = this.resolveDataElementOptions(i, point.active ? 'active' : mode);
+ const pointPosition = scale.getPointPositionForValue(i, this.getParsed(i).r);
+ const x = reset ? scale.xCenter : pointPosition.x;
+ const y = reset ? scale.yCenter : pointPosition.y;
+ const properties = {
+ x,
+ y,
+ angle: pointPosition.angle,
+ skip: isNaN(x) || isNaN(y),
+ options
+ };
+ this.updateElement(point, i, properties, mode);
+ }
+ }
+ }
+
+ class ScatterController extends DatasetController {
+ static id = 'scatter';
+ static defaults = {
+ datasetElementType: false,
+ dataElementType: 'point',
+ showLine: false,
+ fill: false
+ };
+ static overrides = {
+ interaction: {
+ mode: 'point'
+ },
+ scales: {
+ x: {
+ type: 'linear'
+ },
+ y: {
+ type: 'linear'
+ }
+ }
+ };
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const labels = this.chart.data.labels || [];
+ const { xScale , yScale } = meta;
+ const parsed = this.getParsed(index);
+ const x = xScale.getLabelForValue(parsed.x);
+ const y = yScale.getLabelForValue(parsed.y);
+ return {
+ label: labels[index] || '',
+ value: '(' + x + ', ' + y + ')'
+ };
+ }
+ update(mode) {
+ const meta = this._cachedMeta;
+ const { data: points = [] } = meta;
+ const animationsDisabled = this.chart._animationsDisabled;
+ let { start , count } = _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);
+ this._drawStart = start;
+ this._drawCount = count;
+ if (_scaleRangesChanged(meta)) {
+ start = 0;
+ count = points.length;
+ }
+ if (this.options.showLine) {
+ if (!this.datasetElementType) {
+ this.addElements();
+ }
+ const { dataset: line , _dataset } = meta;
+ line._chart = this.chart;
+ line._datasetIndex = this.index;
+ line._decimated = !!_dataset._decimated;
+ line.points = points;
+ const options = this.resolveDatasetElementOptions(mode);
+ options.segment = this.options.segment;
+ this.updateElement(line, undefined, {
+ animated: !animationsDisabled,
+ options
+ }, mode);
+ } else if (this.datasetElementType) {
+ delete meta.dataset;
+ this.datasetElementType = false;
+ }
+ this.updateElements(points, start, count, mode);
+ }
+ addElements() {
+ const { showLine } = this.options;
+ if (!this.datasetElementType && showLine) {
+ this.datasetElementType = this.chart.registry.getElement('line');
+ }
+ super.addElements();
+ }
+ updateElements(points, start, count, mode) {
+ const reset = mode === 'reset';
+ const { iScale , vScale , _stacked , _dataset } = this._cachedMeta;
+ const firstOpts = this.resolveDataElementOptions(start, mode);
+ const sharedOptions = this.getSharedOptions(firstOpts);
+ const includeOptions = this.includeOptions(mode, sharedOptions);
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ const { spanGaps , segment } = this.options;
+ const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;
+ const directUpdate = this.chart._animationsDisabled || reset || mode === 'none';
+ let prevParsed = start > 0 && this.getParsed(start - 1);
+ for(let i = start; i < start + count; ++i){
+ const point = points[i];
+ const parsed = this.getParsed(i);
+ const properties = directUpdate ? point : {};
+ const nullData = isNullOrUndef(parsed[vAxis]);
+ const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);
+ const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);
+ properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;
+ properties.stop = i > 0 && Math.abs(parsed[iAxis] - prevParsed[iAxis]) > maxGapLength;
+ if (segment) {
+ properties.parsed = parsed;
+ properties.raw = _dataset.data[i];
+ }
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);
+ }
+ if (!directUpdate) {
+ this.updateElement(point, i, properties, mode);
+ }
+ prevParsed = parsed;
+ }
+ this.updateSharedOptions(sharedOptions, mode, firstOpts);
+ }
+ getMaxOverflow() {
+ const meta = this._cachedMeta;
+ const data = meta.data || [];
+ if (!this.options.showLine) {
+ let max = 0;
+ for(let i = data.length - 1; i >= 0; --i){
+ max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2);
+ }
+ return max > 0 && max;
+ }
+ const dataset = meta.dataset;
+ const border = dataset.options && dataset.options.borderWidth || 0;
+ if (!data.length) {
+ return border;
+ }
+ const firstPoint = data[0].size(this.resolveDataElementOptions(0));
+ const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));
+ return Math.max(border, firstPoint, lastPoint) / 2;
+ }
+ }
+
+ var controllers = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ BarController: BarController,
+ BubbleController: BubbleController,
+ DoughnutController: DoughnutController,
+ LineController: LineController,
+ PieController: PieController,
+ PolarAreaController: PolarAreaController,
+ RadarController: RadarController,
+ ScatterController: ScatterController
+ });
+
+ function clipArc(ctx, element, endAngle) {
+ const { startAngle , pixelMargin , x , y , outerRadius , innerRadius } = element;
+ let angleMargin = pixelMargin / outerRadius;
+ // Draw an inner border by clipping the arc and drawing a double-width border
+ // Enlarge the clipping arc by 0.33 pixels to eliminate glitches between borders
+ ctx.beginPath();
+ ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin);
+ if (innerRadius > pixelMargin) {
+ angleMargin = pixelMargin / innerRadius;
+ ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true);
+ } else {
+ ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI);
+ }
+ ctx.closePath();
+ ctx.clip();
+ }
+ function toRadiusCorners(value) {
+ return _readValueToProps(value, [
+ 'outerStart',
+ 'outerEnd',
+ 'innerStart',
+ 'innerEnd'
+ ]);
+ }
+ /**
+ * Parse border radius from the provided options
+ */ function parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) {
+ const o = toRadiusCorners(arc.options.borderRadius);
+ const halfThickness = (outerRadius - innerRadius) / 2;
+ const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2);
+ // Outer limits are complicated. We want to compute the available angular distance at
+ // a radius of outerRadius - borderRadius because for small angular distances, this term limits.
+ // We compute at r = outerRadius - borderRadius because this circle defines the center of the border corners.
+ //
+ // If the borderRadius is large, that value can become negative.
+ // This causes the outer borders to lose their radius entirely, which is rather unexpected. To solve that, if borderRadius > outerRadius
+ // we know that the thickness term will dominate and compute the limits at that point
+ const computeOuterLimit = (val)=>{
+ const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2;
+ return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit));
+ };
+ return {
+ outerStart: computeOuterLimit(o.outerStart),
+ outerEnd: computeOuterLimit(o.outerEnd),
+ innerStart: _limitValue(o.innerStart, 0, innerLimit),
+ innerEnd: _limitValue(o.innerEnd, 0, innerLimit)
+ };
+ }
+ /**
+ * Convert (r, 𝜃) to (x, y)
+ */ function rThetaToXY(r, theta, x, y) {
+ return {
+ x: x + r * Math.cos(theta),
+ y: y + r * Math.sin(theta)
+ };
+ }
+ /**
+ * Path the arc, respecting border radius by separating into left and right halves.
+ *
+ * Start End
+ *
+ * 1--->a--->2 Outer
+ * / \
+ * 8 3
+ * | |
+ * | |
+ * 7 4
+ * \ /
+ * 6<---b<---5 Inner
+ */ function pathArc(ctx, element, offset, spacing, end, circular) {
+ const { x , y , startAngle: start , pixelMargin , innerRadius: innerR } = element;
+ const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0);
+ const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0;
+ let spacingOffset = 0;
+ const alpha = end - start;
+ if (spacing) {
+ // When spacing is present, it is the same for all items
+ // So we adjust the start and end angle of the arc such that
+ // the distance is the same as it would be without the spacing
+ const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0;
+ const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0;
+ const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2;
+ const adjustedAngle = avNogSpacingRadius !== 0 ? alpha * avNogSpacingRadius / (avNogSpacingRadius + spacing) : alpha;
+ spacingOffset = (alpha - adjustedAngle) / 2;
+ }
+ const beta = Math.max(0.001, alpha * outerRadius - offset / PI) / outerRadius;
+ const angleOffset = (alpha - beta) / 2;
+ const startAngle = start + angleOffset + spacingOffset;
+ const endAngle = end - angleOffset - spacingOffset;
+ const { outerStart , outerEnd , innerStart , innerEnd } = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle);
+ const outerStartAdjustedRadius = outerRadius - outerStart;
+ const outerEndAdjustedRadius = outerRadius - outerEnd;
+ const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius;
+ const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius;
+ const innerStartAdjustedRadius = innerRadius + innerStart;
+ const innerEndAdjustedRadius = innerRadius + innerEnd;
+ const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius;
+ const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius;
+ ctx.beginPath();
+ if (circular) {
+ // The first arc segments from point 1 to point a to point 2
+ const outerMidAdjustedAngle = (outerStartAdjustedAngle + outerEndAdjustedAngle) / 2;
+ ctx.arc(x, y, outerRadius, outerStartAdjustedAngle, outerMidAdjustedAngle);
+ ctx.arc(x, y, outerRadius, outerMidAdjustedAngle, outerEndAdjustedAngle);
+ // The corner segment from point 2 to point 3
+ if (outerEnd > 0) {
+ const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI);
+ }
+ // The line from point 3 to point 4
+ const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x, y);
+ ctx.lineTo(p4.x, p4.y);
+ // The corner segment from point 4 to point 5
+ if (innerEnd > 0) {
+ const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI);
+ }
+ // The inner arc from point 5 to point b to point 6
+ const innerMidAdjustedAngle = (endAngle - innerEnd / innerRadius + (startAngle + innerStart / innerRadius)) / 2;
+ ctx.arc(x, y, innerRadius, endAngle - innerEnd / innerRadius, innerMidAdjustedAngle, true);
+ ctx.arc(x, y, innerRadius, innerMidAdjustedAngle, startAngle + innerStart / innerRadius, true);
+ // The corner segment from point 6 to point 7
+ if (innerStart > 0) {
+ const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI);
+ }
+ // The line from point 7 to point 8
+ const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x, y);
+ ctx.lineTo(p8.x, p8.y);
+ // The corner segment from point 8 to point 1
+ if (outerStart > 0) {
+ const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle);
+ }
+ } else {
+ ctx.moveTo(x, y);
+ const outerStartX = Math.cos(outerStartAdjustedAngle) * outerRadius + x;
+ const outerStartY = Math.sin(outerStartAdjustedAngle) * outerRadius + y;
+ ctx.lineTo(outerStartX, outerStartY);
+ const outerEndX = Math.cos(outerEndAdjustedAngle) * outerRadius + x;
+ const outerEndY = Math.sin(outerEndAdjustedAngle) * outerRadius + y;
+ ctx.lineTo(outerEndX, outerEndY);
+ }
+ ctx.closePath();
+ }
+ function drawArc(ctx, element, offset, spacing, circular) {
+ const { fullCircles , startAngle , circumference } = element;
+ let endAngle = element.endAngle;
+ if (fullCircles) {
+ pathArc(ctx, element, offset, spacing, endAngle, circular);
+ for(let i = 0; i < fullCircles; ++i){
+ ctx.fill();
+ }
+ if (!isNaN(circumference)) {
+ endAngle = startAngle + (circumference % TAU || TAU);
+ }
+ }
+ pathArc(ctx, element, offset, spacing, endAngle, circular);
+ ctx.fill();
+ return endAngle;
+ }
+ function drawBorder(ctx, element, offset, spacing, circular) {
+ const { fullCircles , startAngle , circumference , options } = element;
+ const { borderWidth , borderJoinStyle , borderDash , borderDashOffset } = options;
+ const inner = options.borderAlign === 'inner';
+ if (!borderWidth) {
+ return;
+ }
+ ctx.setLineDash(borderDash || []);
+ ctx.lineDashOffset = borderDashOffset;
+ if (inner) {
+ ctx.lineWidth = borderWidth * 2;
+ ctx.lineJoin = borderJoinStyle || 'round';
+ } else {
+ ctx.lineWidth = borderWidth;
+ ctx.lineJoin = borderJoinStyle || 'bevel';
+ }
+ let endAngle = element.endAngle;
+ if (fullCircles) {
+ pathArc(ctx, element, offset, spacing, endAngle, circular);
+ for(let i = 0; i < fullCircles; ++i){
+ ctx.stroke();
+ }
+ if (!isNaN(circumference)) {
+ endAngle = startAngle + (circumference % TAU || TAU);
+ }
+ }
+ if (inner) {
+ clipArc(ctx, element, endAngle);
+ }
+ if (!fullCircles) {
+ pathArc(ctx, element, offset, spacing, endAngle, circular);
+ ctx.stroke();
+ }
+ }
+ class ArcElement extends Element {
+ static id = 'arc';
+ static defaults = {
+ borderAlign: 'center',
+ borderColor: '#fff',
+ borderDash: [],
+ borderDashOffset: 0,
+ borderJoinStyle: undefined,
+ borderRadius: 0,
+ borderWidth: 2,
+ offset: 0,
+ spacing: 0,
+ angle: undefined,
+ circular: true
+ };
+ static defaultRoutes = {
+ backgroundColor: 'backgroundColor'
+ };
+ static descriptors = {
+ _scriptable: true,
+ _indexable: (name)=>name !== 'borderDash'
+ };
+ circumference;
+ endAngle;
+ fullCircles;
+ innerRadius;
+ outerRadius;
+ pixelMargin;
+ startAngle;
+ constructor(cfg){
+ super();
+ this.options = undefined;
+ this.circumference = undefined;
+ this.startAngle = undefined;
+ this.endAngle = undefined;
+ this.innerRadius = undefined;
+ this.outerRadius = undefined;
+ this.pixelMargin = 0;
+ this.fullCircles = 0;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ inRange(chartX, chartY, useFinalPosition) {
+ const point = this.getProps([
+ 'x',
+ 'y'
+ ], useFinalPosition);
+ const { angle , distance } = getAngleFromPoint(point, {
+ x: chartX,
+ y: chartY
+ });
+ const { startAngle , endAngle , innerRadius , outerRadius , circumference } = this.getProps([
+ 'startAngle',
+ 'endAngle',
+ 'innerRadius',
+ 'outerRadius',
+ 'circumference'
+ ], useFinalPosition);
+ const rAdjust = (this.options.spacing + this.options.borderWidth) / 2;
+ const _circumference = valueOrDefault(circumference, endAngle - startAngle);
+ const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle);
+ const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);
+ return betweenAngles && withinRadius;
+ }
+ getCenterPoint(useFinalPosition) {
+ const { x , y , startAngle , endAngle , innerRadius , outerRadius } = this.getProps([
+ 'x',
+ 'y',
+ 'startAngle',
+ 'endAngle',
+ 'innerRadius',
+ 'outerRadius'
+ ], useFinalPosition);
+ const { offset , spacing } = this.options;
+ const halfAngle = (startAngle + endAngle) / 2;
+ const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2;
+ return {
+ x: x + Math.cos(halfAngle) * halfRadius,
+ y: y + Math.sin(halfAngle) * halfRadius
+ };
+ }
+ tooltipPosition(useFinalPosition) {
+ return this.getCenterPoint(useFinalPosition);
+ }
+ draw(ctx) {
+ const { options , circumference } = this;
+ const offset = (options.offset || 0) / 4;
+ const spacing = (options.spacing || 0) / 2;
+ const circular = options.circular;
+ this.pixelMargin = options.borderAlign === 'inner' ? 0.33 : 0;
+ this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0;
+ if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) {
+ return;
+ }
+ ctx.save();
+ const halfAngle = (this.startAngle + this.endAngle) / 2;
+ ctx.translate(Math.cos(halfAngle) * offset, Math.sin(halfAngle) * offset);
+ const fix = 1 - Math.sin(Math.min(PI, circumference || 0));
+ const radiusOffset = offset * fix;
+ ctx.fillStyle = options.backgroundColor;
+ ctx.strokeStyle = options.borderColor;
+ drawArc(ctx, this, radiusOffset, spacing, circular);
+ drawBorder(ctx, this, radiusOffset, spacing, circular);
+ ctx.restore();
+ }
+ }
+
+ function setStyle(ctx, options, style = options) {
+ ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle);
+ ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash));
+ ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset);
+ ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle);
+ ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth);
+ ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor);
+ }
+ function lineTo(ctx, previous, target) {
+ ctx.lineTo(target.x, target.y);
+ }
+ function getLineMethod(options) {
+ if (options.stepped) {
+ return _steppedLineTo;
+ }
+ if (options.tension || options.cubicInterpolationMode === 'monotone') {
+ return _bezierCurveTo;
+ }
+ return lineTo;
+ }
+ function pathVars(points, segment, params = {}) {
+ const count = points.length;
+ const { start: paramsStart = 0 , end: paramsEnd = count - 1 } = params;
+ const { start: segmentStart , end: segmentEnd } = segment;
+ const start = Math.max(paramsStart, segmentStart);
+ const end = Math.min(paramsEnd, segmentEnd);
+ const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd;
+ return {
+ count,
+ start,
+ loop: segment.loop,
+ ilen: end < start && !outside ? count + end - start : end - start
+ };
+ }
+ function pathSegment(ctx, line, segment, params) {
+ const { points , options } = line;
+ const { count , start , loop , ilen } = pathVars(points, segment, params);
+ const lineMethod = getLineMethod(options);
+ let { move =true , reverse } = params || {};
+ let i, point, prev;
+ for(i = 0; i <= ilen; ++i){
+ point = points[(start + (reverse ? ilen - i : i)) % count];
+ if (point.skip) {
+ continue;
+ } else if (move) {
+ ctx.moveTo(point.x, point.y);
+ move = false;
+ } else {
+ lineMethod(ctx, prev, point, reverse, options.stepped);
+ }
+ prev = point;
+ }
+ if (loop) {
+ point = points[(start + (reverse ? ilen : 0)) % count];
+ lineMethod(ctx, prev, point, reverse, options.stepped);
+ }
+ return !!loop;
+ }
+ function fastPathSegment(ctx, line, segment, params) {
+ const points = line.points;
+ const { count , start , ilen } = pathVars(points, segment, params);
+ const { move =true , reverse } = params || {};
+ let avgX = 0;
+ let countX = 0;
+ let i, point, prevX, minY, maxY, lastY;
+ const pointIndex = (index)=>(start + (reverse ? ilen - index : index)) % count;
+ const drawX = ()=>{
+ if (minY !== maxY) {
+ ctx.lineTo(avgX, maxY);
+ ctx.lineTo(avgX, minY);
+ ctx.lineTo(avgX, lastY);
+ }
+ };
+ if (move) {
+ point = points[pointIndex(0)];
+ ctx.moveTo(point.x, point.y);
+ }
+ for(i = 0; i <= ilen; ++i){
+ point = points[pointIndex(i)];
+ if (point.skip) {
+ continue;
+ }
+ const x = point.x;
+ const y = point.y;
+ const truncX = x | 0;
+ if (truncX === prevX) {
+ if (y < minY) {
+ minY = y;
+ } else if (y > maxY) {
+ maxY = y;
+ }
+ avgX = (countX * avgX + x) / ++countX;
+ } else {
+ drawX();
+ ctx.lineTo(x, y);
+ prevX = truncX;
+ countX = 0;
+ minY = maxY = y;
+ }
+ lastY = y;
+ }
+ drawX();
+ }
+ function _getSegmentMethod(line) {
+ const opts = line.options;
+ const borderDash = opts.borderDash && opts.borderDash.length;
+ const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash;
+ return useFastPath ? fastPathSegment : pathSegment;
+ }
+ function _getInterpolationMethod(options) {
+ if (options.stepped) {
+ return _steppedInterpolation;
+ }
+ if (options.tension || options.cubicInterpolationMode === 'monotone') {
+ return _bezierInterpolation;
+ }
+ return _pointInLine;
+ }
+ function strokePathWithCache(ctx, line, start, count) {
+ let path = line._path;
+ if (!path) {
+ path = line._path = new Path2D();
+ if (line.path(path, start, count)) {
+ path.closePath();
+ }
+ }
+ setStyle(ctx, line.options);
+ ctx.stroke(path);
+ }
+ function strokePathDirect(ctx, line, start, count) {
+ const { segments , options } = line;
+ const segmentMethod = _getSegmentMethod(line);
+ for (const segment of segments){
+ setStyle(ctx, options, segment.style);
+ ctx.beginPath();
+ if (segmentMethod(ctx, line, segment, {
+ start,
+ end: start + count - 1
+ })) {
+ ctx.closePath();
+ }
+ ctx.stroke();
+ }
+ }
+ const usePath2D = typeof Path2D === 'function';
+ function draw(ctx, line, start, count) {
+ if (usePath2D && !line.options.segment) {
+ strokePathWithCache(ctx, line, start, count);
+ } else {
+ strokePathDirect(ctx, line, start, count);
+ }
+ }
+ class LineElement extends Element {
+ static id = 'line';
+ static defaults = {
+ borderCapStyle: 'butt',
+ borderDash: [],
+ borderDashOffset: 0,
+ borderJoinStyle: 'miter',
+ borderWidth: 3,
+ capBezierPoints: true,
+ cubicInterpolationMode: 'default',
+ fill: false,
+ spanGaps: false,
+ stepped: false,
+ tension: 0
+ };
+ static defaultRoutes = {
+ backgroundColor: 'backgroundColor',
+ borderColor: 'borderColor'
+ };
+ static descriptors = {
+ _scriptable: true,
+ _indexable: (name)=>name !== 'borderDash' && name !== 'fill'
+ };
+ constructor(cfg){
+ super();
+ this.animated = true;
+ this.options = undefined;
+ this._chart = undefined;
+ this._loop = undefined;
+ this._fullLoop = undefined;
+ this._path = undefined;
+ this._points = undefined;
+ this._segments = undefined;
+ this._decimated = false;
+ this._pointsUpdated = false;
+ this._datasetIndex = undefined;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ updateControlPoints(chartArea, indexAxis) {
+ const options = this.options;
+ if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) {
+ const loop = options.spanGaps ? this._loop : this._fullLoop;
+ _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis);
+ this._pointsUpdated = true;
+ }
+ }
+ set points(points) {
+ this._points = points;
+ delete this._segments;
+ delete this._path;
+ this._pointsUpdated = false;
+ }
+ get points() {
+ return this._points;
+ }
+ get segments() {
+ return this._segments || (this._segments = _computeSegments(this, this.options.segment));
+ }
+ first() {
+ const segments = this.segments;
+ const points = this.points;
+ return segments.length && points[segments[0].start];
+ }
+ last() {
+ const segments = this.segments;
+ const points = this.points;
+ const count = segments.length;
+ return count && points[segments[count - 1].end];
+ }
+ interpolate(point, property) {
+ const options = this.options;
+ const value = point[property];
+ const points = this.points;
+ const segments = _boundSegments(this, {
+ property,
+ start: value,
+ end: value
+ });
+ if (!segments.length) {
+ return;
+ }
+ const result = [];
+ const _interpolate = _getInterpolationMethod(options);
+ let i, ilen;
+ for(i = 0, ilen = segments.length; i < ilen; ++i){
+ const { start , end } = segments[i];
+ const p1 = points[start];
+ const p2 = points[end];
+ if (p1 === p2) {
+ result.push(p1);
+ continue;
+ }
+ const t = Math.abs((value - p1[property]) / (p2[property] - p1[property]));
+ const interpolated = _interpolate(p1, p2, t, options.stepped);
+ interpolated[property] = point[property];
+ result.push(interpolated);
+ }
+ return result.length === 1 ? result[0] : result;
+ }
+ pathSegment(ctx, segment, params) {
+ const segmentMethod = _getSegmentMethod(this);
+ return segmentMethod(ctx, this, segment, params);
+ }
+ path(ctx, start, count) {
+ const segments = this.segments;
+ const segmentMethod = _getSegmentMethod(this);
+ let loop = this._loop;
+ start = start || 0;
+ count = count || this.points.length - start;
+ for (const segment of segments){
+ loop &= segmentMethod(ctx, this, segment, {
+ start,
+ end: start + count - 1
+ });
+ }
+ return !!loop;
+ }
+ draw(ctx, chartArea, start, count) {
+ const options = this.options || {};
+ const points = this.points || [];
+ if (points.length && options.borderWidth) {
+ ctx.save();
+ draw(ctx, this, start, count);
+ ctx.restore();
+ }
+ if (this.animated) {
+ this._pointsUpdated = false;
+ this._path = undefined;
+ }
+ }
+ }
+
+ function inRange$1(el, pos, axis, useFinalPosition) {
+ const options = el.options;
+ const { [axis]: value } = el.getProps([
+ axis
+ ], useFinalPosition);
+ return Math.abs(pos - value) < options.radius + options.hitRadius;
+ }
+ class PointElement extends Element {
+ static id = 'point';
+ parsed;
+ skip;
+ stop;
+ /**
+ * @type {any}
+ */ static defaults = {
+ borderWidth: 1,
+ hitRadius: 1,
+ hoverBorderWidth: 1,
+ hoverRadius: 4,
+ pointStyle: 'circle',
+ radius: 3,
+ rotation: 0
+ };
+ /**
+ * @type {any}
+ */ static defaultRoutes = {
+ backgroundColor: 'backgroundColor',
+ borderColor: 'borderColor'
+ };
+ constructor(cfg){
+ super();
+ this.options = undefined;
+ this.parsed = undefined;
+ this.skip = undefined;
+ this.stop = undefined;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ inRange(mouseX, mouseY, useFinalPosition) {
+ const options = this.options;
+ const { x , y } = this.getProps([
+ 'x',
+ 'y'
+ ], useFinalPosition);
+ return Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2) < Math.pow(options.hitRadius + options.radius, 2);
+ }
+ inXRange(mouseX, useFinalPosition) {
+ return inRange$1(this, mouseX, 'x', useFinalPosition);
+ }
+ inYRange(mouseY, useFinalPosition) {
+ return inRange$1(this, mouseY, 'y', useFinalPosition);
+ }
+ getCenterPoint(useFinalPosition) {
+ const { x , y } = this.getProps([
+ 'x',
+ 'y'
+ ], useFinalPosition);
+ return {
+ x,
+ y
+ };
+ }
+ size(options) {
+ options = options || this.options || {};
+ let radius = options.radius || 0;
+ radius = Math.max(radius, radius && options.hoverRadius || 0);
+ const borderWidth = radius && options.borderWidth || 0;
+ return (radius + borderWidth) * 2;
+ }
+ draw(ctx, area) {
+ const options = this.options;
+ if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) {
+ return;
+ }
+ ctx.strokeStyle = options.borderColor;
+ ctx.lineWidth = options.borderWidth;
+ ctx.fillStyle = options.backgroundColor;
+ drawPoint(ctx, options, this.x, this.y);
+ }
+ getRange() {
+ const options = this.options || {};
+ // @ts-expect-error Fallbacks should never be hit in practice
+ return options.radius + options.hitRadius;
+ }
+ }
+
+ function getBarBounds(bar, useFinalPosition) {
+ const { x , y , base , width , height } = bar.getProps([
+ 'x',
+ 'y',
+ 'base',
+ 'width',
+ 'height'
+ ], useFinalPosition);
+ let left, right, top, bottom, half;
+ if (bar.horizontal) {
+ half = height / 2;
+ left = Math.min(x, base);
+ right = Math.max(x, base);
+ top = y - half;
+ bottom = y + half;
+ } else {
+ half = width / 2;
+ left = x - half;
+ right = x + half;
+ top = Math.min(y, base);
+ bottom = Math.max(y, base);
+ }
+ return {
+ left,
+ top,
+ right,
+ bottom
+ };
+ }
+ function skipOrLimit(skip, value, min, max) {
+ return skip ? 0 : _limitValue(value, min, max);
+ }
+ function parseBorderWidth(bar, maxW, maxH) {
+ const value = bar.options.borderWidth;
+ const skip = bar.borderSkipped;
+ const o = toTRBL(value);
+ return {
+ t: skipOrLimit(skip.top, o.top, 0, maxH),
+ r: skipOrLimit(skip.right, o.right, 0, maxW),
+ b: skipOrLimit(skip.bottom, o.bottom, 0, maxH),
+ l: skipOrLimit(skip.left, o.left, 0, maxW)
+ };
+ }
+ function parseBorderRadius(bar, maxW, maxH) {
+ const { enableBorderRadius } = bar.getProps([
+ 'enableBorderRadius'
+ ]);
+ const value = bar.options.borderRadius;
+ const o = toTRBLCorners(value);
+ const maxR = Math.min(maxW, maxH);
+ const skip = bar.borderSkipped;
+ const enableBorder = enableBorderRadius || isObject(value);
+ return {
+ topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR),
+ topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR),
+ bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR),
+ bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR)
+ };
+ }
+ function boundingRects(bar) {
+ const bounds = getBarBounds(bar);
+ const width = bounds.right - bounds.left;
+ const height = bounds.bottom - bounds.top;
+ const border = parseBorderWidth(bar, width / 2, height / 2);
+ const radius = parseBorderRadius(bar, width / 2, height / 2);
+ return {
+ outer: {
+ x: bounds.left,
+ y: bounds.top,
+ w: width,
+ h: height,
+ radius
+ },
+ inner: {
+ x: bounds.left + border.l,
+ y: bounds.top + border.t,
+ w: width - border.l - border.r,
+ h: height - border.t - border.b,
+ radius: {
+ topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),
+ topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),
+ bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),
+ bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r))
+ }
+ }
+ };
+ }
+ function inRange(bar, x, y, useFinalPosition) {
+ const skipX = x === null;
+ const skipY = y === null;
+ const skipBoth = skipX && skipY;
+ const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);
+ return bounds && (skipX || _isBetween(x, bounds.left, bounds.right)) && (skipY || _isBetween(y, bounds.top, bounds.bottom));
+ }
+ function hasRadius(radius) {
+ return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;
+ }
+ function addNormalRectPath(ctx, rect) {
+ ctx.rect(rect.x, rect.y, rect.w, rect.h);
+ }
+ function inflateRect(rect, amount, refRect = {}) {
+ const x = rect.x !== refRect.x ? -amount : 0;
+ const y = rect.y !== refRect.y ? -amount : 0;
+ const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x;
+ const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y;
+ return {
+ x: rect.x + x,
+ y: rect.y + y,
+ w: rect.w + w,
+ h: rect.h + h,
+ radius: rect.radius
+ };
+ }
+ class BarElement extends Element {
+ static id = 'bar';
+ static defaults = {
+ borderSkipped: 'start',
+ borderWidth: 0,
+ borderRadius: 0,
+ inflateAmount: 'auto',
+ pointStyle: undefined
+ };
+ static defaultRoutes = {
+ backgroundColor: 'backgroundColor',
+ borderColor: 'borderColor'
+ };
+ constructor(cfg){
+ super();
+ this.options = undefined;
+ this.horizontal = undefined;
+ this.base = undefined;
+ this.width = undefined;
+ this.height = undefined;
+ this.inflateAmount = undefined;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ draw(ctx) {
+ const { inflateAmount , options: { borderColor , backgroundColor } } = this;
+ const { inner , outer } = boundingRects(this);
+ const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;
+ ctx.save();
+ if (outer.w !== inner.w || outer.h !== inner.h) {
+ ctx.beginPath();
+ addRectPath(ctx, inflateRect(outer, inflateAmount, inner));
+ ctx.clip();
+ addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));
+ ctx.fillStyle = borderColor;
+ ctx.fill('evenodd');
+ }
+ ctx.beginPath();
+ addRectPath(ctx, inflateRect(inner, inflateAmount));
+ ctx.fillStyle = backgroundColor;
+ ctx.fill();
+ ctx.restore();
+ }
+ inRange(mouseX, mouseY, useFinalPosition) {
+ return inRange(this, mouseX, mouseY, useFinalPosition);
+ }
+ inXRange(mouseX, useFinalPosition) {
+ return inRange(this, mouseX, null, useFinalPosition);
+ }
+ inYRange(mouseY, useFinalPosition) {
+ return inRange(this, null, mouseY, useFinalPosition);
+ }
+ getCenterPoint(useFinalPosition) {
+ const { x , y , base , horizontal } = this.getProps([
+ 'x',
+ 'y',
+ 'base',
+ 'horizontal'
+ ], useFinalPosition);
+ return {
+ x: horizontal ? (x + base) / 2 : x,
+ y: horizontal ? y : (y + base) / 2
+ };
+ }
+ getRange(axis) {
+ return axis === 'x' ? this.width / 2 : this.height / 2;
+ }
+ }
+
+ var elements = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ ArcElement: ArcElement,
+ BarElement: BarElement,
+ LineElement: LineElement,
+ PointElement: PointElement
+ });
+
+ const addIfString = (labels, raw, index, addedLabels)=>{
+ if (typeof raw === 'string') {
+ index = labels.push(raw) - 1;
+ addedLabels.unshift({
+ index,
+ label: raw
+ });
+ } else if (isNaN(raw)) {
+ index = null;
+ }
+ return index;
+ };
+ function findOrAddLabel(labels, raw, index, addedLabels) {
+ const first = labels.indexOf(raw);
+ if (first === -1) {
+ return addIfString(labels, raw, index, addedLabels);
+ }
+ const last = labels.lastIndexOf(raw);
+ return first !== last ? index : first;
+ }
+ const validIndex = (index, max)=>index === null ? null : _limitValue(Math.round(index), 0, max);
+ function _getLabelForValue(value) {
+ const labels = this.getLabels();
+ if (value >= 0 && value < labels.length) {
+ return labels[value];
+ }
+ return value;
+ }
+ class CategoryScale extends Scale {
+ static id = 'category';
+ static defaults = {
+ ticks: {
+ callback: _getLabelForValue
+ }
+ };
+ constructor(cfg){
+ super(cfg);
+ this._startValue = undefined;
+ this._valueRange = 0;
+ this._addedLabels = [];
+ }
+ init(scaleOptions) {
+ const added = this._addedLabels;
+ if (added.length) {
+ const labels = this.getLabels();
+ for (const { index , label } of added){
+ if (labels[index] === label) {
+ labels.splice(index, 1);
+ }
+ }
+ this._addedLabels = [];
+ }
+ super.init(scaleOptions);
+ }
+ parse(raw, index) {
+ if (isNullOrUndef(raw)) {
+ return null;
+ }
+ const labels = this.getLabels();
+ index = isFinite(index) && labels[index] === raw ? index : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);
+ return validIndex(index, labels.length - 1);
+ }
+ determineDataLimits() {
+ const { minDefined , maxDefined } = this.getUserBounds();
+ let { min , max } = this.getMinMax(true);
+ if (this.options.bounds === 'ticks') {
+ if (!minDefined) {
+ min = 0;
+ }
+ if (!maxDefined) {
+ max = this.getLabels().length - 1;
+ }
+ }
+ this.min = min;
+ this.max = max;
+ }
+ buildTicks() {
+ const min = this.min;
+ const max = this.max;
+ const offset = this.options.offset;
+ const ticks = [];
+ let labels = this.getLabels();
+ labels = min === 0 && max === labels.length - 1 ? labels : labels.slice(min, max + 1);
+ this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);
+ this._startValue = this.min - (offset ? 0.5 : 0);
+ for(let value = min; value <= max; value++){
+ ticks.push({
+ value
+ });
+ }
+ return ticks;
+ }
+ getLabelForValue(value) {
+ return _getLabelForValue.call(this, value);
+ }
+ configure() {
+ super.configure();
+ if (!this.isHorizontal()) {
+ this._reversePixels = !this._reversePixels;
+ }
+ }
+ getPixelForValue(value) {
+ if (typeof value !== 'number') {
+ value = this.parse(value);
+ }
+ return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
+ }
+ getPixelForTick(index) {
+ const ticks = this.ticks;
+ if (index < 0 || index > ticks.length - 1) {
+ return null;
+ }
+ return this.getPixelForValue(ticks[index].value);
+ }
+ getValueForPixel(pixel) {
+ return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);
+ }
+ getBasePixel() {
+ return this.bottom;
+ }
+ }
+
+ function generateTicks$1(generationOptions, dataRange) {
+ const ticks = [];
+ const MIN_SPACING = 1e-14;
+ const { bounds , step , min , max , precision , count , maxTicks , maxDigits , includeBounds } = generationOptions;
+ const unit = step || 1;
+ const maxSpaces = maxTicks - 1;
+ const { min: rmin , max: rmax } = dataRange;
+ const minDefined = !isNullOrUndef(min);
+ const maxDefined = !isNullOrUndef(max);
+ const countDefined = !isNullOrUndef(count);
+ const minSpacing = (rmax - rmin) / (maxDigits + 1);
+ let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;
+ let factor, niceMin, niceMax, numSpaces;
+ if (spacing < MIN_SPACING && !minDefined && !maxDefined) {
+ return [
+ {
+ value: rmin
+ },
+ {
+ value: rmax
+ }
+ ];
+ }
+ numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);
+ if (numSpaces > maxSpaces) {
+ spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;
+ }
+ if (!isNullOrUndef(precision)) {
+ factor = Math.pow(10, precision);
+ spacing = Math.ceil(spacing * factor) / factor;
+ }
+ if (bounds === 'ticks') {
+ niceMin = Math.floor(rmin / spacing) * spacing;
+ niceMax = Math.ceil(rmax / spacing) * spacing;
+ } else {
+ niceMin = rmin;
+ niceMax = rmax;
+ }
+ if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) {
+ numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));
+ spacing = (max - min) / numSpaces;
+ niceMin = min;
+ niceMax = max;
+ } else if (countDefined) {
+ niceMin = minDefined ? min : niceMin;
+ niceMax = maxDefined ? max : niceMax;
+ numSpaces = count - 1;
+ spacing = (niceMax - niceMin) / numSpaces;
+ } else {
+ numSpaces = (niceMax - niceMin) / spacing;
+ if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {
+ numSpaces = Math.round(numSpaces);
+ } else {
+ numSpaces = Math.ceil(numSpaces);
+ }
+ }
+ const decimalPlaces = Math.max(_decimalPlaces(spacing), _decimalPlaces(niceMin));
+ factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);
+ niceMin = Math.round(niceMin * factor) / factor;
+ niceMax = Math.round(niceMax * factor) / factor;
+ let j = 0;
+ if (minDefined) {
+ if (includeBounds && niceMin !== min) {
+ ticks.push({
+ value: min
+ });
+ if (niceMin < min) {
+ j++;
+ }
+ if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {
+ j++;
+ }
+ } else if (niceMin < min) {
+ j++;
+ }
+ }
+ for(; j < numSpaces; ++j){
+ const tickValue = Math.round((niceMin + j * spacing) * factor) / factor;
+ if (maxDefined && tickValue > max) {
+ break;
+ }
+ ticks.push({
+ value: tickValue
+ });
+ }
+ if (maxDefined && includeBounds && niceMax !== max) {
+ if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {
+ ticks[ticks.length - 1].value = max;
+ } else {
+ ticks.push({
+ value: max
+ });
+ }
+ } else if (!maxDefined || niceMax === max) {
+ ticks.push({
+ value: niceMax
+ });
+ }
+ return ticks;
+ }
+ function relativeLabelSize(value, minSpacing, { horizontal , minRotation }) {
+ const rad = toRadians(minRotation);
+ const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001;
+ const length = 0.75 * minSpacing * ('' + value).length;
+ return Math.min(minSpacing / ratio, length);
+ }
+ class LinearScaleBase extends Scale {
+ constructor(cfg){
+ super(cfg);
+ this.start = undefined;
+ this.end = undefined;
+ this._startValue = undefined;
+ this._endValue = undefined;
+ this._valueRange = 0;
+ }
+ parse(raw, index) {
+ if (isNullOrUndef(raw)) {
+ return null;
+ }
+ if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) {
+ return null;
+ }
+ return +raw;
+ }
+ handleTickRangeOptions() {
+ const { beginAtZero } = this.options;
+ const { minDefined , maxDefined } = this.getUserBounds();
+ let { min , max } = this;
+ const setMin = (v)=>min = minDefined ? min : v;
+ const setMax = (v)=>max = maxDefined ? max : v;
+ if (beginAtZero) {
+ const minSign = sign(min);
+ const maxSign = sign(max);
+ if (minSign < 0 && maxSign < 0) {
+ setMax(0);
+ } else if (minSign > 0 && maxSign > 0) {
+ setMin(0);
+ }
+ }
+ if (min === max) {
+ let offset = max === 0 ? 1 : Math.abs(max * 0.05);
+ setMax(max + offset);
+ if (!beginAtZero) {
+ setMin(min - offset);
+ }
+ }
+ this.min = min;
+ this.max = max;
+ }
+ getTickLimit() {
+ const tickOpts = this.options.ticks;
+ let { maxTicksLimit , stepSize } = tickOpts;
+ let maxTicks;
+ if (stepSize) {
+ maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;
+ if (maxTicks > 1000) {
+ console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);
+ maxTicks = 1000;
+ }
+ } else {
+ maxTicks = this.computeTickLimit();
+ maxTicksLimit = maxTicksLimit || 11;
+ }
+ if (maxTicksLimit) {
+ maxTicks = Math.min(maxTicksLimit, maxTicks);
+ }
+ return maxTicks;
+ }
+ computeTickLimit() {
+ return Number.POSITIVE_INFINITY;
+ }
+ buildTicks() {
+ const opts = this.options;
+ const tickOpts = opts.ticks;
+ let maxTicks = this.getTickLimit();
+ maxTicks = Math.max(2, maxTicks);
+ const numericGeneratorOptions = {
+ maxTicks,
+ bounds: opts.bounds,
+ min: opts.min,
+ max: opts.max,
+ precision: tickOpts.precision,
+ step: tickOpts.stepSize,
+ count: tickOpts.count,
+ maxDigits: this._maxDigits(),
+ horizontal: this.isHorizontal(),
+ minRotation: tickOpts.minRotation || 0,
+ includeBounds: tickOpts.includeBounds !== false
+ };
+ const dataRange = this._range || this;
+ const ticks = generateTicks$1(numericGeneratorOptions, dataRange);
+ if (opts.bounds === 'ticks') {
+ _setMinAndMaxByKey(ticks, this, 'value');
+ }
+ if (opts.reverse) {
+ ticks.reverse();
+ this.start = this.max;
+ this.end = this.min;
+ } else {
+ this.start = this.min;
+ this.end = this.max;
+ }
+ return ticks;
+ }
+ configure() {
+ const ticks = this.ticks;
+ let start = this.min;
+ let end = this.max;
+ super.configure();
+ if (this.options.offset && ticks.length) {
+ const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;
+ start -= offset;
+ end += offset;
+ }
+ this._startValue = start;
+ this._endValue = end;
+ this._valueRange = end - start;
+ }
+ getLabelForValue(value) {
+ return formatNumber(value, this.chart.options.locale, this.options.ticks.format);
+ }
+ }
+
+ class LinearScale extends LinearScaleBase {
+ static id = 'linear';
+ static defaults = {
+ ticks: {
+ callback: Ticks.formatters.numeric
+ }
+ };
+ determineDataLimits() {
+ const { min , max } = this.getMinMax(true);
+ this.min = isNumberFinite(min) ? min : 0;
+ this.max = isNumberFinite(max) ? max : 1;
+ this.handleTickRangeOptions();
+ }
+ computeTickLimit() {
+ const horizontal = this.isHorizontal();
+ const length = horizontal ? this.width : this.height;
+ const minRotation = toRadians(this.options.ticks.minRotation);
+ const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001;
+ const tickFont = this._resolveTickFontOptions(0);
+ return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));
+ }
+ getPixelForValue(value) {
+ return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
+ }
+ getValueForPixel(pixel) {
+ return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;
+ }
+ }
+
+ const log10Floor = (v)=>Math.floor(log10(v));
+ const changeExponent = (v, m)=>Math.pow(10, log10Floor(v) + m);
+ function isMajor(tickVal) {
+ const remain = tickVal / Math.pow(10, log10Floor(tickVal));
+ return remain === 1;
+ }
+ function steps(min, max, rangeExp) {
+ const rangeStep = Math.pow(10, rangeExp);
+ const start = Math.floor(min / rangeStep);
+ const end = Math.ceil(max / rangeStep);
+ return end - start;
+ }
+ function startExp(min, max) {
+ const range = max - min;
+ let rangeExp = log10Floor(range);
+ while(steps(min, max, rangeExp) > 10){
+ rangeExp++;
+ }
+ while(steps(min, max, rangeExp) < 10){
+ rangeExp--;
+ }
+ return Math.min(rangeExp, log10Floor(min));
+ }
+ function generateTicks(generationOptions, { min , max }) {
+ min = finiteOrDefault(generationOptions.min, min);
+ const ticks = [];
+ const minExp = log10Floor(min);
+ let exp = startExp(min, max);
+ let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;
+ const stepSize = Math.pow(10, exp);
+ const base = minExp > exp ? Math.pow(10, minExp) : 0;
+ const start = Math.round((min - base) * precision) / precision;
+ const offset = Math.floor((min - base) / stepSize / 10) * stepSize * 10;
+ let significand = Math.floor((start - offset) / Math.pow(10, exp));
+ let value = finiteOrDefault(generationOptions.min, Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision);
+ while(value < max){
+ ticks.push({
+ value,
+ major: isMajor(value),
+ significand
+ });
+ if (significand >= 10) {
+ significand = significand < 15 ? 15 : 20;
+ } else {
+ significand++;
+ }
+ if (significand >= 20) {
+ exp++;
+ significand = 2;
+ precision = exp >= 0 ? 1 : precision;
+ }
+ value = Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision;
+ }
+ const lastTick = finiteOrDefault(generationOptions.max, value);
+ ticks.push({
+ value: lastTick,
+ major: isMajor(lastTick),
+ significand
+ });
+ return ticks;
+ }
+ class LogarithmicScale extends Scale {
+ static id = 'logarithmic';
+ static defaults = {
+ ticks: {
+ callback: Ticks.formatters.logarithmic,
+ major: {
+ enabled: true
+ }
+ }
+ };
+ constructor(cfg){
+ super(cfg);
+ this.start = undefined;
+ this.end = undefined;
+ this._startValue = undefined;
+ this._valueRange = 0;
+ }
+ parse(raw, index) {
+ const value = LinearScaleBase.prototype.parse.apply(this, [
+ raw,
+ index
+ ]);
+ if (value === 0) {
+ this._zero = true;
+ return undefined;
+ }
+ return isNumberFinite(value) && value > 0 ? value : null;
+ }
+ determineDataLimits() {
+ const { min , max } = this.getMinMax(true);
+ this.min = isNumberFinite(min) ? Math.max(0, min) : null;
+ this.max = isNumberFinite(max) ? Math.max(0, max) : null;
+ if (this.options.beginAtZero) {
+ this._zero = true;
+ }
+ if (this._zero && this.min !== this._suggestedMin && !isNumberFinite(this._userMin)) {
+ this.min = min === changeExponent(this.min, 0) ? changeExponent(this.min, -1) : changeExponent(this.min, 0);
+ }
+ this.handleTickRangeOptions();
+ }
+ handleTickRangeOptions() {
+ const { minDefined , maxDefined } = this.getUserBounds();
+ let min = this.min;
+ let max = this.max;
+ const setMin = (v)=>min = minDefined ? min : v;
+ const setMax = (v)=>max = maxDefined ? max : v;
+ if (min === max) {
+ if (min <= 0) {
+ setMin(1);
+ setMax(10);
+ } else {
+ setMin(changeExponent(min, -1));
+ setMax(changeExponent(max, +1));
+ }
+ }
+ if (min <= 0) {
+ setMin(changeExponent(max, -1));
+ }
+ if (max <= 0) {
+ setMax(changeExponent(min, +1));
+ }
+ this.min = min;
+ this.max = max;
+ }
+ buildTicks() {
+ const opts = this.options;
+ const generationOptions = {
+ min: this._userMin,
+ max: this._userMax
+ };
+ const ticks = generateTicks(generationOptions, this);
+ if (opts.bounds === 'ticks') {
+ _setMinAndMaxByKey(ticks, this, 'value');
+ }
+ if (opts.reverse) {
+ ticks.reverse();
+ this.start = this.max;
+ this.end = this.min;
+ } else {
+ this.start = this.min;
+ this.end = this.max;
+ }
+ return ticks;
+ }
+ getLabelForValue(value) {
+ return value === undefined ? '0' : formatNumber(value, this.chart.options.locale, this.options.ticks.format);
+ }
+ configure() {
+ const start = this.min;
+ super.configure();
+ this._startValue = log10(start);
+ this._valueRange = log10(this.max) - log10(start);
+ }
+ getPixelForValue(value) {
+ if (value === undefined || value === 0) {
+ value = this.min;
+ }
+ if (value === null || isNaN(value)) {
+ return NaN;
+ }
+ return this.getPixelForDecimal(value === this.min ? 0 : (log10(value) - this._startValue) / this._valueRange);
+ }
+ getValueForPixel(pixel) {
+ const decimal = this.getDecimalForPixel(pixel);
+ return Math.pow(10, this._startValue + decimal * this._valueRange);
+ }
+ }
+
+ function getTickBackdropHeight(opts) {
+ const tickOpts = opts.ticks;
+ if (tickOpts.display && opts.display) {
+ const padding = toPadding(tickOpts.backdropPadding);
+ return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height;
+ }
+ return 0;
+ }
+ function measureLabelSize(ctx, font, label) {
+ label = isArray(label) ? label : [
+ label
+ ];
+ return {
+ w: _longestText(ctx, font.string, label),
+ h: label.length * font.lineHeight
+ };
+ }
+ function determineLimits(angle, pos, size, min, max) {
+ if (angle === min || angle === max) {
+ return {
+ start: pos - size / 2,
+ end: pos + size / 2
+ };
+ } else if (angle < min || angle > max) {
+ return {
+ start: pos - size,
+ end: pos
+ };
+ }
+ return {
+ start: pos,
+ end: pos + size
+ };
+ }
+ function fitWithPointLabels(scale) {
+ const orig = {
+ l: scale.left + scale._padding.left,
+ r: scale.right - scale._padding.right,
+ t: scale.top + scale._padding.top,
+ b: scale.bottom - scale._padding.bottom
+ };
+ const limits = Object.assign({}, orig);
+ const labelSizes = [];
+ const padding = [];
+ const valueCount = scale._pointLabels.length;
+ const pointLabelOpts = scale.options.pointLabels;
+ const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;
+ for(let i = 0; i < valueCount; i++){
+ const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i));
+ padding[i] = opts.padding;
+ const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle);
+ const plFont = toFont(opts.font);
+ const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]);
+ labelSizes[i] = textSize;
+ const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle);
+ const angle = Math.round(toDegrees(angleRadians));
+ const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);
+ const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);
+ updateLimits(limits, orig, angleRadians, hLimits, vLimits);
+ }
+ scale.setCenterPoint(orig.l - limits.l, limits.r - orig.r, orig.t - limits.t, limits.b - orig.b);
+ scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);
+ }
+ function updateLimits(limits, orig, angle, hLimits, vLimits) {
+ const sin = Math.abs(Math.sin(angle));
+ const cos = Math.abs(Math.cos(angle));
+ let x = 0;
+ let y = 0;
+ if (hLimits.start < orig.l) {
+ x = (orig.l - hLimits.start) / sin;
+ limits.l = Math.min(limits.l, orig.l - x);
+ } else if (hLimits.end > orig.r) {
+ x = (hLimits.end - orig.r) / sin;
+ limits.r = Math.max(limits.r, orig.r + x);
+ }
+ if (vLimits.start < orig.t) {
+ y = (orig.t - vLimits.start) / cos;
+ limits.t = Math.min(limits.t, orig.t - y);
+ } else if (vLimits.end > orig.b) {
+ y = (vLimits.end - orig.b) / cos;
+ limits.b = Math.max(limits.b, orig.b + y);
+ }
+ }
+ function createPointLabelItem(scale, index, itemOpts) {
+ const outerDistance = scale.drawingArea;
+ const { extra , additionalAngle , padding , size } = itemOpts;
+ const pointLabelPosition = scale.getPointPosition(index, outerDistance + extra + padding, additionalAngle);
+ const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));
+ const y = yForAngle(pointLabelPosition.y, size.h, angle);
+ const textAlign = getTextAlignForAngle(angle);
+ const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);
+ return {
+ visible: true,
+ x: pointLabelPosition.x,
+ y,
+ textAlign,
+ left,
+ top: y,
+ right: left + size.w,
+ bottom: y + size.h
+ };
+ }
+ function isNotOverlapped(item, area) {
+ if (!area) {
+ return true;
+ }
+ const { left , top , right , bottom } = item;
+ const apexesInArea = _isPointInArea({
+ x: left,
+ y: top
+ }, area) || _isPointInArea({
+ x: left,
+ y: bottom
+ }, area) || _isPointInArea({
+ x: right,
+ y: top
+ }, area) || _isPointInArea({
+ x: right,
+ y: bottom
+ }, area);
+ return !apexesInArea;
+ }
+ function buildPointLabelItems(scale, labelSizes, padding) {
+ const items = [];
+ const valueCount = scale._pointLabels.length;
+ const opts = scale.options;
+ const { centerPointLabels , display } = opts.pointLabels;
+ const itemOpts = {
+ extra: getTickBackdropHeight(opts) / 2,
+ additionalAngle: centerPointLabels ? PI / valueCount : 0
+ };
+ let area;
+ for(let i = 0; i < valueCount; i++){
+ itemOpts.padding = padding[i];
+ itemOpts.size = labelSizes[i];
+ const item = createPointLabelItem(scale, i, itemOpts);
+ items.push(item);
+ if (display === 'auto') {
+ item.visible = isNotOverlapped(item, area);
+ if (item.visible) {
+ area = item;
+ }
+ }
+ }
+ return items;
+ }
+ function getTextAlignForAngle(angle) {
+ if (angle === 0 || angle === 180) {
+ return 'center';
+ } else if (angle < 180) {
+ return 'left';
+ }
+ return 'right';
+ }
+ function leftForTextAlign(x, w, align) {
+ if (align === 'right') {
+ x -= w;
+ } else if (align === 'center') {
+ x -= w / 2;
+ }
+ return x;
+ }
+ function yForAngle(y, h, angle) {
+ if (angle === 90 || angle === 270) {
+ y -= h / 2;
+ } else if (angle > 270 || angle < 90) {
+ y -= h;
+ }
+ return y;
+ }
+ function drawPointLabelBox(ctx, opts, item) {
+ const { left , top , right , bottom } = item;
+ const { backdropColor } = opts;
+ if (!isNullOrUndef(backdropColor)) {
+ const borderRadius = toTRBLCorners(opts.borderRadius);
+ const padding = toPadding(opts.backdropPadding);
+ ctx.fillStyle = backdropColor;
+ const backdropLeft = left - padding.left;
+ const backdropTop = top - padding.top;
+ const backdropWidth = right - left + padding.width;
+ const backdropHeight = bottom - top + padding.height;
+ if (Object.values(borderRadius).some((v)=>v !== 0)) {
+ ctx.beginPath();
+ addRoundedRectPath(ctx, {
+ x: backdropLeft,
+ y: backdropTop,
+ w: backdropWidth,
+ h: backdropHeight,
+ radius: borderRadius
+ });
+ ctx.fill();
+ } else {
+ ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight);
+ }
+ }
+ }
+ function drawPointLabels(scale, labelCount) {
+ const { ctx , options: { pointLabels } } = scale;
+ for(let i = labelCount - 1; i >= 0; i--){
+ const item = scale._pointLabelItems[i];
+ if (!item.visible) {
+ continue;
+ }
+ const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i));
+ drawPointLabelBox(ctx, optsAtIndex, item);
+ const plFont = toFont(optsAtIndex.font);
+ const { x , y , textAlign } = item;
+ renderText(ctx, scale._pointLabels[i], x, y + plFont.lineHeight / 2, plFont, {
+ color: optsAtIndex.color,
+ textAlign: textAlign,
+ textBaseline: 'middle'
+ });
+ }
+ }
+ function pathRadiusLine(scale, radius, circular, labelCount) {
+ const { ctx } = scale;
+ if (circular) {
+ ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);
+ } else {
+ let pointPosition = scale.getPointPosition(0, radius);
+ ctx.moveTo(pointPosition.x, pointPosition.y);
+ for(let i = 1; i < labelCount; i++){
+ pointPosition = scale.getPointPosition(i, radius);
+ ctx.lineTo(pointPosition.x, pointPosition.y);
+ }
+ }
+ }
+ function drawRadiusLine(scale, gridLineOpts, radius, labelCount, borderOpts) {
+ const ctx = scale.ctx;
+ const circular = gridLineOpts.circular;
+ const { color , lineWidth } = gridLineOpts;
+ if (!circular && !labelCount || !color || !lineWidth || radius < 0) {
+ return;
+ }
+ ctx.save();
+ ctx.strokeStyle = color;
+ ctx.lineWidth = lineWidth;
+ ctx.setLineDash(borderOpts.dash);
+ ctx.lineDashOffset = borderOpts.dashOffset;
+ ctx.beginPath();
+ pathRadiusLine(scale, radius, circular, labelCount);
+ ctx.closePath();
+ ctx.stroke();
+ ctx.restore();
+ }
+ function createPointLabelContext(parent, index, label) {
+ return createContext(parent, {
+ label,
+ index,
+ type: 'pointLabel'
+ });
+ }
+ class RadialLinearScale extends LinearScaleBase {
+ static id = 'radialLinear';
+ static defaults = {
+ display: true,
+ animate: true,
+ position: 'chartArea',
+ angleLines: {
+ display: true,
+ lineWidth: 1,
+ borderDash: [],
+ borderDashOffset: 0.0
+ },
+ grid: {
+ circular: false
+ },
+ startAngle: 0,
+ ticks: {
+ showLabelBackdrop: true,
+ callback: Ticks.formatters.numeric
+ },
+ pointLabels: {
+ backdropColor: undefined,
+ backdropPadding: 2,
+ display: true,
+ font: {
+ size: 10
+ },
+ callback (label) {
+ return label;
+ },
+ padding: 5,
+ centerPointLabels: false
+ }
+ };
+ static defaultRoutes = {
+ 'angleLines.color': 'borderColor',
+ 'pointLabels.color': 'color',
+ 'ticks.color': 'color'
+ };
+ static descriptors = {
+ angleLines: {
+ _fallback: 'grid'
+ }
+ };
+ constructor(cfg){
+ super(cfg);
+ this.xCenter = undefined;
+ this.yCenter = undefined;
+ this.drawingArea = undefined;
+ this._pointLabels = [];
+ this._pointLabelItems = [];
+ }
+ setDimensions() {
+ const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);
+ const w = this.width = this.maxWidth - padding.width;
+ const h = this.height = this.maxHeight - padding.height;
+ this.xCenter = Math.floor(this.left + w / 2 + padding.left);
+ this.yCenter = Math.floor(this.top + h / 2 + padding.top);
+ this.drawingArea = Math.floor(Math.min(w, h) / 2);
+ }
+ determineDataLimits() {
+ const { min , max } = this.getMinMax(false);
+ this.min = isNumberFinite(min) && !isNaN(min) ? min : 0;
+ this.max = isNumberFinite(max) && !isNaN(max) ? max : 0;
+ this.handleTickRangeOptions();
+ }
+ computeTickLimit() {
+ return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));
+ }
+ generateTickLabels(ticks) {
+ LinearScaleBase.prototype.generateTickLabels.call(this, ticks);
+ this._pointLabels = this.getLabels().map((value, index)=>{
+ const label = callback(this.options.pointLabels.callback, [
+ value,
+ index
+ ], this);
+ return label || label === 0 ? label : '';
+ }).filter((v, i)=>this.chart.getDataVisibility(i));
+ }
+ fit() {
+ const opts = this.options;
+ if (opts.display && opts.pointLabels.display) {
+ fitWithPointLabels(this);
+ } else {
+ this.setCenterPoint(0, 0, 0, 0);
+ }
+ }
+ setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {
+ this.xCenter += Math.floor((leftMovement - rightMovement) / 2);
+ this.yCenter += Math.floor((topMovement - bottomMovement) / 2);
+ this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));
+ }
+ getIndexAngle(index) {
+ const angleMultiplier = TAU / (this._pointLabels.length || 1);
+ const startAngle = this.options.startAngle || 0;
+ return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));
+ }
+ getDistanceFromCenterForValue(value) {
+ if (isNullOrUndef(value)) {
+ return NaN;
+ }
+ const scalingFactor = this.drawingArea / (this.max - this.min);
+ if (this.options.reverse) {
+ return (this.max - value) * scalingFactor;
+ }
+ return (value - this.min) * scalingFactor;
+ }
+ getValueForDistanceFromCenter(distance) {
+ if (isNullOrUndef(distance)) {
+ return NaN;
+ }
+ const scaledDistance = distance / (this.drawingArea / (this.max - this.min));
+ return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;
+ }
+ getPointLabelContext(index) {
+ const pointLabels = this._pointLabels || [];
+ if (index >= 0 && index < pointLabels.length) {
+ const pointLabel = pointLabels[index];
+ return createPointLabelContext(this.getContext(), index, pointLabel);
+ }
+ }
+ getPointPosition(index, distanceFromCenter, additionalAngle = 0) {
+ const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;
+ return {
+ x: Math.cos(angle) * distanceFromCenter + this.xCenter,
+ y: Math.sin(angle) * distanceFromCenter + this.yCenter,
+ angle
+ };
+ }
+ getPointPositionForValue(index, value) {
+ return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));
+ }
+ getBasePosition(index) {
+ return this.getPointPositionForValue(index || 0, this.getBaseValue());
+ }
+ getPointLabelPosition(index) {
+ const { left , top , right , bottom } = this._pointLabelItems[index];
+ return {
+ left,
+ top,
+ right,
+ bottom
+ };
+ }
+ drawBackground() {
+ const { backgroundColor , grid: { circular } } = this.options;
+ if (backgroundColor) {
+ const ctx = this.ctx;
+ ctx.save();
+ ctx.beginPath();
+ pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);
+ ctx.closePath();
+ ctx.fillStyle = backgroundColor;
+ ctx.fill();
+ ctx.restore();
+ }
+ }
+ drawGrid() {
+ const ctx = this.ctx;
+ const opts = this.options;
+ const { angleLines , grid , border } = opts;
+ const labelCount = this._pointLabels.length;
+ let i, offset, position;
+ if (opts.pointLabels.display) {
+ drawPointLabels(this, labelCount);
+ }
+ if (grid.display) {
+ this.ticks.forEach((tick, index)=>{
+ if (index !== 0) {
+ offset = this.getDistanceFromCenterForValue(tick.value);
+ const context = this.getContext(index);
+ const optsAtIndex = grid.setContext(context);
+ const optsAtIndexBorder = border.setContext(context);
+ drawRadiusLine(this, optsAtIndex, offset, labelCount, optsAtIndexBorder);
+ }
+ });
+ }
+ if (angleLines.display) {
+ ctx.save();
+ for(i = labelCount - 1; i >= 0; i--){
+ const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i));
+ const { color , lineWidth } = optsAtIndex;
+ if (!lineWidth || !color) {
+ continue;
+ }
+ ctx.lineWidth = lineWidth;
+ ctx.strokeStyle = color;
+ ctx.setLineDash(optsAtIndex.borderDash);
+ ctx.lineDashOffset = optsAtIndex.borderDashOffset;
+ offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max);
+ position = this.getPointPosition(i, offset);
+ ctx.beginPath();
+ ctx.moveTo(this.xCenter, this.yCenter);
+ ctx.lineTo(position.x, position.y);
+ ctx.stroke();
+ }
+ ctx.restore();
+ }
+ }
+ drawBorder() {}
+ drawLabels() {
+ const ctx = this.ctx;
+ const opts = this.options;
+ const tickOpts = opts.ticks;
+ if (!tickOpts.display) {
+ return;
+ }
+ const startAngle = this.getIndexAngle(0);
+ let offset, width;
+ ctx.save();
+ ctx.translate(this.xCenter, this.yCenter);
+ ctx.rotate(startAngle);
+ ctx.textAlign = 'center';
+ ctx.textBaseline = 'middle';
+ this.ticks.forEach((tick, index)=>{
+ if (index === 0 && !opts.reverse) {
+ return;
+ }
+ const optsAtIndex = tickOpts.setContext(this.getContext(index));
+ const tickFont = toFont(optsAtIndex.font);
+ offset = this.getDistanceFromCenterForValue(this.ticks[index].value);
+ if (optsAtIndex.showLabelBackdrop) {
+ ctx.font = tickFont.string;
+ width = ctx.measureText(tick.label).width;
+ ctx.fillStyle = optsAtIndex.backdropColor;
+ const padding = toPadding(optsAtIndex.backdropPadding);
+ ctx.fillRect(-width / 2 - padding.left, -offset - tickFont.size / 2 - padding.top, width + padding.width, tickFont.size + padding.height);
+ }
+ renderText(ctx, tick.label, 0, -offset, tickFont, {
+ color: optsAtIndex.color,
+ strokeColor: optsAtIndex.textStrokeColor,
+ strokeWidth: optsAtIndex.textStrokeWidth
+ });
+ });
+ ctx.restore();
+ }
+ drawTitle() {}
+ }
+
+ const INTERVALS = {
+ millisecond: {
+ common: true,
+ size: 1,
+ steps: 1000
+ },
+ second: {
+ common: true,
+ size: 1000,
+ steps: 60
+ },
+ minute: {
+ common: true,
+ size: 60000,
+ steps: 60
+ },
+ hour: {
+ common: true,
+ size: 3600000,
+ steps: 24
+ },
+ day: {
+ common: true,
+ size: 86400000,
+ steps: 30
+ },
+ week: {
+ common: false,
+ size: 604800000,
+ steps: 4
+ },
+ month: {
+ common: true,
+ size: 2.628e9,
+ steps: 12
+ },
+ quarter: {
+ common: false,
+ size: 7.884e9,
+ steps: 4
+ },
+ year: {
+ common: true,
+ size: 3.154e10
+ }
+ };
+ const UNITS = /* #__PURE__ */ Object.keys(INTERVALS);
+ function sorter(a, b) {
+ return a - b;
+ }
+ function parse(scale, input) {
+ if (isNullOrUndef(input)) {
+ return null;
+ }
+ const adapter = scale._adapter;
+ const { parser , round , isoWeekday } = scale._parseOpts;
+ let value = input;
+ if (typeof parser === 'function') {
+ value = parser(value);
+ }
+ if (!isNumberFinite(value)) {
+ value = typeof parser === 'string' ? adapter.parse(value, parser) : adapter.parse(value);
+ }
+ if (value === null) {
+ return null;
+ }
+ if (round) {
+ value = round === 'week' && (isNumber(isoWeekday) || isoWeekday === true) ? adapter.startOf(value, 'isoWeek', isoWeekday) : adapter.startOf(value, round);
+ }
+ return +value;
+ }
+ function determineUnitForAutoTicks(minUnit, min, max, capacity) {
+ const ilen = UNITS.length;
+ for(let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i){
+ const interval = INTERVALS[UNITS[i]];
+ const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER;
+ if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {
+ return UNITS[i];
+ }
+ }
+ return UNITS[ilen - 1];
+ }
+ function determineUnitForFormatting(scale, numTicks, minUnit, min, max) {
+ for(let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--){
+ const unit = UNITS[i];
+ if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) {
+ return unit;
+ }
+ }
+ return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];
+ }
+ function determineMajorUnit(unit) {
+ for(let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i){
+ if (INTERVALS[UNITS[i]].common) {
+ return UNITS[i];
+ }
+ }
+ }
+ function addTick(ticks, time, timestamps) {
+ if (!timestamps) {
+ ticks[time] = true;
+ } else if (timestamps.length) {
+ const { lo , hi } = _lookup(timestamps, time);
+ const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi];
+ ticks[timestamp] = true;
+ }
+ }
+ function setMajorTicks(scale, ticks, map, majorUnit) {
+ const adapter = scale._adapter;
+ const first = +adapter.startOf(ticks[0].value, majorUnit);
+ const last = ticks[ticks.length - 1].value;
+ let major, index;
+ for(major = first; major <= last; major = +adapter.add(major, 1, majorUnit)){
+ index = map[major];
+ if (index >= 0) {
+ ticks[index].major = true;
+ }
+ }
+ return ticks;
+ }
+ function ticksFromTimestamps(scale, values, majorUnit) {
+ const ticks = [];
+ const map = {};
+ const ilen = values.length;
+ let i, value;
+ for(i = 0; i < ilen; ++i){
+ value = values[i];
+ map[value] = i;
+ ticks.push({
+ value,
+ major: false
+ });
+ }
+ return ilen === 0 || !majorUnit ? ticks : setMajorTicks(scale, ticks, map, majorUnit);
+ }
+ class TimeScale extends Scale {
+ static id = 'time';
+ static defaults = {
+ bounds: 'data',
+ adapters: {},
+ time: {
+ parser: false,
+ unit: false,
+ round: false,
+ isoWeekday: false,
+ minUnit: 'millisecond',
+ displayFormats: {}
+ },
+ ticks: {
+ source: 'auto',
+ callback: false,
+ major: {
+ enabled: false
+ }
+ }
+ };
+ constructor(props){
+ super(props);
+ this._cache = {
+ data: [],
+ labels: [],
+ all: []
+ };
+ this._unit = 'day';
+ this._majorUnit = undefined;
+ this._offsets = {};
+ this._normalized = false;
+ this._parseOpts = undefined;
+ }
+ init(scaleOpts, opts = {}) {
+ const time = scaleOpts.time || (scaleOpts.time = {});
+ const adapter = this._adapter = new _adapters._date(scaleOpts.adapters.date);
+ adapter.init(opts);
+ mergeIf(time.displayFormats, adapter.formats());
+ this._parseOpts = {
+ parser: time.parser,
+ round: time.round,
+ isoWeekday: time.isoWeekday
+ };
+ super.init(scaleOpts);
+ this._normalized = opts.normalized;
+ }
+ parse(raw, index) {
+ if (raw === undefined) {
+ return null;
+ }
+ return parse(this, raw);
+ }
+ beforeLayout() {
+ super.beforeLayout();
+ this._cache = {
+ data: [],
+ labels: [],
+ all: []
+ };
+ }
+ determineDataLimits() {
+ const options = this.options;
+ const adapter = this._adapter;
+ const unit = options.time.unit || 'day';
+ let { min , max , minDefined , maxDefined } = this.getUserBounds();
+ function _applyBounds(bounds) {
+ if (!minDefined && !isNaN(bounds.min)) {
+ min = Math.min(min, bounds.min);
+ }
+ if (!maxDefined && !isNaN(bounds.max)) {
+ max = Math.max(max, bounds.max);
+ }
+ }
+ if (!minDefined || !maxDefined) {
+ _applyBounds(this._getLabelBounds());
+ if (options.bounds !== 'ticks' || options.ticks.source !== 'labels') {
+ _applyBounds(this.getMinMax(false));
+ }
+ }
+ min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit);
+ max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1;
+ this.min = Math.min(min, max - 1);
+ this.max = Math.max(min + 1, max);
+ }
+ _getLabelBounds() {
+ const arr = this.getLabelTimestamps();
+ let min = Number.POSITIVE_INFINITY;
+ let max = Number.NEGATIVE_INFINITY;
+ if (arr.length) {
+ min = arr[0];
+ max = arr[arr.length - 1];
+ }
+ return {
+ min,
+ max
+ };
+ }
+ buildTicks() {
+ const options = this.options;
+ const timeOpts = options.time;
+ const tickOpts = options.ticks;
+ const timestamps = tickOpts.source === 'labels' ? this.getLabelTimestamps() : this._generate();
+ if (options.bounds === 'ticks' && timestamps.length) {
+ this.min = this._userMin || timestamps[0];
+ this.max = this._userMax || timestamps[timestamps.length - 1];
+ }
+ const min = this.min;
+ const max = this.max;
+ const ticks = _filterBetween(timestamps, min, max);
+ this._unit = timeOpts.unit || (tickOpts.autoSkip ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min)) : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max));
+ this._majorUnit = !tickOpts.major.enabled || this._unit === 'year' ? undefined : determineMajorUnit(this._unit);
+ this.initOffsets(timestamps);
+ if (options.reverse) {
+ ticks.reverse();
+ }
+ return ticksFromTimestamps(this, ticks, this._majorUnit);
+ }
+ afterAutoSkip() {
+ if (this.options.offsetAfterAutoskip) {
+ this.initOffsets(this.ticks.map((tick)=>+tick.value));
+ }
+ }
+ initOffsets(timestamps = []) {
+ let start = 0;
+ let end = 0;
+ let first, last;
+ if (this.options.offset && timestamps.length) {
+ first = this.getDecimalForValue(timestamps[0]);
+ if (timestamps.length === 1) {
+ start = 1 - first;
+ } else {
+ start = (this.getDecimalForValue(timestamps[1]) - first) / 2;
+ }
+ last = this.getDecimalForValue(timestamps[timestamps.length - 1]);
+ if (timestamps.length === 1) {
+ end = last;
+ } else {
+ end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2;
+ }
+ }
+ const limit = timestamps.length < 3 ? 0.5 : 0.25;
+ start = _limitValue(start, 0, limit);
+ end = _limitValue(end, 0, limit);
+ this._offsets = {
+ start,
+ end,
+ factor: 1 / (start + 1 + end)
+ };
+ }
+ _generate() {
+ const adapter = this._adapter;
+ const min = this.min;
+ const max = this.max;
+ const options = this.options;
+ const timeOpts = options.time;
+ const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min));
+ const stepSize = valueOrDefault(options.ticks.stepSize, 1);
+ const weekday = minor === 'week' ? timeOpts.isoWeekday : false;
+ const hasWeekday = isNumber(weekday) || weekday === true;
+ const ticks = {};
+ let first = min;
+ let time, count;
+ if (hasWeekday) {
+ first = +adapter.startOf(first, 'isoWeek', weekday);
+ }
+ first = +adapter.startOf(first, hasWeekday ? 'day' : minor);
+ if (adapter.diff(max, min, minor) > 100000 * stepSize) {
+ throw new Error(min + ' and ' + max + ' are too far apart with stepSize of ' + stepSize + ' ' + minor);
+ }
+ const timestamps = options.ticks.source === 'data' && this.getDataTimestamps();
+ for(time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++){
+ addTick(ticks, time, timestamps);
+ }
+ if (time === max || options.bounds === 'ticks' || count === 1) {
+ addTick(ticks, time, timestamps);
+ }
+ return Object.keys(ticks).sort(sorter).map((x)=>+x);
+ }
+ getLabelForValue(value) {
+ const adapter = this._adapter;
+ const timeOpts = this.options.time;
+ if (timeOpts.tooltipFormat) {
+ return adapter.format(value, timeOpts.tooltipFormat);
+ }
+ return adapter.format(value, timeOpts.displayFormats.datetime);
+ }
+ format(value, format) {
+ const options = this.options;
+ const formats = options.time.displayFormats;
+ const unit = this._unit;
+ const fmt = format || formats[unit];
+ return this._adapter.format(value, fmt);
+ }
+ _tickFormatFunction(time, index, ticks, format) {
+ const options = this.options;
+ const formatter = options.ticks.callback;
+ if (formatter) {
+ return callback(formatter, [
+ time,
+ index,
+ ticks
+ ], this);
+ }
+ const formats = options.time.displayFormats;
+ const unit = this._unit;
+ const majorUnit = this._majorUnit;
+ const minorFormat = unit && formats[unit];
+ const majorFormat = majorUnit && formats[majorUnit];
+ const tick = ticks[index];
+ const major = majorUnit && majorFormat && tick && tick.major;
+ return this._adapter.format(time, format || (major ? majorFormat : minorFormat));
+ }
+ generateTickLabels(ticks) {
+ let i, ilen, tick;
+ for(i = 0, ilen = ticks.length; i < ilen; ++i){
+ tick = ticks[i];
+ tick.label = this._tickFormatFunction(tick.value, i, ticks);
+ }
+ }
+ getDecimalForValue(value) {
+ return value === null ? NaN : (value - this.min) / (this.max - this.min);
+ }
+ getPixelForValue(value) {
+ const offsets = this._offsets;
+ const pos = this.getDecimalForValue(value);
+ return this.getPixelForDecimal((offsets.start + pos) * offsets.factor);
+ }
+ getValueForPixel(pixel) {
+ const offsets = this._offsets;
+ const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
+ return this.min + pos * (this.max - this.min);
+ }
+ _getLabelSize(label) {
+ const ticksOpts = this.options.ticks;
+ const tickLabelWidth = this.ctx.measureText(label).width;
+ const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation);
+ const cosRotation = Math.cos(angle);
+ const sinRotation = Math.sin(angle);
+ const tickFontSize = this._resolveTickFontOptions(0).size;
+ return {
+ w: tickLabelWidth * cosRotation + tickFontSize * sinRotation,
+ h: tickLabelWidth * sinRotation + tickFontSize * cosRotation
+ };
+ }
+ _getLabelCapacity(exampleTime) {
+ const timeOpts = this.options.time;
+ const displayFormats = timeOpts.displayFormats;
+ const format = displayFormats[timeOpts.unit] || displayFormats.millisecond;
+ const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [
+ exampleTime
+ ], this._majorUnit), format);
+ const size = this._getLabelSize(exampleLabel);
+ const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1;
+ return capacity > 0 ? capacity : 1;
+ }
+ getDataTimestamps() {
+ let timestamps = this._cache.data || [];
+ let i, ilen;
+ if (timestamps.length) {
+ return timestamps;
+ }
+ const metas = this.getMatchingVisibleMetas();
+ if (this._normalized && metas.length) {
+ return this._cache.data = metas[0].controller.getAllParsedValues(this);
+ }
+ for(i = 0, ilen = metas.length; i < ilen; ++i){
+ timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(this));
+ }
+ return this._cache.data = this.normalize(timestamps);
+ }
+ getLabelTimestamps() {
+ const timestamps = this._cache.labels || [];
+ let i, ilen;
+ if (timestamps.length) {
+ return timestamps;
+ }
+ const labels = this.getLabels();
+ for(i = 0, ilen = labels.length; i < ilen; ++i){
+ timestamps.push(parse(this, labels[i]));
+ }
+ return this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps);
+ }
+ normalize(values) {
+ return _arrayUnique(values.sort(sorter));
+ }
+ }
+
+ function interpolate(table, val, reverse) {
+ let lo = 0;
+ let hi = table.length - 1;
+ let prevSource, nextSource, prevTarget, nextTarget;
+ if (reverse) {
+ if (val >= table[lo].pos && val <= table[hi].pos) {
+ ({ lo , hi } = _lookupByKey(table, 'pos', val));
+ }
+ ({ pos: prevSource , time: prevTarget } = table[lo]);
+ ({ pos: nextSource , time: nextTarget } = table[hi]);
+ } else {
+ if (val >= table[lo].time && val <= table[hi].time) {
+ ({ lo , hi } = _lookupByKey(table, 'time', val));
+ }
+ ({ time: prevSource , pos: prevTarget } = table[lo]);
+ ({ time: nextSource , pos: nextTarget } = table[hi]);
+ }
+ const span = nextSource - prevSource;
+ return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget;
+ }
+ class TimeSeriesScale extends TimeScale {
+ static id = 'timeseries';
+ static defaults = TimeScale.defaults;
+ constructor(props){
+ super(props);
+ this._table = [];
+ this._minPos = undefined;
+ this._tableRange = undefined;
+ }
+ initOffsets() {
+ const timestamps = this._getTimestampsForTable();
+ const table = this._table = this.buildLookupTable(timestamps);
+ this._minPos = interpolate(table, this.min);
+ this._tableRange = interpolate(table, this.max) - this._minPos;
+ super.initOffsets(timestamps);
+ }
+ buildLookupTable(timestamps) {
+ const { min , max } = this;
+ const items = [];
+ const table = [];
+ let i, ilen, prev, curr, next;
+ for(i = 0, ilen = timestamps.length; i < ilen; ++i){
+ curr = timestamps[i];
+ if (curr >= min && curr <= max) {
+ items.push(curr);
+ }
+ }
+ if (items.length < 2) {
+ return [
+ {
+ time: min,
+ pos: 0
+ },
+ {
+ time: max,
+ pos: 1
+ }
+ ];
+ }
+ for(i = 0, ilen = items.length; i < ilen; ++i){
+ next = items[i + 1];
+ prev = items[i - 1];
+ curr = items[i];
+ if (Math.round((next + prev) / 2) !== curr) {
+ table.push({
+ time: curr,
+ pos: i / (ilen - 1)
+ });
+ }
+ }
+ return table;
+ }
+ _generate() {
+ const min = this.min;
+ const max = this.max;
+ let timestamps = super.getDataTimestamps();
+ if (!timestamps.includes(min) || !timestamps.length) {
+ timestamps.splice(0, 0, min);
+ }
+ if (!timestamps.includes(max) || timestamps.length === 1) {
+ timestamps.push(max);
+ }
+ return timestamps.sort((a, b)=>a - b);
+ }
+ _getTimestampsForTable() {
+ let timestamps = this._cache.all || [];
+ if (timestamps.length) {
+ return timestamps;
+ }
+ const data = this.getDataTimestamps();
+ const label = this.getLabelTimestamps();
+ if (data.length && label.length) {
+ timestamps = this.normalize(data.concat(label));
+ } else {
+ timestamps = data.length ? data : label;
+ }
+ timestamps = this._cache.all = timestamps;
+ return timestamps;
+ }
+ getDecimalForValue(value) {
+ return (interpolate(this._table, value) - this._minPos) / this._tableRange;
+ }
+ getValueForPixel(pixel) {
+ const offsets = this._offsets;
+ const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
+ return interpolate(this._table, decimal * this._tableRange + this._minPos, true);
+ }
+ }
+
+ var scales = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ CategoryScale: CategoryScale,
+ LinearScale: LinearScale,
+ LogarithmicScale: LogarithmicScale,
+ RadialLinearScale: RadialLinearScale,
+ TimeScale: TimeScale,
+ TimeSeriesScale: TimeSeriesScale
+ });
+
+ 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)' // grey
+ ];
+ // Border colors with 50% transparency
+ const BACKGROUND_COLORS = /* #__PURE__ */ BORDER_COLORS.map((color)=>color.replace('rgb(', 'rgba(').replace(')', ', 0.5)'));
+ function getBorderColor(i) {
+ return BORDER_COLORS[i % BORDER_COLORS.length];
+ }
+ function getBackgroundColor(i) {
+ return BACKGROUND_COLORS[i % BACKGROUND_COLORS.length];
+ }
+ function colorizeDefaultDataset(dataset, i) {
+ dataset.borderColor = getBorderColor(i);
+ dataset.backgroundColor = getBackgroundColor(i);
+ return ++i;
+ }
+ function colorizeDoughnutDataset(dataset, i) {
+ dataset.backgroundColor = dataset.data.map(()=>getBorderColor(i++));
+ return i;
+ }
+ function colorizePolarAreaDataset(dataset, i) {
+ dataset.backgroundColor = dataset.data.map(()=>getBackgroundColor(i++));
+ return i;
+ }
+ function getColorizer(chart) {
+ let i = 0;
+ return (dataset, datasetIndex)=>{
+ const controller = chart.getDatasetMeta(datasetIndex).controller;
+ if (controller instanceof DoughnutController) {
+ i = colorizeDoughnutDataset(dataset, i);
+ } else if (controller instanceof PolarAreaController) {
+ i = colorizePolarAreaDataset(dataset, i);
+ } else if (controller) {
+ i = colorizeDefaultDataset(dataset, i);
+ }
+ };
+ }
+ function containsColorsDefinitions(descriptors) {
+ let k;
+ for(k in descriptors){
+ if (descriptors[k].borderColor || descriptors[k].backgroundColor) {
+ return true;
+ }
+ }
+ return false;
+ }
+ function containsColorsDefinition(descriptor) {
+ return descriptor && (descriptor.borderColor || descriptor.backgroundColor);
+ }
+ var plugin_colors = {
+ id: 'colors',
+ defaults: {
+ enabled: true,
+ forceOverride: false
+ },
+ beforeLayout (chart, _args, options) {
+ if (!options.enabled) {
+ return;
+ }
+ const { data: { datasets } , options: chartOptions } = chart.config;
+ const { elements } = chartOptions;
+ if (!options.forceOverride && (containsColorsDefinitions(datasets) || containsColorsDefinition(chartOptions) || elements && containsColorsDefinitions(elements))) {
+ return;
+ }
+ const colorizer = getColorizer(chart);
+ datasets.forEach(colorizer);
+ }
+ };
+
+ function lttbDecimation(data, start, count, availableWidth, options) {
+ const samples = options.samples || availableWidth;
+ if (samples >= count) {
+ return data.slice(start, start + count);
+ }
+ const decimated = [];
+ const bucketWidth = (count - 2) / (samples - 2);
+ let sampledIndex = 0;
+ const endIndex = start + count - 1;
+ let a = start;
+ let i, maxAreaPoint, maxArea, area, nextA;
+ decimated[sampledIndex++] = data[a];
+ for(i = 0; i < samples - 2; i++){
+ let avgX = 0;
+ let avgY = 0;
+ let j;
+ const avgRangeStart = Math.floor((i + 1) * bucketWidth) + 1 + start;
+ const avgRangeEnd = Math.min(Math.floor((i + 2) * bucketWidth) + 1, count) + start;
+ const avgRangeLength = avgRangeEnd - avgRangeStart;
+ for(j = avgRangeStart; j < avgRangeEnd; j++){
+ avgX += data[j].x;
+ avgY += data[j].y;
+ }
+ avgX /= avgRangeLength;
+ avgY /= avgRangeLength;
+ const rangeOffs = Math.floor(i * bucketWidth) + 1 + start;
+ const rangeTo = Math.min(Math.floor((i + 1) * bucketWidth) + 1, count) + start;
+ const { x: pointAx , y: pointAy } = data[a];
+ maxArea = area = -1;
+ for(j = rangeOffs; j < rangeTo; j++){
+ area = 0.5 * Math.abs((pointAx - avgX) * (data[j].y - pointAy) - (pointAx - data[j].x) * (avgY - pointAy));
+ if (area > maxArea) {
+ maxArea = area;
+ maxAreaPoint = data[j];
+ nextA = j;
+ }
+ }
+ decimated[sampledIndex++] = maxAreaPoint;
+ a = nextA;
+ }
+ decimated[sampledIndex++] = data[endIndex];
+ return decimated;
+ }
+ function minMaxDecimation(data, start, count, availableWidth) {
+ let avgX = 0;
+ let countX = 0;
+ let i, point, x, y, prevX, minIndex, maxIndex, startIndex, minY, maxY;
+ const decimated = [];
+ const endIndex = start + count - 1;
+ const xMin = data[start].x;
+ const xMax = data[endIndex].x;
+ const dx = xMax - xMin;
+ for(i = start; i < start + count; ++i){
+ point = data[i];
+ x = (point.x - xMin) / dx * availableWidth;
+ y = point.y;
+ const truncX = x | 0;
+ if (truncX === prevX) {
+ if (y < minY) {
+ minY = y;
+ minIndex = i;
+ } else if (y > maxY) {
+ maxY = y;
+ maxIndex = i;
+ }
+ avgX = (countX * avgX + point.x) / ++countX;
+ } else {
+ const lastIndex = i - 1;
+ if (!isNullOrUndef(minIndex) && !isNullOrUndef(maxIndex)) {
+ const intermediateIndex1 = Math.min(minIndex, maxIndex);
+ const intermediateIndex2 = Math.max(minIndex, maxIndex);
+ if (intermediateIndex1 !== startIndex && intermediateIndex1 !== lastIndex) {
+ decimated.push({
+ ...data[intermediateIndex1],
+ x: avgX
+ });
+ }
+ if (intermediateIndex2 !== startIndex && intermediateIndex2 !== lastIndex) {
+ decimated.push({
+ ...data[intermediateIndex2],
+ x: avgX
+ });
+ }
+ }
+ if (i > 0 && lastIndex !== startIndex) {
+ decimated.push(data[lastIndex]);
+ }
+ decimated.push(point);
+ prevX = truncX;
+ countX = 0;
+ minY = maxY = y;
+ minIndex = maxIndex = startIndex = i;
+ }
+ }
+ return decimated;
+ }
+ function cleanDecimatedDataset(dataset) {
+ if (dataset._decimated) {
+ const data = dataset._data;
+ delete dataset._decimated;
+ delete dataset._data;
+ Object.defineProperty(dataset, 'data', {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: data
+ });
+ }
+ }
+ function cleanDecimatedData(chart) {
+ chart.data.datasets.forEach((dataset)=>{
+ cleanDecimatedDataset(dataset);
+ });
+ }
+ function getStartAndCountOfVisiblePointsSimplified(meta, points) {
+ const pointCount = points.length;
+ let start = 0;
+ let count;
+ const { iScale } = meta;
+ const { min , max , minDefined , maxDefined } = iScale.getUserBounds();
+ if (minDefined) {
+ start = _limitValue(_lookupByKey(points, iScale.axis, min).lo, 0, pointCount - 1);
+ }
+ if (maxDefined) {
+ count = _limitValue(_lookupByKey(points, iScale.axis, max).hi + 1, start, pointCount) - start;
+ } else {
+ count = pointCount - start;
+ }
+ return {
+ start,
+ count
+ };
+ }
+ var plugin_decimation = {
+ id: 'decimation',
+ defaults: {
+ algorithm: 'min-max',
+ enabled: false
+ },
+ beforeElementsUpdate: (chart, args, options)=>{
+ if (!options.enabled) {
+ cleanDecimatedData(chart);
+ return;
+ }
+ const availableWidth = chart.width;
+ chart.data.datasets.forEach((dataset, datasetIndex)=>{
+ const { _data , indexAxis } = dataset;
+ const meta = chart.getDatasetMeta(datasetIndex);
+ const data = _data || dataset.data;
+ if (resolve([
+ indexAxis,
+ chart.options.indexAxis
+ ]) === 'y') {
+ return;
+ }
+ if (!meta.controller.supportsDecimation) {
+ return;
+ }
+ const xAxis = chart.scales[meta.xAxisID];
+ if (xAxis.type !== 'linear' && xAxis.type !== 'time') {
+ return;
+ }
+ if (chart.options.parsing) {
+ return;
+ }
+ let { start , count } = getStartAndCountOfVisiblePointsSimplified(meta, data);
+ const threshold = options.threshold || 4 * availableWidth;
+ if (count <= threshold) {
+ cleanDecimatedDataset(dataset);
+ return;
+ }
+ if (isNullOrUndef(_data)) {
+ dataset._data = data;
+ delete dataset.data;
+ Object.defineProperty(dataset, 'data', {
+ configurable: true,
+ enumerable: true,
+ get: function() {
+ return this._decimated;
+ },
+ set: function(d) {
+ this._data = d;
+ }
+ });
+ }
+ let decimated;
+ switch(options.algorithm){
+ case 'lttb':
+ decimated = lttbDecimation(data, start, count, availableWidth, options);
+ break;
+ case 'min-max':
+ decimated = minMaxDecimation(data, start, count, availableWidth);
+ break;
+ default:
+ throw new Error(`Unsupported decimation algorithm '${options.algorithm}'`);
+ }
+ dataset._decimated = decimated;
+ });
+ },
+ destroy (chart) {
+ cleanDecimatedData(chart);
+ }
+ };
+
+ function _segments(line, target, property) {
+ const segments = line.segments;
+ const points = line.points;
+ const tpoints = target.points;
+ const parts = [];
+ for (const segment of segments){
+ let { start , end } = segment;
+ end = _findSegmentEnd(start, end, points);
+ const bounds = _getBounds(property, points[start], points[end], segment.loop);
+ if (!target.segments) {
+ parts.push({
+ source: segment,
+ target: bounds,
+ start: points[start],
+ end: points[end]
+ });
+ continue;
+ }
+ const targetSegments = _boundSegments(target, bounds);
+ for (const tgt of targetSegments){
+ const subBounds = _getBounds(property, tpoints[tgt.start], tpoints[tgt.end], tgt.loop);
+ const fillSources = _boundSegment(segment, points, subBounds);
+ for (const fillSource of fillSources){
+ parts.push({
+ source: fillSource,
+ target: tgt,
+ start: {
+ [property]: _getEdge(bounds, subBounds, 'start', Math.max)
+ },
+ end: {
+ [property]: _getEdge(bounds, subBounds, 'end', Math.min)
+ }
+ });
+ }
+ }
+ }
+ return parts;
+ }
+ function _getBounds(property, first, last, loop) {
+ if (loop) {
+ return;
+ }
+ let start = first[property];
+ let end = last[property];
+ if (property === 'angle') {
+ start = _normalizeAngle(start);
+ end = _normalizeAngle(end);
+ }
+ return {
+ property,
+ start,
+ end
+ };
+ }
+ function _pointsFromSegments(boundary, line) {
+ const { x =null , y =null } = boundary || {};
+ const linePoints = line.points;
+ const points = [];
+ line.segments.forEach(({ start , end })=>{
+ end = _findSegmentEnd(start, end, linePoints);
+ const first = linePoints[start];
+ const last = linePoints[end];
+ if (y !== null) {
+ points.push({
+ x: first.x,
+ y
+ });
+ points.push({
+ x: last.x,
+ y
+ });
+ } else if (x !== null) {
+ points.push({
+ x,
+ y: first.y
+ });
+ points.push({
+ x,
+ y: last.y
+ });
+ }
+ });
+ return points;
+ }
+ function _findSegmentEnd(start, end, points) {
+ for(; end > start; end--){
+ const point = points[end];
+ if (!isNaN(point.x) && !isNaN(point.y)) {
+ break;
+ }
+ }
+ return end;
+ }
+ function _getEdge(a, b, prop, fn) {
+ if (a && b) {
+ return fn(a[prop], b[prop]);
+ }
+ return a ? a[prop] : b ? b[prop] : 0;
+ }
+
+ function _createBoundaryLine(boundary, line) {
+ let points = [];
+ let _loop = false;
+ if (isArray(boundary)) {
+ _loop = true;
+ points = boundary;
+ } else {
+ points = _pointsFromSegments(boundary, line);
+ }
+ return points.length ? new LineElement({
+ points,
+ options: {
+ tension: 0
+ },
+ _loop,
+ _fullLoop: _loop
+ }) : null;
+ }
+ function _shouldApplyFill(source) {
+ return source && source.fill !== false;
+ }
+
+ function _resolveTarget(sources, index, propagate) {
+ const source = sources[index];
+ let fill = source.fill;
+ const visited = [
+ index
+ ];
+ let target;
+ if (!propagate) {
+ return fill;
+ }
+ while(fill !== false && visited.indexOf(fill) === -1){
+ if (!isNumberFinite(fill)) {
+ return fill;
+ }
+ target = sources[fill];
+ if (!target) {
+ return false;
+ }
+ if (target.visible) {
+ return fill;
+ }
+ visited.push(fill);
+ fill = target.fill;
+ }
+ return false;
+ }
+ function _decodeFill(line, index, count) {
+ const fill = parseFillOption(line);
+ if (isObject(fill)) {
+ return isNaN(fill.value) ? false : fill;
+ }
+ let target = parseFloat(fill);
+ if (isNumberFinite(target) && Math.floor(target) === target) {
+ return decodeTargetIndex(fill[0], index, target, count);
+ }
+ return [
+ 'origin',
+ 'start',
+ 'end',
+ 'stack',
+ 'shape'
+ ].indexOf(fill) >= 0 && fill;
+ }
+ function decodeTargetIndex(firstCh, index, target, count) {
+ if (firstCh === '-' || firstCh === '+') {
+ target = index + target;
+ }
+ if (target === index || target < 0 || target >= count) {
+ return false;
+ }
+ return target;
+ }
+ function _getTargetPixel(fill, scale) {
+ let pixel = null;
+ if (fill === 'start') {
+ pixel = scale.bottom;
+ } else if (fill === 'end') {
+ pixel = scale.top;
+ } else if (isObject(fill)) {
+ pixel = scale.getPixelForValue(fill.value);
+ } else if (scale.getBasePixel) {
+ pixel = scale.getBasePixel();
+ }
+ return pixel;
+ }
+ function _getTargetValue(fill, scale, startValue) {
+ let value;
+ if (fill === 'start') {
+ value = startValue;
+ } else if (fill === 'end') {
+ value = scale.options.reverse ? scale.min : scale.max;
+ } else if (isObject(fill)) {
+ value = fill.value;
+ } else {
+ value = scale.getBaseValue();
+ }
+ return value;
+ }
+ function parseFillOption(line) {
+ const options = line.options;
+ const fillOption = options.fill;
+ let fill = valueOrDefault(fillOption && fillOption.target, fillOption);
+ if (fill === undefined) {
+ fill = !!options.backgroundColor;
+ }
+ if (fill === false || fill === null) {
+ return false;
+ }
+ if (fill === true) {
+ return 'origin';
+ }
+ return fill;
+ }
+
+ function _buildStackLine(source) {
+ const { scale , index , line } = source;
+ const points = [];
+ const segments = line.segments;
+ const sourcePoints = line.points;
+ const linesBelow = getLinesBelow(scale, index);
+ linesBelow.push(_createBoundaryLine({
+ x: null,
+ y: scale.bottom
+ }, line));
+ for(let i = 0; i < segments.length; i++){
+ const segment = segments[i];
+ for(let j = segment.start; j <= segment.end; j++){
+ addPointsBelow(points, sourcePoints[j], linesBelow);
+ }
+ }
+ return new LineElement({
+ points,
+ options: {}
+ });
+ }
+ function getLinesBelow(scale, index) {
+ const below = [];
+ const metas = scale.getMatchingVisibleMetas('line');
+ for(let i = 0; i < metas.length; i++){
+ const meta = metas[i];
+ if (meta.index === index) {
+ break;
+ }
+ if (!meta.hidden) {
+ below.unshift(meta.dataset);
+ }
+ }
+ return below;
+ }
+ function addPointsBelow(points, sourcePoint, linesBelow) {
+ const postponed = [];
+ for(let j = 0; j < linesBelow.length; j++){
+ const line = linesBelow[j];
+ const { first , last , point } = findPoint(line, sourcePoint, 'x');
+ if (!point || first && last) {
+ continue;
+ }
+ if (first) {
+ postponed.unshift(point);
+ } else {
+ points.push(point);
+ if (!last) {
+ break;
+ }
+ }
+ }
+ points.push(...postponed);
+ }
+ function findPoint(line, sourcePoint, property) {
+ const point = line.interpolate(sourcePoint, property);
+ if (!point) {
+ return {};
+ }
+ const pointValue = point[property];
+ const segments = line.segments;
+ const linePoints = line.points;
+ let first = false;
+ let last = false;
+ for(let i = 0; i < segments.length; i++){
+ const segment = segments[i];
+ const firstValue = linePoints[segment.start][property];
+ const lastValue = linePoints[segment.end][property];
+ if (_isBetween(pointValue, firstValue, lastValue)) {
+ first = pointValue === firstValue;
+ last = pointValue === lastValue;
+ break;
+ }
+ }
+ return {
+ first,
+ last,
+ point
+ };
+ }
+
+ class simpleArc {
+ constructor(opts){
+ this.x = opts.x;
+ this.y = opts.y;
+ this.radius = opts.radius;
+ }
+ pathSegment(ctx, bounds, opts) {
+ const { x , y , radius } = this;
+ bounds = bounds || {
+ start: 0,
+ end: TAU
+ };
+ ctx.arc(x, y, radius, bounds.end, bounds.start, true);
+ return !opts.bounds;
+ }
+ interpolate(point) {
+ const { x , y , radius } = this;
+ const angle = point.angle;
+ return {
+ x: x + Math.cos(angle) * radius,
+ y: y + Math.sin(angle) * radius,
+ angle
+ };
+ }
+ }
+
+ function _getTarget(source) {
+ const { chart , fill , line } = source;
+ if (isNumberFinite(fill)) {
+ return getLineByIndex(chart, fill);
+ }
+ if (fill === 'stack') {
+ return _buildStackLine(source);
+ }
+ if (fill === 'shape') {
+ return true;
+ }
+ const boundary = computeBoundary(source);
+ if (boundary instanceof simpleArc) {
+ return boundary;
+ }
+ return _createBoundaryLine(boundary, line);
+ }
+ function getLineByIndex(chart, index) {
+ const meta = chart.getDatasetMeta(index);
+ const visible = meta && chart.isDatasetVisible(index);
+ return visible ? meta.dataset : null;
+ }
+ function computeBoundary(source) {
+ const scale = source.scale || {};
+ if (scale.getPointPositionForValue) {
+ return computeCircularBoundary(source);
+ }
+ return computeLinearBoundary(source);
+ }
+ function computeLinearBoundary(source) {
+ const { scale ={} , fill } = source;
+ const pixel = _getTargetPixel(fill, scale);
+ if (isNumberFinite(pixel)) {
+ const horizontal = scale.isHorizontal();
+ return {
+ x: horizontal ? pixel : null,
+ y: horizontal ? null : pixel
+ };
+ }
+ return null;
+ }
+ function computeCircularBoundary(source) {
+ const { scale , fill } = source;
+ const options = scale.options;
+ const length = scale.getLabels().length;
+ const start = options.reverse ? scale.max : scale.min;
+ const value = _getTargetValue(fill, scale, start);
+ const target = [];
+ if (options.grid.circular) {
+ const center = scale.getPointPositionForValue(0, start);
+ return new simpleArc({
+ x: center.x,
+ y: center.y,
+ radius: scale.getDistanceFromCenterForValue(value)
+ });
+ }
+ for(let i = 0; i < length; ++i){
+ target.push(scale.getPointPositionForValue(i, value));
+ }
+ return target;
+ }
+
+ function _drawfill(ctx, source, area) {
+ const target = _getTarget(source);
+ const { line , scale , axis } = source;
+ const lineOpts = line.options;
+ const fillOption = lineOpts.fill;
+ const color = lineOpts.backgroundColor;
+ const { above =color , below =color } = fillOption || {};
+ if (target && line.points.length) {
+ clipArea(ctx, area);
+ doFill(ctx, {
+ line,
+ target,
+ above,
+ below,
+ area,
+ scale,
+ axis
+ });
+ unclipArea(ctx);
+ }
+ }
+ function doFill(ctx, cfg) {
+ const { line , target , above , below , area , scale } = cfg;
+ const property = line._loop ? 'angle' : cfg.axis;
+ ctx.save();
+ if (property === 'x' && below !== above) {
+ clipVertical(ctx, target, area.top);
+ fill(ctx, {
+ line,
+ target,
+ color: above,
+ scale,
+ property
+ });
+ ctx.restore();
+ ctx.save();
+ clipVertical(ctx, target, area.bottom);
+ }
+ fill(ctx, {
+ line,
+ target,
+ color: below,
+ scale,
+ property
+ });
+ ctx.restore();
+ }
+ function clipVertical(ctx, target, clipY) {
+ const { segments , points } = target;
+ let first = true;
+ let lineLoop = false;
+ ctx.beginPath();
+ for (const segment of segments){
+ const { start , end } = segment;
+ const firstPoint = points[start];
+ const lastPoint = points[_findSegmentEnd(start, end, points)];
+ if (first) {
+ ctx.moveTo(firstPoint.x, firstPoint.y);
+ first = false;
+ } else {
+ ctx.lineTo(firstPoint.x, clipY);
+ ctx.lineTo(firstPoint.x, firstPoint.y);
+ }
+ lineLoop = !!target.pathSegment(ctx, segment, {
+ move: lineLoop
+ });
+ if (lineLoop) {
+ ctx.closePath();
+ } else {
+ ctx.lineTo(lastPoint.x, clipY);
+ }
+ }
+ ctx.lineTo(target.first().x, clipY);
+ ctx.closePath();
+ ctx.clip();
+ }
+ function fill(ctx, cfg) {
+ const { line , target , property , color , scale } = cfg;
+ const segments = _segments(line, target, property);
+ for (const { source: src , target: tgt , start , end } of segments){
+ const { style: { backgroundColor =color } = {} } = src;
+ const notShape = target !== true;
+ ctx.save();
+ ctx.fillStyle = backgroundColor;
+ clipBounds(ctx, scale, notShape && _getBounds(property, start, end));
+ ctx.beginPath();
+ const lineLoop = !!line.pathSegment(ctx, src);
+ let loop;
+ if (notShape) {
+ if (lineLoop) {
+ ctx.closePath();
+ } else {
+ interpolatedLineTo(ctx, target, end, property);
+ }
+ const targetLoop = !!target.pathSegment(ctx, tgt, {
+ move: lineLoop,
+ reverse: true
+ });
+ loop = lineLoop && targetLoop;
+ if (!loop) {
+ interpolatedLineTo(ctx, target, start, property);
+ }
+ }
+ ctx.closePath();
+ ctx.fill(loop ? 'evenodd' : 'nonzero');
+ ctx.restore();
+ }
+ }
+ function clipBounds(ctx, scale, bounds) {
+ const { top , bottom } = scale.chart.chartArea;
+ const { property , start , end } = bounds || {};
+ if (property === 'x') {
+ ctx.beginPath();
+ ctx.rect(start, top, end - start, bottom - top);
+ ctx.clip();
+ }
+ }
+ function interpolatedLineTo(ctx, target, point, property) {
+ const interpolatedPoint = target.interpolate(point, property);
+ if (interpolatedPoint) {
+ ctx.lineTo(interpolatedPoint.x, interpolatedPoint.y);
+ }
+ }
+
+ var index = {
+ id: 'filler',
+ afterDatasetsUpdate (chart, _args, options) {
+ const count = (chart.data.datasets || []).length;
+ const sources = [];
+ let meta, i, line, source;
+ for(i = 0; i < count; ++i){
+ meta = chart.getDatasetMeta(i);
+ line = meta.dataset;
+ source = null;
+ if (line && line.options && line instanceof LineElement) {
+ source = {
+ visible: chart.isDatasetVisible(i),
+ index: i,
+ fill: _decodeFill(line, i, count),
+ chart,
+ axis: meta.controller.options.indexAxis,
+ scale: meta.vScale,
+ line
+ };
+ }
+ meta.$filler = source;
+ sources.push(source);
+ }
+ for(i = 0; i < count; ++i){
+ source = sources[i];
+ if (!source || source.fill === false) {
+ continue;
+ }
+ source.fill = _resolveTarget(sources, i, options.propagate);
+ }
+ },
+ beforeDraw (chart, _args, options) {
+ const draw = options.drawTime === 'beforeDraw';
+ const metasets = chart.getSortedVisibleDatasetMetas();
+ const area = chart.chartArea;
+ for(let i = metasets.length - 1; i >= 0; --i){
+ const source = metasets[i].$filler;
+ if (!source) {
+ continue;
+ }
+ source.line.updateControlPoints(area, source.axis);
+ if (draw && source.fill) {
+ _drawfill(chart.ctx, source, area);
+ }
+ }
+ },
+ beforeDatasetsDraw (chart, _args, options) {
+ if (options.drawTime !== 'beforeDatasetsDraw') {
+ return;
+ }
+ const metasets = chart.getSortedVisibleDatasetMetas();
+ for(let i = metasets.length - 1; i >= 0; --i){
+ const source = metasets[i].$filler;
+ if (_shouldApplyFill(source)) {
+ _drawfill(chart.ctx, source, chart.chartArea);
+ }
+ }
+ },
+ beforeDatasetDraw (chart, args, options) {
+ const source = args.meta.$filler;
+ if (!_shouldApplyFill(source) || options.drawTime !== 'beforeDatasetDraw') {
+ return;
+ }
+ _drawfill(chart.ctx, source, chart.chartArea);
+ },
+ defaults: {
+ propagate: true,
+ drawTime: 'beforeDatasetDraw'
+ }
+ };
+
+ const getBoxSize = (labelOpts, fontSize)=>{
+ let { boxHeight =fontSize , boxWidth =fontSize } = labelOpts;
+ if (labelOpts.usePointStyle) {
+ boxHeight = Math.min(boxHeight, fontSize);
+ boxWidth = labelOpts.pointStyleWidth || Math.min(boxWidth, fontSize);
+ }
+ return {
+ boxWidth,
+ boxHeight,
+ itemHeight: Math.max(fontSize, boxHeight)
+ };
+ };
+ const itemsEqual = (a, b)=>a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index;
+ class Legend extends Element {
+ constructor(config){
+ super();
+ this._added = false;
+ this.legendHitBoxes = [];
+ this._hoveredItem = null;
+ this.doughnutMode = false;
+ this.chart = config.chart;
+ this.options = config.options;
+ this.ctx = config.ctx;
+ this.legendItems = undefined;
+ this.columnSizes = undefined;
+ this.lineWidths = undefined;
+ this.maxHeight = undefined;
+ this.maxWidth = undefined;
+ this.top = undefined;
+ this.bottom = undefined;
+ this.left = undefined;
+ this.right = undefined;
+ this.height = undefined;
+ this.width = undefined;
+ this._margins = undefined;
+ this.position = undefined;
+ this.weight = undefined;
+ this.fullSize = undefined;
+ }
+ update(maxWidth, maxHeight, margins) {
+ this.maxWidth = maxWidth;
+ this.maxHeight = maxHeight;
+ this._margins = margins;
+ this.setDimensions();
+ this.buildLabels();
+ this.fit();
+ }
+ setDimensions() {
+ if (this.isHorizontal()) {
+ this.width = this.maxWidth;
+ this.left = this._margins.left;
+ this.right = this.width;
+ } else {
+ this.height = this.maxHeight;
+ this.top = this._margins.top;
+ this.bottom = this.height;
+ }
+ }
+ buildLabels() {
+ const labelOpts = this.options.labels || {};
+ let legendItems = callback(labelOpts.generateLabels, [
+ this.chart
+ ], this) || [];
+ if (labelOpts.filter) {
+ legendItems = legendItems.filter((item)=>labelOpts.filter(item, this.chart.data));
+ }
+ if (labelOpts.sort) {
+ legendItems = legendItems.sort((a, b)=>labelOpts.sort(a, b, this.chart.data));
+ }
+ if (this.options.reverse) {
+ legendItems.reverse();
+ }
+ this.legendItems = legendItems;
+ }
+ fit() {
+ const { options , ctx } = this;
+ if (!options.display) {
+ this.width = this.height = 0;
+ return;
+ }
+ const labelOpts = options.labels;
+ const labelFont = toFont(labelOpts.font);
+ const fontSize = labelFont.size;
+ const titleHeight = this._computeTitleHeight();
+ const { boxWidth , itemHeight } = getBoxSize(labelOpts, fontSize);
+ let width, height;
+ ctx.font = labelFont.string;
+ if (this.isHorizontal()) {
+ width = this.maxWidth;
+ height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;
+ } else {
+ height = this.maxHeight;
+ width = this._fitCols(titleHeight, labelFont, boxWidth, itemHeight) + 10;
+ }
+ this.width = Math.min(width, options.maxWidth || this.maxWidth);
+ this.height = Math.min(height, options.maxHeight || this.maxHeight);
+ }
+ _fitRows(titleHeight, fontSize, boxWidth, itemHeight) {
+ const { ctx , maxWidth , options: { labels: { padding } } } = this;
+ const hitboxes = this.legendHitBoxes = [];
+ const lineWidths = this.lineWidths = [
+ 0
+ ];
+ const lineHeight = itemHeight + padding;
+ let totalHeight = titleHeight;
+ ctx.textAlign = 'left';
+ ctx.textBaseline = 'middle';
+ let row = -1;
+ let top = -lineHeight;
+ this.legendItems.forEach((legendItem, i)=>{
+ const itemWidth = boxWidth + fontSize / 2 + ctx.measureText(legendItem.text).width;
+ if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {
+ totalHeight += lineHeight;
+ lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0;
+ top += lineHeight;
+ row++;
+ }
+ hitboxes[i] = {
+ left: 0,
+ top,
+ row,
+ width: itemWidth,
+ height: itemHeight
+ };
+ lineWidths[lineWidths.length - 1] += itemWidth + padding;
+ });
+ return totalHeight;
+ }
+ _fitCols(titleHeight, labelFont, boxWidth, _itemHeight) {
+ const { ctx , maxHeight , options: { labels: { padding } } } = this;
+ const hitboxes = this.legendHitBoxes = [];
+ const columnSizes = this.columnSizes = [];
+ const heightLimit = maxHeight - titleHeight;
+ let totalWidth = padding;
+ let currentColWidth = 0;
+ let currentColHeight = 0;
+ let left = 0;
+ let col = 0;
+ this.legendItems.forEach((legendItem, i)=>{
+ const { itemWidth , itemHeight } = calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight);
+ if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {
+ totalWidth += currentColWidth + padding;
+ columnSizes.push({
+ width: currentColWidth,
+ height: currentColHeight
+ });
+ left += currentColWidth + padding;
+ col++;
+ currentColWidth = currentColHeight = 0;
+ }
+ hitboxes[i] = {
+ left,
+ top: currentColHeight,
+ col,
+ width: itemWidth,
+ height: itemHeight
+ };
+ currentColWidth = Math.max(currentColWidth, itemWidth);
+ currentColHeight += itemHeight + padding;
+ });
+ totalWidth += currentColWidth;
+ columnSizes.push({
+ width: currentColWidth,
+ height: currentColHeight
+ });
+ return totalWidth;
+ }
+ adjustHitBoxes() {
+ if (!this.options.display) {
+ return;
+ }
+ const titleHeight = this._computeTitleHeight();
+ const { legendHitBoxes: hitboxes , options: { align , labels: { padding } , rtl } } = this;
+ const rtlHelper = getRtlAdapter(rtl, this.left, this.width);
+ if (this.isHorizontal()) {
+ let row = 0;
+ let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
+ for (const hitbox of hitboxes){
+ if (row !== hitbox.row) {
+ row = hitbox.row;
+ left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
+ }
+ hitbox.top += this.top + titleHeight + padding;
+ hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);
+ left += hitbox.width + padding;
+ }
+ } else {
+ let col = 0;
+ let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
+ for (const hitbox of hitboxes){
+ if (hitbox.col !== col) {
+ col = hitbox.col;
+ top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
+ }
+ hitbox.top = top;
+ hitbox.left += this.left + padding;
+ hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);
+ top += hitbox.height + padding;
+ }
+ }
+ }
+ isHorizontal() {
+ return this.options.position === 'top' || this.options.position === 'bottom';
+ }
+ draw() {
+ if (this.options.display) {
+ const ctx = this.ctx;
+ clipArea(ctx, this);
+ this._draw();
+ unclipArea(ctx);
+ }
+ }
+ _draw() {
+ const { options: opts , columnSizes , lineWidths , ctx } = this;
+ const { align , labels: labelOpts } = opts;
+ const defaultColor = defaults.color;
+ const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
+ const labelFont = toFont(labelOpts.font);
+ const { padding } = labelOpts;
+ const fontSize = labelFont.size;
+ const halfFontSize = fontSize / 2;
+ let cursor;
+ this.drawTitle();
+ ctx.textAlign = rtlHelper.textAlign('left');
+ ctx.textBaseline = 'middle';
+ ctx.lineWidth = 0.5;
+ ctx.font = labelFont.string;
+ const { boxWidth , boxHeight , itemHeight } = getBoxSize(labelOpts, fontSize);
+ const drawLegendBox = function(x, y, legendItem) {
+ if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {
+ return;
+ }
+ ctx.save();
+ const lineWidth = valueOrDefault(legendItem.lineWidth, 1);
+ ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);
+ ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt');
+ ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);
+ ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter');
+ ctx.lineWidth = lineWidth;
+ ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);
+ ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));
+ if (labelOpts.usePointStyle) {
+ const drawOptions = {
+ radius: boxHeight * Math.SQRT2 / 2,
+ pointStyle: legendItem.pointStyle,
+ rotation: legendItem.rotation,
+ borderWidth: lineWidth
+ };
+ const centerX = rtlHelper.xPlus(x, boxWidth / 2);
+ const centerY = y + halfFontSize;
+ drawPointLegend(ctx, drawOptions, centerX, centerY, labelOpts.pointStyleWidth && boxWidth);
+ } else {
+ const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0);
+ const xBoxLeft = rtlHelper.leftForLtr(x, boxWidth);
+ const borderRadius = toTRBLCorners(legendItem.borderRadius);
+ ctx.beginPath();
+ if (Object.values(borderRadius).some((v)=>v !== 0)) {
+ addRoundedRectPath(ctx, {
+ x: xBoxLeft,
+ y: yBoxTop,
+ w: boxWidth,
+ h: boxHeight,
+ radius: borderRadius
+ });
+ } else {
+ ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);
+ }
+ ctx.fill();
+ if (lineWidth !== 0) {
+ ctx.stroke();
+ }
+ }
+ ctx.restore();
+ };
+ const fillText = function(x, y, legendItem) {
+ renderText(ctx, legendItem.text, x, y + itemHeight / 2, labelFont, {
+ strikethrough: legendItem.hidden,
+ textAlign: rtlHelper.textAlign(legendItem.textAlign)
+ });
+ };
+ const isHorizontal = this.isHorizontal();
+ const titleHeight = this._computeTitleHeight();
+ if (isHorizontal) {
+ cursor = {
+ x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),
+ y: this.top + padding + titleHeight,
+ line: 0
+ };
+ } else {
+ cursor = {
+ x: this.left + padding,
+ y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),
+ line: 0
+ };
+ }
+ overrideTextDirection(this.ctx, opts.textDirection);
+ const lineHeight = itemHeight + padding;
+ this.legendItems.forEach((legendItem, i)=>{
+ ctx.strokeStyle = legendItem.fontColor;
+ ctx.fillStyle = legendItem.fontColor;
+ const textWidth = ctx.measureText(legendItem.text).width;
+ const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));
+ const width = boxWidth + halfFontSize + textWidth;
+ let x = cursor.x;
+ let y = cursor.y;
+ rtlHelper.setWidth(this.width);
+ if (isHorizontal) {
+ if (i > 0 && x + width + padding > this.right) {
+ y = cursor.y += lineHeight;
+ cursor.line++;
+ x = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);
+ }
+ } else if (i > 0 && y + lineHeight > this.bottom) {
+ x = cursor.x = x + columnSizes[cursor.line].width + padding;
+ cursor.line++;
+ y = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);
+ }
+ const realX = rtlHelper.x(x);
+ drawLegendBox(realX, y, legendItem);
+ x = _textX(textAlign, x + boxWidth + halfFontSize, isHorizontal ? x + width : this.right, opts.rtl);
+ fillText(rtlHelper.x(x), y, legendItem);
+ if (isHorizontal) {
+ cursor.x += width + padding;
+ } else if (typeof legendItem.text !== 'string') {
+ const fontLineHeight = labelFont.lineHeight;
+ cursor.y += calculateLegendItemHeight(legendItem, fontLineHeight) + padding;
+ } else {
+ cursor.y += lineHeight;
+ }
+ });
+ restoreTextDirection(this.ctx, opts.textDirection);
+ }
+ drawTitle() {
+ const opts = this.options;
+ const titleOpts = opts.title;
+ const titleFont = toFont(titleOpts.font);
+ const titlePadding = toPadding(titleOpts.padding);
+ if (!titleOpts.display) {
+ return;
+ }
+ const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
+ const ctx = this.ctx;
+ const position = titleOpts.position;
+ const halfFontSize = titleFont.size / 2;
+ const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;
+ let y;
+ let left = this.left;
+ let maxWidth = this.width;
+ if (this.isHorizontal()) {
+ maxWidth = Math.max(...this.lineWidths);
+ y = this.top + topPaddingPlusHalfFontSize;
+ left = _alignStartEnd(opts.align, left, this.right - maxWidth);
+ } else {
+ const maxHeight = this.columnSizes.reduce((acc, size)=>Math.max(acc, size.height), 0);
+ y = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());
+ }
+ const x = _alignStartEnd(position, left, left + maxWidth);
+ ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));
+ ctx.textBaseline = 'middle';
+ ctx.strokeStyle = titleOpts.color;
+ ctx.fillStyle = titleOpts.color;
+ ctx.font = titleFont.string;
+ renderText(ctx, titleOpts.text, x, y, titleFont);
+ }
+ _computeTitleHeight() {
+ const titleOpts = this.options.title;
+ const titleFont = toFont(titleOpts.font);
+ const titlePadding = toPadding(titleOpts.padding);
+ return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;
+ }
+ _getLegendItemAt(x, y) {
+ let i, hitBox, lh;
+ if (_isBetween(x, this.left, this.right) && _isBetween(y, this.top, this.bottom)) {
+ lh = this.legendHitBoxes;
+ for(i = 0; i < lh.length; ++i){
+ hitBox = lh[i];
+ if (_isBetween(x, hitBox.left, hitBox.left + hitBox.width) && _isBetween(y, hitBox.top, hitBox.top + hitBox.height)) {
+ return this.legendItems[i];
+ }
+ }
+ }
+ return null;
+ }
+ handleEvent(e) {
+ const opts = this.options;
+ if (!isListened(e.type, opts)) {
+ return;
+ }
+ const hoveredItem = this._getLegendItemAt(e.x, e.y);
+ if (e.type === 'mousemove' || e.type === 'mouseout') {
+ const previous = this._hoveredItem;
+ const sameItem = itemsEqual(previous, hoveredItem);
+ if (previous && !sameItem) {
+ callback(opts.onLeave, [
+ e,
+ previous,
+ this
+ ], this);
+ }
+ this._hoveredItem = hoveredItem;
+ if (hoveredItem && !sameItem) {
+ callback(opts.onHover, [
+ e,
+ hoveredItem,
+ this
+ ], this);
+ }
+ } else if (hoveredItem) {
+ callback(opts.onClick, [
+ e,
+ hoveredItem,
+ this
+ ], this);
+ }
+ }
+ }
+ function calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight) {
+ const itemWidth = calculateItemWidth(legendItem, boxWidth, labelFont, ctx);
+ const itemHeight = calculateItemHeight(_itemHeight, legendItem, labelFont.lineHeight);
+ return {
+ itemWidth,
+ itemHeight
+ };
+ }
+ function calculateItemWidth(legendItem, boxWidth, labelFont, ctx) {
+ let legendItemText = legendItem.text;
+ if (legendItemText && typeof legendItemText !== 'string') {
+ legendItemText = legendItemText.reduce((a, b)=>a.length > b.length ? a : b);
+ }
+ return boxWidth + labelFont.size / 2 + ctx.measureText(legendItemText).width;
+ }
+ function calculateItemHeight(_itemHeight, legendItem, fontLineHeight) {
+ let itemHeight = _itemHeight;
+ if (typeof legendItem.text !== 'string') {
+ itemHeight = calculateLegendItemHeight(legendItem, fontLineHeight);
+ }
+ return itemHeight;
+ }
+ function calculateLegendItemHeight(legendItem, fontLineHeight) {
+ const labelHeight = legendItem.text ? legendItem.text.length : 0;
+ return fontLineHeight * labelHeight;
+ }
+ function isListened(type, opts) {
+ if ((type === 'mousemove' || type === 'mouseout') && (opts.onHover || opts.onLeave)) {
+ return true;
+ }
+ if (opts.onClick && (type === 'click' || type === 'mouseup')) {
+ return true;
+ }
+ return false;
+ }
+ var plugin_legend = {
+ id: 'legend',
+ _element: Legend,
+ start (chart, _args, options) {
+ const legend = chart.legend = new Legend({
+ ctx: chart.ctx,
+ options,
+ chart
+ });
+ layouts.configure(chart, legend, options);
+ layouts.addBox(chart, legend);
+ },
+ stop (chart) {
+ layouts.removeBox(chart, chart.legend);
+ delete chart.legend;
+ },
+ beforeUpdate (chart, _args, options) {
+ const legend = chart.legend;
+ layouts.configure(chart, legend, options);
+ legend.options = options;
+ },
+ afterUpdate (chart) {
+ const legend = chart.legend;
+ legend.buildLabels();
+ legend.adjustHitBoxes();
+ },
+ afterEvent (chart, args) {
+ if (!args.replay) {
+ chart.legend.handleEvent(args.event);
+ }
+ },
+ defaults: {
+ display: true,
+ position: 'top',
+ align: 'center',
+ fullSize: true,
+ reverse: false,
+ weight: 1000,
+ onClick (e, legendItem, legend) {
+ const index = legendItem.datasetIndex;
+ const ci = legend.chart;
+ if (ci.isDatasetVisible(index)) {
+ ci.hide(index);
+ legendItem.hidden = true;
+ } else {
+ ci.show(index);
+ legendItem.hidden = false;
+ }
+ },
+ onHover: null,
+ onLeave: null,
+ labels: {
+ color: (ctx)=>ctx.chart.options.color,
+ boxWidth: 40,
+ padding: 10,
+ generateLabels (chart) {
+ const datasets = chart.data.datasets;
+ const { labels: { usePointStyle , pointStyle , textAlign , color , useBorderRadius , borderRadius } } = chart.legend.options;
+ return chart._getSortedDatasetMetas().map((meta)=>{
+ const style = meta.controller.getStyle(usePointStyle ? 0 : undefined);
+ const borderWidth = toPadding(style.borderWidth);
+ return {
+ text: datasets[meta.index].label,
+ fillStyle: style.backgroundColor,
+ fontColor: color,
+ hidden: !meta.visible,
+ lineCap: style.borderCapStyle,
+ lineDash: style.borderDash,
+ lineDashOffset: style.borderDashOffset,
+ lineJoin: style.borderJoinStyle,
+ lineWidth: (borderWidth.width + borderWidth.height) / 4,
+ strokeStyle: style.borderColor,
+ pointStyle: pointStyle || style.pointStyle,
+ rotation: style.rotation,
+ textAlign: textAlign || style.textAlign,
+ borderRadius: useBorderRadius && (borderRadius || style.borderRadius),
+ datasetIndex: meta.index
+ };
+ }, this);
+ }
+ },
+ title: {
+ color: (ctx)=>ctx.chart.options.color,
+ display: false,
+ position: 'center',
+ text: ''
+ }
+ },
+ descriptors: {
+ _scriptable: (name)=>!name.startsWith('on'),
+ labels: {
+ _scriptable: (name)=>![
+ 'generateLabels',
+ 'filter',
+ 'sort'
+ ].includes(name)
+ }
+ }
+ };
+
+ class Title extends Element {
+ constructor(config){
+ super();
+ this.chart = config.chart;
+ this.options = config.options;
+ this.ctx = config.ctx;
+ this._padding = undefined;
+ this.top = undefined;
+ this.bottom = undefined;
+ this.left = undefined;
+ this.right = undefined;
+ this.width = undefined;
+ this.height = undefined;
+ this.position = undefined;
+ this.weight = undefined;
+ this.fullSize = undefined;
+ }
+ update(maxWidth, maxHeight) {
+ const opts = this.options;
+ this.left = 0;
+ this.top = 0;
+ if (!opts.display) {
+ this.width = this.height = this.right = this.bottom = 0;
+ return;
+ }
+ this.width = this.right = maxWidth;
+ this.height = this.bottom = maxHeight;
+ const lineCount = isArray(opts.text) ? opts.text.length : 1;
+ this._padding = toPadding(opts.padding);
+ const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;
+ if (this.isHorizontal()) {
+ this.height = textSize;
+ } else {
+ this.width = textSize;
+ }
+ }
+ isHorizontal() {
+ const pos = this.options.position;
+ return pos === 'top' || pos === 'bottom';
+ }
+ _drawArgs(offset) {
+ const { top , left , bottom , right , options } = this;
+ const align = options.align;
+ let rotation = 0;
+ let maxWidth, titleX, titleY;
+ if (this.isHorizontal()) {
+ titleX = _alignStartEnd(align, left, right);
+ titleY = top + offset;
+ maxWidth = right - left;
+ } else {
+ if (options.position === 'left') {
+ titleX = left + offset;
+ titleY = _alignStartEnd(align, bottom, top);
+ rotation = PI * -0.5;
+ } else {
+ titleX = right - offset;
+ titleY = _alignStartEnd(align, top, bottom);
+ rotation = PI * 0.5;
+ }
+ maxWidth = bottom - top;
+ }
+ return {
+ titleX,
+ titleY,
+ maxWidth,
+ rotation
+ };
+ }
+ draw() {
+ const ctx = this.ctx;
+ const opts = this.options;
+ if (!opts.display) {
+ return;
+ }
+ const fontOpts = toFont(opts.font);
+ const lineHeight = fontOpts.lineHeight;
+ const offset = lineHeight / 2 + this._padding.top;
+ const { titleX , titleY , maxWidth , rotation } = this._drawArgs(offset);
+ renderText(ctx, opts.text, 0, 0, fontOpts, {
+ color: opts.color,
+ maxWidth,
+ rotation,
+ textAlign: _toLeftRightCenter(opts.align),
+ textBaseline: 'middle',
+ translation: [
+ titleX,
+ titleY
+ ]
+ });
+ }
+ }
+ function createTitle(chart, titleOpts) {
+ const title = new Title({
+ ctx: chart.ctx,
+ options: titleOpts,
+ chart
+ });
+ layouts.configure(chart, title, titleOpts);
+ layouts.addBox(chart, title);
+ chart.titleBlock = title;
+ }
+ var plugin_title = {
+ id: 'title',
+ _element: Title,
+ start (chart, _args, options) {
+ createTitle(chart, options);
+ },
+ stop (chart) {
+ const titleBlock = chart.titleBlock;
+ layouts.removeBox(chart, titleBlock);
+ delete chart.titleBlock;
+ },
+ beforeUpdate (chart, _args, options) {
+ const title = chart.titleBlock;
+ layouts.configure(chart, title, options);
+ title.options = options;
+ },
+ defaults: {
+ align: 'center',
+ display: false,
+ font: {
+ weight: 'bold'
+ },
+ fullSize: true,
+ padding: 10,
+ position: 'top',
+ text: '',
+ weight: 2000
+ },
+ defaultRoutes: {
+ color: 'color'
+ },
+ descriptors: {
+ _scriptable: true,
+ _indexable: false
+ }
+ };
+
+ const map = new WeakMap();
+ var plugin_subtitle = {
+ id: 'subtitle',
+ start (chart, _args, options) {
+ const title = new Title({
+ ctx: chart.ctx,
+ options,
+ chart
+ });
+ layouts.configure(chart, title, options);
+ layouts.addBox(chart, title);
+ map.set(chart, title);
+ },
+ stop (chart) {
+ layouts.removeBox(chart, map.get(chart));
+ map.delete(chart);
+ },
+ beforeUpdate (chart, _args, options) {
+ const title = map.get(chart);
+ layouts.configure(chart, title, options);
+ title.options = options;
+ },
+ defaults: {
+ align: 'center',
+ display: false,
+ font: {
+ weight: 'normal'
+ },
+ fullSize: true,
+ padding: 0,
+ position: 'top',
+ text: '',
+ weight: 1500
+ },
+ defaultRoutes: {
+ color: 'color'
+ },
+ descriptors: {
+ _scriptable: true,
+ _indexable: false
+ }
+ };
+
+ const positioners = {
+ average (items) {
+ if (!items.length) {
+ return false;
+ }
+ let i, len;
+ let x = 0;
+ let y = 0;
+ let count = 0;
+ for(i = 0, len = items.length; i < len; ++i){
+ const el = items[i].element;
+ if (el && el.hasValue()) {
+ const pos = el.tooltipPosition();
+ x += pos.x;
+ y += pos.y;
+ ++count;
+ }
+ }
+ return {
+ x: x / count,
+ y: y / count
+ };
+ },
+ nearest (items, eventPosition) {
+ if (!items.length) {
+ return false;
+ }
+ let x = eventPosition.x;
+ let y = eventPosition.y;
+ let minDistance = Number.POSITIVE_INFINITY;
+ let i, len, nearestElement;
+ for(i = 0, len = items.length; i < len; ++i){
+ const el = items[i].element;
+ if (el && el.hasValue()) {
+ const center = el.getCenterPoint();
+ const d = distanceBetweenPoints(eventPosition, center);
+ if (d < minDistance) {
+ minDistance = d;
+ nearestElement = el;
+ }
+ }
+ }
+ if (nearestElement) {
+ const tp = nearestElement.tooltipPosition();
+ x = tp.x;
+ y = tp.y;
+ }
+ return {
+ x,
+ y
+ };
+ }
+ };
+ function pushOrConcat(base, toPush) {
+ if (toPush) {
+ if (isArray(toPush)) {
+ Array.prototype.push.apply(base, toPush);
+ } else {
+ base.push(toPush);
+ }
+ }
+ return base;
+ }
+ function splitNewlines(str) {
+ if ((typeof str === 'string' || str instanceof String) && str.indexOf('\n') > -1) {
+ return str.split('\n');
+ }
+ return str;
+ }
+ function createTooltipItem(chart, item) {
+ const { element , datasetIndex , index } = item;
+ const controller = chart.getDatasetMeta(datasetIndex).controller;
+ const { label , value } = controller.getLabelAndValue(index);
+ return {
+ chart,
+ label,
+ parsed: controller.getParsed(index),
+ raw: chart.data.datasets[datasetIndex].data[index],
+ formattedValue: value,
+ dataset: controller.getDataset(),
+ dataIndex: index,
+ datasetIndex,
+ element
+ };
+ }
+ function getTooltipSize(tooltip, options) {
+ const ctx = tooltip.chart.ctx;
+ const { body , footer , title } = tooltip;
+ const { boxWidth , boxHeight } = options;
+ const bodyFont = toFont(options.bodyFont);
+ const titleFont = toFont(options.titleFont);
+ const footerFont = toFont(options.footerFont);
+ const titleLineCount = title.length;
+ const footerLineCount = footer.length;
+ const bodyLineItemCount = body.length;
+ const padding = toPadding(options.padding);
+ let height = padding.height;
+ let width = 0;
+ let combinedBodyLength = body.reduce((count, bodyItem)=>count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);
+ combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;
+ if (titleLineCount) {
+ height += titleLineCount * titleFont.lineHeight + (titleLineCount - 1) * options.titleSpacing + options.titleMarginBottom;
+ }
+ if (combinedBodyLength) {
+ const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;
+ height += bodyLineItemCount * bodyLineHeight + (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight + (combinedBodyLength - 1) * options.bodySpacing;
+ }
+ if (footerLineCount) {
+ height += options.footerMarginTop + footerLineCount * footerFont.lineHeight + (footerLineCount - 1) * options.footerSpacing;
+ }
+ let widthPadding = 0;
+ const maxLineWidth = function(line) {
+ width = Math.max(width, ctx.measureText(line).width + widthPadding);
+ };
+ ctx.save();
+ ctx.font = titleFont.string;
+ each(tooltip.title, maxLineWidth);
+ ctx.font = bodyFont.string;
+ each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);
+ widthPadding = options.displayColors ? boxWidth + 2 + options.boxPadding : 0;
+ each(body, (bodyItem)=>{
+ each(bodyItem.before, maxLineWidth);
+ each(bodyItem.lines, maxLineWidth);
+ each(bodyItem.after, maxLineWidth);
+ });
+ widthPadding = 0;
+ ctx.font = footerFont.string;
+ each(tooltip.footer, maxLineWidth);
+ ctx.restore();
+ width += padding.width;
+ return {
+ width,
+ height
+ };
+ }
+ function determineYAlign(chart, size) {
+ const { y , height } = size;
+ if (y < height / 2) {
+ return 'top';
+ } else if (y > chart.height - height / 2) {
+ return 'bottom';
+ }
+ return 'center';
+ }
+ function doesNotFitWithAlign(xAlign, chart, options, size) {
+ const { x , width } = size;
+ const caret = options.caretSize + options.caretPadding;
+ if (xAlign === 'left' && x + width + caret > chart.width) {
+ return true;
+ }
+ if (xAlign === 'right' && x - width - caret < 0) {
+ return true;
+ }
+ }
+ function determineXAlign(chart, options, size, yAlign) {
+ const { x , width } = size;
+ const { width: chartWidth , chartArea: { left , right } } = chart;
+ let xAlign = 'center';
+ if (yAlign === 'center') {
+ xAlign = x <= (left + right) / 2 ? 'left' : 'right';
+ } else if (x <= width / 2) {
+ xAlign = 'left';
+ } else if (x >= chartWidth - width / 2) {
+ xAlign = 'right';
+ }
+ if (doesNotFitWithAlign(xAlign, chart, options, size)) {
+ xAlign = 'center';
+ }
+ return xAlign;
+ }
+ function determineAlignment(chart, options, size) {
+ const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);
+ return {
+ xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),
+ yAlign
+ };
+ }
+ function alignX(size, xAlign) {
+ let { x , width } = size;
+ if (xAlign === 'right') {
+ x -= width;
+ } else if (xAlign === 'center') {
+ x -= width / 2;
+ }
+ return x;
+ }
+ function alignY(size, yAlign, paddingAndSize) {
+ let { y , height } = size;
+ if (yAlign === 'top') {
+ y += paddingAndSize;
+ } else if (yAlign === 'bottom') {
+ y -= height + paddingAndSize;
+ } else {
+ y -= height / 2;
+ }
+ return y;
+ }
+ function getBackgroundPoint(options, size, alignment, chart) {
+ const { caretSize , caretPadding , cornerRadius } = options;
+ const { xAlign , yAlign } = alignment;
+ const paddingAndSize = caretSize + caretPadding;
+ const { topLeft , topRight , bottomLeft , bottomRight } = toTRBLCorners(cornerRadius);
+ let x = alignX(size, xAlign);
+ const y = alignY(size, yAlign, paddingAndSize);
+ if (yAlign === 'center') {
+ if (xAlign === 'left') {
+ x += paddingAndSize;
+ } else if (xAlign === 'right') {
+ x -= paddingAndSize;
+ }
+ } else if (xAlign === 'left') {
+ x -= Math.max(topLeft, bottomLeft) + caretSize;
+ } else if (xAlign === 'right') {
+ x += Math.max(topRight, bottomRight) + caretSize;
+ }
+ return {
+ x: _limitValue(x, 0, chart.width - size.width),
+ y: _limitValue(y, 0, chart.height - size.height)
+ };
+ }
+ function getAlignedX(tooltip, align, options) {
+ const padding = toPadding(options.padding);
+ return align === 'center' ? tooltip.x + tooltip.width / 2 : align === 'right' ? tooltip.x + tooltip.width - padding.right : tooltip.x + padding.left;
+ }
+ function getBeforeAfterBodyLines(callback) {
+ return pushOrConcat([], splitNewlines(callback));
+ }
+ function createTooltipContext(parent, tooltip, tooltipItems) {
+ return createContext(parent, {
+ tooltip,
+ tooltipItems,
+ type: 'tooltip'
+ });
+ }
+ function overrideCallbacks(callbacks, context) {
+ const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;
+ return override ? callbacks.override(override) : callbacks;
+ }
+ const defaultCallbacks = {
+ beforeTitle: noop,
+ title (tooltipItems) {
+ if (tooltipItems.length > 0) {
+ const item = tooltipItems[0];
+ const labels = item.chart.data.labels;
+ const labelCount = labels ? labels.length : 0;
+ if (this && this.options && this.options.mode === 'dataset') {
+ return item.dataset.label || '';
+ } else if (item.label) {
+ return item.label;
+ } else if (labelCount > 0 && item.dataIndex < labelCount) {
+ return labels[item.dataIndex];
+ }
+ }
+ return '';
+ },
+ afterTitle: noop,
+ beforeBody: noop,
+ beforeLabel: noop,
+ label (tooltipItem) {
+ if (this && this.options && this.options.mode === 'dataset') {
+ return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue;
+ }
+ let label = tooltipItem.dataset.label || '';
+ if (label) {
+ label += ': ';
+ }
+ const value = tooltipItem.formattedValue;
+ if (!isNullOrUndef(value)) {
+ label += value;
+ }
+ return label;
+ },
+ labelColor (tooltipItem) {
+ const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
+ const options = meta.controller.getStyle(tooltipItem.dataIndex);
+ return {
+ borderColor: options.borderColor,
+ backgroundColor: options.backgroundColor,
+ borderWidth: options.borderWidth,
+ borderDash: options.borderDash,
+ borderDashOffset: options.borderDashOffset,
+ borderRadius: 0
+ };
+ },
+ labelTextColor () {
+ return this.options.bodyColor;
+ },
+ labelPointStyle (tooltipItem) {
+ const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
+ const options = meta.controller.getStyle(tooltipItem.dataIndex);
+ return {
+ pointStyle: options.pointStyle,
+ rotation: options.rotation
+ };
+ },
+ afterLabel: noop,
+ afterBody: noop,
+ beforeFooter: noop,
+ footer: noop,
+ afterFooter: noop
+ };
+ function invokeCallbackWithFallback(callbacks, name, ctx, arg) {
+ const result = callbacks[name].call(ctx, arg);
+ if (typeof result === 'undefined') {
+ return defaultCallbacks[name].call(ctx, arg);
+ }
+ return result;
+ }
+ class Tooltip extends Element {
+ static positioners = positioners;
+ constructor(config){
+ super();
+ this.opacity = 0;
+ this._active = [];
+ this._eventPosition = undefined;
+ this._size = undefined;
+ this._cachedAnimations = undefined;
+ this._tooltipItems = [];
+ this.$animations = undefined;
+ this.$context = undefined;
+ this.chart = config.chart;
+ this.options = config.options;
+ this.dataPoints = undefined;
+ this.title = undefined;
+ this.beforeBody = undefined;
+ this.body = undefined;
+ this.afterBody = undefined;
+ this.footer = undefined;
+ this.xAlign = undefined;
+ this.yAlign = undefined;
+ this.x = undefined;
+ this.y = undefined;
+ this.height = undefined;
+ this.width = undefined;
+ this.caretX = undefined;
+ this.caretY = undefined;
+ this.labelColors = undefined;
+ this.labelPointStyles = undefined;
+ this.labelTextColors = undefined;
+ }
+ initialize(options) {
+ this.options = options;
+ this._cachedAnimations = undefined;
+ this.$context = undefined;
+ }
+ _resolveAnimations() {
+ const cached = this._cachedAnimations;
+ if (cached) {
+ return cached;
+ }
+ const chart = this.chart;
+ const options = this.options.setContext(this.getContext());
+ const opts = options.enabled && chart.options.animation && options.animations;
+ const animations = new Animations(this.chart, opts);
+ if (opts._cacheable) {
+ this._cachedAnimations = Object.freeze(animations);
+ }
+ return animations;
+ }
+ getContext() {
+ return this.$context || (this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));
+ }
+ getTitle(context, options) {
+ const { callbacks } = options;
+ const beforeTitle = invokeCallbackWithFallback(callbacks, 'beforeTitle', this, context);
+ const title = invokeCallbackWithFallback(callbacks, 'title', this, context);
+ const afterTitle = invokeCallbackWithFallback(callbacks, 'afterTitle', this, context);
+ let lines = [];
+ lines = pushOrConcat(lines, splitNewlines(beforeTitle));
+ lines = pushOrConcat(lines, splitNewlines(title));
+ lines = pushOrConcat(lines, splitNewlines(afterTitle));
+ return lines;
+ }
+ getBeforeBody(tooltipItems, options) {
+ return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, 'beforeBody', this, tooltipItems));
+ }
+ getBody(tooltipItems, options) {
+ const { callbacks } = options;
+ const bodyItems = [];
+ each(tooltipItems, (context)=>{
+ const bodyItem = {
+ before: [],
+ lines: [],
+ after: []
+ };
+ const scoped = overrideCallbacks(callbacks, context);
+ pushOrConcat(bodyItem.before, splitNewlines(invokeCallbackWithFallback(scoped, 'beforeLabel', this, context)));
+ pushOrConcat(bodyItem.lines, invokeCallbackWithFallback(scoped, 'label', this, context));
+ pushOrConcat(bodyItem.after, splitNewlines(invokeCallbackWithFallback(scoped, 'afterLabel', this, context)));
+ bodyItems.push(bodyItem);
+ });
+ return bodyItems;
+ }
+ getAfterBody(tooltipItems, options) {
+ return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, 'afterBody', this, tooltipItems));
+ }
+ getFooter(tooltipItems, options) {
+ const { callbacks } = options;
+ const beforeFooter = invokeCallbackWithFallback(callbacks, 'beforeFooter', this, tooltipItems);
+ const footer = invokeCallbackWithFallback(callbacks, 'footer', this, tooltipItems);
+ const afterFooter = invokeCallbackWithFallback(callbacks, 'afterFooter', this, tooltipItems);
+ let lines = [];
+ lines = pushOrConcat(lines, splitNewlines(beforeFooter));
+ lines = pushOrConcat(lines, splitNewlines(footer));
+ lines = pushOrConcat(lines, splitNewlines(afterFooter));
+ return lines;
+ }
+ _createItems(options) {
+ const active = this._active;
+ const data = this.chart.data;
+ const labelColors = [];
+ const labelPointStyles = [];
+ const labelTextColors = [];
+ let tooltipItems = [];
+ let i, len;
+ for(i = 0, len = active.length; i < len; ++i){
+ tooltipItems.push(createTooltipItem(this.chart, active[i]));
+ }
+ if (options.filter) {
+ tooltipItems = tooltipItems.filter((element, index, array)=>options.filter(element, index, array, data));
+ }
+ if (options.itemSort) {
+ tooltipItems = tooltipItems.sort((a, b)=>options.itemSort(a, b, data));
+ }
+ each(tooltipItems, (context)=>{
+ const scoped = overrideCallbacks(options.callbacks, context);
+ labelColors.push(invokeCallbackWithFallback(scoped, 'labelColor', this, context));
+ labelPointStyles.push(invokeCallbackWithFallback(scoped, 'labelPointStyle', this, context));
+ labelTextColors.push(invokeCallbackWithFallback(scoped, 'labelTextColor', this, context));
+ });
+ this.labelColors = labelColors;
+ this.labelPointStyles = labelPointStyles;
+ this.labelTextColors = labelTextColors;
+ this.dataPoints = tooltipItems;
+ return tooltipItems;
+ }
+ update(changed, replay) {
+ const options = this.options.setContext(this.getContext());
+ const active = this._active;
+ let properties;
+ let tooltipItems = [];
+ if (!active.length) {
+ if (this.opacity !== 0) {
+ properties = {
+ opacity: 0
+ };
+ }
+ } else {
+ const position = positioners[options.position].call(this, active, this._eventPosition);
+ tooltipItems = this._createItems(options);
+ this.title = this.getTitle(tooltipItems, options);
+ this.beforeBody = this.getBeforeBody(tooltipItems, options);
+ this.body = this.getBody(tooltipItems, options);
+ this.afterBody = this.getAfterBody(tooltipItems, options);
+ this.footer = this.getFooter(tooltipItems, options);
+ const size = this._size = getTooltipSize(this, options);
+ const positionAndSize = Object.assign({}, position, size);
+ const alignment = determineAlignment(this.chart, options, positionAndSize);
+ const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);
+ this.xAlign = alignment.xAlign;
+ this.yAlign = alignment.yAlign;
+ properties = {
+ opacity: 1,
+ x: backgroundPoint.x,
+ y: backgroundPoint.y,
+ width: size.width,
+ height: size.height,
+ caretX: position.x,
+ caretY: position.y
+ };
+ }
+ this._tooltipItems = tooltipItems;
+ this.$context = undefined;
+ if (properties) {
+ this._resolveAnimations().update(this, properties);
+ }
+ if (changed && options.external) {
+ options.external.call(this, {
+ chart: this.chart,
+ tooltip: this,
+ replay
+ });
+ }
+ }
+ drawCaret(tooltipPoint, ctx, size, options) {
+ const caretPosition = this.getCaretPosition(tooltipPoint, size, options);
+ ctx.lineTo(caretPosition.x1, caretPosition.y1);
+ ctx.lineTo(caretPosition.x2, caretPosition.y2);
+ ctx.lineTo(caretPosition.x3, caretPosition.y3);
+ }
+ getCaretPosition(tooltipPoint, size, options) {
+ const { xAlign , yAlign } = this;
+ const { caretSize , cornerRadius } = options;
+ const { topLeft , topRight , bottomLeft , bottomRight } = toTRBLCorners(cornerRadius);
+ const { x: ptX , y: ptY } = tooltipPoint;
+ const { width , height } = size;
+ let x1, x2, x3, y1, y2, y3;
+ if (yAlign === 'center') {
+ y2 = ptY + height / 2;
+ if (xAlign === 'left') {
+ x1 = ptX;
+ x2 = x1 - caretSize;
+ y1 = y2 + caretSize;
+ y3 = y2 - caretSize;
+ } else {
+ x1 = ptX + width;
+ x2 = x1 + caretSize;
+ y1 = y2 - caretSize;
+ y3 = y2 + caretSize;
+ }
+ x3 = x1;
+ } else {
+ if (xAlign === 'left') {
+ x2 = ptX + Math.max(topLeft, bottomLeft) + caretSize;
+ } else if (xAlign === 'right') {
+ x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;
+ } else {
+ x2 = this.caretX;
+ }
+ if (yAlign === 'top') {
+ y1 = ptY;
+ y2 = y1 - caretSize;
+ x1 = x2 - caretSize;
+ x3 = x2 + caretSize;
+ } else {
+ y1 = ptY + height;
+ y2 = y1 + caretSize;
+ x1 = x2 + caretSize;
+ x3 = x2 - caretSize;
+ }
+ y3 = y1;
+ }
+ return {
+ x1,
+ x2,
+ x3,
+ y1,
+ y2,
+ y3
+ };
+ }
+ drawTitle(pt, ctx, options) {
+ const title = this.title;
+ const length = title.length;
+ let titleFont, titleSpacing, i;
+ if (length) {
+ const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
+ pt.x = getAlignedX(this, options.titleAlign, options);
+ ctx.textAlign = rtlHelper.textAlign(options.titleAlign);
+ ctx.textBaseline = 'middle';
+ titleFont = toFont(options.titleFont);
+ titleSpacing = options.titleSpacing;
+ ctx.fillStyle = options.titleColor;
+ ctx.font = titleFont.string;
+ for(i = 0; i < length; ++i){
+ ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2);
+ pt.y += titleFont.lineHeight + titleSpacing;
+ if (i + 1 === length) {
+ pt.y += options.titleMarginBottom - titleSpacing;
+ }
+ }
+ }
+ }
+ _drawColorBox(ctx, pt, i, rtlHelper, options) {
+ const labelColor = this.labelColors[i];
+ const labelPointStyle = this.labelPointStyles[i];
+ const { boxHeight , boxWidth } = options;
+ const bodyFont = toFont(options.bodyFont);
+ const colorX = getAlignedX(this, 'left', options);
+ const rtlColorX = rtlHelper.x(colorX);
+ const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;
+ const colorY = pt.y + yOffSet;
+ if (options.usePointStyle) {
+ const drawOptions = {
+ radius: Math.min(boxWidth, boxHeight) / 2,
+ pointStyle: labelPointStyle.pointStyle,
+ rotation: labelPointStyle.rotation,
+ borderWidth: 1
+ };
+ const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;
+ const centerY = colorY + boxHeight / 2;
+ ctx.strokeStyle = options.multiKeyBackground;
+ ctx.fillStyle = options.multiKeyBackground;
+ drawPoint(ctx, drawOptions, centerX, centerY);
+ ctx.strokeStyle = labelColor.borderColor;
+ ctx.fillStyle = labelColor.backgroundColor;
+ drawPoint(ctx, drawOptions, centerX, centerY);
+ } else {
+ ctx.lineWidth = isObject(labelColor.borderWidth) ? Math.max(...Object.values(labelColor.borderWidth)) : labelColor.borderWidth || 1;
+ ctx.strokeStyle = labelColor.borderColor;
+ ctx.setLineDash(labelColor.borderDash || []);
+ ctx.lineDashOffset = labelColor.borderDashOffset || 0;
+ const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth);
+ const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - 2);
+ const borderRadius = toTRBLCorners(labelColor.borderRadius);
+ if (Object.values(borderRadius).some((v)=>v !== 0)) {
+ ctx.beginPath();
+ ctx.fillStyle = options.multiKeyBackground;
+ addRoundedRectPath(ctx, {
+ x: outerX,
+ y: colorY,
+ w: boxWidth,
+ h: boxHeight,
+ radius: borderRadius
+ });
+ ctx.fill();
+ ctx.stroke();
+ ctx.fillStyle = labelColor.backgroundColor;
+ ctx.beginPath();
+ addRoundedRectPath(ctx, {
+ x: innerX,
+ y: colorY + 1,
+ w: boxWidth - 2,
+ h: boxHeight - 2,
+ radius: borderRadius
+ });
+ ctx.fill();
+ } else {
+ ctx.fillStyle = options.multiKeyBackground;
+ ctx.fillRect(outerX, colorY, boxWidth, boxHeight);
+ ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);
+ ctx.fillStyle = labelColor.backgroundColor;
+ ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);
+ }
+ }
+ ctx.fillStyle = this.labelTextColors[i];
+ }
+ drawBody(pt, ctx, options) {
+ const { body } = this;
+ const { bodySpacing , bodyAlign , displayColors , boxHeight , boxWidth , boxPadding } = options;
+ const bodyFont = toFont(options.bodyFont);
+ let bodyLineHeight = bodyFont.lineHeight;
+ let xLinePadding = 0;
+ const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
+ const fillLineOfText = function(line) {
+ ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);
+ pt.y += bodyLineHeight + bodySpacing;
+ };
+ const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);
+ let bodyItem, textColor, lines, i, j, ilen, jlen;
+ ctx.textAlign = bodyAlign;
+ ctx.textBaseline = 'middle';
+ ctx.font = bodyFont.string;
+ pt.x = getAlignedX(this, bodyAlignForCalculation, options);
+ ctx.fillStyle = options.bodyColor;
+ each(this.beforeBody, fillLineOfText);
+ xLinePadding = displayColors && bodyAlignForCalculation !== 'right' ? bodyAlign === 'center' ? boxWidth / 2 + boxPadding : boxWidth + 2 + boxPadding : 0;
+ for(i = 0, ilen = body.length; i < ilen; ++i){
+ bodyItem = body[i];
+ textColor = this.labelTextColors[i];
+ ctx.fillStyle = textColor;
+ each(bodyItem.before, fillLineOfText);
+ lines = bodyItem.lines;
+ if (displayColors && lines.length) {
+ this._drawColorBox(ctx, pt, i, rtlHelper, options);
+ bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);
+ }
+ for(j = 0, jlen = lines.length; j < jlen; ++j){
+ fillLineOfText(lines[j]);
+ bodyLineHeight = bodyFont.lineHeight;
+ }
+ each(bodyItem.after, fillLineOfText);
+ }
+ xLinePadding = 0;
+ bodyLineHeight = bodyFont.lineHeight;
+ each(this.afterBody, fillLineOfText);
+ pt.y -= bodySpacing;
+ }
+ drawFooter(pt, ctx, options) {
+ const footer = this.footer;
+ const length = footer.length;
+ let footerFont, i;
+ if (length) {
+ const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
+ pt.x = getAlignedX(this, options.footerAlign, options);
+ pt.y += options.footerMarginTop;
+ ctx.textAlign = rtlHelper.textAlign(options.footerAlign);
+ ctx.textBaseline = 'middle';
+ footerFont = toFont(options.footerFont);
+ ctx.fillStyle = options.footerColor;
+ ctx.font = footerFont.string;
+ for(i = 0; i < length; ++i){
+ ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2);
+ pt.y += footerFont.lineHeight + options.footerSpacing;
+ }
+ }
+ }
+ drawBackground(pt, ctx, tooltipSize, options) {
+ const { xAlign , yAlign } = this;
+ const { x , y } = pt;
+ const { width , height } = tooltipSize;
+ const { topLeft , topRight , bottomLeft , bottomRight } = toTRBLCorners(options.cornerRadius);
+ ctx.fillStyle = options.backgroundColor;
+ ctx.strokeStyle = options.borderColor;
+ ctx.lineWidth = options.borderWidth;
+ ctx.beginPath();
+ ctx.moveTo(x + topLeft, y);
+ if (yAlign === 'top') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x + width - topRight, y);
+ ctx.quadraticCurveTo(x + width, y, x + width, y + topRight);
+ if (yAlign === 'center' && xAlign === 'right') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x + width, y + height - bottomRight);
+ ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height);
+ if (yAlign === 'bottom') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x + bottomLeft, y + height);
+ ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft);
+ if (yAlign === 'center' && xAlign === 'left') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x, y + topLeft);
+ ctx.quadraticCurveTo(x, y, x + topLeft, y);
+ ctx.closePath();
+ ctx.fill();
+ if (options.borderWidth > 0) {
+ ctx.stroke();
+ }
+ }
+ _updateAnimationTarget(options) {
+ const chart = this.chart;
+ const anims = this.$animations;
+ const animX = anims && anims.x;
+ const animY = anims && anims.y;
+ if (animX || animY) {
+ const position = positioners[options.position].call(this, this._active, this._eventPosition);
+ if (!position) {
+ return;
+ }
+ const size = this._size = getTooltipSize(this, options);
+ const positionAndSize = Object.assign({}, position, this._size);
+ const alignment = determineAlignment(chart, options, positionAndSize);
+ const point = getBackgroundPoint(options, positionAndSize, alignment, chart);
+ if (animX._to !== point.x || animY._to !== point.y) {
+ this.xAlign = alignment.xAlign;
+ this.yAlign = alignment.yAlign;
+ this.width = size.width;
+ this.height = size.height;
+ this.caretX = position.x;
+ this.caretY = position.y;
+ this._resolveAnimations().update(this, point);
+ }
+ }
+ }
+ _willRender() {
+ return !!this.opacity;
+ }
+ draw(ctx) {
+ const options = this.options.setContext(this.getContext());
+ let opacity = this.opacity;
+ if (!opacity) {
+ return;
+ }
+ this._updateAnimationTarget(options);
+ const tooltipSize = {
+ width: this.width,
+ height: this.height
+ };
+ const pt = {
+ x: this.x,
+ y: this.y
+ };
+ opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;
+ const padding = toPadding(options.padding);
+ const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;
+ if (options.enabled && hasTooltipContent) {
+ ctx.save();
+ ctx.globalAlpha = opacity;
+ this.drawBackground(pt, ctx, tooltipSize, options);
+ overrideTextDirection(ctx, options.textDirection);
+ pt.y += padding.top;
+ this.drawTitle(pt, ctx, options);
+ this.drawBody(pt, ctx, options);
+ this.drawFooter(pt, ctx, options);
+ restoreTextDirection(ctx, options.textDirection);
+ ctx.restore();
+ }
+ }
+ getActiveElements() {
+ return this._active || [];
+ }
+ setActiveElements(activeElements, eventPosition) {
+ const lastActive = this._active;
+ const active = activeElements.map(({ datasetIndex , index })=>{
+ const meta = this.chart.getDatasetMeta(datasetIndex);
+ if (!meta) {
+ throw new Error('Cannot find a dataset at index ' + datasetIndex);
+ }
+ return {
+ datasetIndex,
+ element: meta.data[index],
+ index
+ };
+ });
+ const changed = !_elementsEqual(lastActive, active);
+ const positionChanged = this._positionChanged(active, eventPosition);
+ if (changed || positionChanged) {
+ this._active = active;
+ this._eventPosition = eventPosition;
+ this._ignoreReplayEvents = true;
+ this.update(true);
+ }
+ }
+ handleEvent(e, replay, inChartArea = true) {
+ if (replay && this._ignoreReplayEvents) {
+ return false;
+ }
+ this._ignoreReplayEvents = false;
+ const options = this.options;
+ const lastActive = this._active || [];
+ const active = this._getActiveElements(e, lastActive, replay, inChartArea);
+ const positionChanged = this._positionChanged(active, e);
+ const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;
+ if (changed) {
+ this._active = active;
+ if (options.enabled || options.external) {
+ this._eventPosition = {
+ x: e.x,
+ y: e.y
+ };
+ this.update(true, replay);
+ }
+ }
+ return changed;
+ }
+ _getActiveElements(e, lastActive, replay, inChartArea) {
+ const options = this.options;
+ if (e.type === 'mouseout') {
+ return [];
+ }
+ if (!inChartArea) {
+ return lastActive.filter((i)=>this.chart.data.datasets[i.datasetIndex] && this.chart.getDatasetMeta(i.datasetIndex).controller.getParsed(i.index) !== undefined);
+ }
+ const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);
+ if (options.reverse) {
+ active.reverse();
+ }
+ return active;
+ }
+ _positionChanged(active, e) {
+ const { caretX , caretY , options } = this;
+ const position = positioners[options.position].call(this, active, e);
+ return position !== false && (caretX !== position.x || caretY !== position.y);
+ }
+ }
+ var plugin_tooltip = {
+ id: 'tooltip',
+ _element: Tooltip,
+ positioners,
+ afterInit (chart, _args, options) {
+ if (options) {
+ chart.tooltip = new Tooltip({
+ chart,
+ options
+ });
+ }
+ },
+ beforeUpdate (chart, _args, options) {
+ if (chart.tooltip) {
+ chart.tooltip.initialize(options);
+ }
+ },
+ reset (chart, _args, options) {
+ if (chart.tooltip) {
+ chart.tooltip.initialize(options);
+ }
+ },
+ afterDraw (chart) {
+ const tooltip = chart.tooltip;
+ if (tooltip && tooltip._willRender()) {
+ const args = {
+ tooltip
+ };
+ if (chart.notifyPlugins('beforeTooltipDraw', {
+ ...args,
+ cancelable: true
+ }) === false) {
+ return;
+ }
+ tooltip.draw(chart.ctx);
+ chart.notifyPlugins('afterTooltipDraw', args);
+ }
+ },
+ afterEvent (chart, args) {
+ if (chart.tooltip) {
+ const useFinalPosition = args.replay;
+ if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {
+ args.changed = true;
+ }
+ }
+ },
+ defaults: {
+ enabled: true,
+ external: null,
+ position: 'average',
+ backgroundColor: 'rgba(0,0,0,0.8)',
+ titleColor: '#fff',
+ titleFont: {
+ weight: 'bold'
+ },
+ titleSpacing: 2,
+ titleMarginBottom: 6,
+ titleAlign: 'left',
+ bodyColor: '#fff',
+ bodySpacing: 2,
+ bodyFont: {},
+ bodyAlign: 'left',
+ footerColor: '#fff',
+ footerSpacing: 2,
+ footerMarginTop: 6,
+ footerFont: {
+ weight: 'bold'
+ },
+ footerAlign: 'left',
+ padding: 6,
+ caretPadding: 2,
+ caretSize: 5,
+ cornerRadius: 6,
+ boxHeight: (ctx, opts)=>opts.bodyFont.size,
+ boxWidth: (ctx, opts)=>opts.bodyFont.size,
+ multiKeyBackground: '#fff',
+ displayColors: true,
+ boxPadding: 0,
+ borderColor: 'rgba(0,0,0,0)',
+ borderWidth: 0,
+ animation: {
+ duration: 400,
+ easing: 'easeOutQuart'
+ },
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: [
+ 'x',
+ 'y',
+ 'width',
+ 'height',
+ 'caretX',
+ 'caretY'
+ ]
+ },
+ opacity: {
+ easing: 'linear',
+ duration: 200
+ }
+ },
+ callbacks: defaultCallbacks
+ },
+ defaultRoutes: {
+ bodyFont: 'font',
+ footerFont: 'font',
+ titleFont: 'font'
+ },
+ descriptors: {
+ _scriptable: (name)=>name !== 'filter' && name !== 'itemSort' && name !== 'external',
+ _indexable: false,
+ callbacks: {
+ _scriptable: false,
+ _indexable: false
+ },
+ animation: {
+ _fallback: false
+ },
+ animations: {
+ _fallback: 'animation'
+ }
+ },
+ additionalOptionScopes: [
+ 'interaction'
+ ]
+ };
+
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ // Register built-ins
+ Chart.register(controllers, scales, elements, plugins);
+ Chart.helpers = {
+ ...helpers
+ };
+ Chart._adapters = _adapters;
+ Chart.Animation = Animation;
+ Chart.Animations = Animations;
+ Chart.animator = animator;
+ Chart.controllers = registry.controllers.items;
+ Chart.DatasetController = DatasetController;
+ Chart.Element = Element;
+ Chart.elements = elements;
+ Chart.Interaction = Interaction;
+ Chart.layouts = layouts;
+ Chart.platforms = platforms;
+ Chart.Scale = Scale;
+ Chart.Ticks = Ticks;
+ // Compatibility with ESM extensions
+ Object.assign(Chart, controllers, scales, elements, plugins, platforms);
+ Chart.Chart = Chart;
+ if (typeof window !== 'undefined') {
+ window.Chart = Chart;
+ }
+
+ return Chart;
+
+}));
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/lib/Chart/chartjs-plugin-datalabels.js b/addons_extensions/ftp_custom_dashboards/static/src/lib/Chart/chartjs-plugin-datalabels.js
new file mode 100644
index 000000000..3437cef0d
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/lib/Chart/chartjs-plugin-datalabels.js
@@ -0,0 +1,1357 @@
+/*!
+ * chartjs-plugin-datalabels v2.2.0
+ * https://chartjs-plugin-datalabels.netlify.app
+ * (c) 2017-2022 chartjs-plugin-datalabels contributors
+ * Released under the MIT license
+ */
+
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('chart.js/helpers'), require('chart.js')) :
+ typeof define === 'function' && define.amd ? define(['chart.js/helpers', 'chart.js'], factory) :
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ChartDataLabels = factory(global.Chart.helpers, global.Chart));
+ })(this, (function (helpers, chart_js) { 'use strict';
+
+ var devicePixelRatio = (function() {
+ if (typeof window !== 'undefined') {
+ if (window.devicePixelRatio) {
+ return window.devicePixelRatio;
+ }
+
+ // devicePixelRatio is undefined on IE10
+ // https://stackoverflow.com/a/20204180/8837887
+ // https://github.com/chartjs/chartjs-plugin-datalabels/issues/85
+ var screen = window.screen;
+ if (screen) {
+ return (screen.deviceXDPI || 1) / (screen.logicalXDPI || 1);
+ }
+ }
+
+ return 1;
+ }());
+
+ var utils = {
+ // @todo move this in Chart.helpers.toTextLines
+ toTextLines: function(inputs) {
+ var lines = [];
+ var input;
+
+ inputs = [].concat(inputs);
+ while (inputs.length) {
+ input = inputs.pop();
+ if (typeof input === 'string') {
+ lines.unshift.apply(lines, input.split('\n'));
+ } else if (Array.isArray(input)) {
+ inputs.push.apply(inputs, input);
+ } else if (!helpers.isNullOrUndef(inputs)) {
+ lines.unshift('' + input);
+ }
+ }
+
+ return lines;
+ },
+
+ // @todo move this in Chart.helpers.canvas.textSize
+ // @todo cache calls of measureText if font doesn't change?!
+ textSize: function(ctx, lines, font) {
+ var items = [].concat(lines);
+ var ilen = items.length;
+ var prev = ctx.font;
+ var width = 0;
+ var i;
+
+ ctx.font = font.string;
+
+ for (i = 0; i < ilen; ++i) {
+ width = Math.max(ctx.measureText(items[i]).width, width);
+ }
+
+ ctx.font = prev;
+
+ return {
+ height: ilen * font.lineHeight,
+ width: width
+ };
+ },
+
+ /**
+ * Returns value bounded by min and max. This is equivalent to max(min, min(value, max)).
+ * @todo move this method in Chart.helpers.bound
+ * https://doc.qt.io/qt-5/qtglobal.html#qBound
+ */
+ bound: function(min, value, max) {
+ return Math.max(min, Math.min(value, max));
+ },
+
+ /**
+ * Returns an array of pair [value, state] where state is:
+ * * -1: value is only in a0 (removed)
+ * * 1: value is only in a1 (added)
+ */
+ arrayDiff: function(a0, a1) {
+ var prev = a0.slice();
+ var updates = [];
+ var i, j, ilen, v;
+
+ for (i = 0, ilen = a1.length; i < ilen; ++i) {
+ v = a1[i];
+ j = prev.indexOf(v);
+
+ if (j === -1) {
+ updates.push([v, 1]);
+ } else {
+ prev.splice(j, 1);
+ }
+ }
+
+ for (i = 0, ilen = prev.length; i < ilen; ++i) {
+ updates.push([prev[i], -1]);
+ }
+
+ return updates;
+ },
+
+ /**
+ * https://github.com/chartjs/chartjs-plugin-datalabels/issues/70
+ */
+ rasterize: function(v) {
+ return Math.round(v * devicePixelRatio) / devicePixelRatio;
+ }
+ };
+
+ function orient(point, origin) {
+ var x0 = origin.x;
+ var y0 = origin.y;
+
+ if (x0 === null) {
+ return {x: 0, y: -1};
+ }
+ if (y0 === null) {
+ return {x: 1, y: 0};
+ }
+
+ var dx = point.x - x0;
+ var dy = point.y - y0;
+ var ln = Math.sqrt(dx * dx + dy * dy);
+
+ return {
+ x: ln ? dx / ln : 0,
+ y: ln ? dy / ln : -1
+ };
+ }
+
+ function aligned(x, y, vx, vy, align) {
+ switch (align) {
+ case 'center':
+ vx = vy = 0;
+ break;
+ case 'bottom':
+ vx = 0;
+ vy = 1;
+ break;
+ case 'right':
+ vx = 1;
+ vy = 0;
+ break;
+ case 'left':
+ vx = -1;
+ vy = 0;
+ break;
+ case 'top':
+ vx = 0;
+ vy = -1;
+ break;
+ case 'start':
+ vx = -vx;
+ vy = -vy;
+ break;
+ case 'end':
+ // keep natural orientation
+ break;
+ default:
+ // clockwise rotation (in degree)
+ align *= (Math.PI / 180);
+ vx = Math.cos(align);
+ vy = Math.sin(align);
+ break;
+ }
+
+ return {
+ x: x,
+ y: y,
+ vx: vx,
+ vy: vy
+ };
+ }
+
+ // Line clipping (Cohen–Sutherland algorithm)
+ // https://en.wikipedia.org/wiki/Cohen–Sutherland_algorithm
+
+ var R_INSIDE = 0;
+ var R_LEFT = 1;
+ var R_RIGHT = 2;
+ var R_BOTTOM = 4;
+ var R_TOP = 8;
+
+ function region(x, y, rect) {
+ var res = R_INSIDE;
+
+ if (x < rect.left) {
+ res |= R_LEFT;
+ } else if (x > rect.right) {
+ res |= R_RIGHT;
+ }
+ if (y < rect.top) {
+ res |= R_TOP;
+ } else if (y > rect.bottom) {
+ res |= R_BOTTOM;
+ }
+
+ return res;
+ }
+
+ function clipped(segment, area) {
+ var x0 = segment.x0;
+ var y0 = segment.y0;
+ var x1 = segment.x1;
+ var y1 = segment.y1;
+ var r0 = region(x0, y0, area);
+ var r1 = region(x1, y1, area);
+ var r, x, y;
+
+ // eslint-disable-next-line no-constant-condition
+ while (true) {
+ if (!(r0 | r1) || (r0 & r1)) {
+ // both points inside or on the same side: no clipping
+ break;
+ }
+
+ // at least one point is outside
+ r = r0 || r1;
+
+ if (r & R_TOP) {
+ x = x0 + (x1 - x0) * (area.top - y0) / (y1 - y0);
+ y = area.top;
+ } else if (r & R_BOTTOM) {
+ x = x0 + (x1 - x0) * (area.bottom - y0) / (y1 - y0);
+ y = area.bottom;
+ } else if (r & R_RIGHT) {
+ y = y0 + (y1 - y0) * (area.right - x0) / (x1 - x0);
+ x = area.right;
+ } else if (r & R_LEFT) {
+ y = y0 + (y1 - y0) * (area.left - x0) / (x1 - x0);
+ x = area.left;
+ }
+
+ if (r === r0) {
+ x0 = x;
+ y0 = y;
+ r0 = region(x0, y0, area);
+ } else {
+ x1 = x;
+ y1 = y;
+ r1 = region(x1, y1, area);
+ }
+ }
+
+ return {
+ x0: x0,
+ x1: x1,
+ y0: y0,
+ y1: y1
+ };
+ }
+
+ function compute$1(range, config) {
+ var anchor = config.anchor;
+ var segment = range;
+ var x, y;
+
+ if (config.clamp) {
+ segment = clipped(segment, config.area);
+ }
+
+ if (anchor === 'start') {
+ x = segment.x0;
+ y = segment.y0;
+ } else if (anchor === 'end') {
+ x = segment.x1;
+ y = segment.y1;
+ } else {
+ x = (segment.x0 + segment.x1) / 2;
+ y = (segment.y0 + segment.y1) / 2;
+ }
+
+ return aligned(x, y, range.vx, range.vy, config.align);
+ }
+
+ var positioners = {
+ arc: function(el, config) {
+ var angle = (el.startAngle + el.endAngle) / 2;
+ var vx = Math.cos(angle);
+ var vy = Math.sin(angle);
+ var r0 = el.innerRadius;
+ var r1 = el.outerRadius;
+
+ return compute$1({
+ x0: el.x + vx * r0,
+ y0: el.y + vy * r0,
+ x1: el.x + vx * r1,
+ y1: el.y + vy * r1,
+ vx: vx,
+ vy: vy
+ }, config);
+ },
+
+ point: function(el, config) {
+ var v = orient(el, config.origin);
+ var rx = v.x * el.options.radius;
+ var ry = v.y * el.options.radius;
+
+ return compute$1({
+ x0: el.x - rx,
+ y0: el.y - ry,
+ x1: el.x + rx,
+ y1: el.y + ry,
+ vx: v.x,
+ vy: v.y
+ }, config);
+ },
+
+ bar: function(el, config) {
+ var v = orient(el, config.origin);
+ var x = el.x;
+ var y = el.y;
+ var sx = 0;
+ var sy = 0;
+
+ if (el.horizontal) {
+ x = Math.min(el.x, el.base);
+ sx = Math.abs(el.base - el.x);
+ } else {
+ y = Math.min(el.y, el.base);
+ sy = Math.abs(el.base - el.y);
+ }
+
+ return compute$1({
+ x0: x,
+ y0: y + sy,
+ x1: x + sx,
+ y1: y,
+ vx: v.x,
+ vy: v.y
+ }, config);
+ },
+
+ fallback: function(el, config) {
+ var v = orient(el, config.origin);
+
+ return compute$1({
+ x0: el.x,
+ y0: el.y,
+ x1: el.x + (el.width || 0),
+ y1: el.y + (el.height || 0),
+ vx: v.x,
+ vy: v.y
+ }, config);
+ }
+ };
+
+ var rasterize = utils.rasterize;
+
+ function boundingRects(model) {
+ var borderWidth = model.borderWidth || 0;
+ var padding = model.padding;
+ var th = model.size.height;
+ var tw = model.size.width;
+ var tx = -tw / 2;
+ var ty = -th / 2;
+
+ return {
+ frame: {
+ x: tx - padding.left - borderWidth,
+ y: ty - padding.top - borderWidth,
+ w: tw + padding.width + borderWidth * 2,
+ h: th + padding.height + borderWidth * 2
+ },
+ text: {
+ x: tx,
+ y: ty,
+ w: tw,
+ h: th
+ }
+ };
+ }
+
+ function getScaleOrigin(el, context) {
+ var scale = context.chart.getDatasetMeta(context.datasetIndex).vScale;
+
+ if (!scale) {
+ return null;
+ }
+
+ if (scale.xCenter !== undefined && scale.yCenter !== undefined) {
+ return {x: scale.xCenter, y: scale.yCenter};
+ }
+
+ var pixel = scale.getBasePixel();
+ return el.horizontal ?
+ {x: pixel, y: null} :
+ {x: null, y: pixel};
+ }
+
+ function getPositioner(el) {
+ if (el instanceof chart_js.ArcElement) {
+ return positioners.arc;
+ }
+ if (el instanceof chart_js.PointElement) {
+ return positioners.point;
+ }
+ if (el instanceof chart_js.BarElement) {
+ return positioners.bar;
+ }
+ return positioners.fallback;
+ }
+
+ function drawRoundedRect(ctx, x, y, w, h, radius) {
+ var HALF_PI = Math.PI / 2;
+
+ if (radius) {
+ var r = Math.min(radius, h / 2, w / 2);
+ var left = x + r;
+ var top = y + r;
+ var right = x + w - r;
+ var bottom = y + h - r;
+
+ ctx.moveTo(x, top);
+ if (left < right && top < bottom) {
+ ctx.arc(left, top, r, -Math.PI, -HALF_PI);
+ ctx.arc(right, top, r, -HALF_PI, 0);
+ ctx.arc(right, bottom, r, 0, HALF_PI);
+ ctx.arc(left, bottom, r, HALF_PI, Math.PI);
+ } else if (left < right) {
+ ctx.moveTo(left, y);
+ ctx.arc(right, top, r, -HALF_PI, HALF_PI);
+ ctx.arc(left, top, r, HALF_PI, Math.PI + HALF_PI);
+ } else if (top < bottom) {
+ ctx.arc(left, top, r, -Math.PI, 0);
+ ctx.arc(left, bottom, r, 0, Math.PI);
+ } else {
+ ctx.arc(left, top, r, -Math.PI, Math.PI);
+ }
+ ctx.closePath();
+ ctx.moveTo(x, y);
+ } else {
+ ctx.rect(x, y, w, h);
+ }
+ }
+
+ function drawFrame(ctx, rect, model) {
+ var bgColor = model.backgroundColor;
+ var borderColor = model.borderColor;
+ var borderWidth = model.borderWidth;
+
+ if (!bgColor && (!borderColor || !borderWidth)) {
+ return;
+ }
+
+ ctx.beginPath();
+
+ drawRoundedRect(
+ ctx,
+ rasterize(rect.x) + borderWidth / 2,
+ rasterize(rect.y) + borderWidth / 2,
+ rasterize(rect.w) - borderWidth,
+ rasterize(rect.h) - borderWidth,
+ model.borderRadius);
+
+ ctx.closePath();
+
+ if (bgColor) {
+ ctx.fillStyle = bgColor;
+ ctx.fill();
+ }
+
+ if (borderColor && borderWidth) {
+ ctx.strokeStyle = borderColor;
+ ctx.lineWidth = borderWidth;
+ ctx.lineJoin = 'miter';
+ ctx.stroke();
+ }
+ }
+
+ function textGeometry(rect, align, font) {
+ var h = font.lineHeight;
+ var w = rect.w;
+ var x = rect.x;
+ var y = rect.y + h / 2;
+
+ if (align === 'center') {
+ x += w / 2;
+ } else if (align === 'end' || align === 'right') {
+ x += w;
+ }
+
+ return {
+ h: h,
+ w: w,
+ x: x,
+ y: y
+ };
+ }
+
+ function drawTextLine(ctx, text, cfg) {
+ var shadow = ctx.shadowBlur;
+ var stroked = cfg.stroked;
+ var x = rasterize(cfg.x);
+ var y = rasterize(cfg.y);
+ var w = rasterize(cfg.w);
+
+ if (stroked) {
+ ctx.strokeText(text, x, y, w);
+ }
+
+ if (cfg.filled) {
+ if (shadow && stroked) {
+ // Prevent drawing shadow on both the text stroke and fill, so
+ // if the text is stroked, remove the shadow for the text fill.
+ ctx.shadowBlur = 0;
+ }
+
+ ctx.fillText(text, x, y, w);
+
+ if (shadow && stroked) {
+ ctx.shadowBlur = shadow;
+ }
+ }
+ }
+
+ function drawText(ctx, lines, rect, model) {
+ var align = model.textAlign;
+ var color = model.color;
+ var filled = !!color;
+ var font = model.font;
+ var ilen = lines.length;
+ var strokeColor = model.textStrokeColor;
+ var strokeWidth = model.textStrokeWidth;
+ var stroked = strokeColor && strokeWidth;
+ var i;
+
+ if (!ilen || (!filled && !stroked)) {
+ return;
+ }
+
+ // Adjust coordinates based on text alignment and line height
+ rect = textGeometry(rect, align, font);
+
+ ctx.font = font.string;
+ ctx.textAlign = align;
+ ctx.textBaseline = 'middle';
+ ctx.shadowBlur = model.textShadowBlur;
+ ctx.shadowColor = model.textShadowColor;
+
+ if (filled) {
+ ctx.fillStyle = color;
+ }
+ if (stroked) {
+ ctx.lineJoin = 'round';
+ ctx.lineWidth = strokeWidth;
+ ctx.strokeStyle = strokeColor;
+ }
+
+ for (i = 0, ilen = lines.length; i < ilen; ++i) {
+ drawTextLine(ctx, lines[i], {
+ stroked: stroked,
+ filled: filled,
+ w: rect.w,
+ x: rect.x,
+ y: rect.y + rect.h * i
+ });
+ }
+ }
+
+ var Label = function(config, ctx, el, index) {
+ var me = this;
+
+ me._config = config;
+ me._index = index;
+ me._model = null;
+ me._rects = null;
+ me._ctx = ctx;
+ me._el = el;
+ };
+
+ helpers.merge(Label.prototype, {
+ /**
+ * @private
+ */
+ _modelize: function(display, lines, config, context) {
+ var me = this;
+ var index = me._index;
+ var font = helpers.toFont(helpers.resolve([config.font, {}], context, index));
+ var color = helpers.resolve([config.color, chart_js.defaults.color], context, index);
+
+ return {
+ align: helpers.resolve([config.align, 'center'], context, index),
+ anchor: helpers.resolve([config.anchor, 'center'], context, index),
+ area: context.chart.chartArea,
+ backgroundColor: helpers.resolve([config.backgroundColor, null], context, index),
+ borderColor: helpers.resolve([config.borderColor, null], context, index),
+ borderRadius: helpers.resolve([config.borderRadius, 0], context, index),
+ borderWidth: helpers.resolve([config.borderWidth, 0], context, index),
+ clamp: helpers.resolve([config.clamp, false], context, index),
+ clip: helpers.resolve([config.clip, false], context, index),
+ color: color,
+ display: display,
+ font: font,
+ lines: lines,
+ offset: helpers.resolve([config.offset, 4], context, index),
+ opacity: helpers.resolve([config.opacity, 1], context, index),
+ origin: getScaleOrigin(me._el, context),
+ padding: helpers.toPadding(helpers.resolve([config.padding, 4], context, index)),
+ positioner: getPositioner(me._el),
+ rotation: helpers.resolve([config.rotation, 0], context, index) * (Math.PI / 180),
+ size: utils.textSize(me._ctx, lines, font),
+ textAlign: helpers.resolve([config.textAlign, 'start'], context, index),
+ textShadowBlur: helpers.resolve([config.textShadowBlur, 0], context, index),
+ textShadowColor: helpers.resolve([config.textShadowColor, color], context, index),
+ textStrokeColor: helpers.resolve([config.textStrokeColor, color], context, index),
+ textStrokeWidth: helpers.resolve([config.textStrokeWidth, 0], context, index)
+ };
+ },
+
+ update: function(context) {
+ var me = this;
+ var model = null;
+ var rects = null;
+ var index = me._index;
+ var config = me._config;
+ var value, label, lines;
+
+ // We first resolve the display option (separately) to avoid computing
+ // other options in case the label is hidden (i.e. display: false).
+ var display = helpers.resolve([config.display, true], context, index);
+
+ if (display) {
+ value = context.dataset.data[index];
+ label = helpers.valueOrDefault(helpers.callback(config.formatter, [value, context]), value);
+ lines = helpers.isNullOrUndef(label) ? [] : utils.toTextLines(label);
+
+ if (lines.length) {
+ model = me._modelize(display, lines, config, context);
+ rects = boundingRects(model);
+ }
+ }
+
+ me._model = model;
+ me._rects = rects;
+ },
+
+ geometry: function() {
+ return this._rects ? this._rects.frame : {};
+ },
+
+ rotation: function() {
+ return this._model ? this._model.rotation : 0;
+ },
+
+ visible: function() {
+ return this._model && this._model.opacity;
+ },
+
+ model: function() {
+ return this._model;
+ },
+
+ draw: function(chart, center) {
+ var me = this;
+ var ctx = chart.ctx;
+ var model = me._model;
+ var rects = me._rects;
+ var area;
+
+ if (!this.visible()) {
+ return;
+ }
+
+ ctx.save();
+
+ if (model.clip) {
+ area = model.area;
+ ctx.beginPath();
+ ctx.rect(
+ area.left,
+ area.top,
+ area.right - area.left,
+ area.bottom - area.top);
+ ctx.clip();
+ }
+
+ ctx.globalAlpha = utils.bound(0, model.opacity, 1);
+ ctx.translate(rasterize(center.x), rasterize(center.y));
+ ctx.rotate(model.rotation);
+
+ drawFrame(ctx, rects.frame, model);
+ drawText(ctx, model.lines, rects.text, model);
+
+ ctx.restore();
+ }
+ });
+
+ var MIN_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991; // eslint-disable-line es/no-number-minsafeinteger
+ var MAX_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991; // eslint-disable-line es/no-number-maxsafeinteger
+
+ function rotated(point, center, angle) {
+ var cos = Math.cos(angle);
+ var sin = Math.sin(angle);
+ var cx = center.x;
+ var cy = center.y;
+
+ return {
+ x: cx + cos * (point.x - cx) - sin * (point.y - cy),
+ y: cy + sin * (point.x - cx) + cos * (point.y - cy)
+ };
+ }
+
+ function projected(points, axis) {
+ var min = MAX_INTEGER;
+ var max = MIN_INTEGER;
+ var origin = axis.origin;
+ var i, pt, vx, vy, dp;
+
+ for (i = 0; i < points.length; ++i) {
+ pt = points[i];
+ vx = pt.x - origin.x;
+ vy = pt.y - origin.y;
+ dp = axis.vx * vx + axis.vy * vy;
+ min = Math.min(min, dp);
+ max = Math.max(max, dp);
+ }
+
+ return {
+ min: min,
+ max: max
+ };
+ }
+
+ function toAxis(p0, p1) {
+ var vx = p1.x - p0.x;
+ var vy = p1.y - p0.y;
+ var ln = Math.sqrt(vx * vx + vy * vy);
+
+ return {
+ vx: (p1.x - p0.x) / ln,
+ vy: (p1.y - p0.y) / ln,
+ origin: p0,
+ ln: ln
+ };
+ }
+
+ var HitBox = function() {
+ this._rotation = 0;
+ this._rect = {
+ x: 0,
+ y: 0,
+ w: 0,
+ h: 0
+ };
+ };
+
+ helpers.merge(HitBox.prototype, {
+ center: function() {
+ var r = this._rect;
+ return {
+ x: r.x + r.w / 2,
+ y: r.y + r.h / 2
+ };
+ },
+
+ update: function(center, rect, rotation) {
+ this._rotation = rotation;
+ this._rect = {
+ x: rect.x + center.x,
+ y: rect.y + center.y,
+ w: rect.w,
+ h: rect.h
+ };
+ },
+
+ contains: function(point) {
+ var me = this;
+ var margin = 1;
+ var rect = me._rect;
+
+ point = rotated(point, me.center(), -me._rotation);
+
+ return !(point.x < rect.x - margin
+ || point.y < rect.y - margin
+ || point.x > rect.x + rect.w + margin * 2
+ || point.y > rect.y + rect.h + margin * 2);
+ },
+
+ // Separating Axis Theorem
+ // https://gamedevelopment.tutsplus.com/tutorials/collision-detection-using-the-separating-axis-theorem--gamedev-169
+ intersects: function(other) {
+ var r0 = this._points();
+ var r1 = other._points();
+ var axes = [
+ toAxis(r0[0], r0[1]),
+ toAxis(r0[0], r0[3])
+ ];
+ var i, pr0, pr1;
+
+ if (this._rotation !== other._rotation) {
+ // Only separate with r1 axis if the rotation is different,
+ // else it's enough to separate r0 and r1 with r0 axis only!
+ axes.push(
+ toAxis(r1[0], r1[1]),
+ toAxis(r1[0], r1[3])
+ );
+ }
+
+ for (i = 0; i < axes.length; ++i) {
+ pr0 = projected(r0, axes[i]);
+ pr1 = projected(r1, axes[i]);
+
+ if (pr0.max < pr1.min || pr1.max < pr0.min) {
+ return false;
+ }
+ }
+
+ return true;
+ },
+
+ /**
+ * @private
+ */
+ _points: function() {
+ var me = this;
+ var rect = me._rect;
+ var angle = me._rotation;
+ var center = me.center();
+
+ return [
+ rotated({x: rect.x, y: rect.y}, center, angle),
+ rotated({x: rect.x + rect.w, y: rect.y}, center, angle),
+ rotated({x: rect.x + rect.w, y: rect.y + rect.h}, center, angle),
+ rotated({x: rect.x, y: rect.y + rect.h}, center, angle)
+ ];
+ }
+ });
+
+ function coordinates(el, model, geometry) {
+ var point = model.positioner(el, model);
+ var vx = point.vx;
+ var vy = point.vy;
+
+ if (!vx && !vy) {
+ // if aligned center, we don't want to offset the center point
+ return {x: point.x, y: point.y};
+ }
+
+ var w = geometry.w;
+ var h = geometry.h;
+
+ // take in account the label rotation
+ var rotation = model.rotation;
+ var dx = Math.abs(w / 2 * Math.cos(rotation)) + Math.abs(h / 2 * Math.sin(rotation));
+ var dy = Math.abs(w / 2 * Math.sin(rotation)) + Math.abs(h / 2 * Math.cos(rotation));
+
+ // scale the unit vector (vx, vy) to get at least dx or dy equal to
+ // w or h respectively (else we would calculate the distance to the
+ // ellipse inscribed in the bounding rect)
+ var vs = 1 / Math.max(Math.abs(vx), Math.abs(vy));
+ dx *= vx * vs;
+ dy *= vy * vs;
+
+ // finally, include the explicit offset
+ dx += model.offset * vx;
+ dy += model.offset * vy;
+
+ return {
+ x: point.x + dx,
+ y: point.y + dy
+ };
+ }
+
+ function collide(labels, collider) {
+ var i, j, s0, s1;
+
+ // IMPORTANT Iterate in the reverse order since items at the end of the
+ // list have an higher weight/priority and thus should be less impacted
+ // by the overlapping strategy.
+
+ for (i = labels.length - 1; i >= 0; --i) {
+ s0 = labels[i].$layout;
+
+ for (j = i - 1; j >= 0 && s0._visible; --j) {
+ s1 = labels[j].$layout;
+
+ if (s1._visible && s0._box.intersects(s1._box)) {
+ collider(s0, s1);
+ }
+ }
+ }
+
+ return labels;
+ }
+
+ function compute(labels) {
+ var i, ilen, label, state, geometry, center, proxy;
+
+ // Initialize labels for overlap detection
+ for (i = 0, ilen = labels.length; i < ilen; ++i) {
+ label = labels[i];
+ state = label.$layout;
+
+ if (state._visible) {
+ // Chart.js 3 removed el._model in favor of getProps(), making harder to
+ // abstract reading values in positioners. Also, using string arrays to
+ // read values (i.e. var {a,b,c} = el.getProps(["a","b","c"])) would make
+ // positioners inefficient in the normal case (i.e. not the final values)
+ // and the code a bit ugly, so let's use a Proxy instead.
+ proxy = new Proxy(label._el, {get: (el, p) => el.getProps([p], true)[p]});
+
+ geometry = label.geometry();
+ center = coordinates(proxy, label.model(), geometry);
+ state._box.update(center, geometry, label.rotation());
+ }
+ }
+
+ // Auto hide overlapping labels
+ return collide(labels, function(s0, s1) {
+ var h0 = s0._hidable;
+ var h1 = s1._hidable;
+
+ if ((h0 && h1) || h1) {
+ s1._visible = false;
+ } else if (h0) {
+ s0._visible = false;
+ }
+ });
+ }
+
+ var layout = {
+ prepare: function(datasets) {
+ var labels = [];
+ var i, j, ilen, jlen, label;
+
+ for (i = 0, ilen = datasets.length; i < ilen; ++i) {
+ for (j = 0, jlen = datasets[i].length; j < jlen; ++j) {
+ label = datasets[i][j];
+ labels.push(label);
+ label.$layout = {
+ _box: new HitBox(),
+ _hidable: false,
+ _visible: true,
+ _set: i,
+ _idx: label._index
+ };
+ }
+ }
+
+ // TODO New `z` option: labels with a higher z-index are drawn
+ // of top of the ones with a lower index. Lowest z-index labels
+ // are also discarded first when hiding overlapping labels.
+ labels.sort(function(a, b) {
+ var sa = a.$layout;
+ var sb = b.$layout;
+
+ return sa._idx === sb._idx
+ ? sb._set - sa._set
+ : sb._idx - sa._idx;
+ });
+
+ this.update(labels);
+
+ return labels;
+ },
+
+ update: function(labels) {
+ var dirty = false;
+ var i, ilen, label, model, state;
+
+ for (i = 0, ilen = labels.length; i < ilen; ++i) {
+ label = labels[i];
+ model = label.model();
+ state = label.$layout;
+ state._hidable = model && model.display === 'auto';
+ state._visible = label.visible();
+ dirty |= state._hidable;
+ }
+
+ if (dirty) {
+ compute(labels);
+ }
+ },
+
+ lookup: function(labels, point) {
+ var i, state;
+
+ // IMPORTANT Iterate in the reverse order since items at the end of
+ // the list have an higher z-index, thus should be picked first.
+
+ for (i = labels.length - 1; i >= 0; --i) {
+ state = labels[i].$layout;
+
+ if (state && state._visible && state._box.contains(point)) {
+ return labels[i];
+ }
+ }
+
+ return null;
+ },
+
+ draw: function(chart, labels) {
+ var i, ilen, label, state, geometry, center;
+
+ for (i = 0, ilen = labels.length; i < ilen; ++i) {
+ label = labels[i];
+ state = label.$layout;
+
+ if (state._visible) {
+ geometry = label.geometry();
+ center = coordinates(label._el, label.model(), geometry);
+ state._box.update(center, geometry, label.rotation());
+ label.draw(chart, center);
+ }
+ }
+ }
+ };
+
+ var formatter = function(value) {
+ if (helpers.isNullOrUndef(value)) {
+ return null;
+ }
+
+ var label = value;
+ var keys, klen, k;
+ if (helpers.isObject(value)) {
+ if (!helpers.isNullOrUndef(value.label)) {
+ label = value.label;
+ } else if (!helpers.isNullOrUndef(value.r)) {
+ label = value.r;
+ } else {
+ label = '';
+ keys = Object.keys(value);
+ for (k = 0, klen = keys.length; k < klen; ++k) {
+ label += (k !== 0 ? ', ' : '') + keys[k] + ': ' + value[keys[k]];
+ }
+ }
+ }
+
+ return '' + label;
+ };
+
+ /**
+ * IMPORTANT: make sure to also update tests and TypeScript definition
+ * files (`/test/specs/defaults.spec.js` and `/types/options.d.ts`)
+ */
+
+ var defaults = {
+ align: 'center',
+ anchor: 'center',
+ backgroundColor: null,
+ borderColor: null,
+ borderRadius: 0,
+ borderWidth: 0,
+ clamp: false,
+ clip: false,
+ color: undefined,
+ display: true,
+ font: {
+ family: undefined,
+ lineHeight: 1.2,
+ size: undefined,
+ style: undefined,
+ weight: null
+ },
+ formatter: formatter,
+ labels: undefined,
+ listeners: {},
+ offset: 4,
+ opacity: 1,
+ padding: {
+ top: 4,
+ right: 4,
+ bottom: 4,
+ left: 4
+ },
+ rotation: 0,
+ textAlign: 'start',
+ textStrokeColor: undefined,
+ textStrokeWidth: 0,
+ textShadowBlur: 0,
+ textShadowColor: undefined
+ };
+
+ /**
+ * @see https://github.com/chartjs/Chart.js/issues/4176
+ */
+
+ var EXPANDO_KEY = '$datalabels';
+ var DEFAULT_KEY = '$default';
+
+ function configure(dataset, options) {
+ var override = dataset.datalabels;
+ var listeners = {};
+ var configs = [];
+ var labels, keys;
+
+ if (override === false) {
+ return null;
+ }
+ if (override === true) {
+ override = {};
+ }
+
+ options = helpers.merge({}, [options, override]);
+ labels = options.labels || {};
+ keys = Object.keys(labels);
+ delete options.labels;
+
+ if (keys.length) {
+ keys.forEach(function(key) {
+ if (labels[key]) {
+ configs.push(helpers.merge({}, [
+ options,
+ labels[key],
+ {_key: key}
+ ]));
+ }
+ });
+ } else {
+ // Default label if no "named" label defined.
+ configs.push(options);
+ }
+
+ // listeners: {: {: }}
+ listeners = configs.reduce(function(target, config) {
+ helpers.each(config.listeners || {}, function(fn, event) {
+ target[event] = target[event] || {};
+ target[event][config._key || DEFAULT_KEY] = fn;
+ });
+
+ delete config.listeners;
+ return target;
+ }, {});
+
+ return {
+ labels: configs,
+ listeners: listeners
+ };
+ }
+
+ function dispatchEvent(chart, listeners, label, event) {
+ if (!listeners) {
+ return;
+ }
+
+ var context = label.$context;
+ var groups = label.$groups;
+ var callback;
+
+ if (!listeners[groups._set]) {
+ return;
+ }
+
+ callback = listeners[groups._set][groups._key];
+ if (!callback) {
+ return;
+ }
+
+ if (helpers.callback(callback, [context, event]) === true) {
+ // Users are allowed to tweak the given context by injecting values that can be
+ // used in scriptable options to display labels differently based on the current
+ // event (e.g. highlight an hovered label). That's why we update the label with
+ // the output context and schedule a new chart render by setting it dirty.
+ chart[EXPANDO_KEY]._dirty = true;
+ label.update(context);
+ }
+ }
+
+ function dispatchMoveEvents(chart, listeners, previous, label, event) {
+ var enter, leave;
+
+ if (!previous && !label) {
+ return;
+ }
+
+ if (!previous) {
+ enter = true;
+ } else if (!label) {
+ leave = true;
+ } else if (previous !== label) {
+ leave = enter = true;
+ }
+
+ if (leave) {
+ dispatchEvent(chart, listeners.leave, previous, event);
+ }
+ if (enter) {
+ dispatchEvent(chart, listeners.enter, label, event);
+ }
+ }
+
+ function handleMoveEvents(chart, event) {
+ var expando = chart[EXPANDO_KEY];
+ var listeners = expando._listeners;
+ var previous, label;
+
+ if (!listeners.enter && !listeners.leave) {
+ return;
+ }
+
+ if (event.type === 'mousemove') {
+ label = layout.lookup(expando._labels, event);
+ } else if (event.type !== 'mouseout') {
+ return;
+ }
+
+ previous = expando._hovered;
+ expando._hovered = label;
+ dispatchMoveEvents(chart, listeners, previous, label, event);
+ }
+
+ function handleClickEvents(chart, event) {
+ var expando = chart[EXPANDO_KEY];
+ var handlers = expando._listeners.click;
+ var label = handlers && layout.lookup(expando._labels, event);
+ if (label) {
+ dispatchEvent(chart, handlers, label, event);
+ }
+ }
+
+ var plugin = {
+ id: 'datalabels',
+
+ defaults: defaults,
+
+ beforeInit: function(chart) {
+ chart[EXPANDO_KEY] = {
+ _actives: []
+ };
+ },
+
+ beforeUpdate: function(chart) {
+ var expando = chart[EXPANDO_KEY];
+ expando._listened = false;
+ expando._listeners = {}; // {: {: {: }}}
+ expando._datasets = []; // per dataset labels: [Label[]]
+ expando._labels = []; // layouted labels: Label[]
+ },
+
+ afterDatasetUpdate: function(chart, args, options) {
+ var datasetIndex = args.index;
+ var expando = chart[EXPANDO_KEY];
+ var labels = expando._datasets[datasetIndex] = [];
+ var visible = chart.isDatasetVisible(datasetIndex);
+ var dataset = chart.data.datasets[datasetIndex];
+ var config = configure(dataset, options);
+ var elements = args.meta.data || [];
+ var ctx = chart.ctx;
+ var i, j, ilen, jlen, cfg, key, el, label;
+
+ ctx.save();
+
+ for (i = 0, ilen = elements.length; i < ilen; ++i) {
+ el = elements[i];
+ el[EXPANDO_KEY] = [];
+
+ if (visible && el && chart.getDataVisibility(i) && !el.skip) {
+ for (j = 0, jlen = config.labels.length; j < jlen; ++j) {
+ cfg = config.labels[j];
+ key = cfg._key;
+
+ label = new Label(cfg, ctx, el, i);
+ label.$groups = {
+ _set: datasetIndex,
+ _key: key || DEFAULT_KEY
+ };
+ label.$context = {
+ active: false,
+ chart: chart,
+ dataIndex: i,
+ dataset: dataset,
+ datasetIndex: datasetIndex
+ };
+
+ label.update(label.$context);
+ el[EXPANDO_KEY].push(label);
+ labels.push(label);
+ }
+ }
+ }
+
+ ctx.restore();
+
+ // Store listeners at the chart level and per event type to optimize
+ // cases where no listeners are registered for a specific event.
+ helpers.merge(expando._listeners, config.listeners, {
+ merger: function(event, target, source) {
+ target[event] = target[event] || {};
+ target[event][args.index] = source[event];
+ expando._listened = true;
+ }
+ });
+ },
+
+ afterUpdate: function(chart) {
+ chart[EXPANDO_KEY]._labels = layout.prepare(chart[EXPANDO_KEY]._datasets);
+ },
+
+ // Draw labels on top of all dataset elements
+ // https://github.com/chartjs/chartjs-plugin-datalabels/issues/29
+ // https://github.com/chartjs/chartjs-plugin-datalabels/issues/32
+ afterDatasetsDraw: function(chart) {
+ layout.draw(chart, chart[EXPANDO_KEY]._labels);
+ },
+
+ beforeEvent: function(chart, args) {
+ // If there is no listener registered for this chart, `listened` will be false,
+ // meaning we can immediately ignore the incoming event and avoid useless extra
+ // computation for users who don't implement label interactions.
+ if (chart[EXPANDO_KEY]._listened) {
+ var event = args.event;
+ switch (event.type) {
+ case 'mousemove':
+ case 'mouseout':
+ handleMoveEvents(chart, event);
+ break;
+ case 'click':
+ handleClickEvents(chart, event);
+ break;
+ }
+ }
+ },
+
+ afterEvent: function(chart) {
+ var expando = chart[EXPANDO_KEY];
+ var previous = expando._actives;
+ var actives = expando._actives = chart.getActiveElements();
+ var updates = utils.arrayDiff(previous, actives);
+ var i, ilen, j, jlen, update, label, labels;
+
+ for (i = 0, ilen = updates.length; i < ilen; ++i) {
+ update = updates[i];
+ if (update[1]) {
+ labels = update[0].element[EXPANDO_KEY] || [];
+ for (j = 0, jlen = labels.length; j < jlen; ++j) {
+ label = labels[j];
+ label.$context.active = (update[1] === 1);
+ label.update(label.$context);
+ }
+ }
+ }
+
+ if (expando._dirty || updates.length) {
+ layout.update(expando._labels);
+ chart.render();
+ }
+
+ delete expando._dirty;
+ }
+ };
+
+ return plugin;
+
+ }));
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/lib/d3/d3.min.js b/addons_extensions/ftp_custom_dashboards/static/src/lib/d3/d3.min.js
new file mode 100644
index 000000000..05ebb40cb
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/lib/d3/d3.min.js
@@ -0,0 +1,2 @@
+// https://d3js.org v6.7.0 Copyright 2021 Mike Bostock
+!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).d3=t.d3||{})}(this,(function(t){"use strict";function n(t,n){return tn?1:t>=n?0:NaN}function e(t){let e=t,r=t;function i(t,n,e,i){for(null==e&&(e=0),null==i&&(i=t.length);e>>1;r(t[o],n)<0?e=o+1:i=o}return e}return 1===t.length&&(e=(n,e)=>t(n)-e,r=function(t){return(e,r)=>n(t(e),r)}(t)),{left:i,center:function(t,n,r,o){null==r&&(r=0),null==o&&(o=t.length);const a=i(t,n,r,o-1);return a>r&&e(t[a-1],n)>-e(t[a],n)?a-1:a},right:function(t,n,e,i){for(null==e&&(e=0),null==i&&(i=t.length);e>>1;r(t[o],n)>0?i=o:e=o+1}return e}}}function r(t){return null===t?NaN:+t}const i=e(n),o=i.right,a=i.left,u=e(r).center;function c(t,n){let e=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&++e;else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(i=+i)>=i&&++e}return e}function f(t){return 0|t.length}function s(t){return!(t>0)}function l(t){return"object"!=typeof t||"length"in t?t:Array.from(t)}function h(t,n){let e,r=0,i=0,o=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(e=n-i,i+=e/++r,o+=e*(n-i));else{let a=-1;for(let u of t)null!=(u=n(u,++a,t))&&(u=+u)>=u&&(e=u-i,i+=e/++r,o+=e*(u-i))}if(r>1)return o/(r-1)}function d(t,n){const e=h(t,n);return e?Math.sqrt(e):e}function p(t,n){let e,r;if(void 0===n)for(const n of t)null!=n&&(void 0===e?n>=n&&(e=r=n):(e>n&&(e=n),r=o&&(e=r=o):(e>o&&(e=o),r0){for(o=t[--i];i>0&&(n=o,e=t[--i],o=n+e,r=e-(o-n),!r););i>0&&(r<0&&t[i-1]<0||r>0&&t[i-1]>0)&&(e=2*r,n=o+e,e==n-o&&(o=n))}return o}}class y extends Map{constructor(t,n=x){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),null!=t)for(const[n,e]of t)this.set(n,e)}get(t){return super.get(_(this,t))}has(t){return super.has(_(this,t))}set(t,n){return super.set(b(this,t),n)}delete(t){return super.delete(m(this,t))}}class v extends Set{constructor(t,n=x){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),null!=t)for(const n of t)this.add(n)}has(t){return super.has(_(this,t))}add(t){return super.add(b(this,t))}delete(t){return super.delete(m(this,t))}}function _({_intern:t,_key:n},e){const r=n(e);return t.has(r)?t.get(r):e}function b({_intern:t,_key:n},e){const r=n(e);return t.has(r)?t.get(r):(t.set(r,e),e)}function m({_intern:t,_key:n},e){const r=n(e);return t.has(r)&&(e=t.get(e),t.delete(r)),e}function x(t){return null!==t&&"object"==typeof t?t.valueOf():t}function w(t){return t}function M(t,...n){return S(t,w,w,n)}function A(t,n,...e){return S(t,w,n,e)}function T(t){if(1!==t.length)throw new Error("duplicate key");return t[0]}function S(t,n,e,r){return function t(i,o){if(o>=r.length)return e(i);const a=new y,u=r[o++];let c=-1;for(const t of i){const n=u(t,++c,i),e=a.get(n);e?e.push(t):a.set(n,[t])}for(const[n,e]of a)a.set(n,t(e,o));return n(a)}(t,0)}function E(t,n){return Array.from(n,(n=>t[n]))}function k(t,...e){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");t=Array.from(t);let[r=n]=e;if(1===r.length||e.length>1){const i=Uint32Array.from(t,((t,n)=>n));return e.length>1?(e=e.map((n=>t.map(n))),i.sort(((t,r)=>{for(const i of e){const e=n(i[t],i[r]);if(e)return e}}))):(r=t.map(r),i.sort(((t,e)=>n(r[t],r[e])))),E(t,i)}return t.sort(r)}var N=Array.prototype.slice;function C(t){return function(){return t}}var P=Math.sqrt(50),z=Math.sqrt(10),D=Math.sqrt(2);function q(t,n,e){var r,i,o,a,u=-1;if(e=+e,(t=+t)===(n=+n)&&e>0)return[t];if((r=n0){let e=Math.round(t/a),r=Math.round(n/a);for(e*an&&--r,o=new Array(i=r-e+1);++un&&--r,o=new Array(i=r-e+1);++u=0?(o>=P?10:o>=z?5:o>=D?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=P?10:o>=z?5:o>=D?2:1)}function F(t,n,e){var r=Math.abs(n-t)/Math.max(0,e),i=Math.pow(10,Math.floor(Math.log(r)/Math.LN10)),o=r/i;return o>=P?i*=10:o>=z?i*=5:o>=D&&(i*=2),n0?(t=Math.floor(t/i)*i,n=Math.ceil(n/i)*i):i<0&&(t=Math.ceil(t*i)/i,n=Math.floor(n*i)/i),r=i}}function I(t){return Math.ceil(Math.log(c(t))/Math.LN2)+1}function U(){var t=w,n=p,e=I;function r(r){Array.isArray(r)||(r=Array.from(r));var i,a,u=r.length,c=new Array(u);for(i=0;i=l)if(t>=l&&n===p){const t=R(s,l,e);isFinite(t)&&(t>0?l=(Math.floor(l/t)+1)*t:t<0&&(l=(Math.ceil(l*-t)+1)/-t))}else h.pop()}for(var d=h.length;h[0]<=s;)h.shift(),--d;for(;h[d-1]>l;)h.pop(),--d;var g,y=new Array(d+1);for(i=0;i<=d;++i)(g=y[i]=[]).x0=i>0?h[i-1]:s,g.x1=i=n)&&(e=n);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(e=i)&&(e=i)}return e}function Y(t,n){let e;if(void 0===n)for(const n of t)null!=n&&(e>n||void 0===e&&n>=n)&&(e=n);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(e>i||void 0===e&&i>=i)&&(e=i)}return e}function L(t,e,r=0,i=t.length-1,o=n){for(;i>r;){if(i-r>600){const n=i-r+1,a=e-r+1,u=Math.log(n),c=.5*Math.exp(2*u/3),f=.5*Math.sqrt(u*c*(n-c)/n)*(a-n/2<0?-1:1);L(t,e,Math.max(r,Math.floor(e-a*c/n+f)),Math.min(i,Math.floor(e+(n-a)*c/n+f)),o)}const n=t[e];let a=r,u=i;for(j(t,r,e),o(t[i],n)>0&&j(t,r,i);a0;)--u}0===o(t[r],n)?j(t,r,u):(++u,j(t,u,i)),u<=e&&(r=u+1),e<=u&&(i=u-1)}return t}function j(t,n,e){const r=t[n];t[n]=t[e],t[e]=r}function H(t,n,e){if(r=(t=Float64Array.from(function*(t,n){if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(yield n);else{let e=-1;for(let r of t)null!=(r=n(r,++e,t))&&(r=+r)>=r&&(yield r)}}(t,e))).length){if((n=+n)<=0||r<2)return Y(t);if(n>=1)return B(t);var r,i=(r-1)*n,o=Math.floor(i),a=B(L(t,o).subarray(0,o+1));return a+(Y(t.subarray(o+1))-a)*(i-o)}}function X(t,n,e=r){if(i=t.length){if((n=+n)<=0||i<2)return+e(t[0],0,t);if(n>=1)return+e(t[i-1],i-1,t);var i,o=(i-1)*n,a=Math.floor(o),u=+e(t[a],a,t);return u+(+e(t[a+1],a+1,t)-u)*(o-a)}}function G(t,n){let e,r=-1,i=-1;if(void 0===n)for(const n of t)++i,null!=n&&(e=n)&&(e=n,r=i);else for(let o of t)null!=(o=n(o,++i,t))&&(e=o)&&(e=o,r=i);return r}function V(t){return Array.from(function*(t){for(const n of t)yield*n}(t))}function $(t,n){let e,r=-1,i=-1;if(void 0===n)for(const n of t)++i,null!=n&&(e>n||void 0===e&&n>=n)&&(e=n,r=i);else for(let o of t)null!=(o=n(o,++i,t))&&(e>o||void 0===e&&o>=o)&&(e=o,r=i);return r}function W(t,n){return[t,n]}function Z(t,n,e){t=+t,n=+n,e=(i=arguments.length)<2?(n=t,t=0,1):i<3?1:+e;for(var r=-1,i=0|Math.max(0,Math.ceil((n-t)/e)),o=new Array(i);++r+t(n)}function st(t,n){return n=Math.max(0,t.bandwidth()-2*n)/2,t.round()&&(n=Math.round(n)),e=>+t(e)+n}function lt(){return!this.__axis}function ht(t,n){var e=[],r=null,i=null,o=6,a=6,u=3,c="undefined"!=typeof window&&window.devicePixelRatio>1?0:.5,f=1===t||4===t?-1:1,s=4===t||2===t?"x":"y",l=1===t||3===t?ut:ct;function h(h){var d=null==r?n.ticks?n.ticks.apply(n,e):n.domain():r,p=null==i?n.tickFormat?n.tickFormat.apply(n,e):ot:i,g=Math.max(o,0)+u,y=n.range(),v=+y[0]+c,_=+y[y.length-1]+c,b=(n.bandwidth?st:ft)(n.copy(),c),m=h.selection?h.selection():h,x=m.selectAll(".domain").data([null]),w=m.selectAll(".tick").data(d,n).order(),M=w.exit(),A=w.enter().append("g").attr("class","tick"),T=w.select("line"),S=w.select("text");x=x.merge(x.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),w=w.merge(A),T=T.merge(A.append("line").attr("stroke","currentColor").attr(s+"2",f*o)),S=S.merge(A.append("text").attr("fill","currentColor").attr(s,f*g).attr("dy",1===t?"0em":3===t?"0.71em":"0.32em")),h!==m&&(x=x.transition(h),w=w.transition(h),T=T.transition(h),S=S.transition(h),M=M.transition(h).attr("opacity",at).attr("transform",(function(t){return isFinite(t=b(t))?l(t+c):this.getAttribute("transform")})),A.attr("opacity",at).attr("transform",(function(t){var n=this.parentNode.__axis;return l((n&&isFinite(n=n(t))?n:b(t))+c)}))),M.remove(),x.attr("d",4===t||2===t?a?"M"+f*a+","+v+"H"+c+"V"+_+"H"+f*a:"M"+c+","+v+"V"+_:a?"M"+v+","+f*a+"V"+c+"H"+_+"V"+f*a:"M"+v+","+c+"H"+_),w.attr("opacity",1).attr("transform",(function(t){return l(b(t)+c)})),T.attr(s+"2",f*o),S.attr(s,f*g).text(p),m.filter(lt).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",2===t?"start":4===t?"end":"middle"),m.each((function(){this.__axis=b}))}return h.scale=function(t){return arguments.length?(n=t,h):n},h.ticks=function(){return e=it.call(arguments),h},h.tickArguments=function(t){return arguments.length?(e=null==t?[]:it.call(t),h):e.slice()},h.tickValues=function(t){return arguments.length?(r=null==t?null:it.call(t),h):r&&r.slice()},h.tickFormat=function(t){return arguments.length?(i=t,h):i},h.tickSize=function(t){return arguments.length?(o=a=+t,h):o},h.tickSizeInner=function(t){return arguments.length?(o=+t,h):o},h.tickSizeOuter=function(t){return arguments.length?(a=+t,h):a},h.tickPadding=function(t){return arguments.length?(u=+t,h):u},h.offset=function(t){return arguments.length?(c=+t,h):c},h}var dt={value:()=>{}};function pt(){for(var t,n=0,e=arguments.length,r={};n=0&&(e=t.slice(r+1),t=t.slice(0,r)),t&&!n.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:e}}))}function vt(t,n){for(var e,r=0,i=t.length;r0)for(var e,r,i=new Array(e),o=0;o=0&&"xmlns"!==(n=t.slice(0,e))&&(t=t.slice(e+1)),mt.hasOwnProperty(n)?{space:mt[n],local:t}:t}function wt(t){return function(){var n=this.ownerDocument,e=this.namespaceURI;return e===bt&&n.documentElement.namespaceURI===bt?n.createElement(t):n.createElementNS(e,t)}}function Mt(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function At(t){var n=xt(t);return(n.local?Mt:wt)(n)}function Tt(){}function St(t){return null==t?Tt:function(){return this.querySelector(t)}}function Et(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}function kt(){return[]}function Nt(t){return null==t?kt:function(){return this.querySelectorAll(t)}}function Ct(t){return function(){return this.matches(t)}}function Pt(t){return function(n){return n.matches(t)}}var zt=Array.prototype.find;function Dt(){return this.firstElementChild}var qt=Array.prototype.filter;function Rt(){return this.children}function Ft(t){return new Array(t.length)}function Ot(t,n){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=n}function It(t){return function(){return t}}function Ut(t,n,e,r,i,o){for(var a,u=0,c=n.length,f=o.length;un?1:t>=n?0:NaN}function jt(t){return function(){this.removeAttribute(t)}}function Ht(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Xt(t,n){return function(){this.setAttribute(t,n)}}function Gt(t,n){return function(){this.setAttributeNS(t.space,t.local,n)}}function Vt(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttribute(t):this.setAttribute(t,e)}}function $t(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,e)}}function Wt(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function Zt(t){return function(){this.style.removeProperty(t)}}function Kt(t,n,e){return function(){this.style.setProperty(t,n,e)}}function Qt(t,n,e){return function(){var r=n.apply(this,arguments);null==r?this.style.removeProperty(t):this.style.setProperty(t,r,e)}}function Jt(t,n){return t.style.getPropertyValue(n)||Wt(t).getComputedStyle(t,null).getPropertyValue(n)}function tn(t){return function(){delete this[t]}}function nn(t,n){return function(){this[t]=n}}function en(t,n){return function(){var e=n.apply(this,arguments);null==e?delete this[t]:this[t]=e}}function rn(t){return t.trim().split(/^|\s+/)}function on(t){return t.classList||new an(t)}function an(t){this._node=t,this._names=rn(t.getAttribute("class")||"")}function un(t,n){for(var e=on(t),r=-1,i=n.length;++r=0&&(n=t.slice(e+1),t=t.slice(0,e)),{type:t,name:n}}))}function Tn(t){return function(){var n=this.__on;if(n){for(var e,r=0,i=-1,o=n.length;r=0&&(this._names.splice(n,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var Cn=[null];function Pn(t,n){this._groups=t,this._parents=n}function zn(){return new Pn([[document.documentElement]],Cn)}function Dn(t){return"string"==typeof t?new Pn([[document.querySelector(t)]],[document.documentElement]):new Pn([[t]],Cn)}Pn.prototype=zn.prototype={constructor:Pn,select:function(t){"function"!=typeof t&&(t=St(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i=x&&(x=m+1);!(b=y[x])&&++x=0;)(r=i[o])&&(a&&4^r.compareDocumentPosition(a)&&a.parentNode.insertBefore(r,a),a=r);return this},sort:function(t){function n(n,e){return n&&e?t(n.__data__,e.__data__):!n-!e}t||(t=Lt);for(var e=this._groups,r=e.length,i=new Array(r),o=0;o1?this.each((null==n?Zt:"function"==typeof n?Qt:Kt)(t,n,null==e?"":e)):Jt(this.node(),t)},property:function(t,n){return arguments.length>1?this.each((null==n?tn:"function"==typeof n?en:nn)(t,n)):this.node()[t]},classed:function(t,n){var e=rn(t+"");if(arguments.length<2){for(var r=on(this.node()),i=-1,o=e.length;++i()=>t;function Hn(t,{sourceEvent:n,subject:e,target:r,identifier:i,active:o,x:a,y:u,dx:c,dy:f,dispatch:s}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},subject:{value:e,enumerable:!0,configurable:!0},target:{value:r,enumerable:!0,configurable:!0},identifier:{value:i,enumerable:!0,configurable:!0},active:{value:o,enumerable:!0,configurable:!0},x:{value:a,enumerable:!0,configurable:!0},y:{value:u,enumerable:!0,configurable:!0},dx:{value:c,enumerable:!0,configurable:!0},dy:{value:f,enumerable:!0,configurable:!0},_:{value:s}})}function Xn(t){return!t.ctrlKey&&!t.button}function Gn(){return this.parentNode}function Vn(t,n){return null==n?{x:t.x,y:t.y}:n}function $n(){return navigator.maxTouchPoints||"ontouchstart"in this}function Wn(t,n,e){t.prototype=n.prototype=e,e.constructor=t}function Zn(t,n){var e=Object.create(t.prototype);for(var r in n)e[r]=n[r];return e}function Kn(){}Hn.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t};var Qn=.7,Jn=1/Qn,te="\\s*([+-]?\\d+)\\s*",ne="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",ee="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",re=/^#([0-9a-f]{3,8})$/,ie=new RegExp("^rgb\\("+[te,te,te]+"\\)$"),oe=new RegExp("^rgb\\("+[ee,ee,ee]+"\\)$"),ae=new RegExp("^rgba\\("+[te,te,te,ne]+"\\)$"),ue=new RegExp("^rgba\\("+[ee,ee,ee,ne]+"\\)$"),ce=new RegExp("^hsl\\("+[ne,ee,ee]+"\\)$"),fe=new RegExp("^hsla\\("+[ne,ee,ee,ne]+"\\)$"),se={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function le(){return this.rgb().formatHex()}function he(){return this.rgb().formatRgb()}function de(t){var n,e;return t=(t+"").trim().toLowerCase(),(n=re.exec(t))?(e=n[1].length,n=parseInt(n[1],16),6===e?pe(n):3===e?new _e(n>>8&15|n>>4&240,n>>4&15|240&n,(15&n)<<4|15&n,1):8===e?ge(n>>24&255,n>>16&255,n>>8&255,(255&n)/255):4===e?ge(n>>12&15|n>>8&240,n>>8&15|n>>4&240,n>>4&15|240&n,((15&n)<<4|15&n)/255):null):(n=ie.exec(t))?new _e(n[1],n[2],n[3],1):(n=oe.exec(t))?new _e(255*n[1]/100,255*n[2]/100,255*n[3]/100,1):(n=ae.exec(t))?ge(n[1],n[2],n[3],n[4]):(n=ue.exec(t))?ge(255*n[1]/100,255*n[2]/100,255*n[3]/100,n[4]):(n=ce.exec(t))?we(n[1],n[2]/100,n[3]/100,1):(n=fe.exec(t))?we(n[1],n[2]/100,n[3]/100,n[4]):se.hasOwnProperty(t)?pe(se[t]):"transparent"===t?new _e(NaN,NaN,NaN,0):null}function pe(t){return new _e(t>>16&255,t>>8&255,255&t,1)}function ge(t,n,e,r){return r<=0&&(t=n=e=NaN),new _e(t,n,e,r)}function ye(t){return t instanceof Kn||(t=de(t)),t?new _e((t=t.rgb()).r,t.g,t.b,t.opacity):new _e}function ve(t,n,e,r){return 1===arguments.length?ye(t):new _e(t,n,e,null==r?1:r)}function _e(t,n,e,r){this.r=+t,this.g=+n,this.b=+e,this.opacity=+r}function be(){return"#"+xe(this.r)+xe(this.g)+xe(this.b)}function me(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function xe(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function we(t,n,e,r){return r<=0?t=n=e=NaN:e<=0||e>=1?t=n=NaN:n<=0&&(t=NaN),new Te(t,n,e,r)}function Me(t){if(t instanceof Te)return new Te(t.h,t.s,t.l,t.opacity);if(t instanceof Kn||(t=de(t)),!t)return new Te;if(t instanceof Te)return t;var n=(t=t.rgb()).r/255,e=t.g/255,r=t.b/255,i=Math.min(n,e,r),o=Math.max(n,e,r),a=NaN,u=o-i,c=(o+i)/2;return u?(a=n===o?(e-r)/u+6*(e0&&c<1?0:a,new Te(a,u,c,t.opacity)}function Ae(t,n,e,r){return 1===arguments.length?Me(t):new Te(t,n,e,null==r?1:r)}function Te(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function Se(t,n,e){return 255*(t<60?n+(e-n)*t/60:t<180?e:t<240?n+(e-n)*(240-t)/60:n)}Wn(Kn,de,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:le,formatHex:le,formatHsl:function(){return Me(this).formatHsl()},formatRgb:he,toString:he}),Wn(_e,ve,Zn(Kn,{brighter:function(t){return t=null==t?Jn:Math.pow(Jn,t),new _e(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?Qn:Math.pow(Qn,t),new _e(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:be,formatHex:be,formatRgb:me,toString:me})),Wn(Te,Ae,Zn(Kn,{brighter:function(t){return t=null==t?Jn:Math.pow(Jn,t),new Te(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?Qn:Math.pow(Qn,t),new Te(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),n=isNaN(t)||isNaN(this.s)?0:this.s,e=this.l,r=e+(e<.5?e:1-e)*n,i=2*e-r;return new _e(Se(t>=240?t-240:t+120,i,r),Se(t,i,r),Se(t<120?t+240:t-120,i,r),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));const Ee=Math.PI/180,ke=180/Math.PI,Ne=.96422,Ce=.82521,Pe=4/29,ze=6/29,De=3*ze*ze;function qe(t){if(t instanceof Fe)return new Fe(t.l,t.a,t.b,t.opacity);if(t instanceof je)return He(t);t instanceof _e||(t=ye(t));var n,e,r=Be(t.r),i=Be(t.g),o=Be(t.b),a=Oe((.2225045*r+.7168786*i+.0606169*o)/1);return r===i&&i===o?n=e=a:(n=Oe((.4360747*r+.3850649*i+.1430804*o)/Ne),e=Oe((.0139322*r+.0971045*i+.7141733*o)/Ce)),new Fe(116*a-16,500*(n-a),200*(a-e),t.opacity)}function Re(t,n,e,r){return 1===arguments.length?qe(t):new Fe(t,n,e,null==r?1:r)}function Fe(t,n,e,r){this.l=+t,this.a=+n,this.b=+e,this.opacity=+r}function Oe(t){return t>.008856451679035631?Math.pow(t,1/3):t/De+Pe}function Ie(t){return t>ze?t*t*t:De*(t-Pe)}function Ue(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function Be(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function Ye(t){if(t instanceof je)return new je(t.h,t.c,t.l,t.opacity);if(t instanceof Fe||(t=qe(t)),0===t.a&&0===t.b)return new je(NaN,0=1?(e=1,n-1):Math.floor(e*n),i=t[r],o=t[r+1],a=r>0?t[r-1]:2*i-o,u=r()=>t;function ar(t,n){return function(e){return t+e*n}}function ur(t,n){var e=n-t;return e?ar(t,e>180||e<-180?e-360*Math.round(e/360):e):or(isNaN(t)?n:t)}function cr(t){return 1==(t=+t)?fr:function(n,e){return e-n?function(t,n,e){return t=Math.pow(t,e),n=Math.pow(n,e)-t,e=1/e,function(r){return Math.pow(t+r*n,e)}}(n,e,t):or(isNaN(n)?e:n)}}function fr(t,n){var e=n-t;return e?ar(t,e):or(isNaN(t)?n:t)}var sr=function t(n){var e=cr(n);function r(t,n){var r=e((t=ve(t)).r,(n=ve(n)).r),i=e(t.g,n.g),o=e(t.b,n.b),a=fr(t.opacity,n.opacity);return function(n){return t.r=r(n),t.g=i(n),t.b=o(n),t.opacity=a(n),t+""}}return r.gamma=t,r}(1);function lr(t){return function(n){var e,r,i=n.length,o=new Array(i),a=new Array(i),u=new Array(i);for(e=0;eo&&(i=n.slice(o,i),u[a]?u[a]+=i:u[++a]=i),(e=e[0])===(r=r[0])?u[a]?u[a]+=r:u[++a]=r:(u[++a]=null,c.push({i:a,x:_r(e,r)})),o=xr.lastIndex;return o180?n+=360:n-t>180&&(t+=360),o.push({i:e.push(i(e)+"rotate(",null,r)-2,x:_r(t,n)})):n&&e.push(i(e)+"rotate("+n+r)}(o.rotate,a.rotate,u,c),function(t,n,e,o){t!==n?o.push({i:e.push(i(e)+"skewX(",null,r)-2,x:_r(t,n)}):n&&e.push(i(e)+"skewX("+n+r)}(o.skewX,a.skewX,u,c),function(t,n,e,r,o,a){if(t!==e||n!==r){var u=o.push(i(o)+"scale(",null,",",null,")");a.push({i:u-4,x:_r(t,e)},{i:u-2,x:_r(n,r)})}else 1===e&&1===r||o.push(i(o)+"scale("+e+","+r+")")}(o.scaleX,o.scaleY,a.scaleX,a.scaleY,u,c),o=a=null,function(t){for(var n,e=-1,r=c.length;++e=0&&n._call.call(null,t),n=n._next;--Gr}function oi(){Zr=(Wr=Qr.now())+Kr,Gr=Vr=0;try{ii()}finally{Gr=0,function(){var t,n,e=Hr,r=1/0;for(;e;)e._call?(r>e._time&&(r=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:Hr=n);Xr=t,ui(r)}(),Zr=0}}function ai(){var t=Qr.now(),n=t-Wr;n>1e3&&(Kr-=n,Wr=t)}function ui(t){Gr||(Vr&&(Vr=clearTimeout(Vr)),t-Zr>24?(t<1/0&&(Vr=setTimeout(oi,t-Qr.now()-Kr)),$r&&($r=clearInterval($r))):($r||(Wr=Qr.now(),$r=setInterval(ai,1e3)),Gr=1,Jr(oi)))}function ci(t,n,e){var r=new ei;return n=null==n?0:+n,r.restart((e=>{r.stop(),t(e+n)}),n,e),r}ei.prototype=ri.prototype={constructor:ei,restart:function(t,n,e){if("function"!=typeof t)throw new TypeError("callback is not a function");e=(null==e?ti():+e)+(null==n?0:+n),this._next||Xr===this||(Xr?Xr._next=this:Hr=this,Xr=this),this._call=t,this._time=e,ui()},stop:function(){this._call&&(this._call=null,this._time=1/0,ui())}};var fi=pt("start","end","cancel","interrupt"),si=[];function li(t,n,e,r,i,o){var a=t.__transition;if(a){if(e in a)return}else t.__transition={};!function(t,n,e){var r,i=t.__transition;function o(t){e.state=1,e.timer.restart(a,e.delay,e.time),e.delay<=t&&a(t-e.delay)}function a(o){var f,s,l,h;if(1!==e.state)return c();for(f in i)if((h=i[f]).name===e.name){if(3===h.state)return ci(a);4===h.state?(h.state=6,h.timer.stop(),h.on.call("interrupt",t,t.__data__,h.index,h.group),delete i[f]):+f0)throw new Error("too late; already scheduled");return e}function di(t,n){var e=pi(t,n);if(e.state>3)throw new Error("too late; already running");return e}function pi(t,n){var e=t.__transition;if(!e||!(e=e[n]))throw new Error("transition not found");return e}function gi(t,n){var e,r,i,o=t.__transition,a=!0;if(o){for(i in n=null==n?null:n+"",o)(e=o[i]).name===n?(r=e.state>2&&e.state<5,e.state=6,e.timer.stop(),e.on.call(r?"interrupt":"cancel",t,t.__data__,e.index,e.group),delete o[i]):a=!1;a&&delete t.__transition}}function yi(t,n){var e,r;return function(){var i=di(this,t),o=i.tween;if(o!==e)for(var a=0,u=(r=e=o).length;a=0&&(t=t.slice(0,n)),!t||"start"===t}))}(n)?hi:di;return function(){var a=o(this,t),u=a.on;u!==r&&(i=(r=u).copy()).on(n,e),a.on=i}}var Fi=zn.prototype.constructor;function Oi(t){return function(){this.style.removeProperty(t)}}function Ii(t,n,e){return function(r){this.style.setProperty(t,n.call(this,r),e)}}function Ui(t,n,e){var r,i;function o(){var o=n.apply(this,arguments);return o!==i&&(r=(i=o)&&Ii(t,o,e)),r}return o._value=n,o}function Bi(t){return function(n){this.textContent=t.call(this,n)}}function Yi(t){var n,e;function r(){var r=t.apply(this,arguments);return r!==e&&(n=(e=r)&&Bi(r)),n}return r._value=t,r}var Li=0;function ji(t,n,e,r){this._groups=t,this._parents=n,this._name=e,this._id=r}function Hi(t){return zn().transition(t)}function Xi(){return++Li}var Gi=zn.prototype;ji.prototype=Hi.prototype={constructor:ji,select:function(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=St(t));for(var r=this._groups,i=r.length,o=new Array(i),a=0;a()=>t;function mo(t,{sourceEvent:n,target:e,selection:r,mode:i,dispatch:o}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},target:{value:e,enumerable:!0,configurable:!0},selection:{value:r,enumerable:!0,configurable:!0},mode:{value:i,enumerable:!0,configurable:!0},_:{value:o}})}function xo(t){t.stopImmediatePropagation()}function wo(t){t.preventDefault(),t.stopImmediatePropagation()}var Mo={name:"drag"},Ao={name:"space"},To={name:"handle"},So={name:"center"};const{abs:Eo,max:ko,min:No}=Math;function Co(t){return[+t[0],+t[1]]}function Po(t){return[Co(t[0]),Co(t[1])]}var zo={name:"x",handles:["w","e"].map(Bo),input:function(t,n){return null==t?null:[[+t[0],n[0][1]],[+t[1],n[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},Do={name:"y",handles:["n","s"].map(Bo),input:function(t,n){return null==t?null:[[n[0][0],+t[0]],[n[1][0],+t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},qo={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(Bo),input:function(t){return null==t?null:Po(t)},output:function(t){return t}},Ro={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Fo={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Oo={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},Io={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},Uo={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function Bo(t){return{type:t}}function Yo(t){return!t.ctrlKey&&!t.button}function Lo(){var t=this.ownerSVGElement||this;return t.hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function jo(){return navigator.maxTouchPoints||"ontouchstart"in this}function Ho(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function Xo(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}function Go(t){var n,e=Lo,r=Yo,i=jo,o=!0,a=pt("start","brush","end"),u=6;function c(n){var e=n.property("__brush",g).selectAll(".overlay").data([Bo("overlay")]);e.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Ro.overlay).merge(e).each((function(){var t=Ho(this).extent;Dn(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])})),n.selectAll(".selection").data([Bo("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Ro.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var r=n.selectAll(".handle").data(t.handles,(function(t){return t.type}));r.exit().remove(),r.enter().append("rect").attr("class",(function(t){return"handle handle--"+t.type})).attr("cursor",(function(t){return Ro[t.type]})),n.each(f).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",h).filter(i).on("touchstart.brush",h).on("touchmove.brush",d).on("touchend.brush touchcancel.brush",p).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function f(){var t=Dn(this),n=Ho(this).selection;n?(t.selectAll(".selection").style("display",null).attr("x",n[0][0]).attr("y",n[0][1]).attr("width",n[1][0]-n[0][0]).attr("height",n[1][1]-n[0][1]),t.selectAll(".handle").style("display",null).attr("x",(function(t){return"e"===t.type[t.type.length-1]?n[1][0]-u/2:n[0][0]-u/2})).attr("y",(function(t){return"s"===t.type[0]?n[1][1]-u/2:n[0][1]-u/2})).attr("width",(function(t){return"n"===t.type||"s"===t.type?n[1][0]-n[0][0]+u:u})).attr("height",(function(t){return"e"===t.type||"w"===t.type?n[1][1]-n[0][1]+u:u}))):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function s(t,n,e){var r=t.__brush.emitter;return!r||e&&r.clean?new l(t,n,e):r}function l(t,n,e){this.that=t,this.args=n,this.state=t.__brush,this.active=0,this.clean=e}function h(e){if((!n||e.touches)&&r.apply(this,arguments)){var i,a,u,c,l,h,d,p,g,y,v,_=this,b=e.target.__data__.type,m="selection"===(o&&e.metaKey?b="overlay":b)?Mo:o&&e.altKey?So:To,x=t===Do?null:Io[b],w=t===zo?null:Uo[b],M=Ho(_),A=M.extent,T=M.selection,S=A[0][0],E=A[0][1],k=A[1][0],N=A[1][1],C=0,P=0,z=x&&w&&o&&e.shiftKey,D=Array.from(e.touches||[e],(t=>{const n=t.identifier;return(t=In(t,_)).point0=t.slice(),t.identifier=n,t}));if("overlay"===b){T&&(g=!0);const n=[D[0],D[1]||D[0]];M.selection=T=[[i=t===Do?S:No(n[0][0],n[1][0]),u=t===zo?E:No(n[0][1],n[1][1])],[l=t===Do?k:ko(n[0][0],n[1][0]),d=t===zo?N:ko(n[0][1],n[1][1])]],D.length>1&&U()}else i=T[0][0],u=T[0][1],l=T[1][0],d=T[1][1];a=i,c=u,h=l,p=d;var q=Dn(_).attr("pointer-events","none"),R=q.selectAll(".overlay").attr("cursor",Ro[b]);gi(_);var F=s(_,arguments,!0).beforestart();if(e.touches)F.moved=I,F.ended=B;else{var O=Dn(e.view).on("mousemove.brush",I,!0).on("mouseup.brush",B,!0);o&&O.on("keydown.brush",Y,!0).on("keyup.brush",L,!0),Yn(e.view)}f.call(_),F.start(e,m.name)}function I(t){for(const n of t.changedTouches||[t])for(const t of D)t.identifier===n.identifier&&(t.cur=In(n,_));if(z&&!y&&!v&&1===D.length){const t=D[0];Eo(t.cur[0]-t[0])>Eo(t.cur[1]-t[1])?v=!0:y=!0}for(const t of D)t.cur&&(t[0]=t.cur[0],t[1]=t.cur[1]);g=!0,wo(t),U(t)}function U(t){const n=D[0],e=n.point0;var r;switch(C=n[0]-e[0],P=n[1]-e[1],m){case Ao:case Mo:x&&(C=ko(S-i,No(k-l,C)),a=i+C,h=l+C),w&&(P=ko(E-u,No(N-d,P)),c=u+P,p=d+P);break;case To:D[1]?(x&&(a=ko(S,No(k,D[0][0])),h=ko(S,No(k,D[1][0])),x=1),w&&(c=ko(E,No(N,D[0][1])),p=ko(E,No(N,D[1][1])),w=1)):(x<0?(C=ko(S-i,No(k-i,C)),a=i+C,h=l):x>0&&(C=ko(S-l,No(k-l,C)),a=i,h=l+C),w<0?(P=ko(E-u,No(N-u,P)),c=u+P,p=d):w>0&&(P=ko(E-d,No(N-d,P)),c=u,p=d+P));break;case So:x&&(a=ko(S,No(k,i-C*x)),h=ko(S,No(k,l+C*x))),w&&(c=ko(E,No(N,u-P*w)),p=ko(E,No(N,d+P*w)))}h0&&(i=a-C),w<0?d=p-P:w>0&&(u=c-P),m=Ao,R.attr("cursor",Ro.selection),U());break;default:return}wo(t)}function L(t){switch(t.keyCode){case 16:z&&(y=v=z=!1,U());break;case 18:m===So&&(x<0?l=h:x>0&&(i=a),w<0?d=p:w>0&&(u=c),m=To,U());break;case 32:m===Ao&&(t.altKey?(x&&(l=h-C*x,i=a+C*x),w&&(d=p-P*w,u=c+P*w),m=So):(x<0?l=h:x>0&&(i=a),w<0?d=p:w>0&&(u=c),m=To),R.attr("cursor",Ro[b]),U());break;default:return}wo(t)}}function d(t){s(this,arguments).moved(t)}function p(t){s(this,arguments).ended(t)}function g(){var n=this.__brush||{selection:null};return n.extent=Po(e.apply(this,arguments)),n.dim=t,n}return c.move=function(n,e){n.tween?n.on("start.brush",(function(t){s(this,arguments).beforestart().start(t)})).on("interrupt.brush end.brush",(function(t){s(this,arguments).end(t)})).tween("brush",(function(){var n=this,r=n.__brush,i=s(n,arguments),o=r.selection,a=t.input("function"==typeof e?e.apply(this,arguments):e,r.extent),u=Mr(o,a);function c(t){r.selection=1===t&&null===a?null:u(t),f.call(n),i.brush()}return null!==o&&null!==a?c:c(1)})):n.each((function(){var n=this,r=arguments,i=n.__brush,o=t.input("function"==typeof e?e.apply(n,r):e,i.extent),a=s(n,r).beforestart();gi(n),i.selection=null===o?null:o,f.call(n),a.start().brush().end()}))},c.clear=function(t){c.move(t,null)},l.prototype={beforestart:function(){return 1==++this.active&&(this.state.emitter=this,this.starting=!0),this},start:function(t,n){return this.starting?(this.starting=!1,this.emit("start",t,n)):this.emit("brush",t),this},brush:function(t,n){return this.emit("brush",t,n),this},end:function(t,n){return 0==--this.active&&(delete this.state.emitter,this.emit("end",t,n)),this},emit:function(n,e,r){var i=Dn(this.that).datum();a.call(n,this.that,new mo(n,{sourceEvent:e,target:c,selection:t.output(this.state.selection),mode:r,dispatch:a}),i)}},c.extent=function(t){return arguments.length?(e="function"==typeof t?t:bo(Po(t)),c):e},c.filter=function(t){return arguments.length?(r="function"==typeof t?t:bo(!!t),c):r},c.touchable=function(t){return arguments.length?(i="function"==typeof t?t:bo(!!t),c):i},c.handleSize=function(t){return arguments.length?(u=+t,c):u},c.keyModifiers=function(t){return arguments.length?(o=!!t,c):o},c.on=function(){var t=a.on.apply(a,arguments);return t===a?c:t},c}var Vo=Math.abs,$o=Math.cos,Wo=Math.sin,Zo=Math.PI,Ko=Zo/2,Qo=2*Zo,Jo=Math.max,ta=1e-12;function na(t,n){return Array.from({length:n-t},((n,e)=>t+e))}function ea(t){return function(n,e){return t(n.source.value+n.target.value,e.source.value+e.target.value)}}function ra(t,n){var e=0,r=null,i=null,o=null;function a(a){var u,c=a.length,f=new Array(c),s=na(0,c),l=new Array(c*c),h=new Array(c),d=0;a=Float64Array.from({length:c*c},n?(t,n)=>a[n%c][n/c|0]:(t,n)=>a[n/c|0][n%c]);for(let n=0;nr(f[t],f[n])));for(const e of s){const r=n;if(t){const t=na(1+~c,c).filter((t=>t<0?a[~t*c+e]:a[e*c+t]));i&&t.sort(((t,n)=>i(t<0?-a[~t*c+e]:a[e*c+t],n<0?-a[~n*c+e]:a[e*c+n])));for(const r of t)if(r<0){(l[~r*c+e]||(l[~r*c+e]={source:null,target:null})).target={index:e,startAngle:n,endAngle:n+=a[~r*c+e]*d,value:a[~r*c+e]}}else{(l[e*c+r]||(l[e*c+r]={source:null,target:null})).source={index:e,startAngle:n,endAngle:n+=a[e*c+r]*d,value:a[e*c+r]}}h[e]={index:e,startAngle:r,endAngle:n,value:f[e]}}else{const t=na(0,c).filter((t=>a[e*c+t]||a[t*c+e]));i&&t.sort(((t,n)=>i(a[e*c+t],a[e*c+n])));for(const r of t){let t;if(eaa)if(Math.abs(s*u-c*f)>aa&&i){var h=e-o,d=r-a,p=u*u+c*c,g=h*h+d*d,y=Math.sqrt(p),v=Math.sqrt(l),_=i*Math.tan((ia-Math.acos((p+l-g)/(2*y*v)))/2),b=_/v,m=_/y;Math.abs(b-1)>aa&&(this._+="L"+(t+b*f)+","+(n+b*s)),this._+="A"+i+","+i+",0,0,"+ +(s*h>f*d)+","+(this._x1=t+m*u)+","+(this._y1=n+m*c)}else this._+="L"+(this._x1=t)+","+(this._y1=n);else;},arc:function(t,n,e,r,i,o){t=+t,n=+n,o=!!o;var a=(e=+e)*Math.cos(r),u=e*Math.sin(r),c=t+a,f=n+u,s=1^o,l=o?r-i:i-r;if(e<0)throw new Error("negative radius: "+e);null===this._x1?this._+="M"+c+","+f:(Math.abs(this._x1-c)>aa||Math.abs(this._y1-f)>aa)&&(this._+="L"+c+","+f),e&&(l<0&&(l=l%oa+oa),l>ua?this._+="A"+e+","+e+",0,1,"+s+","+(t-a)+","+(n-u)+"A"+e+","+e+",0,1,"+s+","+(this._x1=c)+","+(this._y1=f):l>aa&&(this._+="A"+e+","+e+",0,"+ +(l>=ia)+","+s+","+(this._x1=t+e*Math.cos(i))+","+(this._y1=n+e*Math.sin(i))))},rect:function(t,n,e,r){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)+"h"+ +e+"v"+ +r+"h"+-e+"Z"},toString:function(){return this._}};var sa=Array.prototype.slice;function la(t){return function(){return t}}function ha(t){return t.source}function da(t){return t.target}function pa(t){return t.radius}function ga(t){return t.startAngle}function ya(t){return t.endAngle}function va(){return 0}function _a(){return 10}function ba(t){var n=ha,e=da,r=pa,i=pa,o=ga,a=ya,u=va,c=null;function f(){var f,s=n.apply(this,arguments),l=e.apply(this,arguments),h=u.apply(this,arguments)/2,d=sa.call(arguments),p=+r.apply(this,(d[0]=s,d)),g=o.apply(this,d)-Ko,y=a.apply(this,d)-Ko,v=+i.apply(this,(d[0]=l,d)),_=o.apply(this,d)-Ko,b=a.apply(this,d)-Ko;if(c||(c=f=fa()),h>ta&&(Vo(y-g)>2*h+ta?y>g?(g+=h,y-=h):(g-=h,y+=h):g=y=(g+y)/2,Vo(b-_)>2*h+ta?b>_?(_+=h,b-=h):(_-=h,b+=h):_=b=(_+b)/2),c.moveTo(p*$o(g),p*Wo(g)),c.arc(0,0,p,g,y),g!==_||y!==b)if(t){var m=+t.apply(this,arguments),x=v-m,w=(_+b)/2;c.quadraticCurveTo(0,0,x*$o(_),x*Wo(_)),c.lineTo(v*$o(w),v*Wo(w)),c.lineTo(x*$o(b),x*Wo(b))}else c.quadraticCurveTo(0,0,v*$o(_),v*Wo(_)),c.arc(0,0,v,_,b);if(c.quadraticCurveTo(0,0,p*$o(g),p*Wo(g)),c.closePath(),f)return c=null,f+""||null}return t&&(f.headRadius=function(n){return arguments.length?(t="function"==typeof n?n:la(+n),f):t}),f.radius=function(t){return arguments.length?(r=i="function"==typeof t?t:la(+t),f):r},f.sourceRadius=function(t){return arguments.length?(r="function"==typeof t?t:la(+t),f):r},f.targetRadius=function(t){return arguments.length?(i="function"==typeof t?t:la(+t),f):i},f.startAngle=function(t){return arguments.length?(o="function"==typeof t?t:la(+t),f):o},f.endAngle=function(t){return arguments.length?(a="function"==typeof t?t:la(+t),f):a},f.padAngle=function(t){return arguments.length?(u="function"==typeof t?t:la(+t),f):u},f.source=function(t){return arguments.length?(n=t,f):n},f.target=function(t){return arguments.length?(e=t,f):e},f.context=function(t){return arguments.length?(c=null==t?null:t,f):c},f}var ma=Array.prototype.slice;function xa(t,n){return t-n}var wa=t=>()=>t;function Ma(t,n){for(var e,r=-1,i=n.length;++rr!=d>r&&e<(h-f)*(r-s)/(d-s)+f&&(i=-i)}return i}function Ta(t,n,e){var r,i,o,a;return function(t,n,e){return(n[0]-t[0])*(e[1]-t[1])==(e[0]-t[0])*(n[1]-t[1])}(t,n,e)&&(i=t[r=+(t[0]===n[0])],o=e[r],a=n[r],i<=o&&o<=a||a<=o&&o<=i)}function Sa(){}var Ea=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function ka(){var t=1,n=1,e=I,r=u;function i(t){var n=e(t);if(Array.isArray(n))n=n.slice().sort(xa);else{var r=p(t),i=r[0],a=r[1];n=F(i,a,n),n=Z(Math.floor(i/n)*n,Math.floor(a/n)*n,n)}return n.map((function(n){return o(t,n)}))}function o(e,i){var o=[],u=[];return function(e,r,i){var o,u,c,f,s,l,h=new Array,d=new Array;o=u=-1,f=e[0]>=r,Ea[f<<1].forEach(p);for(;++o=r,Ea[c|f<<1].forEach(p);Ea[f<<0].forEach(p);for(;++u=r,s=e[u*t]>=r,Ea[f<<1|s<<2].forEach(p);++o=r,l=s,s=e[u*t+o+1]>=r,Ea[c|f<<1|s<<2|l<<3].forEach(p);Ea[f|s<<3].forEach(p)}o=-1,s=e[u*t]>=r,Ea[s<<2].forEach(p);for(;++o=r,Ea[s<<2|l<<3].forEach(p);function p(t){var n,e,r=[t[0][0]+o,t[0][1]+u],c=[t[1][0]+o,t[1][1]+u],f=a(r),s=a(c);(n=d[f])?(e=h[s])?(delete d[n.end],delete h[e.start],n===e?(n.ring.push(c),i(n.ring)):h[n.start]=d[e.end]={start:n.start,end:e.end,ring:n.ring.concat(e.ring)}):(delete d[n.end],n.ring.push(c),d[n.end=s]=n):(n=h[s])?(e=d[f])?(delete h[n.start],delete d[e.end],n===e?(n.ring.push(c),i(n.ring)):h[e.start]=d[n.end]={start:e.start,end:n.end,ring:e.ring.concat(n.ring)}):(delete h[n.start],n.ring.unshift(r),h[n.start=f]=n):h[f]=d[s]={start:f,end:s,ring:[r,c]}}Ea[s<<3].forEach(p)}(e,i,(function(t){r(t,e,i),function(t){for(var n=0,e=t.length,r=t[e-1][1]*t[0][0]-t[e-1][0]*t[0][1];++n0?o.push([t]):u.push(t)})),u.forEach((function(t){for(var n,e=0,r=o.length;e0&&a0&&u=0&&o>=0))throw new Error("invalid size");return t=r,n=o,i},i.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?wa(ma.call(t)):wa(t),i):e},i.smooth=function(t){return arguments.length?(r=t?u:Sa,i):r===u},i}function Na(t,n,e){for(var r=t.width,i=t.height,o=1+(e<<1),a=0;a=e&&(u>=o&&(c-=t.data[u-o+a*r]),n.data[u-e+a*r]=c/Math.min(u+1,r-1+o-u,o))}function Ca(t,n,e){for(var r=t.width,i=t.height,o=1+(e<<1),a=0;a=e&&(u>=o&&(c-=t.data[a+(u-o)*r]),n.data[a+(u-e)*r]=c/Math.min(u+1,i-1+o-u,o))}function Pa(t){return t[0]}function za(t){return t[1]}function Da(){return 1}const qa=Math.pow(2,-52),Ra=new Uint32Array(512);class Fa{static from(t,n=Ha,e=Xa){const r=t.length,i=new Float64Array(2*r);for(let o=0;o>1;if(n>0&&"number"!=typeof t[0])throw new Error("Expected coords to contain numbers.");this.coords=t;const e=Math.max(2*n-5,0);this._triangles=new Uint32Array(3*e),this._halfedges=new Int32Array(3*e),this._hashSize=Math.ceil(Math.sqrt(n)),this._hullPrev=new Uint32Array(n),this._hullNext=new Uint32Array(n),this._hullTri=new Uint32Array(n),this._hullHash=new Int32Array(this._hashSize).fill(-1),this._ids=new Uint32Array(n),this._dists=new Float64Array(n),this.update()}update(){const{coords:t,_hullPrev:n,_hullNext:e,_hullTri:r,_hullHash:i}=this,o=t.length>>1;let a=1/0,u=1/0,c=-1/0,f=-1/0;for(let n=0;nc&&(c=e),r>f&&(f=r),this._ids[n]=n}const s=(a+c)/2,l=(u+f)/2;let h,d,p,g=1/0;for(let n=0;n0&&(d=n,g=e)}let _=t[2*d],b=t[2*d+1],m=1/0;for(let n=0;nr&&(n[e++]=i,r=this._dists[i])}return this.hull=n.subarray(0,e),this.triangles=new Uint32Array(0),void(this.halfedges=new Uint32Array(0))}if(Ua(y,v,_,b,x,w)){const t=d,n=_,e=b;d=p,_=x,b=w,p=t,x=n,w=e}const M=function(t,n,e,r,i,o){const a=e-t,u=r-n,c=i-t,f=o-n,s=a*a+u*u,l=c*c+f*f,h=.5/(a*f-u*c);return{x:t+(f*s-u*l)*h,y:n+(a*l-c*s)*h}}(y,v,_,b,x,w);this._cx=M.x,this._cy=M.y;for(let n=0;n0&&Math.abs(f-o)<=qa&&Math.abs(s-a)<=qa)continue;if(o=f,a=s,c===h||c===d||c===p)continue;let l=0;for(let t=0,n=this._hashKey(f,s);t0?3-e:1+e)/4}(t-this._cx,n-this._cy)*this._hashSize)%this._hashSize}_legalize(t){const{_triangles:n,_halfedges:e,coords:r}=this;let i=0,o=0;for(;;){const a=e[t],u=t-t%3;if(o=u+(t+2)%3,-1===a){if(0===i)break;t=Ra[--i];continue}const c=a-a%3,f=u+(t+1)%3,s=c+(a+2)%3,l=n[o],h=n[t],d=n[f],p=n[s];if(Ba(r[2*l],r[2*l+1],r[2*h],r[2*h+1],r[2*d],r[2*d+1],r[2*p],r[2*p+1])){n[t]=p,n[a]=l;const r=e[s];if(-1===r){let n=this._hullStart;do{if(this._hullTri[n]===s){this._hullTri[n]=t;break}n=this._hullPrev[n]}while(n!==this._hullStart)}this._link(t,r),this._link(a,e[o]),this._link(o,s);const u=c+(a+1)%3;i=33306690738754716e-32*Math.abs(a+u)?a-u:0}function Ua(t,n,e,r,i,o){return(Ia(i,o,t,n,e,r)||Ia(t,n,e,r,i,o)||Ia(e,r,i,o,t,n))<0}function Ba(t,n,e,r,i,o,a,u){const c=t-a,f=n-u,s=e-a,l=r-u,h=i-a,d=o-u,p=s*s+l*l,g=h*h+d*d;return c*(l*g-p*d)-f*(s*g-p*h)+(c*c+f*f)*(s*d-l*h)<0}function Ya(t,n,e,r,i,o){const a=e-t,u=r-n,c=i-t,f=o-n,s=a*a+u*u,l=c*c+f*f,h=.5/(a*f-u*c),d=(f*s-u*l)*h,p=(a*l-c*s)*h;return d*d+p*p}function La(t,n,e,r){if(r-e<=20)for(let i=e+1;i<=r;i++){const r=t[i],o=n[r];let a=i-1;for(;a>=e&&n[t[a]]>o;)t[a+1]=t[a--];t[a+1]=r}else{let i=e+1,o=r;ja(t,e+r>>1,i),n[t[e]]>n[t[r]]&&ja(t,e,r),n[t[i]]>n[t[r]]&&ja(t,i,r),n[t[e]]>n[t[i]]&&ja(t,e,i);const a=t[i],u=n[a];for(;;){do{i++}while(n[t[i]]u);if(o=o-e?(La(t,n,i,r),La(t,n,e,o-1)):(La(t,n,e,o-1),La(t,n,i,r))}}function ja(t,n,e){const r=t[n];t[n]=t[e],t[e]=r}function Ha(t){return t[0]}function Xa(t){return t[1]}const Ga=1e-6;class Va{constructor(){this._x0=this._y0=this._x1=this._y1=null,this._=""}moveTo(t,n){this._+=`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}`}closePath(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")}lineTo(t,n){this._+=`L${this._x1=+t},${this._y1=+n}`}arc(t,n,e){const r=(t=+t)+(e=+e),i=n=+n;if(e<0)throw new Error("negative radius");null===this._x1?this._+=`M${r},${i}`:(Math.abs(this._x1-r)>Ga||Math.abs(this._y1-i)>Ga)&&(this._+="L"+r+","+i),e&&(this._+=`A${e},${e},0,1,1,${t-e},${n}A${e},${e},0,1,1,${this._x1=r},${this._y1=i}`)}rect(t,n,e,r){this._+=`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}h${+e}v${+r}h${-e}Z`}value(){return this._||null}}class $a{constructor(){this._=[]}moveTo(t,n){this._.push([t,n])}closePath(){this._.push(this._[0].slice())}lineTo(t,n){this._.push([t,n])}value(){return this._.length?this._:null}}class Wa{constructor(t,[n,e,r,i]=[0,0,960,500]){if(!((r=+r)>=(n=+n)&&(i=+i)>=(e=+e)))throw new Error("invalid bounds");this.delaunay=t,this._circumcenters=new Float64Array(2*t.points.length),this.vectors=new Float64Array(2*t.points.length),this.xmax=r,this.xmin=n,this.ymax=i,this.ymin=e,this._init()}update(){return this.delaunay.update(),this._init(),this}_init(){const{delaunay:{points:t,hull:n,triangles:e},vectors:r}=this,i=this.circumcenters=this._circumcenters.subarray(0,e.length/3*2);for(let n,r,o=0,a=0,u=e.length;o1;)i-=2;for(let t=2;t4)for(let t=0;t0){if(n>=this.ymax)return null;(i=(this.ymax-n)/r)0){if(t>=this.xmax)return null;(i=(this.xmax-t)/e)this.xmax?2:0)|(nthis.ymax?8:0)}}const Za=2*Math.PI,Ka=Math.pow;function Qa(t){return t[0]}function Ja(t){return t[1]}function tu(t,n,e){return[t+Math.sin(t+n)*e,n+Math.cos(t-n)*e]}class nu{static from(t,n=Qa,e=Ja,r){return new nu("length"in t?function(t,n,e,r){const i=t.length,o=new Float64Array(2*i);for(let a=0;a2&&function(t){const{triangles:n,coords:e}=t;for(let t=0;t1e-10)return!1}return!0}(t)){this.collinear=Int32Array.from({length:n.length/2},((t,n)=>n)).sort(((t,e)=>n[2*t]-n[2*e]||n[2*t+1]-n[2*e+1]));const t=this.collinear[0],e=this.collinear[this.collinear.length-1],r=[n[2*t],n[2*t+1],n[2*e],n[2*e+1]],i=1e-8*Math.hypot(r[3]-r[1],r[2]-r[0]);for(let t=0,e=n.length/2;t0&&(this.triangles=new Int32Array(3).fill(-1),this.halfedges=new Int32Array(3).fill(-1),this.triangles[0]=r[0],this.triangles[1]=r[1],this.triangles[2]=r[1],o[r[0]]=1,2===r.length&&(o[r[1]]=0))}voronoi(t){return new Wa(this,t)}*neighbors(t){const{inedges:n,hull:e,_hullIndex:r,halfedges:i,triangles:o,collinear:a}=this;if(a){const n=a.indexOf(t);return n>0&&(yield a[n-1]),void(n=0&&i!==e&&i!==r;)e=i;return i}_step(t,n,e){const{inedges:r,hull:i,_hullIndex:o,halfedges:a,triangles:u,points:c}=this;if(-1===r[t]||!c.length)return(t+1)%(c.length>>1);let f=t,s=Ka(n-c[2*t],2)+Ka(e-c[2*t+1],2);const l=r[t];let h=l;do{let r=u[h];const l=Ka(n-c[2*r],2)+Ka(e-c[2*r+1],2);if(l9999?"+"+au(t,6):au(t,4)}(t.getUTCFullYear())+"-"+au(t.getUTCMonth()+1,2)+"-"+au(t.getUTCDate(),2)+(i?"T"+au(n,2)+":"+au(e,2)+":"+au(r,2)+"."+au(i,3)+"Z":r?"T"+au(n,2)+":"+au(e,2)+":"+au(r,2)+"Z":e||n?"T"+au(n,2)+":"+au(e,2)+"Z":"")}function cu(t){var n=new RegExp('["'+t+"\n\r]"),e=t.charCodeAt(0);function r(t,n){var r,i=[],o=t.length,a=0,u=0,c=o<=0,f=!1;function s(){if(c)return ru;if(f)return f=!1,eu;var n,r,i=a;if(34===t.charCodeAt(i)){for(;a++=o?c=!0:10===(r=t.charCodeAt(a++))?f=!0:13===r&&(f=!0,10===t.charCodeAt(a)&&++a),t.slice(i+1,n-1).replace(/""/g,'"')}for(;aNu(n,e).then((n=>(new DOMParser).parseFromString(n,t)))}var Ru=qu("application/xml"),Fu=qu("text/html"),Ou=qu("image/svg+xml");function Iu(t,n,e,r){if(isNaN(n)||isNaN(e))return t;var i,o,a,u,c,f,s,l,h,d=t._root,p={data:r},g=t._x0,y=t._y0,v=t._x1,_=t._y1;if(!d)return t._root=p,t;for(;d.length;)if((f=n>=(o=(g+v)/2))?g=o:v=o,(s=e>=(a=(y+_)/2))?y=a:_=a,i=d,!(d=d[l=s<<1|f]))return i[l]=p,t;if(u=+t._x.call(null,d.data),c=+t._y.call(null,d.data),n===u&&e===c)return p.next=d,i?i[l]=p:t._root=p,t;do{i=i?i[l]=new Array(4):t._root=new Array(4),(f=n>=(o=(g+v)/2))?g=o:v=o,(s=e>=(a=(y+_)/2))?y=a:_=a}while((l=s<<1|f)==(h=(c>=a)<<1|u>=o));return i[h]=d,i[l]=p,t}function Uu(t,n,e,r,i){this.node=t,this.x0=n,this.y0=e,this.x1=r,this.y1=i}function Bu(t){return t[0]}function Yu(t){return t[1]}function Lu(t,n,e){var r=new ju(null==n?Bu:n,null==e?Yu:e,NaN,NaN,NaN,NaN);return null==t?r:r.addAll(t)}function ju(t,n,e,r,i,o){this._x=t,this._y=n,this._x0=e,this._y0=r,this._x1=i,this._y1=o,this._root=void 0}function Hu(t){for(var n={data:t.data},e=n;t=t.next;)e=e.next={data:t.data};return n}var Xu=Lu.prototype=ju.prototype;function Gu(t){return function(){return t}}function Vu(t){return 1e-6*(t()-.5)}function $u(t){return t.x+t.vx}function Wu(t){return t.y+t.vy}function Zu(t){return t.index}function Ku(t,n){var e=t.get(n);if(!e)throw new Error("node not found: "+n);return e}Xu.copy=function(){var t,n,e=new ju(this._x,this._y,this._x0,this._y0,this._x1,this._y1),r=this._root;if(!r)return e;if(!r.length)return e._root=Hu(r),e;for(t=[{source:r,target:e._root=new Array(4)}];r=t.pop();)for(var i=0;i<4;++i)(n=r.source[i])&&(n.length?t.push({source:n,target:r.target[i]=new Array(4)}):r.target[i]=Hu(n));return e},Xu.add=function(t){const n=+this._x.call(null,t),e=+this._y.call(null,t);return Iu(this.cover(n,e),n,e,t)},Xu.addAll=function(t){var n,e,r,i,o=t.length,a=new Array(o),u=new Array(o),c=1/0,f=1/0,s=-1/0,l=-1/0;for(e=0;es&&(s=r),il&&(l=i));if(c>s||f>l)return this;for(this.cover(c,f).cover(s,l),e=0;et||t>=i||r>n||n>=o;)switch(u=(nh||(o=c.y0)>d||(a=c.x1)=v)<<1|t>=y)&&(c=p[p.length-1],p[p.length-1]=p[p.length-1-f],p[p.length-1-f]=c)}else{var _=t-+this._x.call(null,g.data),b=n-+this._y.call(null,g.data),m=_*_+b*b;if(m=(u=(p+y)/2))?p=u:y=u,(s=a>=(c=(g+v)/2))?g=c:v=c,n=d,!(d=d[l=s<<1|f]))return this;if(!d.length)break;(n[l+1&3]||n[l+2&3]||n[l+3&3])&&(e=n,h=l)}for(;d.data!==t;)if(r=d,!(d=d.next))return this;return(i=d.next)&&delete d.next,r?(i?r.next=i:delete r.next,this):n?(i?n[l]=i:delete n[l],(d=n[0]||n[1]||n[2]||n[3])&&d===(n[3]||n[2]||n[1]||n[0])&&!d.length&&(e?e[h]=d:this._root=d),this):(this._root=i,this)},Xu.removeAll=function(t){for(var n=0,e=t.length;n1?r[0]+r.slice(2):r,+t.slice(e+1)]}function rc(t){return(t=ec(Math.abs(t)))?t[1]:NaN}var ic,oc=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function ac(t){if(!(n=oc.exec(t)))throw new Error("invalid format: "+t);var n;return new uc({fill:n[1],align:n[2],sign:n[3],symbol:n[4],zero:n[5],width:n[6],comma:n[7],precision:n[8]&&n[8].slice(1),trim:n[9],type:n[10]})}function uc(t){this.fill=void 0===t.fill?" ":t.fill+"",this.align=void 0===t.align?">":t.align+"",this.sign=void 0===t.sign?"-":t.sign+"",this.symbol=void 0===t.symbol?"":t.symbol+"",this.zero=!!t.zero,this.width=void 0===t.width?void 0:+t.width,this.comma=!!t.comma,this.precision=void 0===t.precision?void 0:+t.precision,this.trim=!!t.trim,this.type=void 0===t.type?"":t.type+""}function cc(t,n){var e=ec(t,n);if(!e)return t+"";var r=e[0],i=e[1];return i<0?"0."+new Array(-i).join("0")+r:r.length>i+1?r.slice(0,i+1)+"."+r.slice(i+1):r+new Array(i-r.length+2).join("0")}ac.prototype=uc.prototype,uc.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var fc={"%":(t,n)=>(100*t).toFixed(n),b:t=>Math.round(t).toString(2),c:t=>t+"",d:function(t){return Math.abs(t=Math.round(t))>=1e21?t.toLocaleString("en").replace(/,/g,""):t.toString(10)},e:(t,n)=>t.toExponential(n),f:(t,n)=>t.toFixed(n),g:(t,n)=>t.toPrecision(n),o:t=>Math.round(t).toString(8),p:(t,n)=>cc(100*t,n),r:cc,s:function(t,n){var e=ec(t,n);if(!e)return t+"";var r=e[0],i=e[1],o=i-(ic=3*Math.max(-8,Math.min(8,Math.floor(i/3))))+1,a=r.length;return o===a?r:o>a?r+new Array(o-a+1).join("0"):o>0?r.slice(0,o)+"."+r.slice(o):"0."+new Array(1-o).join("0")+ec(t,Math.max(0,n+o-1))[0]},X:t=>Math.round(t).toString(16).toUpperCase(),x:t=>Math.round(t).toString(16)};function sc(t){return t}var lc,hc=Array.prototype.map,dc=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function pc(t){var n,e,r=void 0===t.grouping||void 0===t.thousands?sc:(n=hc.call(t.grouping,Number),e=t.thousands+"",function(t,r){for(var i=t.length,o=[],a=0,u=n[0],c=0;i>0&&u>0&&(c+u+1>r&&(u=Math.max(1,r-c)),o.push(t.substring(i-=u,i+u)),!((c+=u+1)>r));)u=n[a=(a+1)%n.length];return o.reverse().join(e)}),i=void 0===t.currency?"":t.currency[0]+"",o=void 0===t.currency?"":t.currency[1]+"",a=void 0===t.decimal?".":t.decimal+"",u=void 0===t.numerals?sc:function(t){return function(n){return n.replace(/[0-9]/g,(function(n){return t[+n]}))}}(hc.call(t.numerals,String)),c=void 0===t.percent?"%":t.percent+"",f=void 0===t.minus?"−":t.minus+"",s=void 0===t.nan?"NaN":t.nan+"";function l(t){var n=(t=ac(t)).fill,e=t.align,l=t.sign,h=t.symbol,d=t.zero,p=t.width,g=t.comma,y=t.precision,v=t.trim,_=t.type;"n"===_?(g=!0,_="g"):fc[_]||(void 0===y&&(y=12),v=!0,_="g"),(d||"0"===n&&"="===e)&&(d=!0,n="0",e="=");var b="$"===h?i:"#"===h&&/[boxX]/.test(_)?"0"+_.toLowerCase():"",m="$"===h?o:/[%p]/.test(_)?c:"",x=fc[_],w=/[defgprs%]/.test(_);function M(t){var i,o,c,h=b,M=m;if("c"===_)M=x(t)+M,t="";else{var A=(t=+t)<0||1/t<0;if(t=isNaN(t)?s:x(Math.abs(t),y),v&&(t=function(t){t:for(var n,e=t.length,r=1,i=-1;r0&&(i=0)}return i>0?t.slice(0,i)+t.slice(n+1):t}(t)),A&&0==+t&&"+"!==l&&(A=!1),h=(A?"("===l?l:f:"-"===l||"("===l?"":l)+h,M=("s"===_?dc[8+ic/3]:"")+M+(A&&"("===l?")":""),w)for(i=-1,o=t.length;++i(c=t.charCodeAt(i))||c>57){M=(46===c?a+t.slice(i+1):t.slice(i))+M,t=t.slice(0,i);break}}g&&!d&&(t=r(t,1/0));var T=h.length+t.length+M.length,S=T>1)+h+t+M+S.slice(T);break;default:t=S+h+t+M}return u(t)}return y=void 0===y?6:/[gprs]/.test(_)?Math.max(1,Math.min(21,y)):Math.max(0,Math.min(20,y)),M.toString=function(){return t+""},M}return{format:l,formatPrefix:function(t,n){var e=l(((t=ac(t)).type="f",t)),r=3*Math.max(-8,Math.min(8,Math.floor(rc(n)/3))),i=Math.pow(10,-r),o=dc[8+r/3];return function(t){return e(i*t)+o}}}}function gc(n){return lc=pc(n),t.format=lc.format,t.formatPrefix=lc.formatPrefix,lc}function yc(t){return Math.max(0,-rc(Math.abs(t)))}function vc(t,n){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(rc(n)/3)))-rc(Math.abs(t)))}function _c(t,n){return t=Math.abs(t),n=Math.abs(n)-t,Math.max(0,rc(n)-rc(t))+1}t.format=void 0,t.formatPrefix=void 0,gc({thousands:",",grouping:[3],currency:["$",""]});var bc=1e-6,mc=1e-12,xc=Math.PI,wc=xc/2,Mc=xc/4,Ac=2*xc,Tc=180/xc,Sc=xc/180,Ec=Math.abs,kc=Math.atan,Nc=Math.atan2,Cc=Math.cos,Pc=Math.ceil,zc=Math.exp,Dc=Math.hypot,qc=Math.log,Rc=Math.pow,Fc=Math.sin,Oc=Math.sign||function(t){return t>0?1:t<0?-1:0},Ic=Math.sqrt,Uc=Math.tan;function Bc(t){return t>1?0:t<-1?xc:Math.acos(t)}function Yc(t){return t>1?wc:t<-1?-wc:Math.asin(t)}function Lc(t){return(t=Fc(t/2))*t}function jc(){}function Hc(t,n){t&&Gc.hasOwnProperty(t.type)&&Gc[t.type](t,n)}var Xc={Feature:function(t,n){Hc(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r=0?1:-1,i=r*e,o=Cc(n=(n*=Sc)/2+Mc),a=Fc(n),u=tf*a,c=Jc*o+u*Cc(i),f=u*r*Fc(i);df.add(Nc(f,c)),Qc=t,Jc=o,tf=a}function mf(t){return[Nc(t[1],t[0]),Yc(t[2])]}function xf(t){var n=t[0],e=t[1],r=Cc(e);return[r*Cc(n),r*Fc(n),Fc(e)]}function wf(t,n){return t[0]*n[0]+t[1]*n[1]+t[2]*n[2]}function Mf(t,n){return[t[1]*n[2]-t[2]*n[1],t[2]*n[0]-t[0]*n[2],t[0]*n[1]-t[1]*n[0]]}function Af(t,n){t[0]+=n[0],t[1]+=n[1],t[2]+=n[2]}function Tf(t,n){return[t[0]*n,t[1]*n,t[2]*n]}function Sf(t){var n=Ic(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=n,t[1]/=n,t[2]/=n}var Ef,kf,Nf,Cf,Pf,zf,Df,qf,Rf,Ff,Of,If,Uf,Bf,Yf,Lf,jf={point:Hf,lineStart:Gf,lineEnd:Vf,polygonStart:function(){jf.point=$f,jf.lineStart=Wf,jf.lineEnd=Zf,sf=new g,gf.polygonStart()},polygonEnd:function(){gf.polygonEnd(),jf.point=Hf,jf.lineStart=Gf,jf.lineEnd=Vf,df<0?(nf=-(rf=180),ef=-(of=90)):sf>bc?of=90:sf<-1e-6&&(ef=-90),hf[0]=nf,hf[1]=rf},sphere:function(){nf=-(rf=180),ef=-(of=90)}};function Hf(t,n){lf.push(hf=[nf=t,rf=t]),nof&&(of=n)}function Xf(t,n){var e=xf([t*Sc,n*Sc]);if(ff){var r=Mf(ff,e),i=Mf([r[1],-r[0],0],r);Sf(i),i=mf(i);var o,a=t-af,u=a>0?1:-1,c=i[0]*Tc*u,f=Ec(a)>180;f^(u*afof&&(of=o):f^(u*af<(c=(c+360)%360-180)&&cof&&(of=n)),f?tKf(nf,rf)&&(rf=t):Kf(t,rf)>Kf(nf,rf)&&(nf=t):rf>=nf?(trf&&(rf=t)):t>af?Kf(nf,t)>Kf(nf,rf)&&(rf=t):Kf(t,rf)>Kf(nf,rf)&&(nf=t)}else lf.push(hf=[nf=t,rf=t]);nof&&(of=n),ff=e,af=t}function Gf(){jf.point=Xf}function Vf(){hf[0]=nf,hf[1]=rf,jf.point=Hf,ff=null}function $f(t,n){if(ff){var e=t-af;sf.add(Ec(e)>180?e+(e>0?360:-360):e)}else uf=t,cf=n;gf.point(t,n),Xf(t,n)}function Wf(){gf.lineStart()}function Zf(){$f(uf,cf),gf.lineEnd(),Ec(sf)>bc&&(nf=-(rf=180)),hf[0]=nf,hf[1]=rf,ff=null}function Kf(t,n){return(n-=t)<0?n+360:n}function Qf(t,n){return t[0]-n[0]}function Jf(t,n){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:nxc?t+Math.round(-t/Ac)*Ac:t,n]}function ps(t,n,e){return(t%=Ac)?n||e?hs(ys(t),vs(n,e)):ys(t):n||e?vs(n,e):ds}function gs(t){return function(n,e){return[(n+=t)>xc?n-Ac:n<-xc?n+Ac:n,e]}}function ys(t){var n=gs(t);return n.invert=gs(-t),n}function vs(t,n){var e=Cc(t),r=Fc(t),i=Cc(n),o=Fc(n);function a(t,n){var a=Cc(n),u=Cc(t)*a,c=Fc(t)*a,f=Fc(n),s=f*e+u*r;return[Nc(c*i-s*o,u*e-f*r),Yc(s*i+c*o)]}return a.invert=function(t,n){var a=Cc(n),u=Cc(t)*a,c=Fc(t)*a,f=Fc(n),s=f*i-c*o;return[Nc(c*i+f*o,u*e+s*r),Yc(s*e-u*r)]},a}function _s(t){function n(n){return(n=t(n[0]*Sc,n[1]*Sc))[0]*=Tc,n[1]*=Tc,n}return t=ps(t[0]*Sc,t[1]*Sc,t.length>2?t[2]*Sc:0),n.invert=function(n){return(n=t.invert(n[0]*Sc,n[1]*Sc))[0]*=Tc,n[1]*=Tc,n},n}function bs(t,n,e,r,i,o){if(e){var a=Cc(n),u=Fc(n),c=r*e;null==i?(i=n+r*Ac,o=n-c/2):(i=ms(a,i),o=ms(a,o),(r>0?io)&&(i+=r*Ac));for(var f,s=i;r>0?s>o:s1&&n.push(n.pop().concat(n.shift()))},result:function(){var e=n;return n=[],t=null,e}}}function ws(t,n){return Ec(t[0]-n[0])=0;--o)i.point((s=f[o])[0],s[1]);else r(h.x,h.p.x,-1,i);h=h.p}f=(h=h.o).z,d=!d}while(!h.v);i.lineEnd()}}}function Ts(t){if(n=t.length){for(var n,e,r=0,i=t[0];++r=0?1:-1,E=S*T,k=E>xc,N=v*M;if(c.add(Nc(N*S*Fc(E),_*A+N*Cc(E))),a+=k?T+S*Ac:T,k^p>=e^x>=e){var C=Mf(xf(d),xf(m));Sf(C);var P=Mf(o,C);Sf(P);var z=(k^T>=0?-1:1)*Yc(P[2]);(r>z||r===z&&(C[0]||C[1]))&&(u+=k^T>=0?1:-1)}}return(a<-1e-6||a0){for(l||(i.polygonStart(),l=!0),i.lineStart(),t=0;t1&&2&c&&h.push(h.pop().concat(h.shift())),a.push(h.filter(Ns))}return h}}function Ns(t){return t.length>1}function Cs(t,n){return((t=t.x)[0]<0?t[1]-wc-bc:wc-t[1])-((n=n.x)[0]<0?n[1]-wc-bc:wc-n[1])}ds.invert=ds;var Ps=ks((function(){return!0}),(function(t){var n,e=NaN,r=NaN,i=NaN;return{lineStart:function(){t.lineStart(),n=1},point:function(o,a){var u=o>0?xc:-xc,c=Ec(o-e);Ec(c-xc)0?wc:-wc),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),t.point(o,r),n=0):i!==u&&c>=xc&&(Ec(e-i)bc?kc((Fc(n)*(o=Cc(r))*Fc(e)-Fc(r)*(i=Cc(n))*Fc(t))/(i*o*a)):(n+r)/2}(e,r,o,a),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),n=0),t.point(e=o,r=a),i=u},lineEnd:function(){t.lineEnd(),e=r=NaN},clean:function(){return 2-n}}}),(function(t,n,e,r){var i;if(null==t)i=e*wc,r.point(-xc,i),r.point(0,i),r.point(xc,i),r.point(xc,0),r.point(xc,-i),r.point(0,-i),r.point(-xc,-i),r.point(-xc,0),r.point(-xc,i);else if(Ec(t[0]-n[0])>bc){var o=t[0]0,i=Ec(n)>bc;function o(t,e){return Cc(t)*Cc(e)>n}function a(t,e,r){var i=[1,0,0],o=Mf(xf(t),xf(e)),a=wf(o,o),u=o[0],c=a-u*u;if(!c)return!r&&t;var f=n*a/c,s=-n*u/c,l=Mf(i,o),h=Tf(i,f);Af(h,Tf(o,s));var d=l,p=wf(h,d),g=wf(d,d),y=p*p-g*(wf(h,h)-1);if(!(y<0)){var v=Ic(y),_=Tf(d,(-p-v)/g);if(Af(_,h),_=mf(_),!r)return _;var b,m=t[0],x=e[0],w=t[1],M=e[1];x0^_[1]<(Ec(_[0]-m)xc^(m<=_[0]&&_[0]<=x)){var S=Tf(d,(-p+v)/g);return Af(S,h),[_,mf(S)]}}}function u(n,e){var i=r?t:xc-t,o=0;return n<-i?o|=1:n>i&&(o|=2),e<-i?o|=4:e>i&&(o|=8),o}return ks(o,(function(t){var n,e,c,f,s;return{lineStart:function(){f=c=!1,s=1},point:function(l,h){var d,p=[l,h],g=o(l,h),y=r?g?0:u(l,h):g?u(l+(l<0?xc:-xc),h):0;if(!n&&(f=c=g)&&t.lineStart(),g!==c&&(!(d=a(n,p))||ws(n,d)||ws(p,d))&&(p[2]=1),g!==c)s=0,g?(t.lineStart(),d=a(p,n),t.point(d[0],d[1])):(d=a(n,p),t.point(d[0],d[1],2),t.lineEnd()),n=d;else if(i&&n&&r^g){var v;y&e||!(v=a(p,n,!0))||(s=0,r?(t.lineStart(),t.point(v[0][0],v[0][1]),t.point(v[1][0],v[1][1]),t.lineEnd()):(t.point(v[1][0],v[1][1]),t.lineEnd(),t.lineStart(),t.point(v[0][0],v[0][1],3)))}!g||n&&ws(n,p)||t.point(p[0],p[1]),n=p,c=g,e=y},lineEnd:function(){c&&t.lineEnd(),n=null},clean:function(){return s|(f&&c)<<1}}}),(function(n,r,i,o){bs(o,t,e,i,n,r)}),r?[0,-t]:[-xc,t-xc])}var Ds,qs,Rs,Fs,Os=1e9,Is=-Os;function Us(t,n,e,r){function i(i,o){return t<=i&&i<=e&&n<=o&&o<=r}function o(i,o,u,f){var s=0,l=0;if(null==i||(s=a(i,u))!==(l=a(o,u))||c(i,o)<0^u>0)do{f.point(0===s||3===s?t:e,s>1?r:n)}while((s=(s+u+4)%4)!==l);else f.point(o[0],o[1])}function a(r,i){return Ec(r[0]-t)0?0:3:Ec(r[0]-e)0?2:1:Ec(r[1]-n)0?1:0:i>0?3:2}function u(t,n){return c(t.x,n.x)}function c(t,n){var e=a(t,1),r=a(n,1);return e!==r?e-r:0===e?n[1]-t[1]:1===e?t[0]-n[0]:2===e?t[1]-n[1]:n[0]-t[0]}return function(a){var c,f,s,l,h,d,p,g,y,v,_,b=a,m=xs(),x={point:w,lineStart:function(){x.point=M,f&&f.push(s=[]);v=!0,y=!1,p=g=NaN},lineEnd:function(){c&&(M(l,h),d&&y&&m.rejoin(),c.push(m.result()));x.point=w,y&&b.lineEnd()},polygonStart:function(){b=m,c=[],f=[],_=!0},polygonEnd:function(){var n=function(){for(var n=0,e=0,i=f.length;er&&(h-o)*(r-a)>(d-a)*(t-o)&&++n:d<=r&&(h-o)*(r-a)<(d-a)*(t-o)&&--n;return n}(),e=_&&n,i=(c=V(c)).length;(e||i)&&(a.polygonStart(),e&&(a.lineStart(),o(null,null,1,a),a.lineEnd()),i&&As(c,u,n,o,a),a.polygonEnd());b=a,c=f=s=null}};function w(t,n){i(t,n)&&b.point(t,n)}function M(o,a){var u=i(o,a);if(f&&s.push([o,a]),v)l=o,h=a,d=u,v=!1,u&&(b.lineStart(),b.point(o,a));else if(u&&y)b.point(o,a);else{var c=[p=Math.max(Is,Math.min(Os,p)),g=Math.max(Is,Math.min(Os,g))],m=[o=Math.max(Is,Math.min(Os,o)),a=Math.max(Is,Math.min(Os,a))];!function(t,n,e,r,i,o){var a,u=t[0],c=t[1],f=0,s=1,l=n[0]-u,h=n[1]-c;if(a=e-u,l||!(a>0)){if(a/=l,l<0){if(a0){if(a>s)return;a>f&&(f=a)}if(a=i-u,l||!(a<0)){if(a/=l,l<0){if(a>s)return;a>f&&(f=a)}else if(l>0){if(a0)){if(a/=h,h<0){if(a0){if(a>s)return;a>f&&(f=a)}if(a=o-c,h||!(a<0)){if(a/=h,h<0){if(a>s)return;a>f&&(f=a)}else if(h>0){if(a0&&(t[0]=u+f*l,t[1]=c+f*h),s<1&&(n[0]=u+s*l,n[1]=c+s*h),!0}}}}}(c,m,t,n,e,r)?u&&(b.lineStart(),b.point(o,a),_=!1):(y||(b.lineStart(),b.point(c[0],c[1])),b.point(m[0],m[1]),u||b.lineEnd(),_=!1)}p=o,g=a,y=u}return x}}var Bs={sphere:jc,point:jc,lineStart:function(){Bs.point=Ls,Bs.lineEnd=Ys},lineEnd:jc,polygonStart:jc,polygonEnd:jc};function Ys(){Bs.point=Bs.lineEnd=jc}function Ls(t,n){qs=t*=Sc,Rs=Fc(n*=Sc),Fs=Cc(n),Bs.point=js}function js(t,n){t*=Sc;var e=Fc(n*=Sc),r=Cc(n),i=Ec(t-qs),o=Cc(i),a=r*Fc(i),u=Fs*e-Rs*r*o,c=Rs*e+Fs*r*o;Ds.add(Nc(Ic(a*a+u*u),c)),qs=t,Rs=e,Fs=r}function Hs(t){return Ds=new g,Wc(t,Bs),+Ds}var Xs=[null,null],Gs={type:"LineString",coordinates:Xs};function Vs(t,n){return Xs[0]=t,Xs[1]=n,Hs(Gs)}var $s={Feature:function(t,n){return Zs(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r0&&(i=Vs(t[o],t[o-1]))>0&&e<=i&&r<=i&&(e+r-i)*(1-Math.pow((e-r)/i,2))bc})).map(c)).concat(Z(Pc(o/d)*d,i,d).filter((function(t){return Ec(t%g)>bc})).map(f))}return v.lines=function(){return _().map((function(t){return{type:"LineString",coordinates:t}}))},v.outline=function(){return{type:"Polygon",coordinates:[s(r).concat(l(a).slice(1),s(e).reverse().slice(1),l(u).reverse().slice(1))]}},v.extent=function(t){return arguments.length?v.extentMajor(t).extentMinor(t):v.extentMinor()},v.extentMajor=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],u=+t[0][1],a=+t[1][1],r>e&&(t=r,r=e,e=t),u>a&&(t=u,u=a,a=t),v.precision(y)):[[r,u],[e,a]]},v.extentMinor=function(e){return arguments.length?(n=+e[0][0],t=+e[1][0],o=+e[0][1],i=+e[1][1],n>t&&(e=n,n=t,t=e),o>i&&(e=o,o=i,i=e),v.precision(y)):[[n,o],[t,i]]},v.step=function(t){return arguments.length?v.stepMajor(t).stepMinor(t):v.stepMinor()},v.stepMajor=function(t){return arguments.length?(p=+t[0],g=+t[1],v):[p,g]},v.stepMinor=function(t){return arguments.length?(h=+t[0],d=+t[1],v):[h,d]},v.precision=function(h){return arguments.length?(y=+h,c=el(o,i,90),f=rl(n,t,y),s=el(u,a,90),l=rl(r,e,y),v):y},v.extentMajor([[-180,-89.999999],[180,89.999999]]).extentMinor([[-180,-80.000001],[180,80.000001]])}var ol,al,ul,cl,fl=t=>t,sl=new g,ll=new g,hl={point:jc,lineStart:jc,lineEnd:jc,polygonStart:function(){hl.lineStart=dl,hl.lineEnd=yl},polygonEnd:function(){hl.lineStart=hl.lineEnd=hl.point=jc,sl.add(Ec(ll)),ll=new g},result:function(){var t=sl/2;return sl=new g,t}};function dl(){hl.point=pl}function pl(t,n){hl.point=gl,ol=ul=t,al=cl=n}function gl(t,n){ll.add(cl*t-ul*n),ul=t,cl=n}function yl(){gl(ol,al)}var vl=1/0,_l=vl,bl=-vl,ml=bl,xl={point:function(t,n){tbl&&(bl=t);n<_l&&(_l=n);n>ml&&(ml=n)},lineStart:jc,lineEnd:jc,polygonStart:jc,polygonEnd:jc,result:function(){var t=[[vl,_l],[bl,ml]];return bl=ml=-(_l=vl=1/0),t}};var wl,Ml,Al,Tl,Sl=0,El=0,kl=0,Nl=0,Cl=0,Pl=0,zl=0,Dl=0,ql=0,Rl={point:Fl,lineStart:Ol,lineEnd:Bl,polygonStart:function(){Rl.lineStart=Yl,Rl.lineEnd=Ll},polygonEnd:function(){Rl.point=Fl,Rl.lineStart=Ol,Rl.lineEnd=Bl},result:function(){var t=ql?[zl/ql,Dl/ql]:Pl?[Nl/Pl,Cl/Pl]:kl?[Sl/kl,El/kl]:[NaN,NaN];return Sl=El=kl=Nl=Cl=Pl=zl=Dl=ql=0,t}};function Fl(t,n){Sl+=t,El+=n,++kl}function Ol(){Rl.point=Il}function Il(t,n){Rl.point=Ul,Fl(Al=t,Tl=n)}function Ul(t,n){var e=t-Al,r=n-Tl,i=Ic(e*e+r*r);Nl+=i*(Al+t)/2,Cl+=i*(Tl+n)/2,Pl+=i,Fl(Al=t,Tl=n)}function Bl(){Rl.point=Fl}function Yl(){Rl.point=jl}function Ll(){Hl(wl,Ml)}function jl(t,n){Rl.point=Hl,Fl(wl=Al=t,Ml=Tl=n)}function Hl(t,n){var e=t-Al,r=n-Tl,i=Ic(e*e+r*r);Nl+=i*(Al+t)/2,Cl+=i*(Tl+n)/2,Pl+=i,zl+=(i=Tl*t-Al*n)*(Al+t),Dl+=i*(Tl+n),ql+=3*i,Fl(Al=t,Tl=n)}function Xl(t){this._context=t}Xl.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._context.moveTo(t,n),this._point=1;break;case 1:this._context.lineTo(t,n);break;default:this._context.moveTo(t+this._radius,n),this._context.arc(t,n,this._radius,0,Ac)}},result:jc};var Gl,Vl,$l,Wl,Zl,Kl=new g,Ql={point:jc,lineStart:function(){Ql.point=Jl},lineEnd:function(){Gl&&th(Vl,$l),Ql.point=jc},polygonStart:function(){Gl=!0},polygonEnd:function(){Gl=null},result:function(){var t=+Kl;return Kl=new g,t}};function Jl(t,n){Ql.point=th,Vl=Wl=t,$l=Zl=n}function th(t,n){Wl-=t,Zl-=n,Kl.add(Ic(Wl*Wl+Zl*Zl)),Wl=t,Zl=n}function nh(){this._string=[]}function eh(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function rh(t){return function(n){var e=new ih;for(var r in t)e[r]=t[r];return e.stream=n,e}}function ih(){}function oh(t,n,e){var r=t.clipExtent&&t.clipExtent();return t.scale(150).translate([0,0]),null!=r&&t.clipExtent(null),Wc(e,t.stream(xl)),n(xl.result()),null!=r&&t.clipExtent(r),t}function ah(t,n,e){return oh(t,(function(e){var r=n[1][0]-n[0][0],i=n[1][1]-n[0][1],o=Math.min(r/(e[1][0]-e[0][0]),i/(e[1][1]-e[0][1])),a=+n[0][0]+(r-o*(e[1][0]+e[0][0]))/2,u=+n[0][1]+(i-o*(e[1][1]+e[0][1]))/2;t.scale(150*o).translate([a,u])}),e)}function uh(t,n,e){return ah(t,[[0,0],n],e)}function ch(t,n,e){return oh(t,(function(e){var r=+n,i=r/(e[1][0]-e[0][0]),o=(r-i*(e[1][0]+e[0][0]))/2,a=-i*e[0][1];t.scale(150*i).translate([o,a])}),e)}function fh(t,n,e){return oh(t,(function(e){var r=+n,i=r/(e[1][1]-e[0][1]),o=-i*e[0][0],a=(r-i*(e[1][1]+e[0][1]))/2;t.scale(150*i).translate([o,a])}),e)}nh.prototype={_radius:4.5,_circle:eh(4.5),pointRadius:function(t){return(t=+t)!==this._radius&&(this._radius=t,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._string.push("Z"),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._string.push("M",t,",",n),this._point=1;break;case 1:this._string.push("L",t,",",n);break;default:null==this._circle&&(this._circle=eh(this._radius)),this._string.push("M",t,",",n,this._circle)}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}return null}},ih.prototype={constructor:ih,point:function(t,n){this.stream.point(t,n)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};var sh=Cc(30*Sc);function lh(t,n){return+n?function(t,n){function e(r,i,o,a,u,c,f,s,l,h,d,p,g,y){var v=f-r,_=s-i,b=v*v+_*_;if(b>4*n&&g--){var m=a+h,x=u+d,w=c+p,M=Ic(m*m+x*x+w*w),A=Yc(w/=M),T=Ec(Ec(w)-1)n||Ec((v*N+_*C)/b-.5)>.3||a*h+u*d+c*p2?t[2]%360*Sc:0,N()):[y*Tc,v*Tc,_*Tc]},E.angle=function(t){return arguments.length?(b=t%360*Sc,N()):b*Tc},E.reflectX=function(t){return arguments.length?(m=t?-1:1,N()):m<0},E.reflectY=function(t){return arguments.length?(x=t?-1:1,N()):x<0},E.precision=function(t){return arguments.length?(a=lh(u,S=t*t),C()):Ic(S)},E.fitExtent=function(t,n){return ah(E,t,n)},E.fitSize=function(t,n){return uh(E,t,n)},E.fitWidth=function(t,n){return ch(E,t,n)},E.fitHeight=function(t,n){return fh(E,t,n)},function(){return n=t.apply(this,arguments),E.invert=n.invert&&k,N()}}function yh(t){var n=0,e=xc/3,r=gh(t),i=r(n,e);return i.parallels=function(t){return arguments.length?r(n=t[0]*Sc,e=t[1]*Sc):[n*Tc,e*Tc]},i}function vh(t,n){var e=Fc(t),r=(e+Fc(n))/2;if(Ec(r)0?n<-wc+bc&&(n=-wc+bc):n>wc-bc&&(n=wc-bc);var e=i/Rc(Sh(n),r);return[e*Fc(r*t),i-e*Cc(r*t)]}return o.invert=function(t,n){var e=i-n,o=Oc(r)*Ic(t*t+e*e),a=Nc(t,Ec(e))*Oc(e);return e*r<0&&(a-=xc*Oc(t)*Oc(e)),[a/r,2*kc(Rc(i/o,1/r))-wc]},o}function kh(t,n){return[t,n]}function Nh(t,n){var e=Cc(t),r=t===n?Fc(t):(e-Cc(n))/(n-t),i=e/r+t;if(Ec(r)=0;)n+=e[r].value;else n=1;t.value=n}function Xh(t,n){t instanceof Map?(t=[void 0,t],void 0===n&&(n=Vh)):void 0===n&&(n=Gh);for(var e,r,i,o,a,u=new Zh(t),c=[u];e=c.pop();)if((i=n(e.data))&&(a=(i=Array.from(i)).length))for(e.children=i,o=a-1;o>=0;--o)c.push(r=i[o]=new Zh(i[o])),r.parent=e,r.depth=e.depth+1;return u.eachBefore(Wh)}function Gh(t){return t.children}function Vh(t){return Array.isArray(t)?t[1]:null}function $h(t){void 0!==t.data.value&&(t.value=t.data.value),t.data=t.data.data}function Wh(t){var n=0;do{t.height=n}while((t=t.parent)&&t.height<++n)}function Zh(t){this.data=t,this.depth=this.height=0,this.parent=null}function Kh(t){for(var n,e,r=0,i=(t=function(t){for(var n,e,r=t.length;r;)e=Math.random()*r--|0,n=t[r],t[r]=t[e],t[e]=n;return t}(Array.from(t))).length,o=[];r0&&e*e>r*r+i*i}function nd(t,n){for(var e=0;e(a*=a)?(r=(f+a-i)/(2*f),o=Math.sqrt(Math.max(0,a/f-r*r)),e.x=t.x-r*u-o*c,e.y=t.y-r*c+o*u):(r=(f+i-a)/(2*f),o=Math.sqrt(Math.max(0,i/f-r*r)),e.x=n.x+r*u-o*c,e.y=n.y+r*c+o*u)):(e.x=n.x+e.r,e.y=n.y)}function ad(t,n){var e=t.r+n.r-1e-6,r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function ud(t){var n=t._,e=t.next._,r=n.r+e.r,i=(n.x*e.r+e.x*n.r)/r,o=(n.y*e.r+e.y*n.r)/r;return i*i+o*o}function cd(t){this._=t,this.next=null,this.previous=null}function fd(t){if(!(i=(t=function(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}(t)).length))return 0;var n,e,r,i,o,a,u,c,f,s,l;if((n=t[0]).x=0,n.y=0,!(i>1))return n.r;if(e=t[1],n.x=-e.r,e.x=n.r,e.y=0,!(i>2))return n.r+e.r;od(e,n,r=t[2]),n=new cd(n),e=new cd(e),r=new cd(r),n.next=r.previous=e,e.next=n.previous=r,r.next=e.previous=n;t:for(u=3;ubc&&--i>0);return[t/(.8707+(o=r*r)*(o*(o*o*o*(.003971-.001529*o)-.013791)-.131979)),r]},Ih.invert=xh(Yc),Uh.invert=xh((function(t){return 2*kc(t)})),Bh.invert=function(t,n){return[-n,2*kc(zc(t))-wc]},Zh.prototype=Xh.prototype={constructor:Zh,count:function(){return this.eachAfter(Hh)},each:function(t,n){let e=-1;for(const r of this)t.call(n,r,++e,this);return this},eachAfter:function(t,n){for(var e,r,i,o=this,a=[o],u=[],c=-1;o=a.pop();)if(u.push(o),e=o.children)for(r=0,i=e.length;r=0;--r)o.push(e[r]);return this},find:function(t,n){let e=-1;for(const r of this)if(t.call(n,r,++e,this))return r},sum:function(t){return this.eachAfter((function(n){for(var e=+t(n.data)||0,r=n.children,i=r&&r.length;--i>=0;)e+=r[i].value;n.value=e}))},sort:function(t){return this.eachBefore((function(n){n.children&&n.children.sort(t)}))},path:function(t){for(var n=this,e=function(t,n){if(t===n)return t;var e=t.ancestors(),r=n.ancestors(),i=null;t=e.pop(),n=r.pop();for(;t===n;)i=t,t=e.pop(),n=r.pop();return i}(n,t),r=[n];n!==e;)n=n.parent,r.push(n);for(var i=r.length;t!==e;)r.splice(i,0,t),t=t.parent;return r},ancestors:function(){for(var t=this,n=[t];t=t.parent;)n.push(t);return n},descendants:function(){return Array.from(this)},leaves:function(){var t=[];return this.eachBefore((function(n){n.children||t.push(n)})),t},links:function(){var t=this,n=[];return t.each((function(e){e!==t&&n.push({source:e.parent,target:e})})),n},copy:function(){return Xh(this).eachBefore($h)},[Symbol.iterator]:function*(){var t,n,e,r,i=this,o=[i];do{for(t=o.reverse(),o=[];i=t.pop();)if(yield i,n=i.children)for(e=0,r=n.length;eh&&(h=u),y=s*s*g,(d=Math.max(h/y,y/l))>p){s-=u;break}p=d}v.push(a={value:s,dice:c1?n:1)},e}(Pd);var qd=function t(n){function e(t,e,r,i,o){if((a=t._squarify)&&a.ratio===n)for(var a,u,c,f,s,l=-1,h=a.length,d=t.value;++l1?n:1)},e}(Pd);function Rd(t,n,e){return(n[0]-t[0])*(e[1]-t[1])-(n[1]-t[1])*(e[0]-t[0])}function Fd(t,n){return t[0]-n[0]||t[1]-n[1]}function Od(t){const n=t.length,e=[0,1];let r,i=2;for(r=2;r1&&Rd(t[e[i-2]],t[e[i-1]],t[r])<=0;)--i;e[i++]=r}return e.slice(0,i)}var Id=Math.random,Ud=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,1===arguments.length?(e=t,t=0):e-=t,function(){return n()*e+t}}return e.source=t,e}(Id),Bd=function t(n){function e(t,e){return arguments.length<2&&(e=t,t=0),t=Math.floor(t),e=Math.floor(e)-t,function(){return Math.floor(n()*e+t)}}return e.source=t,e}(Id),Yd=function t(n){function e(t,e){var r,i;return t=null==t?0:+t,e=null==e?1:+e,function(){var o;if(null!=r)o=r,r=null;else do{r=2*n()-1,o=2*n()-1,i=r*r+o*o}while(!i||i>1);return t+e*o*Math.sqrt(-2*Math.log(i)/i)}}return e.source=t,e}(Id),Ld=function t(n){var e=Yd.source(n);function r(){var t=e.apply(this,arguments);return function(){return Math.exp(t())}}return r.source=t,r}(Id),jd=function t(n){function e(t){return(t=+t)<=0?()=>0:function(){for(var e=0,r=t;r>1;--r)e+=n();return e+r*n()}}return e.source=t,e}(Id),Hd=function t(n){var e=jd.source(n);function r(t){if(0==(t=+t))return n;var r=e(t);return function(){return r()/t}}return r.source=t,r}(Id),Xd=function t(n){function e(t){return function(){return-Math.log1p(-n())/t}}return e.source=t,e}(Id),Gd=function t(n){function e(t){if((t=+t)<0)throw new RangeError("invalid alpha");return t=1/-t,function(){return Math.pow(1-n(),t)}}return e.source=t,e}(Id),Vd=function t(n){function e(t){if((t=+t)<0||t>1)throw new RangeError("invalid p");return function(){return Math.floor(n()+t)}}return e.source=t,e}(Id),$d=function t(n){function e(t){if((t=+t)<0||t>1)throw new RangeError("invalid p");return 0===t?()=>1/0:1===t?()=>1:(t=Math.log1p(-t),function(){return 1+Math.floor(Math.log1p(-n())/t)})}return e.source=t,e}(Id),Wd=function t(n){var e=Yd.source(n)();function r(t,r){if((t=+t)<0)throw new RangeError("invalid k");if(0===t)return()=>0;if(r=null==r?1:+r,1===t)return()=>-Math.log1p(-n())*r;var i=(t<1?t+1:t)-1/3,o=1/(3*Math.sqrt(i)),a=t<1?()=>Math.pow(n(),1/t):()=>1;return function(){do{do{var t=e(),u=1+o*t}while(u<=0);u*=u*u;var c=1-n()}while(c>=1-.0331*t*t*t*t&&Math.log(c)>=.5*t*t+i*(1-u+Math.log(u)));return i*u*a()*r}}return r.source=t,r}(Id),Zd=function t(n){var e=Wd.source(n);function r(t,n){var r=e(t),i=e(n);return function(){var t=r();return 0===t?0:t/(t+i())}}return r.source=t,r}(Id),Kd=function t(n){var e=$d.source(n),r=Zd.source(n);function i(t,n){return t=+t,(n=+n)>=1?()=>t:n<=0?()=>0:function(){for(var i=0,o=t,a=n;o*a>16&&o*(1-a)>16;){var u=Math.floor((o+1)*a),c=r(u,o-u+1)();c<=a?(i+=u,o-=u,a=(a-c)/(1-c)):(o=u-1,a/=c)}for(var f=a<.5,s=e(f?a:1-a),l=s(),h=0;l<=o;++h)l+=s();return i+(f?h:o-h)}}return i.source=t,i}(Id),Qd=function t(n){function e(t,e,r){var i;return 0==(t=+t)?i=t=>-Math.log(t):(t=1/t,i=n=>Math.pow(n,t)),e=null==e?0:+e,r=null==r?1:+r,function(){return e+r*i(-Math.log1p(-n()))}}return e.source=t,e}(Id),Jd=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,function(){return t+e*Math.tan(Math.PI*n())}}return e.source=t,e}(Id),tp=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,function(){var r=n();return t+e*Math.log(r/(1-r))}}return e.source=t,e}(Id),np=function t(n){var e=Wd.source(n),r=Kd.source(n);function i(t){return function(){for(var i=0,o=t;o>16;){var a=Math.floor(.875*o),u=e(a)();if(u>o)return i+r(a-1,o/u)();i+=a,o-=u}for(var c=-Math.log1p(-n()),f=0;c<=o;++f)c-=Math.log1p(-n());return i+f}}return i.source=t,i}(Id);const ep=1/4294967296;function rp(t,n){switch(arguments.length){case 0:break;case 1:this.range(t);break;default:this.range(n).domain(t)}return this}function ip(t,n){switch(arguments.length){case 0:break;case 1:"function"==typeof t?this.interpolator(t):this.range(t);break;default:this.domain(t),"function"==typeof n?this.interpolator(n):this.range(n)}return this}const op=Symbol("implicit");function ap(){var t=new Map,n=[],e=[],r=op;function i(i){var o=i+"",a=t.get(o);if(!a){if(r!==op)return r;t.set(o,a=n.push(i))}return e[(a-1)%e.length]}return i.domain=function(e){if(!arguments.length)return n.slice();n=[],t=new Map;for(const r of e){const e=r+"";t.has(e)||t.set(e,n.push(r))}return i},i.range=function(t){return arguments.length?(e=Array.from(t),i):e.slice()},i.unknown=function(t){return arguments.length?(r=t,i):r},i.copy=function(){return ap(n,e).unknown(r)},rp.apply(i,arguments),i}function up(){var t,n,e=ap().unknown(void 0),r=e.domain,i=e.range,o=0,a=1,u=!1,c=0,f=0,s=.5;function l(){var e=r().length,l=an&&(e=t,t=n,n=e),function(e){return Math.max(t,Math.min(n,e))}}(a[0],a[t-1])),r=t>2?pp:dp,i=o=null,l}function l(n){return null==n||isNaN(n=+n)?e:(i||(i=r(a.map(t),u,c)))(t(f(n)))}return l.invert=function(e){return f(n((o||(o=r(u,a.map(t),_r)))(e)))},l.domain=function(t){return arguments.length?(a=Array.from(t,fp),s()):a.slice()},l.range=function(t){return arguments.length?(u=Array.from(t),s()):u.slice()},l.rangeRound=function(t){return u=Array.from(t),c=Ar,s()},l.clamp=function(t){return arguments.length?(f=!!t||lp,s()):f!==lp},l.interpolate=function(t){return arguments.length?(c=t,s()):c},l.unknown=function(t){return arguments.length?(e=t,l):e},function(e,r){return t=e,n=r,s()}}function vp(){return yp()(lp,lp)}function _p(n,e,r,i){var o,a=F(n,e,r);switch((i=ac(null==i?",f":i)).type){case"s":var u=Math.max(Math.abs(n),Math.abs(e));return null!=i.precision||isNaN(o=vc(a,u))||(i.precision=o),t.formatPrefix(i,u);case"":case"e":case"g":case"p":case"r":null!=i.precision||isNaN(o=_c(a,Math.max(Math.abs(n),Math.abs(e))))||(i.precision=o-("e"===i.type));break;case"f":case"%":null!=i.precision||isNaN(o=yc(a))||(i.precision=o-2*("%"===i.type))}return t.format(i)}function bp(t){var n=t.domain;return t.ticks=function(t){var e=n();return q(e[0],e[e.length-1],null==t?10:t)},t.tickFormat=function(t,e){var r=n();return _p(r[0],r[r.length-1],null==t?10:t,e)},t.nice=function(e){null==e&&(e=10);var r,i,o=n(),a=0,u=o.length-1,c=o[a],f=o[u],s=10;for(f0;){if((i=R(c,f,e))===r)return o[a]=c,o[u]=f,n(o);if(i>0)c=Math.floor(c/i)*i,f=Math.ceil(f/i)*i;else{if(!(i<0))break;c=Math.ceil(c*i)/i,f=Math.floor(f*i)/i}r=i}return t},t}function mp(t,n){var e,r=0,i=(t=t.slice()).length-1,o=t[r],a=t[i];return a0){for(;h<=d;++h)for(s=1,f=r(h);sc)break;g.push(l)}}else for(;h<=d;++h)for(s=a-1,f=r(h);s>=1;--s)if(!((l=f*s)c)break;g.push(l)}2*g.length0))return u;do{u.push(a=new Date(+e)),n(e,o),t(e)}while(a=n)for(;t(n),!e(n);)n.setTime(n-1)}),(function(t,r){if(t>=t)if(r<0)for(;++r<=0;)for(;n(t,-1),!e(t););else for(;--r>=0;)for(;n(t,1),!e(t););}))},e&&(i.count=function(n,r){return Ip.setTime(+n),Up.setTime(+r),t(Ip),t(Up),Math.floor(e(Ip,Up))},i.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?i.filter(r?function(n){return r(n)%t==0}:function(n){return i.count(0,n)%t==0}):i:null}),i}var Yp=Bp((function(){}),(function(t,n){t.setTime(+t+n)}),(function(t,n){return n-t}));Yp.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?Bp((function(n){n.setTime(Math.floor(n/t)*t)}),(function(n,e){n.setTime(+n+e*t)}),(function(n,e){return(e-n)/t})):Yp:null};var Lp=Yp.range;const jp=1e3,Hp=6e4,Xp=36e5,Gp=864e5,Vp=6048e5,$p=2592e6,Wp=31536e6;var Zp=Bp((function(t){t.setTime(t-t.getMilliseconds())}),(function(t,n){t.setTime(+t+n*jp)}),(function(t,n){return(n-t)/jp}),(function(t){return t.getUTCSeconds()})),Kp=Zp.range,Qp=Bp((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*jp)}),(function(t,n){t.setTime(+t+n*Hp)}),(function(t,n){return(n-t)/Hp}),(function(t){return t.getMinutes()})),Jp=Qp.range,tg=Bp((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*jp-t.getMinutes()*Hp)}),(function(t,n){t.setTime(+t+n*Xp)}),(function(t,n){return(n-t)/Xp}),(function(t){return t.getHours()})),ng=tg.range,eg=Bp((t=>t.setHours(0,0,0,0)),((t,n)=>t.setDate(t.getDate()+n)),((t,n)=>(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Hp)/Gp),(t=>t.getDate()-1)),rg=eg.range;function ig(t){return Bp((function(n){n.setDate(n.getDate()-(n.getDay()+7-t)%7),n.setHours(0,0,0,0)}),(function(t,n){t.setDate(t.getDate()+7*n)}),(function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Hp)/Vp}))}var og=ig(0),ag=ig(1),ug=ig(2),cg=ig(3),fg=ig(4),sg=ig(5),lg=ig(6),hg=og.range,dg=ag.range,pg=ug.range,gg=cg.range,yg=fg.range,vg=sg.range,_g=lg.range,bg=Bp((function(t){t.setDate(1),t.setHours(0,0,0,0)}),(function(t,n){t.setMonth(t.getMonth()+n)}),(function(t,n){return n.getMonth()-t.getMonth()+12*(n.getFullYear()-t.getFullYear())}),(function(t){return t.getMonth()})),mg=bg.range,xg=Bp((function(t){t.setMonth(0,1),t.setHours(0,0,0,0)}),(function(t,n){t.setFullYear(t.getFullYear()+n)}),(function(t,n){return n.getFullYear()-t.getFullYear()}),(function(t){return t.getFullYear()}));xg.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Bp((function(n){n.setFullYear(Math.floor(n.getFullYear()/t)*t),n.setMonth(0,1),n.setHours(0,0,0,0)}),(function(n,e){n.setFullYear(n.getFullYear()+e*t)})):null};var wg=xg.range,Mg=Bp((function(t){t.setUTCSeconds(0,0)}),(function(t,n){t.setTime(+t+n*Hp)}),(function(t,n){return(n-t)/Hp}),(function(t){return t.getUTCMinutes()})),Ag=Mg.range,Tg=Bp((function(t){t.setUTCMinutes(0,0,0)}),(function(t,n){t.setTime(+t+n*Xp)}),(function(t,n){return(n-t)/Xp}),(function(t){return t.getUTCHours()})),Sg=Tg.range,Eg=Bp((function(t){t.setUTCHours(0,0,0,0)}),(function(t,n){t.setUTCDate(t.getUTCDate()+n)}),(function(t,n){return(n-t)/Gp}),(function(t){return t.getUTCDate()-1})),kg=Eg.range;function Ng(t){return Bp((function(n){n.setUTCDate(n.getUTCDate()-(n.getUTCDay()+7-t)%7),n.setUTCHours(0,0,0,0)}),(function(t,n){t.setUTCDate(t.getUTCDate()+7*n)}),(function(t,n){return(n-t)/Vp}))}var Cg=Ng(0),Pg=Ng(1),zg=Ng(2),Dg=Ng(3),qg=Ng(4),Rg=Ng(5),Fg=Ng(6),Og=Cg.range,Ig=Pg.range,Ug=zg.range,Bg=Dg.range,Yg=qg.range,Lg=Rg.range,jg=Fg.range,Hg=Bp((function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)}),(function(t,n){t.setUTCMonth(t.getUTCMonth()+n)}),(function(t,n){return n.getUTCMonth()-t.getUTCMonth()+12*(n.getUTCFullYear()-t.getUTCFullYear())}),(function(t){return t.getUTCMonth()})),Xg=Hg.range,Gg=Bp((function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),(function(t,n){t.setUTCFullYear(t.getUTCFullYear()+n)}),(function(t,n){return n.getUTCFullYear()-t.getUTCFullYear()}),(function(t){return t.getUTCFullYear()}));Gg.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Bp((function(n){n.setUTCFullYear(Math.floor(n.getUTCFullYear()/t)*t),n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)}),(function(n,e){n.setUTCFullYear(n.getUTCFullYear()+e*t)})):null};var Vg=Gg.range;function $g(t,n,r,i,o,a){const u=[[Zp,1,jp],[Zp,5,5e3],[Zp,15,15e3],[Zp,30,3e4],[a,1,Hp],[a,5,3e5],[a,15,9e5],[a,30,18e5],[o,1,Xp],[o,3,108e5],[o,6,216e5],[o,12,432e5],[i,1,Gp],[i,2,1728e5],[r,1,Vp],[n,1,$p],[n,3,7776e6],[t,1,Wp]];function c(n,r,i){const o=Math.abs(r-n)/i,a=e((([,,t])=>t)).right(u,o);if(a===u.length)return t.every(F(n/Wp,r/Wp,i));if(0===a)return Yp.every(Math.max(F(n,r,i),1));const[c,f]=u[o/u[a-1][2]=12)]},q:function(t){return 1+~~(t.getMonth()/3)},Q:bv,s:mv,S:By,u:Yy,U:Ly,V:Hy,w:Xy,W:Gy,x:null,X:null,y:Vy,Y:Wy,Z:Ky,"%":_v},m={a:function(t){return a[t.getUTCDay()]},A:function(t){return o[t.getUTCDay()]},b:function(t){return c[t.getUTCMonth()]},B:function(t){return u[t.getUTCMonth()]},c:null,d:Qy,e:Qy,f:rv,g:pv,G:yv,H:Jy,I:tv,j:nv,L:ev,m:iv,M:ov,p:function(t){return i[+(t.getUTCHours()>=12)]},q:function(t){return 1+~~(t.getUTCMonth()/3)},Q:bv,s:mv,S:av,u:uv,U:cv,V:sv,w:lv,W:hv,x:null,X:null,y:dv,Y:gv,Z:vv,"%":_v},x={a:function(t,n,e){var r=d.exec(n.slice(e));return r?(t.w=p.get(r[0].toLowerCase()),e+r[0].length):-1},A:function(t,n,e){var r=l.exec(n.slice(e));return r?(t.w=h.get(r[0].toLowerCase()),e+r[0].length):-1},b:function(t,n,e){var r=v.exec(n.slice(e));return r?(t.m=_.get(r[0].toLowerCase()),e+r[0].length):-1},B:function(t,n,e){var r=g.exec(n.slice(e));return r?(t.m=y.get(r[0].toLowerCase()),e+r[0].length):-1},c:function(t,e,r){return A(t,n,e,r)},d:wy,e:wy,f:ky,g:_y,G:vy,H:Ay,I:Ay,j:My,L:Ey,m:xy,M:Ty,p:function(t,n,e){var r=f.exec(n.slice(e));return r?(t.p=s.get(r[0].toLowerCase()),e+r[0].length):-1},q:my,Q:Cy,s:Py,S:Sy,u:dy,U:py,V:gy,w:hy,W:yy,x:function(t,n,r){return A(t,e,n,r)},X:function(t,n,e){return A(t,r,n,e)},y:_y,Y:vy,Z:by,"%":Ny};function w(t,n){return function(e){var r,i,o,a=[],u=-1,c=0,f=t.length;for(e instanceof Date||(e=new Date(+e));++u53)return null;"w"in o||(o.w=1),"Z"in o?(i=(r=ty(ny(o.y,0,1))).getUTCDay(),r=i>4||0===i?Pg.ceil(r):Pg(r),r=Eg.offset(r,7*(o.V-1)),o.y=r.getUTCFullYear(),o.m=r.getUTCMonth(),o.d=r.getUTCDate()+(o.w+6)%7):(i=(r=Jg(ny(o.y,0,1))).getDay(),r=i>4||0===i?ag.ceil(r):ag(r),r=eg.offset(r,7*(o.V-1)),o.y=r.getFullYear(),o.m=r.getMonth(),o.d=r.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),i="Z"in o?ty(ny(o.y,0,1)).getUTCDay():Jg(ny(o.y,0,1)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(i+5)%7:o.w+7*o.U-(i+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,ty(o)):Jg(o)}}function A(t,n,e,r){for(var i,o,a=0,u=n.length,c=e.length;a=c)return-1;if(37===(i=n.charCodeAt(a++))){if(i=n.charAt(a++),!(o=x[i in iy?n.charAt(a++):i])||(r=o(t,e,r))<0)return-1}else if(i!=e.charCodeAt(r++))return-1}return r}return b.x=w(e,b),b.X=w(r,b),b.c=w(n,b),m.x=w(e,m),m.X=w(r,m),m.c=w(n,m),{format:function(t){var n=w(t+="",b);return n.toString=function(){return t},n},parse:function(t){var n=M(t+="",!1);return n.toString=function(){return t},n},utcFormat:function(t){var n=w(t+="",m);return n.toString=function(){return t},n},utcParse:function(t){var n=M(t+="",!0);return n.toString=function(){return t},n}}}var ry,iy={"-":"",_:" ",0:"0"},oy=/^\s*\d+/,ay=/^%/,uy=/[\\^$*+?|[\]().{}]/g;function cy(t,n,e){var r=t<0?"-":"",i=(r?-t:t)+"",o=i.length;return r+(o[t.toLowerCase(),n])))}function hy(t,n,e){var r=oy.exec(n.slice(e,e+1));return r?(t.w=+r[0],e+r[0].length):-1}function dy(t,n,e){var r=oy.exec(n.slice(e,e+1));return r?(t.u=+r[0],e+r[0].length):-1}function py(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.U=+r[0],e+r[0].length):-1}function gy(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.V=+r[0],e+r[0].length):-1}function yy(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.W=+r[0],e+r[0].length):-1}function vy(t,n,e){var r=oy.exec(n.slice(e,e+4));return r?(t.y=+r[0],e+r[0].length):-1}function _y(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.y=+r[0]+(+r[0]>68?1900:2e3),e+r[0].length):-1}function by(t,n,e){var r=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(n.slice(e,e+6));return r?(t.Z=r[1]?0:-(r[2]+(r[3]||"00")),e+r[0].length):-1}function my(t,n,e){var r=oy.exec(n.slice(e,e+1));return r?(t.q=3*r[0]-3,e+r[0].length):-1}function xy(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.m=r[0]-1,e+r[0].length):-1}function wy(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.d=+r[0],e+r[0].length):-1}function My(t,n,e){var r=oy.exec(n.slice(e,e+3));return r?(t.m=0,t.d=+r[0],e+r[0].length):-1}function Ay(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.H=+r[0],e+r[0].length):-1}function Ty(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.M=+r[0],e+r[0].length):-1}function Sy(t,n,e){var r=oy.exec(n.slice(e,e+2));return r?(t.S=+r[0],e+r[0].length):-1}function Ey(t,n,e){var r=oy.exec(n.slice(e,e+3));return r?(t.L=+r[0],e+r[0].length):-1}function ky(t,n,e){var r=oy.exec(n.slice(e,e+6));return r?(t.L=Math.floor(r[0]/1e3),e+r[0].length):-1}function Ny(t,n,e){var r=ay.exec(n.slice(e,e+1));return r?e+r[0].length:-1}function Cy(t,n,e){var r=oy.exec(n.slice(e));return r?(t.Q=+r[0],e+r[0].length):-1}function Py(t,n,e){var r=oy.exec(n.slice(e));return r?(t.s=+r[0],e+r[0].length):-1}function zy(t,n){return cy(t.getDate(),n,2)}function Dy(t,n){return cy(t.getHours(),n,2)}function qy(t,n){return cy(t.getHours()%12||12,n,2)}function Ry(t,n){return cy(1+eg.count(xg(t),t),n,3)}function Fy(t,n){return cy(t.getMilliseconds(),n,3)}function Oy(t,n){return Fy(t,n)+"000"}function Iy(t,n){return cy(t.getMonth()+1,n,2)}function Uy(t,n){return cy(t.getMinutes(),n,2)}function By(t,n){return cy(t.getSeconds(),n,2)}function Yy(t){var n=t.getDay();return 0===n?7:n}function Ly(t,n){return cy(og.count(xg(t)-1,t),n,2)}function jy(t){var n=t.getDay();return n>=4||0===n?fg(t):fg.ceil(t)}function Hy(t,n){return t=jy(t),cy(fg.count(xg(t),t)+(4===xg(t).getDay()),n,2)}function Xy(t){return t.getDay()}function Gy(t,n){return cy(ag.count(xg(t)-1,t),n,2)}function Vy(t,n){return cy(t.getFullYear()%100,n,2)}function $y(t,n){return cy((t=jy(t)).getFullYear()%100,n,2)}function Wy(t,n){return cy(t.getFullYear()%1e4,n,4)}function Zy(t,n){var e=t.getDay();return cy((t=e>=4||0===e?fg(t):fg.ceil(t)).getFullYear()%1e4,n,4)}function Ky(t){var n=t.getTimezoneOffset();return(n>0?"-":(n*=-1,"+"))+cy(n/60|0,"0",2)+cy(n%60,"0",2)}function Qy(t,n){return cy(t.getUTCDate(),n,2)}function Jy(t,n){return cy(t.getUTCHours(),n,2)}function tv(t,n){return cy(t.getUTCHours()%12||12,n,2)}function nv(t,n){return cy(1+Eg.count(Gg(t),t),n,3)}function ev(t,n){return cy(t.getUTCMilliseconds(),n,3)}function rv(t,n){return ev(t,n)+"000"}function iv(t,n){return cy(t.getUTCMonth()+1,n,2)}function ov(t,n){return cy(t.getUTCMinutes(),n,2)}function av(t,n){return cy(t.getUTCSeconds(),n,2)}function uv(t){var n=t.getUTCDay();return 0===n?7:n}function cv(t,n){return cy(Cg.count(Gg(t)-1,t),n,2)}function fv(t){var n=t.getUTCDay();return n>=4||0===n?qg(t):qg.ceil(t)}function sv(t,n){return t=fv(t),cy(qg.count(Gg(t),t)+(4===Gg(t).getUTCDay()),n,2)}function lv(t){return t.getUTCDay()}function hv(t,n){return cy(Pg.count(Gg(t)-1,t),n,2)}function dv(t,n){return cy(t.getUTCFullYear()%100,n,2)}function pv(t,n){return cy((t=fv(t)).getUTCFullYear()%100,n,2)}function gv(t,n){return cy(t.getUTCFullYear()%1e4,n,4)}function yv(t,n){var e=t.getUTCDay();return cy((t=e>=4||0===e?qg(t):qg.ceil(t)).getUTCFullYear()%1e4,n,4)}function vv(){return"+0000"}function _v(){return"%"}function bv(t){return+t}function mv(t){return Math.floor(+t/1e3)}function xv(n){return ry=ey(n),t.timeFormat=ry.format,t.timeParse=ry.parse,t.utcFormat=ry.utcFormat,t.utcParse=ry.utcParse,ry}t.timeFormat=void 0,t.timeParse=void 0,t.utcFormat=void 0,t.utcParse=void 0,xv({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var wv="%Y-%m-%dT%H:%M:%S.%LZ";var Mv=Date.prototype.toISOString?function(t){return t.toISOString()}:t.utcFormat(wv);var Av=+new Date("2000-01-01T00:00:00.000Z")?function(t){var n=new Date(t);return isNaN(n)?null:n}:t.utcParse(wv);function Tv(t){return new Date(t)}function Sv(t){return t instanceof Date?+t:+new Date(+t)}function Ev(t,n,e,r,i,o,a,u,c,f){var s=vp(),l=s.invert,h=s.domain,d=f(".%L"),p=f(":%S"),g=f("%I:%M"),y=f("%I %p"),v=f("%a %d"),_=f("%b %d"),b=f("%B"),m=f("%Y");function x(t){return(c(t)hr(t[t.length-1]),Xv=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(Dv),Gv=Hv(Xv),Vv=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(Dv),$v=Hv(Vv),Wv=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(Dv),Zv=Hv(Wv),Kv=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(Dv),Qv=Hv(Kv),Jv=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(Dv),t_=Hv(Jv),n_=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(Dv),e_=Hv(n_),r_=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(Dv),i_=Hv(r_),o_=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(Dv),a_=Hv(o_),u_=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(Dv),c_=Hv(u_),f_=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(Dv),s_=Hv(f_),l_=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(Dv),h_=Hv(l_),d_=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(Dv),p_=Hv(d_),g_=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(Dv),y_=Hv(g_),v_=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(Dv),__=Hv(v_),b_=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(Dv),m_=Hv(b_),x_=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(Dv),w_=Hv(x_),M_=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(Dv),A_=Hv(M_),T_=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(Dv),S_=Hv(T_),E_=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(Dv),k_=Hv(E_),N_=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(Dv),C_=Hv(N_),P_=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(Dv),z_=Hv(P_),D_=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(Dv),q_=Hv(D_),R_=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(Dv),F_=Hv(R_),O_=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(Dv),I_=Hv(O_),U_=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(Dv),B_=Hv(U_),Y_=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(Dv),L_=Hv(Y_),j_=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(Dv),H_=Hv(j_);var X_=Lr(tr(300,.5,0),tr(-240,.5,1)),G_=Lr(tr(-100,.75,.35),tr(80,1.5,.8)),V_=Lr(tr(260,.75,.35),tr(80,1.5,.8)),$_=tr();var W_=ve(),Z_=Math.PI/3,K_=2*Math.PI/3;function Q_(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}}var J_=Q_(Dv("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),tb=Q_(Dv("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),nb=Q_(Dv("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),eb=Q_(Dv("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function rb(t){return function(){return t}}var ib=Math.abs,ob=Math.atan2,ab=Math.cos,ub=Math.max,cb=Math.min,fb=Math.sin,sb=Math.sqrt,lb=1e-12,hb=Math.PI,db=hb/2,pb=2*hb;function gb(t){return t>1?0:t<-1?hb:Math.acos(t)}function yb(t){return t>=1?db:t<=-1?-db:Math.asin(t)}function vb(t){return t.innerRadius}function _b(t){return t.outerRadius}function bb(t){return t.startAngle}function mb(t){return t.endAngle}function xb(t){return t&&t.padAngle}function wb(t,n,e,r,i,o,a,u){var c=e-t,f=r-n,s=a-i,l=u-o,h=l*c-s*f;if(!(h*hC*C+P*P&&(A=S,T=E),{cx:A,cy:T,x01:-s,y01:-l,x11:A*(i/x-1),y11:T*(i/x-1)}}var Ab=Array.prototype.slice;function Tb(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}function Sb(t){this._context=t}function Eb(t){return new Sb(t)}function kb(t){return t[0]}function Nb(t){return t[1]}function Cb(t,n){var e=rb(!0),r=null,i=Eb,o=null;function a(a){var u,c,f,s=(a=Tb(a)).length,l=!1;for(null==r&&(o=i(f=fa())),u=0;u<=s;++u)!(u=s;--l)u.point(y[l],v[l]);u.lineEnd(),u.areaEnd()}g&&(y[f]=+t(h,f,c),v[f]=+n(h,f,c),u.point(r?+r(h,f,c):y[f],e?+e(h,f,c):v[f]))}if(d)return u=null,d+""||null}function f(){return Cb().defined(i).curve(a).context(o)}return t="function"==typeof t?t:void 0===t?kb:rb(+t),n="function"==typeof n?n:rb(void 0===n?0:+n),e="function"==typeof e?e:void 0===e?Nb:rb(+e),c.x=function(n){return arguments.length?(t="function"==typeof n?n:rb(+n),r=null,c):t},c.x0=function(n){return arguments.length?(t="function"==typeof n?n:rb(+n),c):t},c.x1=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:rb(+t),c):r},c.y=function(t){return arguments.length?(n="function"==typeof t?t:rb(+t),e=null,c):n},c.y0=function(t){return arguments.length?(n="function"==typeof t?t:rb(+t),c):n},c.y1=function(t){return arguments.length?(e=null==t?null:"function"==typeof t?t:rb(+t),c):e},c.lineX0=c.lineY0=function(){return f().x(t).y(n)},c.lineY1=function(){return f().x(t).y(e)},c.lineX1=function(){return f().x(r).y(n)},c.defined=function(t){return arguments.length?(i="function"==typeof t?t:rb(!!t),c):i},c.curve=function(t){return arguments.length?(a=t,null!=o&&(u=a(o)),c):a},c.context=function(t){return arguments.length?(null==t?o=u=null:u=a(o=t),c):o},c}function zb(t,n){return nt?1:n>=t?0:NaN}function Db(t){return t}Sb.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._context.lineTo(t,n)}}};var qb=Fb(Eb);function Rb(t){this._curve=t}function Fb(t){function n(n){return new Rb(t(n))}return n._curve=t,n}function Ob(t){var n=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?n(Fb(t)):n()._curve},t}function Ib(){return Ob(Cb().curve(qb))}function Ub(){var t=Pb().curve(qb),n=t.curve,e=t.lineX0,r=t.lineX1,i=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return Ob(e())},delete t.lineX0,t.lineEndAngle=function(){return Ob(r())},delete t.lineX1,t.lineInnerRadius=function(){return Ob(i())},delete t.lineY0,t.lineOuterRadius=function(){return Ob(o())},delete t.lineY1,t.curve=function(t){return arguments.length?n(Fb(t)):n()._curve},t}function Bb(t,n){return[(n=+n)*Math.cos(t-=Math.PI/2),n*Math.sin(t)]}function Yb(t){return t.source}function Lb(t){return t.target}function jb(t){var n=Yb,e=Lb,r=kb,i=Nb,o=null;function a(){var a,u=Ab.call(arguments),c=n.apply(this,u),f=e.apply(this,u);if(o||(o=a=fa()),t(o,+r.apply(this,(u[0]=c,u)),+i.apply(this,u),+r.apply(this,(u[0]=f,u)),+i.apply(this,u)),a)return o=null,a+""||null}return a.source=function(t){return arguments.length?(n=t,a):n},a.target=function(t){return arguments.length?(e=t,a):e},a.x=function(t){return arguments.length?(r="function"==typeof t?t:rb(+t),a):r},a.y=function(t){return arguments.length?(i="function"==typeof t?t:rb(+t),a):i},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a}function Hb(t,n,e,r,i){t.moveTo(n,e),t.bezierCurveTo(n=(n+r)/2,e,n,i,r,i)}function Xb(t,n,e,r,i){t.moveTo(n,e),t.bezierCurveTo(n,e=(e+i)/2,r,e,r,i)}function Gb(t,n,e,r,i){var o=Bb(n,e),a=Bb(n,e=(e+i)/2),u=Bb(r,e),c=Bb(r,i);t.moveTo(o[0],o[1]),t.bezierCurveTo(a[0],a[1],u[0],u[1],c[0],c[1])}Rb.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,n){this._curve.point(n*Math.sin(t),n*-Math.cos(t))}};var Vb={draw:function(t,n){var e=Math.sqrt(n/hb);t.moveTo(e,0),t.arc(0,0,e,0,pb)}},$b={draw:function(t,n){var e=Math.sqrt(n/5)/2;t.moveTo(-3*e,-e),t.lineTo(-e,-e),t.lineTo(-e,-3*e),t.lineTo(e,-3*e),t.lineTo(e,-e),t.lineTo(3*e,-e),t.lineTo(3*e,e),t.lineTo(e,e),t.lineTo(e,3*e),t.lineTo(-e,3*e),t.lineTo(-e,e),t.lineTo(-3*e,e),t.closePath()}},Wb=Math.sqrt(1/3),Zb=2*Wb,Kb={draw:function(t,n){var e=Math.sqrt(n/Zb),r=e*Wb;t.moveTo(0,-e),t.lineTo(r,0),t.lineTo(0,e),t.lineTo(-r,0),t.closePath()}},Qb=Math.sin(hb/10)/Math.sin(7*hb/10),Jb=Math.sin(pb/10)*Qb,tm=-Math.cos(pb/10)*Qb,nm={draw:function(t,n){var e=Math.sqrt(.8908130915292852*n),r=Jb*e,i=tm*e;t.moveTo(0,-e),t.lineTo(r,i);for(var o=1;o<5;++o){var a=pb*o/5,u=Math.cos(a),c=Math.sin(a);t.lineTo(c*e,-u*e),t.lineTo(u*r-c*i,c*r+u*i)}t.closePath()}},em={draw:function(t,n){var e=Math.sqrt(n),r=-e/2;t.rect(r,r,e,e)}},rm=Math.sqrt(3),im={draw:function(t,n){var e=-Math.sqrt(n/(3*rm));t.moveTo(0,2*e),t.lineTo(-rm*e,-e),t.lineTo(rm*e,-e),t.closePath()}},om=-.5,am=Math.sqrt(3)/2,um=1/Math.sqrt(12),cm=3*(um/2+1),fm={draw:function(t,n){var e=Math.sqrt(n/cm),r=e/2,i=e*um,o=r,a=e*um+e,u=-o,c=a;t.moveTo(r,i),t.lineTo(o,a),t.lineTo(u,c),t.lineTo(om*r-am*i,am*r+om*i),t.lineTo(om*o-am*a,am*o+om*a),t.lineTo(om*u-am*c,am*u+om*c),t.lineTo(om*r+am*i,om*i-am*r),t.lineTo(om*o+am*a,om*a-am*o),t.lineTo(om*u+am*c,om*c-am*u),t.closePath()}},sm=[Vb,$b,Kb,em,nm,im,fm];function lm(){}function hm(t,n,e){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+n)/6,(t._y0+4*t._y1+e)/6)}function dm(t){this._context=t}function pm(t){this._context=t}function gm(t){this._context=t}dm.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:hm(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:hm(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},pm.prototype={areaStart:lm,areaEnd:lm,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x2,this._y2),this._context.closePath();break;case 2:this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break;case 3:this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x2=t,this._y2=n;break;case 1:this._point=2,this._x3=t,this._y3=n;break;case 2:this._point=3,this._x4=t,this._y4=n,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+n)/6);break;default:hm(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},gm.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var e=(this._x0+4*this._x1+t)/6,r=(this._y0+4*this._y1+n)/6;this._line?this._context.lineTo(e,r):this._context.moveTo(e,r);break;case 3:this._point=4;default:hm(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}};class ym{constructor(t,n){this._context=t,this._x=n}areaStart(){this._line=0}areaEnd(){this._line=NaN}lineStart(){this._point=0}lineEnd(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line}point(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._x?this._context.bezierCurveTo(this._x0=(this._x0+t)/2,this._y0,this._x0,n,t,n):this._context.bezierCurveTo(this._x0,this._y0=(this._y0+n)/2,t,this._y0,t,n)}this._x0=t,this._y0=n}}function vm(t,n){this._basis=new dm(t),this._beta=n}vm.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,n=this._y,e=t.length-1;if(e>0)for(var r,i=t[0],o=n[0],a=t[e]-i,u=n[e]-o,c=-1;++c<=e;)r=c/e,this._basis.point(this._beta*t[c]+(1-this._beta)*(i+r*a),this._beta*n[c]+(1-this._beta)*(o+r*u));this._x=this._y=null,this._basis.lineEnd()},point:function(t,n){this._x.push(+t),this._y.push(+n)}};var _m=function t(n){function e(t){return 1===n?new dm(t):new vm(t,n)}return e.beta=function(n){return t(+n)},e}(.85);function bm(t,n,e){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-n),t._y2+t._k*(t._y1-e),t._x2,t._y2)}function mm(t,n){this._context=t,this._k=(1-n)/6}mm.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:bm(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2,this._x1=t,this._y1=n;break;case 2:this._point=3;default:bm(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var xm=function t(n){function e(t){return new mm(t,n)}return e.tension=function(n){return t(+n)},e}(0);function wm(t,n){this._context=t,this._k=(1-n)/6}wm.prototype={areaStart:lm,areaEnd:lm,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:bm(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Mm=function t(n){function e(t){return new wm(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Am(t,n){this._context=t,this._k=(1-n)/6}Am.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:bm(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Tm=function t(n){function e(t){return new Am(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Sm(t,n,e){var r=t._x1,i=t._y1,o=t._x2,a=t._y2;if(t._l01_a>lb){var u=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,c=3*t._l01_a*(t._l01_a+t._l12_a);r=(r*u-t._x0*t._l12_2a+t._x2*t._l01_2a)/c,i=(i*u-t._y0*t._l12_2a+t._y2*t._l01_2a)/c}if(t._l23_a>lb){var f=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,s=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*f+t._x1*t._l23_2a-n*t._l12_2a)/s,a=(a*f+t._y1*t._l23_2a-e*t._l12_2a)/s}t._context.bezierCurveTo(r,i,o,a,t._x2,t._y2)}function Em(t,n){this._context=t,this._alpha=n}Em.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3;default:Sm(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var km=function t(n){function e(t){return n?new Em(t,n):new mm(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function Nm(t,n){this._context=t,this._alpha=n}Nm.prototype={areaStart:lm,areaEnd:lm,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Sm(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Cm=function t(n){function e(t){return n?new Nm(t,n):new wm(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function Pm(t,n){this._context=t,this._alpha=n}Pm.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Sm(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var zm=function t(n){function e(t){return n?new Pm(t,n):new Am(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function Dm(t){this._context=t}function qm(t){return t<0?-1:1}function Rm(t,n,e){var r=t._x1-t._x0,i=n-t._x1,o=(t._y1-t._y0)/(r||i<0&&-0),a=(e-t._y1)/(i||r<0&&-0),u=(o*i+a*r)/(r+i);return(qm(o)+qm(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(u))||0}function Fm(t,n){var e=t._x1-t._x0;return e?(3*(t._y1-t._y0)/e-n)/2:n}function Om(t,n,e){var r=t._x0,i=t._y0,o=t._x1,a=t._y1,u=(o-r)/3;t._context.bezierCurveTo(r+u,i+u*n,o-u,a-u*e,o,a)}function Im(t){this._context=t}function Um(t){this._context=new Bm(t)}function Bm(t){this._context=t}function Ym(t){this._context=t}function Lm(t){var n,e,r=t.length-1,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=t[0]+2*t[1],n=1;n=0;--n)i[n]=(a[n]-i[n+1])/o[n];for(o[r-1]=(t[r]+i[r-1])/2,n=0;n1)for(var e,r,i,o=1,a=t[n[0]],u=a.length;o=0;)e[n]=n;return e}function Gm(t,n){return t[n]}function Vm(t){const n=[];return n.key=t,n}function $m(t){var n=t.map(Wm);return Xm(t).sort((function(t,e){return n[t]-n[e]}))}function Wm(t){for(var n,e=-1,r=0,i=t.length,o=-1/0;++eo&&(o=n,r=e);return r}function Zm(t){var n=t.map(Km);return Xm(t).sort((function(t,e){return n[t]-n[e]}))}function Km(t){for(var n,e=0,r=-1,i=t.length;++r=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,n),this._context.lineTo(t,n);else{var e=this._x*(1-this._t)+t*this._t;this._context.lineTo(e,this._y),this._context.lineTo(e,n)}}this._x=t,this._y=n}};var Qm=t=>()=>t;function Jm(t,{sourceEvent:n,target:e,transform:r,dispatch:i}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},target:{value:e,enumerable:!0,configurable:!0},transform:{value:r,enumerable:!0,configurable:!0},_:{value:i}})}function tx(t,n,e){this.k=t,this.x=n,this.y=e}tx.prototype={constructor:tx,scale:function(t){return 1===t?this:new tx(this.k*t,this.x,this.y)},translate:function(t,n){return 0===t&0===n?this:new tx(this.k,this.x+this.k*t,this.y+this.k*n)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var nx=new tx(1,0,0);function ex(t){for(;!t.__zoom;)if(!(t=t.parentNode))return nx;return t.__zoom}function rx(t){t.stopImmediatePropagation()}function ix(t){t.preventDefault(),t.stopImmediatePropagation()}function ox(t){return!(t.ctrlKey&&"wheel"!==t.type||t.button)}function ax(){var t=this;return t instanceof SVGElement?(t=t.ownerSVGElement||t).hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]:[[0,0],[t.clientWidth,t.clientHeight]]}function ux(){return this.__zoom||nx}function cx(t){return-t.deltaY*(1===t.deltaMode?.05:t.deltaMode?1:.002)*(t.ctrlKey?10:1)}function fx(){return navigator.maxTouchPoints||"ontouchstart"in this}function sx(t,n,e){var r=t.invertX(n[0][0])-e[0][0],i=t.invertX(n[1][0])-e[1][0],o=t.invertY(n[0][1])-e[0][1],a=t.invertY(n[1][1])-e[1][1];return t.translate(i>r?(r+i)/2:Math.min(0,r)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}ex.prototype=tx.prototype,t.Adder=g,t.Delaunay=nu,t.FormatSpecifier=uc,t.InternMap=y,t.InternSet=v,t.Voronoi=Wa,t.active=function(t,n){var e,r,i=t.__transition;if(i)for(r in n=null==n?null:n+"",i)if((e=i[r]).state>1&&e.name===n)return new ji([[t]],_o,n,+r);return null},t.arc=function(){var t=vb,n=_b,e=rb(0),r=null,i=bb,o=mb,a=xb,u=null;function c(){var c,f,s=+t.apply(this,arguments),l=+n.apply(this,arguments),h=i.apply(this,arguments)-db,d=o.apply(this,arguments)-db,p=ib(d-h),g=d>h;if(u||(u=c=fa()),llb)if(p>pb-lb)u.moveTo(l*ab(h),l*fb(h)),u.arc(0,0,l,h,d,!g),s>lb&&(u.moveTo(s*ab(d),s*fb(d)),u.arc(0,0,s,d,h,g));else{var y,v,_=h,b=d,m=h,x=d,w=p,M=p,A=a.apply(this,arguments)/2,T=A>lb&&(r?+r.apply(this,arguments):sb(s*s+l*l)),S=cb(ib(l-s)/2,+e.apply(this,arguments)),E=S,k=S;if(T>lb){var N=yb(T/s*fb(A)),C=yb(T/l*fb(A));(w-=2*N)>lb?(m+=N*=g?1:-1,x-=N):(w=0,m=x=(h+d)/2),(M-=2*C)>lb?(_+=C*=g?1:-1,b-=C):(M=0,_=b=(h+d)/2)}var P=l*ab(_),z=l*fb(_),D=s*ab(x),q=s*fb(x);if(S>lb){var R,F=l*ab(b),O=l*fb(b),I=s*ab(m),U=s*fb(m);if(plb?k>lb?(y=Mb(I,U,P,z,l,k,g),v=Mb(F,O,D,q,l,k,g),u.moveTo(y.cx+y.x01,y.cy+y.y01),klb&&w>lb?E>lb?(y=Mb(D,q,F,O,s,-E,g),v=Mb(P,z,I,U,s,-E,g),u.lineTo(y.cx+y.x01,y.cy+y.y01),E>a,f=i+2*u>>a,s=wa(20);function l(r){var i=new Float32Array(c*f),l=new Float32Array(c*f);r.forEach((function(r,o,s){var l=+t(r,o,s)+u>>a,h=+n(r,o,s)+u>>a,d=+e(r,o,s);l>=0&&l=0&&h>a),Ca({width:c,height:f,data:l},{width:c,height:f,data:i},o>>a),Na({width:c,height:f,data:i},{width:c,height:f,data:l},o>>a),Ca({width:c,height:f,data:l},{width:c,height:f,data:i},o>>a),Na({width:c,height:f,data:i},{width:c,height:f,data:l},o>>a),Ca({width:c,height:f,data:l},{width:c,height:f,data:i},o>>a);var d=s(i);if(!Array.isArray(d)){var p=B(i);d=F(0,p,d),(d=Z(0,Math.floor(p/d)*d,d)).shift()}return ka().thresholds(d).size([c,f])(i).map(h)}function h(t){return t.value*=Math.pow(2,-2*a),t.coordinates.forEach(d),t}function d(t){t.forEach(p)}function p(t){t.forEach(g)}function g(t){t[0]=t[0]*Math.pow(2,a)-u,t[1]=t[1]*Math.pow(2,a)-u}function y(){return c=r+2*(u=3*o)>>a,f=i+2*u>>a,l}return l.x=function(n){return arguments.length?(t="function"==typeof n?n:wa(+n),l):t},l.y=function(t){return arguments.length?(n="function"==typeof t?t:wa(+t),l):n},l.weight=function(t){return arguments.length?(e="function"==typeof t?t:wa(+t),l):e},l.size=function(t){if(!arguments.length)return[r,i];var n=+t[0],e=+t[1];if(!(n>=0&&e>=0))throw new Error("invalid size");return r=n,i=e,y()},l.cellSize=function(t){if(!arguments.length)return 1<=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(t)/Math.LN2),y()},l.thresholds=function(t){return arguments.length?(s="function"==typeof t?t:Array.isArray(t)?wa(ma.call(t)):wa(t),l):s},l.bandwidth=function(t){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((t=+t)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*t*t+1)-1)/2),y()},l},t.contours=ka,t.count=c,t.create=function(t){return Dn(At(t).call(document.documentElement))},t.creator=At,t.cross=function(...t){const n="function"==typeof t[t.length-1]&&function(t){return n=>t(...n)}(t.pop()),e=(t=t.map(l)).map(f),r=t.length-1,i=new Array(r+1).fill(0),o=[];if(r<0||e.some(s))return o;for(;;){o.push(i.map(((n,e)=>t[e][n])));let a=r;for(;++i[a]===e[a];){if(0===a)return n?o.map(n):o;i[a--]=0}}},t.csv=Pu,t.csvFormat=hu,t.csvFormatBody=du,t.csvFormatRow=gu,t.csvFormatRows=pu,t.csvFormatValue=yu,t.csvParse=su,t.csvParseRows=lu,t.cubehelix=tr,t.cumsum=function(t,n){var e=0,r=0;return Float64Array.from(t,void 0===n?t=>e+=+t||0:i=>e+=+n(i,r++,t)||0)},t.curveBasis=function(t){return new dm(t)},t.curveBasisClosed=function(t){return new pm(t)},t.curveBasisOpen=function(t){return new gm(t)},t.curveBumpX=function(t){return new ym(t,!0)},t.curveBumpY=function(t){return new ym(t,!1)},t.curveBundle=_m,t.curveCardinal=xm,t.curveCardinalClosed=Mm,t.curveCardinalOpen=Tm,t.curveCatmullRom=km,t.curveCatmullRomClosed=Cm,t.curveCatmullRomOpen=zm,t.curveLinear=Eb,t.curveLinearClosed=function(t){return new Dm(t)},t.curveMonotoneX=function(t){return new Im(t)},t.curveMonotoneY=function(t){return new Um(t)},t.curveNatural=function(t){return new Ym(t)},t.curveStep=function(t){return new jm(t,.5)},t.curveStepAfter=function(t){return new jm(t,1)},t.curveStepBefore=function(t){return new jm(t,0)},t.descending=function(t,n){return nt?1:n>=t?0:NaN},t.deviation=d,t.difference=function(t,...n){t=new Set(t);for(const e of n)for(const n of e)t.delete(n);return t},t.disjoint=function(t,n){const e=n[Symbol.iterator](),r=new Set;for(const n of t){if(r.has(n))return!1;let t,i;for(;({value:t,done:i}=e.next())&&!i;){if(Object.is(n,t))return!1;r.add(t)}}return!0},t.dispatch=pt,t.drag=function(){var t,n,e,r,i=Xn,o=Gn,a=Vn,u=$n,c={},f=pt("start","drag","end"),s=0,l=0;function h(t){t.on("mousedown.drag",d).filter(u).on("touchstart.drag",y).on("touchmove.drag",v).on("touchend.drag touchcancel.drag",_).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function d(a,u){if(!r&&i.call(this,a,u)){var c=b(this,o.call(this,a,u),a,u,"mouse");c&&(Dn(a.view).on("mousemove.drag",p,!0).on("mouseup.drag",g,!0),Yn(a.view),Un(a),e=!1,t=a.clientX,n=a.clientY,c("start",a))}}function p(r){if(Bn(r),!e){var i=r.clientX-t,o=r.clientY-n;e=i*i+o*o>l}c.mouse("drag",r)}function g(t){Dn(t.view).on("mousemove.drag mouseup.drag",null),Ln(t.view,e),Bn(t),c.mouse("end",t)}function y(t,n){if(i.call(this,t,n)){var e,r,a=t.changedTouches,u=o.call(this,t,n),c=a.length;for(e=0;e+t,t.easePoly=Ki,t.easePolyIn=Wi,t.easePolyInOut=Ki,t.easePolyOut=Zi,t.easeQuad=Vi,t.easeQuadIn=function(t){return t*t},t.easeQuadInOut=Vi,t.easeQuadOut=function(t){return t*(2-t)},t.easeSin=to,t.easeSinIn=function(t){return 1==+t?1:1-Math.cos(t*Ji)},t.easeSinInOut=to,t.easeSinOut=function(t){return Math.sin(t*Ji)},t.every=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");let e=-1;for(const r of t)if(!n(r,++e,t))return!1;return!0},t.extent=p,t.fcumsum=function(t,n){const e=new g;let r=-1;return Float64Array.from(t,void 0===n?t=>e.add(+t||0):i=>e.add(+n(i,++r,t)||0))},t.filter=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");const e=[];let r=-1;for(const i of t)n(i,++r,t)&&e.push(i);return e},t.forceCenter=function(t,n){var e,r=1;function i(){var i,o,a=e.length,u=0,c=0;for(i=0;if+p||os+p||ac.index){var g=f-u.x-u.vx,y=s-u.y-u.vy,v=g*g+y*y;vt.r&&(t.r=t[n].r)}function c(){if(n){var r,i,o=n.length;for(e=new Array(o),r=0;r[u(t,n,r),t])));for(a=0,i=new Array(f);a=u)){(t.data!==n||t.next)&&(0===l&&(p+=(l=Vu(e))*l),0===h&&(p+=(h=Vu(e))*h),p(t=(1664525*t+1013904223)%Qu)/Qu}();function l(){h(),f.call("tick",n),e1?(null==e?u.delete(t):u.set(t,p(e)),n):u.get(t)},find:function(n,e,r){var i,o,a,u,c,f=0,s=t.length;for(null==r?r=1/0:r*=r,f=0;f1?(f.on(t,e),n):f.on(t)}}},t.forceX=function(t){var n,e,r,i=Gu(.1);function o(t){for(var i,o=0,a=n.length;o=.12&&i<.234&&r>=-.425&&r<-.214?u:i>=.166&&i<.234&&r>=-.214&&r<-.115?c:a).invert(t)},s.stream=function(e){return t&&n===e?t:(r=[a.stream(n=e),u.stream(e),c.stream(e)],i=r.length,t={point:function(t,n){for(var e=-1;++eKf(r[0],r[1])&&(r[1]=i[1]),Kf(i[0],r[1])>Kf(r[0],r[1])&&(r[0]=i[0])):o.push(r=i);for(a=-1/0,n=0,r=o[e=o.length-1];n<=e;r=i,++n)i=o[n],(u=Kf(r[1],i[0]))>a&&(a=u,nf=i[0],rf=r[1])}return lf=hf=null,nf===1/0||ef===1/0?[[NaN,NaN],[NaN,NaN]]:[[nf,ef],[rf,of]]},t.geoCentroid=function(t){Ef=kf=Nf=Cf=Pf=zf=Df=qf=0,Rf=new g,Ff=new g,Of=new g,Wc(t,ts);var n=+Rf,e=+Ff,r=+Of,i=Dc(n,e,r);return i2?t[2]+90:90]):[(t=e())[0],t[1],t[2]-90]},e([0,0,90]).scale(159.155)},t.geoTransverseMercatorRaw=Bh,t.gray=function(t,n){return new Fe(t,0,0,null==n?1:n)},t.greatest=function(t,e=n){let r,i=!1;if(1===e.length){let o;for(const a of t){const t=e(a);(i?n(t,o)>0:0===n(t,t))&&(r=a,o=t,i=!0)}}else for(const n of t)(i?e(n,r)>0:0===e(n,n))&&(r=n,i=!0);return r},t.greatestIndex=function(t,e=n){if(1===e.length)return G(t,e);let r,i=-1,o=-1;for(const n of t)++o,(i<0?0===e(n,n):e(n,r)>0)&&(r=n,i=o);return i},t.group=M,t.groupSort=function(t,e,r){return(1===e.length?k(A(t,e,r),(([t,e],[r,i])=>n(e,i)||n(t,r))):k(M(t,r),(([t,r],[i,o])=>e(r,o)||n(t,i)))).map((([t])=>t))},t.groups=function(t,...n){return S(t,Array.from,w,n)},t.hcl=Le,t.hierarchy=Xh,t.histogram=U,t.hsl=Ae,t.html=Fu,t.image=function(t,n){return new Promise((function(e,r){var i=new Image;for(var o in n)i[o]=n[o];i.onerror=r,i.onload=function(){e(i)},i.src=t}))},t.index=function(t,...n){return S(t,w,T,n)},t.indexes=function(t,...n){return S(t,Array.from,T,n)},t.interpolate=Mr,t.interpolateArray=function(t,n){return(gr(n)?pr:yr)(t,n)},t.interpolateBasis=rr,t.interpolateBasisClosed=ir,t.interpolateBlues=q_,t.interpolateBrBG=Gv,t.interpolateBuGn=s_,t.interpolateBuPu=h_,t.interpolateCividis=function(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-t*(35.34-t*(2381.73-t*(6402.7-t*(7024.72-2710.57*t)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+t*(170.73+t*(52.82-t*(131.46-t*(176.58-67.37*t)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+t*(442.36-t*(2482.43-t*(6167.24-t*(6614.94-2475.67*t)))))))+")"},t.interpolateCool=V_,t.interpolateCubehelix=Yr,t.interpolateCubehelixDefault=X_,t.interpolateCubehelixLong=Lr,t.interpolateDate=vr,t.interpolateDiscrete=function(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}},t.interpolateGnBu=p_,t.interpolateGreens=F_,t.interpolateGreys=I_,t.interpolateHcl=Ir,t.interpolateHclLong=Ur,t.interpolateHsl=Rr,t.interpolateHslLong=Fr,t.interpolateHue=function(t,n){var e=ur(+t,+n);return function(t){var n=e(t);return n-360*Math.floor(n/360)}},t.interpolateInferno=nb,t.interpolateLab=function(t,n){var e=fr((t=Re(t)).l,(n=Re(n)).l),r=fr(t.a,n.a),i=fr(t.b,n.b),o=fr(t.opacity,n.opacity);return function(n){return t.l=e(n),t.a=r(n),t.b=i(n),t.opacity=o(n),t+""}},t.interpolateMagma=tb,t.interpolateNumber=_r,t.interpolateNumberArray=pr,t.interpolateObject=br,t.interpolateOrRd=y_,t.interpolateOranges=H_,t.interpolatePRGn=$v,t.interpolatePiYG=Zv,t.interpolatePlasma=eb,t.interpolatePuBu=m_,t.interpolatePuBuGn=__,t.interpolatePuOr=Qv,t.interpolatePuRd=w_,t.interpolatePurples=B_,t.interpolateRainbow=function(t){(t<0||t>1)&&(t-=Math.floor(t));var n=Math.abs(t-.5);return $_.h=360*t-100,$_.s=1.5-1.5*n,$_.l=.8-.9*n,$_+""},t.interpolateRdBu=t_,t.interpolateRdGy=e_,t.interpolateRdPu=A_,t.interpolateRdYlBu=i_,t.interpolateRdYlGn=a_,t.interpolateReds=L_,t.interpolateRgb=sr,t.interpolateRgbBasis=hr,t.interpolateRgbBasisClosed=dr,t.interpolateRound=Ar,t.interpolateSinebow=function(t){var n;return t=(.5-t)*Math.PI,W_.r=255*(n=Math.sin(t))*n,W_.g=255*(n=Math.sin(t+Z_))*n,W_.b=255*(n=Math.sin(t+K_))*n,W_+""},t.interpolateSpectral=c_,t.interpolateString=wr,t.interpolateTransformCss=Cr,t.interpolateTransformSvg=Pr,t.interpolateTurbo=function(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+t*(1172.33-t*(10793.56-t*(33300.12-t*(38394.49-14825.05*t)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+t*(557.33+t*(1225.33-t*(3574.96-t*(1073.77+707.56*t)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+t*(3211.1-t*(15327.97-t*(27814-t*(22569.18-6838.66*t)))))))+")"},t.interpolateViridis=J_,t.interpolateWarm=G_,t.interpolateYlGn=k_,t.interpolateYlGnBu=S_,t.interpolateYlOrBr=C_,t.interpolateYlOrRd=z_,t.interpolateZoom=Dr,t.interrupt=gi,t.intersection=function(t,...n){t=new Set(t),n=n.map(et);t:for(const e of t)for(const r of n)if(!r.has(e)){t.delete(e);continue t}return t},t.interval=function(t,n,e){var r=new ei,i=n;return null==n?(r.restart(t,n,e),r):(r._restart=r.restart,r.restart=function(t,n,e){n=+n,e=null==e?ti():+e,r._restart((function o(a){a+=i,r._restart(o,i+=n,e),t(a)}),n,e)},r.restart(t,n,e),r)},t.isoFormat=Mv,t.isoParse=Av,t.json=function(t,n){return fetch(t,n).then(Du)},t.lab=Re,t.lch=function(t,n,e,r){return 1===arguments.length?Ye(t):new je(e,n,t,null==r?1:r)},t.least=function(t,e=n){let r,i=!1;if(1===e.length){let o;for(const a of t){const t=e(a);(i?n(t,o)<0:0===n(t,t))&&(r=a,o=t,i=!0)}}else for(const n of t)(i?e(n,r)<0:0===e(n,n))&&(r=n,i=!0);return r},t.leastIndex=K,t.line=Cb,t.lineRadial=Ib,t.linkHorizontal=function(){return jb(Hb)},t.linkRadial=function(){var t=jb(Gb);return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t},t.linkVertical=function(){return jb(Xb)},t.local=Rn,t.map=function(t,n){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");if("function"!=typeof n)throw new TypeError("mapper is not a function");return Array.from(t,((e,r)=>n(e,r,t)))},t.matcher=Ct,t.max=B,t.maxIndex=G,t.mean=function(t,n){let e=0,r=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(++e,r+=n);else{let i=-1;for(let o of t)null!=(o=n(o,++i,t))&&(o=+o)>=o&&(++e,r+=o)}if(e)return r/e},t.median=function(t,n){return H(t,.5,n)},t.merge=V,t.min=Y,t.minIndex=$,t.namespace=xt,t.namespaces=mt,t.nice=O,t.now=ti,t.pack=function(){var t=null,n=1,e=1,r=hd;function i(i){return i.x=n/2,i.y=e/2,t?i.eachBefore(gd(t)).eachAfter(yd(r,.5)).eachBefore(vd(1)):i.eachBefore(gd(pd)).eachAfter(yd(hd,1)).eachAfter(yd(r,i.r/Math.min(n,e))).eachBefore(vd(Math.min(n,e)/(2*i.r))),i}return i.radius=function(n){return arguments.length?(t=sd(n),i):t},i.size=function(t){return arguments.length?(n=+t[0],e=+t[1],i):[n,e]},i.padding=function(t){return arguments.length?(r="function"==typeof t?t:dd(+t),i):r},i},t.packEnclose=Kh,t.packSiblings=function(t){return fd(t),t},t.pairs=function(t,n=W){const e=[];let r,i=!1;for(const o of t)i&&e.push(n(r,o)),r=o,i=!0;return e},t.partition=function(){var t=1,n=1,e=0,r=!1;function i(i){var o=i.height+1;return i.x0=i.y0=e,i.x1=t,i.y1=n/o,i.eachBefore(function(t,n){return function(r){r.children&&bd(r,r.x0,t*(r.depth+1)/n,r.x1,t*(r.depth+2)/n);var i=r.x0,o=r.y0,a=r.x1-e,u=r.y1-e;a0&&(d+=l);for(null!=n?p.sort((function(t,e){return n(g[t],g[e])})):null!=e&&p.sort((function(t,n){return e(a[t],a[n])})),u=0,f=d?(v-h*b)/d:0;u0?l*f:0)+b,g[c]={data:a[c],index:u,value:l,startAngle:y,endAngle:s,padAngle:_};return g}return a.value=function(n){return arguments.length?(t="function"==typeof n?n:rb(+n),a):t},a.sortValues=function(t){return arguments.length?(n=t,e=null,a):n},a.sort=function(t){return arguments.length?(e=t,n=null,a):e},a.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:rb(+t),a):r},a.endAngle=function(t){return arguments.length?(i="function"==typeof t?t:rb(+t),a):i},a.padAngle=function(t){return arguments.length?(o="function"==typeof t?t:rb(+t),a):o},a},t.piecewise=jr,t.pointRadial=Bb,t.pointer=In,t.pointers=function(t,n){return t.target&&(t=On(t),void 0===n&&(n=t.currentTarget),t=t.touches||[t]),Array.from(t,(t=>In(t,n)))},t.polygonArea=function(t){for(var n,e=-1,r=t.length,i=t[r-1],o=0;++eu!=f>u&&a<(c-e)*(u-r)/(f-r)+e&&(s=!s),c=e,f=r;return s},t.polygonHull=function(t){if((e=t.length)<3)return null;var n,e,r=new Array(e),i=new Array(e);for(n=0;n=0;--n)f.push(t[r[o[n]][2]]);for(n=+u;n(n=1664525*n+1013904223|0,ep*(n>>>0))},t.randomLogNormal=Ld,t.randomLogistic=tp,t.randomNormal=Yd,t.randomPareto=Gd,t.randomPoisson=np,t.randomUniform=Ud,t.randomWeibull=Qd,t.range=Z,t.reduce=function(t,n,e){if("function"!=typeof n)throw new TypeError("reducer is not a function");const r=t[Symbol.iterator]();let i,o,a=-1;if(arguments.length<3){if(({done:i,value:e}=r.next()),i)return;++a}for(;({done:i,value:o}=r.next()),!i;)e=n(e,o,++a,t);return e},t.reverse=function(t){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");return Array.from(t).reverse()},t.rgb=ve,t.ribbon=function(){return ba()},t.ribbonArrow=function(){return ba(_a)},t.rollup=A,t.rollups=function(t,n,...e){return S(t,Array.from,n,e)},t.scaleBand=up,t.scaleDiverging=function t(){var n=bp(Pv()(lp));return n.copy=function(){return Nv(n,t())},ip.apply(n,arguments)},t.scaleDivergingLog=function t(){var n=Ep(Pv()).domain([.1,1,10]);return n.copy=function(){return Nv(n,t()).base(n.base())},ip.apply(n,arguments)},t.scaleDivergingPow=zv,t.scaleDivergingSqrt=function(){return zv.apply(null,arguments).exponent(.5)},t.scaleDivergingSymlog=function t(){var n=Cp(Pv());return n.copy=function(){return Nv(n,t()).constant(n.constant())},ip.apply(n,arguments)},t.scaleIdentity=function t(n){var e;function r(t){return null==t||isNaN(t=+t)?e:t}return r.invert=r,r.domain=r.range=function(t){return arguments.length?(n=Array.from(t,fp),r):n.slice()},r.unknown=function(t){return arguments.length?(e=t,r):e},r.copy=function(){return t(n).unknown(e)},n=arguments.length?Array.from(n,fp):[0,1],bp(r)},t.scaleImplicit=op,t.scaleLinear=function t(){var n=vp();return n.copy=function(){return gp(n,t())},rp.apply(n,arguments),bp(n)},t.scaleLog=function t(){var n=Ep(yp()).domain([1,10]);return n.copy=function(){return gp(n,t()).base(n.base())},rp.apply(n,arguments),n},t.scaleOrdinal=ap,t.scalePoint=function(){return cp(up.apply(null,arguments).paddingInner(1))},t.scalePow=Rp,t.scaleQuantile=function t(){var e,r=[],i=[],a=[];function u(){var t=0,n=Math.max(1,i.length);for(a=new Array(n-1);++t0?a[n-1]:r[0],n=i?[a[i-1],r]:[a[n-1],a[n]]},c.unknown=function(t){return arguments.length?(n=t,c):c},c.thresholds=function(){return a.slice()},c.copy=function(){return t().domain([e,r]).range(u).unknown(n)},rp.apply(bp(c),arguments)},t.scaleRadial=function t(){var n,e=vp(),r=[0,1],i=!1;function o(t){var r=Op(e(t));return isNaN(r)?n:i?Math.round(r):r}return o.invert=function(t){return e.invert(Fp(t))},o.domain=function(t){return arguments.length?(e.domain(t),o):e.domain()},o.range=function(t){return arguments.length?(e.range((r=Array.from(t,fp)).map(Fp)),o):r.slice()},o.rangeRound=function(t){return o.range(t).round(!0)},o.round=function(t){return arguments.length?(i=!!t,o):i},o.clamp=function(t){return arguments.length?(e.clamp(t),o):e.clamp()},o.unknown=function(t){return arguments.length?(n=t,o):n},o.copy=function(){return t(e.domain(),r).round(i).clamp(e.clamp()).unknown(n)},rp.apply(o,arguments),bp(o)},t.scaleSequential=function t(){var n=bp(kv()(lp));return n.copy=function(){return Nv(n,t())},ip.apply(n,arguments)},t.scaleSequentialLog=function t(){var n=Ep(kv()).domain([1,10]);return n.copy=function(){return Nv(n,t()).base(n.base())},ip.apply(n,arguments)},t.scaleSequentialPow=Cv,t.scaleSequentialQuantile=function t(){var e=[],r=lp;function i(t){if(null!=t&&!isNaN(t=+t))return r((o(e,t,1)-1)/(e.length-1))}return i.domain=function(t){if(!arguments.length)return e.slice();e=[];for(let n of t)null==n||isNaN(n=+n)||e.push(n);return e.sort(n),i},i.interpolator=function(t){return arguments.length?(r=t,i):r},i.range=function(){return e.map(((t,n)=>r(n/(e.length-1))))},i.quantiles=function(t){return Array.from({length:t+1},((n,r)=>H(e,r/t)))},i.copy=function(){return t(r).domain(e)},ip.apply(i,arguments)},t.scaleSequentialSqrt=function(){return Cv.apply(null,arguments).exponent(.5)},t.scaleSequentialSymlog=function t(){var n=Cp(kv());return n.copy=function(){return Nv(n,t()).constant(n.constant())},ip.apply(n,arguments)},t.scaleSqrt=function(){return Rp.apply(null,arguments).exponent(.5)},t.scaleSymlog=function t(){var n=Cp(yp());return n.copy=function(){return gp(n,t()).constant(n.constant())},rp.apply(n,arguments)},t.scaleThreshold=function t(){var n,e=[.5],r=[0,1],i=1;function a(t){return null!=t&&t<=t?r[o(e,t,0,i)]:n}return a.domain=function(t){return arguments.length?(e=Array.from(t),i=Math.min(e.length,r.length-1),a):e.slice()},a.range=function(t){return arguments.length?(r=Array.from(t),i=Math.min(e.length,r.length-1),a):r.slice()},a.invertExtent=function(t){var n=r.indexOf(t);return[e[n-1],e[n]]},a.unknown=function(t){return arguments.length?(n=t,a):n},a.copy=function(){return t().domain(e).range(r).unknown(n)},rp.apply(a,arguments)},t.scaleTime=function(){return rp.apply(Ev(Kg,Qg,xg,bg,og,eg,tg,Qp,Zp,t.timeFormat).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)},t.scaleUtc=function(){return rp.apply(Ev(Wg,Zg,Gg,Hg,Cg,Eg,Tg,Mg,Zp,t.utcFormat).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)},t.scan=function(t,n){const e=K(t,n);return e<0?void 0:e},t.schemeAccent=Rv,t.schemeBlues=D_,t.schemeBrBG=Xv,t.schemeBuGn=f_,t.schemeBuPu=l_,t.schemeCategory10=qv,t.schemeDark2=Fv,t.schemeGnBu=d_,t.schemeGreens=R_,t.schemeGreys=O_,t.schemeOrRd=g_,t.schemeOranges=j_,t.schemePRGn=Vv,t.schemePaired=Ov,t.schemePastel1=Iv,t.schemePastel2=Uv,t.schemePiYG=Wv,t.schemePuBu=b_,t.schemePuBuGn=v_,t.schemePuOr=Kv,t.schemePuRd=x_,t.schemePurples=U_,t.schemeRdBu=Jv,t.schemeRdGy=n_,t.schemeRdPu=M_,t.schemeRdYlBu=r_,t.schemeRdYlGn=o_,t.schemeReds=Y_,t.schemeSet1=Bv,t.schemeSet2=Yv,t.schemeSet3=Lv,t.schemeSpectral=u_,t.schemeTableau10=jv,t.schemeYlGn=E_,t.schemeYlGnBu=T_,t.schemeYlOrBr=N_,t.schemeYlOrRd=P_,t.select=Dn,t.selectAll=function(t){return"string"==typeof t?new Pn([document.querySelectorAll(t)],[document.documentElement]):new Pn([null==t?[]:Et(t)],Cn)},t.selection=zn,t.selector=St,t.selectorAll=Nt,t.shuffle=Q,t.shuffler=J,t.some=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");let e=-1;for(const r of t)if(n(r,++e,t))return!0;return!1},t.sort=k,t.stack=function(){var t=rb([]),n=Xm,e=Hm,r=Gm;function i(i){var o,a,u=Array.from(t.apply(this,arguments),Vm),c=u.length,f=-1;for(const t of i)for(o=0,++f;o0)for(var e,r,i,o,a,u,c=0,f=t[n[0]].length;c0?(r[0]=o,r[1]=o+=i):i<0?(r[1]=a,r[0]=a+=i):(r[0]=0,r[1]=i)},t.stackOffsetExpand=function(t,n){if((r=t.length)>0){for(var e,r,i,o=0,a=t[0].length;o0){for(var e,r=0,i=t[n[0]],o=i.length;r0&&(r=(e=t[n[0]]).length)>0){for(var e,r,i,o=0,a=1;a0)throw new Error("cycle");return o}return e.id=function(n){return arguments.length?(t=ld(n),e):t},e.parentId=function(t){return arguments.length?(n=ld(t),e):n},e},t.style=Jt,t.subset=function(t,n){return rt(n,t)},t.sum=function(t,n){let e=0;if(void 0===n)for(let n of t)(n=+n)&&(e+=n);else{let r=-1;for(let i of t)(i=+n(i,++r,t))&&(e+=i)}return e},t.superset=rt,t.svg=Ou,t.symbol=function(t,n){var e=null;function r(){var r;if(e||(e=r=fa()),t.apply(this,arguments).draw(e,+n.apply(this,arguments)),r)return e=null,r+""||null}return t="function"==typeof t?t:rb(t||Vb),n="function"==typeof n?n:rb(void 0===n?64:+n),r.type=function(n){return arguments.length?(t="function"==typeof n?n:rb(n),r):t},r.size=function(t){return arguments.length?(n="function"==typeof t?t:rb(+t),r):n},r.context=function(t){return arguments.length?(e=null==t?null:t,r):e},r},t.symbolCircle=Vb,t.symbolCross=$b,t.symbolDiamond=Kb,t.symbolSquare=em,t.symbolStar=nm,t.symbolTriangle=im,t.symbolWye=fm,t.symbols=sm,t.text=Nu,t.thresholdFreedmanDiaconis=function(t,n,e){return Math.ceil((e-n)/(2*(H(t,.75)-H(t,.25))*Math.pow(c(t),-1/3)))},t.thresholdScott=function(t,n,e){return Math.ceil((e-n)/(3.5*d(t)*Math.pow(c(t),-1/3)))},t.thresholdSturges=I,t.tickFormat=_p,t.tickIncrement=R,t.tickStep=F,t.ticks=q,t.timeDay=eg,t.timeDays=rg,t.timeFormatDefaultLocale=xv,t.timeFormatLocale=ey,t.timeFriday=sg,t.timeFridays=vg,t.timeHour=tg,t.timeHours=ng,t.timeInterval=Bp,t.timeMillisecond=Yp,t.timeMilliseconds=Lp,t.timeMinute=Qp,t.timeMinutes=Jp,t.timeMonday=ag,t.timeMondays=dg,t.timeMonth=bg,t.timeMonths=mg,t.timeSaturday=lg,t.timeSaturdays=_g,t.timeSecond=Zp,t.timeSeconds=Kp,t.timeSunday=og,t.timeSundays=hg,t.timeThursday=fg,t.timeThursdays=yg,t.timeTickInterval=Qg,t.timeTicks=Kg,t.timeTuesday=ug,t.timeTuesdays=pg,t.timeWednesday=cg,t.timeWednesdays=gg,t.timeWeek=og,t.timeWeeks=hg,t.timeYear=xg,t.timeYears=wg,t.timeout=ci,t.timer=ri,t.timerFlush=ii,t.transition=Hi,t.transpose=tt,t.tree=function(){var t=Ad,n=1,e=1,r=null;function i(i){var c=function(t){for(var n,e,r,i,o,a=new Nd(t,0),u=[a];n=u.pop();)if(r=n._.children)for(n.children=new Array(o=r.length),i=o-1;i>=0;--i)u.push(e=n.children[i]=new Nd(r[i],i)),e.parent=n;return(a.parent=new Nd(null,0)).children=[a],a}(i);if(c.eachAfter(o),c.parent.m=-c.z,c.eachBefore(a),r)i.eachBefore(u);else{var f=i,s=i,l=i;i.eachBefore((function(t){t.xs.x&&(s=t),t.depth>l.depth&&(l=t)}));var h=f===s?1:t(f,s)/2,d=h-f.x,p=n/(s.x+h+d),g=e/(l.depth||1);i.eachBefore((function(t){t.x=(t.x+d)*p,t.y=t.depth*g}))}return i}function o(n){var e=n.children,r=n.parent.children,i=n.i?r[n.i-1]:null;if(e){!function(t){for(var n,e=0,r=0,i=t.children,o=i.length;--o>=0;)(n=i[o]).z+=e,n.m+=e,e+=n.s+(r+=n.c)}(n);var o=(e[0].z+e[e.length-1].z)/2;i?(n.z=i.z+t(n._,i._),n.m=n.z-o):n.z=o}else i&&(n.z=i.z+t(n._,i._));n.parent.A=function(n,e,r){if(e){for(var i,o=n,a=n,u=e,c=o.parent.children[0],f=o.m,s=a.m,l=u.m,h=c.m;u=Sd(u),o=Td(o),u&&o;)c=Td(c),(a=Sd(a)).a=n,(i=u.z+l-o.z-f+t(u._,o._))>0&&(Ed(kd(u,n,r),n,i),f+=i,s+=i),l+=u.m,f+=o.m,h+=c.m,s+=a.m;u&&!Sd(a)&&(a.t=u,a.m+=l-s),o&&!Td(c)&&(c.t=o,c.m+=f-h,r=n)}return r}(n,i,n.parent.A||r[0])}function a(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function u(t){t.x*=n,t.y=t.depth*e}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.treemap=function(){var t=Dd,n=!1,e=1,r=1,i=[0],o=hd,a=hd,u=hd,c=hd,f=hd;function s(t){return t.x0=t.y0=0,t.x1=e,t.y1=r,t.eachBefore(l),i=[0],n&&t.eachBefore(_d),t}function l(n){var e=i[n.depth],r=n.x0+e,s=n.y0+e,l=n.x1-e,h=n.y1-e;l=e-1){var s=u[n];return s.x0=i,s.y0=o,s.x1=a,void(s.y1=c)}var l=f[n],h=r/2+l,d=n+1,p=e-1;for(;d>>1;f[g]c-o){var _=r?(i*v+a*y)/r:a;t(n,d,y,i,o,_,c),t(d,e,v,_,o,a,c)}else{var b=r?(o*v+c*y)/r:c;t(n,d,y,i,o,a,b),t(d,e,v,i,b,a,c)}}(0,c,t.value,n,e,r,i)},t.treemapDice=bd,t.treemapResquarify=qd,t.treemapSlice=Cd,t.treemapSliceDice=function(t,n,e,r,i){(1&t.depth?Cd:bd)(t,n,e,r,i)},t.treemapSquarify=Dd,t.tsv=zu,t.tsvFormat=mu,t.tsvFormatBody=xu,t.tsvFormatRow=Mu,t.tsvFormatRows=wu,t.tsvFormatValue=Au,t.tsvParse=_u,t.tsvParseRows=bu,t.union=function(...t){const n=new Set;for(const e of t)for(const t of e)n.add(t);return n},t.utcDay=Eg,t.utcDays=kg,t.utcFriday=Rg,t.utcFridays=Lg,t.utcHour=Tg,t.utcHours=Sg,t.utcMillisecond=Yp,t.utcMilliseconds=Lp,t.utcMinute=Mg,t.utcMinutes=Ag,t.utcMonday=Pg,t.utcMondays=Ig,t.utcMonth=Hg,t.utcMonths=Xg,t.utcSaturday=Fg,t.utcSaturdays=jg,t.utcSecond=Zp,t.utcSeconds=Kp,t.utcSunday=Cg,t.utcSundays=Og,t.utcThursday=qg,t.utcThursdays=Yg,t.utcTickInterval=Zg,t.utcTicks=Wg,t.utcTuesday=zg,t.utcTuesdays=Ug,t.utcWednesday=Dg,t.utcWednesdays=Bg,t.utcWeek=Cg,t.utcWeeks=Og,t.utcYear=Gg,t.utcYears=Vg,t.variance=h,t.version="6.7.0",t.window=Wt,t.xml=Ru,t.zip=function(){return tt(arguments)},t.zoom=function(){var t,n,e,r=ox,i=ax,o=sx,a=cx,u=fx,c=[0,1/0],f=[[-1/0,-1/0],[1/0,1/0]],s=250,l=Dr,h=pt("start","zoom","end"),d=500,p=0,g=10;function y(t){t.property("__zoom",ux).on("wheel.zoom",M).on("mousedown.zoom",A).on("dblclick.zoom",T).filter(u).on("touchstart.zoom",S).on("touchmove.zoom",E).on("touchend.zoom touchcancel.zoom",k).style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function v(t,n){return(n=Math.max(c[0],Math.min(c[1],n)))===t.k?t:new tx(n,t.x,t.y)}function _(t,n,e){var r=n[0]-e[0]*t.k,i=n[1]-e[1]*t.k;return r===t.x&&i===t.y?t:new tx(t.k,r,i)}function b(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function m(t,n,e,r){t.on("start.zoom",(function(){x(this,arguments).event(r).start()})).on("interrupt.zoom end.zoom",(function(){x(this,arguments).event(r).end()})).tween("zoom",(function(){var t=this,o=arguments,a=x(t,o).event(r),u=i.apply(t,o),c=null==e?b(u):"function"==typeof e?e.apply(t,o):e,f=Math.max(u[1][0]-u[0][0],u[1][1]-u[0][1]),s=t.__zoom,h="function"==typeof n?n.apply(t,o):n,d=l(s.invert(c).concat(f/s.k),h.invert(c).concat(f/h.k));return function(t){if(1===t)t=h;else{var n=d(t),e=f/n[2];t=new tx(e,c[0]-n[0]*e,c[1]-n[1]*e)}a.zoom(null,t)}}))}function x(t,n,e){return!e&&t.__zooming||new w(t,n)}function w(t,n){this.that=t,this.args=n,this.active=0,this.sourceEvent=null,this.extent=i.apply(t,n),this.taps=0}function M(t,...n){if(r.apply(this,arguments)){var e=x(this,n).event(t),i=this.__zoom,u=Math.max(c[0],Math.min(c[1],i.k*Math.pow(2,a.apply(this,arguments)))),s=In(t);if(e.wheel)e.mouse[0][0]===s[0]&&e.mouse[0][1]===s[1]||(e.mouse[1]=i.invert(e.mouse[0]=s)),clearTimeout(e.wheel);else{if(i.k===u)return;e.mouse=[s,i.invert(s)],gi(this),e.start()}ix(t),e.wheel=setTimeout(l,150),e.zoom("mouse",o(_(v(i,u),e.mouse[0],e.mouse[1]),e.extent,f))}function l(){e.wheel=null,e.end()}}function A(t,...n){if(!e&&r.apply(this,arguments)){var i=x(this,n,!0).event(t),a=Dn(t.view).on("mousemove.zoom",h,!0).on("mouseup.zoom",d,!0),u=In(t,c),c=t.currentTarget,s=t.clientX,l=t.clientY;Yn(t.view),rx(t),i.mouse=[u,this.__zoom.invert(u)],gi(this),i.start()}function h(t){if(ix(t),!i.moved){var n=t.clientX-s,e=t.clientY-l;i.moved=n*n+e*e>p}i.event(t).zoom("mouse",o(_(i.that.__zoom,i.mouse[0]=In(t,c),i.mouse[1]),i.extent,f))}function d(t){a.on("mousemove.zoom mouseup.zoom",null),Ln(t.view,i.moved),ix(t),i.event(t).end()}}function T(t,...n){if(r.apply(this,arguments)){var e=this.__zoom,a=In(t.changedTouches?t.changedTouches[0]:t,this),u=e.invert(a),c=e.k*(t.shiftKey?.5:2),l=o(_(v(e,c),a,u),i.apply(this,n),f);ix(t),s>0?Dn(this).transition().duration(s).call(m,l,a,t):Dn(this).call(y.transform,l,a,t)}}function S(e,...i){if(r.apply(this,arguments)){var o,a,u,c,f=e.touches,s=f.length,l=x(this,i,e.changedTouches.length===s).event(e);for(rx(e),a=0;a=(parseInt(e.getWindow(g).getComputedStyle(g).zIndex,10)||0)&&(n=o);else n=o}else n=o}var v,g;return n},_.matchesUpTo=function(t,e,n){for(;i.default.element(t);){if(O(t,e))return!0;if((t=P(t))===n)return O(t,e)}return!1},_.getActualElement=function(t){return t.correspondingUseElement||t},_.getScrollXY=T,_.getElementClientRect=M,_.getElementRect=function(t){var n=M(t);if(!b.default.isIOS7&&n){var r=T(e.getWindow(t));n.left+=r.x,n.right+=r.x,n.top+=r.y,n.bottom+=r.y}return n},_.getPath=function(t){for(var e=[];t;)e.push(t),t=P(t);return e},_.trySelector=function(t){return!!i.default.string(t)&&(h.default.document.querySelector(t),!0)};var S=function(t){return t.parentNode||t.host};function E(t,e){for(var n,r=[],o=t;(n=S(o))&&o!==e&&n!==o.ownerDocument;)r.unshift(o),o=n;return r}function T(t){return{x:(t=t||e.window).scrollX||t.document.documentElement.scrollLeft,y:t.scrollY||t.document.documentElement.scrollTop}}function M(t){var e=t instanceof h.default.SVGElement?t.getBoundingClientRect():t.getClientRects()[0];return e&&{left:e.left,right:e.right,top:e.top,bottom:e.bottom,width:e.width||e.right-e.left,height:e.height||e.bottom-e.top}}var j={};Object.defineProperty(j,"__esModule",{value:!0}),j.default=function(t,e){for(var n in e)t[n]=e[n];return t};var k={};function I(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,r=Array(e);n1?q(e):e[0];U(r,t.page),V(r,t.client),t.timeStamp=n},B.getTouchPair=N,B.pointerAverage=q,B.touchBBox=function(t){if(!t.length)return null;var e=N(t),n=Math.min(e[0].pageX,e[1].pageX),r=Math.min(e[0].pageY,e[1].pageY),o=Math.max(e[0].pageX,e[1].pageX),i=Math.max(e[0].pageY,e[1].pageY);return{x:n,y:r,left:n,top:r,right:o,bottom:i,width:o-n,height:i-r}},B.touchDistance=function(t,e){var n=e+"X",r=e+"Y",o=N(t),i=o[0][n]-o[1][n],a=o[0][r]-o[1][r];return(0,C.default)(i,a)},B.touchAngle=function(t,e){var n=e+"X",r=e+"Y",o=N(t),i=o[1][n]-o[0][n],a=o[1][r]-o[0][r];return 180*Math.atan2(a,i)/Math.PI},B.getPointerType=function(t){return i.default.string(t.pointerType)?t.pointerType:i.default.number(t.pointerType)?[void 0,void 0,"touch","pen","mouse"][t.pointerType]:/touch/.test(t.type||"")||t instanceof h.default.Touch?"touch":"mouse"},B.getEventTargets=function(t){var e=i.default.func(t.composedPath)?t.composedPath():t.path;return[_.getActualElement(e?e[0]:t.target),_.getActualElement(t.currentTarget)]},B.newCoords=function(){return{page:{x:0,y:0},client:{x:0,y:0},timeStamp:0}},B.coordsToEvent=function(t){return{coords:t,get page(){return this.coords.page},get client(){return this.coords.client},get timeStamp(){return this.coords.timeStamp},get pageX(){return this.coords.page.x},get pageY(){return this.coords.page.y},get clientX(){return this.coords.client.x},get clientY(){return this.coords.client.y},get pointerId(){return this.coords.pointerId},get target(){return this.coords.target},get type(){return this.coords.type},get pointerType(){return this.coords.pointerType},get buttons(){return this.coords.buttons},preventDefault:function(){}}},Object.defineProperty(B,"pointerExtend",{enumerable:!0,get:function(){return F.default}});var $={};function G(t,e){for(var n=0;ns.left&&f.xs.top&&f.y=s.left&&h<=s.right&&g>=s.top&&g<=s.bottom}return v&&i.default.number(u)&&(l=Math.max(0,Math.min(s.right,v.right)-Math.max(s.left,v.left))*Math.max(0,Math.min(s.bottom,v.bottom)-Math.max(s.top,v.top))/(v.width*v.height)>=u),t.options.drop.checker&&(l=t.options.drop.checker(e,n,l,t,a,r,o)),l}(this,t,e,n,r,o,a)},n.dynamicDrop=function(e){return i.default.bool(e)?(t.dynamicDrop=e,n):t.dynamicDrop},(0,j.default)(e.phaselessTypes,{dragenter:!0,dragleave:!0,dropactivate:!0,dropdeactivate:!0,dropmove:!0,drop:!0}),e.methodDict.drop="dropzone",t.dynamicDrop=!1,o.actions.drop=gt.defaults},listeners:{"interactions:before-action-start":function(t){var e=t.interaction;"drag"===e.prepared.name&&(e.dropState={cur:{dropzone:null,element:null},prev:{dropzone:null,element:null},rejected:null,events:null,activeDrops:[]})},"interactions:after-action-start":function(t,e){var n=t.interaction,r=(t.event,t.iEvent);if("drag"===n.prepared.name){var o=n.dropState;o.activeDrops=null,o.events=null,o.activeDrops=ft(e,n.element),o.events=pt(n,0,r),o.events.activate&&(ct(o.activeDrops,o.events.activate),e.fire("actions/drop:start",{interaction:n,dragEvent:r}))}},"interactions:action-move":ht,"interactions:after-action-move":function(t,e){var n=t.interaction,r=t.iEvent;"drag"===n.prepared.name&&(vt(n,n.dropState.events),e.fire("actions/drop:move",{interaction:n,dragEvent:r}),n.dropState.events={})},"interactions:action-end":function(t,e){if("drag"===t.interaction.prepared.name){var n=t.interaction,r=t.iEvent;ht(t,e),vt(n,n.dropState.events),e.fire("actions/drop:end",{interaction:n,dragEvent:r})}},"interactions:stop":function(t){var e=t.interaction;if("drag"===e.prepared.name){var n=e.dropState;n&&(n.activeDrops=null,n.events=null,n.cur.dropzone=null,n.cur.element=null,n.prev.dropzone=null,n.prev.element=null,n.rejected=!1)}}},getActiveDrops:ft,getDrop:dt,getDropEvents:pt,fireDropEvents:vt,defaults:{enabled:!1,accept:null,overlap:"pointer"}},yt=gt;ut.default=yt;var mt={};function bt(t){var e=t.interaction,n=t.iEvent,r=t.phase;if("gesture"===e.prepared.name){var o=e.pointers.map((function(t){return t.pointer})),a="start"===r,s="end"===r,l=e.interactable.options.deltaSource;if(n.touches=[o[0],o[1]],a)n.distance=B.touchDistance(o,l),n.box=B.touchBBox(o),n.scale=1,n.ds=0,n.angle=B.touchAngle(o,l),n.da=0,e.gesture.startDistance=n.distance,e.gesture.startAngle=n.angle;else if(s){var u=e.prevEvent;n.distance=u.distance,n.box=u.box,n.scale=u.scale,n.ds=0,n.angle=u.angle,n.da=0}else n.distance=B.touchDistance(o,l),n.box=B.touchBBox(o),n.scale=n.distance/e.gesture.startDistance,n.angle=B.touchAngle(o,l),n.ds=n.scale-e.gesture.scale,n.da=n.angle-e.gesture.angle;e.gesture.distance=n.distance,e.gesture.angle=n.angle,i.default.number(n.scale)&&n.scale!==1/0&&!isNaN(n.scale)&&(e.gesture.scale=n.scale)}}Object.defineProperty(mt,"__esModule",{value:!0}),mt.default=void 0;var xt={id:"actions/gesture",before:["actions/drag","actions/resize"],install:function(t){var e=t.actions,n=t.Interactable,r=t.defaults;n.prototype.gesturable=function(t){return i.default.object(t)?(this.options.gesture.enabled=!1!==t.enabled,this.setPerAction("gesture",t),this.setOnEvents("gesture",t),this):i.default.bool(t)?(this.options.gesture.enabled=t,this):this.options.gesture},e.map.gesture=xt,e.methodDict.gesture="gesturable",r.actions.gesture=xt.defaults},listeners:{"interactions:action-start":bt,"interactions:action-move":bt,"interactions:action-end":bt,"interactions:new":function(t){t.interaction.gesture={angle:0,distance:0,scale:1,startAngle:0,startDistance:0}},"auto-start:check":function(t){if(!(t.interaction.pointers.length<2)){var e=t.interactable.options.gesture;if(e&&e.enabled)return t.action={name:"gesture"},!1}}},defaults:{},getCursor:function(){return""}},wt=xt;mt.default=wt;var _t={};function Pt(t,e,n,r,o,a,s){if(!e)return!1;if(!0===e){var l=i.default.number(a.width)?a.width:a.right-a.left,u=i.default.number(a.height)?a.height:a.bottom-a.top;if(s=Math.min(s,Math.abs(("left"===t||"right"===t?l:u)/2)),l<0&&("left"===t?t="right":"right"===t&&(t="left")),u<0&&("top"===t?t="bottom":"bottom"===t&&(t="top")),"left"===t)return n.x<(l>=0?a.left:a.right)+s;if("top"===t)return n.y<(u>=0?a.top:a.bottom)+s;if("right"===t)return n.x>(l>=0?a.right:a.left)-s;if("bottom"===t)return n.y>(u>=0?a.bottom:a.top)-s}return!!i.default.element(r)&&(i.default.element(e)?e===r:_.matchesUpTo(r,e,o))}function Ot(t){var e=t.iEvent,n=t.interaction;if("resize"===n.prepared.name&&n.resizeAxes){var r=e;n.interactable.options.resize.square?("y"===n.resizeAxes?r.delta.x=r.delta.y:r.delta.y=r.delta.x,r.axes="xy"):(r.axes=n.resizeAxes,"x"===n.resizeAxes?r.delta.y=0:"y"===n.resizeAxes&&(r.delta.x=0))}}Object.defineProperty(_t,"__esModule",{value:!0}),_t.default=void 0;var St={id:"actions/resize",before:["actions/drag"],install:function(t){var e=t.actions,n=t.browser,r=t.Interactable,o=t.defaults;St.cursors=function(t){return t.isIe9?{x:"e-resize",y:"s-resize",xy:"se-resize",top:"n-resize",left:"w-resize",bottom:"s-resize",right:"e-resize",topleft:"se-resize",bottomright:"se-resize",topright:"ne-resize",bottomleft:"ne-resize"}:{x:"ew-resize",y:"ns-resize",xy:"nwse-resize",top:"ns-resize",left:"ew-resize",bottom:"ns-resize",right:"ew-resize",topleft:"nwse-resize",bottomright:"nwse-resize",topright:"nesw-resize",bottomleft:"nesw-resize"}}(n),St.defaultMargin=n.supportsTouch||n.supportsPointerEvent?20:10,r.prototype.resizable=function(e){return function(t,e,n){return i.default.object(e)?(t.options.resize.enabled=!1!==e.enabled,t.setPerAction("resize",e),t.setOnEvents("resize",e),i.default.string(e.axis)&&/^x$|^y$|^xy$/.test(e.axis)?t.options.resize.axis=e.axis:null===e.axis&&(t.options.resize.axis=n.defaults.actions.resize.axis),i.default.bool(e.preserveAspectRatio)?t.options.resize.preserveAspectRatio=e.preserveAspectRatio:i.default.bool(e.square)&&(t.options.resize.square=e.square),t):i.default.bool(e)?(t.options.resize.enabled=e,t):t.options.resize}(this,e,t)},e.map.resize=St,e.methodDict.resize="resizable",o.actions.resize=St.defaults},listeners:{"interactions:new":function(t){t.interaction.resizeAxes="xy"},"interactions:action-start":function(t){!function(t){var e=t.iEvent,n=t.interaction;if("resize"===n.prepared.name&&n.prepared.edges){var r=e,o=n.rect;n._rects={start:(0,j.default)({},o),corrected:(0,j.default)({},o),previous:(0,j.default)({},o),delta:{left:0,right:0,width:0,top:0,bottom:0,height:0}},r.edges=n.prepared.edges,r.rect=n._rects.corrected,r.deltaRect=n._rects.delta}}(t),Ot(t)},"interactions:action-move":function(t){!function(t){var e=t.iEvent,n=t.interaction;if("resize"===n.prepared.name&&n.prepared.edges){var r=e,o=n.interactable.options.resize.invert,i="reposition"===o||"negate"===o,a=n.rect,s=n._rects,l=s.start,u=s.corrected,c=s.delta,f=s.previous;if((0,j.default)(f,u),i){if((0,j.default)(u,a),"reposition"===o){if(u.top>u.bottom){var d=u.top;u.top=u.bottom,u.bottom=d}if(u.left>u.right){var p=u.left;u.left=u.right,u.right=p}}}else u.top=Math.min(a.top,l.bottom),u.bottom=Math.max(a.bottom,l.top),u.left=Math.min(a.left,l.right),u.right=Math.max(a.right,l.left);for(var v in u.width=u.right-u.left,u.height=u.bottom-u.top,u)c[v]=u[v]-f[v];r.edges=n.prepared.edges,r.rect=u,r.deltaRect=c}}(t),Ot(t)},"interactions:action-end":function(t){var e=t.iEvent,n=t.interaction;if("resize"===n.prepared.name&&n.prepared.edges){var r=e;r.edges=n.prepared.edges,r.rect=n._rects.corrected,r.deltaRect=n._rects.delta}},"auto-start:check":function(t){var e=t.interaction,n=t.interactable,r=t.element,o=t.rect,a=t.buttons;if(o){var s=(0,j.default)({},e.coords.cur.page),l=n.options.resize;if(l&&l.enabled&&(!e.pointerIsDown||!/mouse|pointer/.test(e.pointerType)||0!=(a&l.mouseButtons))){if(i.default.object(l.edges)){var u={left:!1,right:!1,top:!1,bottom:!1};for(var c in u)u[c]=Pt(c,l.edges[c],s,e._latestPointer.eventTarget,r,o,l.margin||St.defaultMargin);u.left=u.left&&!u.right,u.top=u.top&&!u.bottom,(u.left||u.right||u.top||u.bottom)&&(t.action={name:"resize",edges:u})}else{var f="y"!==l.axis&&s.x>o.right-St.defaultMargin,d="x"!==l.axis&&s.y>o.bottom-St.defaultMargin;(f||d)&&(t.action={name:"resize",axes:(f?"x":"")+(d?"y":"")})}return!t.action&&void 0}}}},defaults:{square:!1,preserveAspectRatio:!1,axis:"xy",margin:NaN,edges:null,invert:"none"},cursors:null,getCursor:function(t){var e=t.edges,n=t.axis,r=t.name,o=St.cursors,i=null;if(n)i=o[r+n];else if(e){for(var a="",s=["top","bottom","left","right"],l=0;l=1){var c={x:zt.x*u,y:zt.y*u};if(c.x||c.y){var f=Ft(a);i.default.window(a)?a.scrollBy(c.x,c.y):a&&(a.scrollLeft+=c.x,a.scrollTop+=c.y);var d=Ft(a),p={x:d.x-f.x,y:d.y-f.y};(p.x||p.y)&&e.fire({type:"autoscroll",target:n,interactable:e,delta:p,interaction:t,container:a})}zt.prevTime=s}zt.isScrolling&&(jt.default.cancel(zt.i),zt.i=jt.default.request(zt.scroll))},check:function(t,e){var n;return null==(n=t.options[e].autoScroll)?void 0:n.enabled},onInteractionMove:function(t){var e=t.interaction,n=t.pointer;if(e.interacting()&&zt.check(e.interactable,e.prepared.name))if(e.simulation)zt.x=zt.y=0;else{var r,o,a,s,l=e.interactable,u=e.element,c=e.prepared.name,f=l.options[c].autoScroll,d=Ct(f.container,l,u);if(i.default.window(d))s=n.clientXd.innerWidth-zt.margin,a=n.clientY>d.innerHeight-zt.margin;else{var p=_.getElementClientRect(d);s=n.clientXp.right-zt.margin,a=n.clientY>p.bottom-zt.margin}zt.x=o?1:s?-1:0,zt.y=a?1:r?-1:0,zt.isScrolling||(zt.margin=f.margin,zt.speed=f.speed,zt.start(e))}}};function Ct(t,n,r){return(i.default.string(t)?(0,k.getStringOptionResult)(t,n,r):t)||(0,e.getWindow)(r)}function Ft(t){return i.default.window(t)&&(t=window.document.body),{x:t.scrollLeft,y:t.scrollTop}}var Xt={id:"auto-scroll",install:function(t){var e=t.defaults,n=t.actions;t.autoScroll=zt,zt.now=function(){return t.now()},n.phaselessTypes.autoscroll=!0,e.perAction.autoScroll=zt.defaults},listeners:{"interactions:new":function(t){t.interaction.autoScroll=null},"interactions:destroy":function(t){t.interaction.autoScroll=null,zt.stop(),zt.interaction&&(zt.interaction=null)},"interactions:stop":zt.stop,"interactions:action-move":function(t){return zt.onInteractionMove(t)}}};Rt.default=Xt;var Yt={};Object.defineProperty(Yt,"__esModule",{value:!0}),Yt.warnOnce=function(t,n){var r=!1;return function(){return r||(e.window.console.warn(n),r=!0),t.apply(this,arguments)}},Yt.copyAction=function(t,e){return t.name=e.name,t.axis=e.axis,t.edges=e.edges,t},Yt.sign=void 0,Yt.sign=function(t){return t>=0?1:-1};var Bt={};function Wt(t){return i.default.bool(t)?(this.options.styleCursor=t,this):null===t?(delete this.options.styleCursor,this):this.options.styleCursor}function Lt(t){return i.default.func(t)?(this.options.actionChecker=t,this):null===t?(delete this.options.actionChecker,this):this.options.actionChecker}Object.defineProperty(Bt,"__esModule",{value:!0}),Bt.default=void 0;var Ut={id:"auto-start/interactableMethods",install:function(t){var e=t.Interactable;e.prototype.getAction=function(e,n,r,o){var i=function(t,e,n,r,o){var i=t.getRect(r),a={action:null,interactable:t,interaction:n,element:r,rect:i,buttons:e.buttons||{0:1,1:4,3:8,4:16}[e.button]};return o.fire("auto-start:check",a),a.action}(this,n,r,o,t);return this.options.actionChecker?this.options.actionChecker(e,n,i,this,o,r):i},e.prototype.ignoreFrom=(0,Yt.warnOnce)((function(t){return this._backCompatOption("ignoreFrom",t)}),"Interactable.ignoreFrom() has been deprecated. Use Interactble.draggable({ignoreFrom: newValue})."),e.prototype.allowFrom=(0,Yt.warnOnce)((function(t){return this._backCompatOption("allowFrom",t)}),"Interactable.allowFrom() has been deprecated. Use Interactble.draggable({allowFrom: newValue})."),e.prototype.actionChecker=Lt,e.prototype.styleCursor=Wt}};Bt.default=Ut;var Vt={};function Nt(t,e,n,r,o){return e.testIgnoreAllow(e.options[t.name],n,r)&&e.options[t.name].enabled&&Ht(e,n,t,o)?t:null}function qt(t,e,n,r,o,i,a){for(var s=0,l=r.length;s=s)return!1;if(d.interactable===t){if((u+=p===n.name?1:0)>=i)return!1;if(d.element===e&&(c++,p===n.name&&c>=a))return!1}}}return s>0}function Kt(t,e){return i.default.number(t)?(e.autoStart.maxInteractions=t,this):e.autoStart.maxInteractions}function Zt(t,e,n){var r=n.autoStart.cursorElement;r&&r!==t&&(r.style.cursor=""),t.ownerDocument.documentElement.style.cursor=e,t.style.cursor=e,n.autoStart.cursorElement=e?t:null}function Jt(t,e){var n=t.interactable,r=t.element,o=t.prepared;if("mouse"===t.pointerType&&n&&n.options.styleCursor){var a="";if(o.name){var s=n.options[o.name].cursorChecker;a=i.default.func(s)?s(o,n,r,t._interacting):e.actions.map[o.name].getCursor(o)}Zt(t.element,a||"",e)}else e.autoStart.cursorElement&&Zt(e.autoStart.cursorElement,"",e)}Object.defineProperty(Vt,"__esModule",{value:!0}),Vt.default=void 0;var Qt={id:"auto-start/base",before:["actions"],install:function(t){var e=t.interactStatic,n=t.defaults;t.usePlugin(Bt.default),n.base.actionChecker=null,n.base.styleCursor=!0,(0,j.default)(n.perAction,{manualStart:!1,max:1/0,maxPerElement:1,allowFrom:null,ignoreFrom:null,mouseButtons:1}),e.maxInteractions=function(e){return Kt(e,t)},t.autoStart={maxInteractions:1/0,withinInteractionLimit:Ht,cursorElement:null}},listeners:{"interactions:down":function(t,e){var n=t.interaction,r=t.pointer,o=t.event,i=t.eventTarget;n.interacting()||Gt(n,$t(n,r,o,i,e),e)},"interactions:move":function(t,e){!function(t,e){var n=t.interaction,r=t.pointer,o=t.event,i=t.eventTarget;"mouse"!==n.pointerType||n.pointerIsDown||n.interacting()||Gt(n,$t(n,r,o,i,e),e)}(t,e),function(t,e){var n=t.interaction;if(n.pointerIsDown&&!n.interacting()&&n.pointerWasMoved&&n.prepared.name){e.fire("autoStart:before-start",t);var r=n.interactable,o=n.prepared.name;o&&r&&(r.options[o].manualStart||!Ht(r,n.element,n.prepared,e)?n.stop():(n.start(n.prepared,r,n.element),Jt(n,e)))}}(t,e)},"interactions:stop":function(t,e){var n=t.interaction,r=n.interactable;r&&r.options.styleCursor&&Zt(n.element,"",e)}},maxInteractions:Kt,withinInteractionLimit:Ht,validateAction:Nt};Vt.default=Qt;var te={};Object.defineProperty(te,"__esModule",{value:!0}),te.default=void 0;var ee={id:"auto-start/dragAxis",listeners:{"autoStart:before-start":function(t,e){var n=t.interaction,r=t.eventTarget,o=t.dx,a=t.dy;if("drag"===n.prepared.name){var s=Math.abs(o),l=Math.abs(a),u=n.interactable.options.drag,c=u.startAxis,f=s>l?"x":s0&&(e.autoStartHoldTimer=setTimeout((function(){e.start(e.prepared,e.interactable,e.element)}),n))},"interactions:move":function(t){var e=t.interaction,n=t.duplicate;e.autoStartHoldTimer&&e.pointerWasMoved&&!n&&(clearTimeout(e.autoStartHoldTimer),e.autoStartHoldTimer=null)},"autoStart:before-start":function(t){var e=t.interaction;re(e)>0&&(e.prepared.name=null)}},getHoldDuration:re};ne.default=oe;var ie={};Object.defineProperty(ie,"__esModule",{value:!0}),ie.default=void 0;var ae={id:"auto-start",install:function(t){t.usePlugin(Vt.default),t.usePlugin(ne.default),t.usePlugin(te.default)}};ie.default=ae;var se={};function le(t){return/^(always|never|auto)$/.test(t)?(this.options.preventDefault=t,this):i.default.bool(t)?(this.options.preventDefault=t?"always":"never",this):this.options.preventDefault}function ue(t){var e=t.interaction,n=t.event;e.interactable&&e.interactable.checkAndPreventDefault(n)}function ce(t){var n=t.Interactable;n.prototype.preventDefault=le,n.prototype.checkAndPreventDefault=function(n){return function(t,n,r){var o=t.options.preventDefault;if("never"!==o)if("always"!==o){if(n.events.supportsPassive&&/^touch(start|move)$/.test(r.type)){var a=(0,e.getWindow)(r.target).document,s=n.getDocOptions(a);if(!s||!s.events||!1!==s.events.passive)return}/^(mouse|pointer|touch)*(down|start)/i.test(r.type)||i.default.element(r.target)&&(0,_.matchesSelector)(r.target,"input,select,textarea,[contenteditable=true],[contenteditable=true] *")||r.preventDefault()}else r.preventDefault()}(this,t,n)},t.interactions.docEvents.push({type:"dragstart",listener:function(e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=Array(e);n150)return null;var e=180*Math.atan2(t.prevEvent.velocityY,t.prevEvent.velocityX)/Math.PI;e<0&&(e+=360);var n=112.5<=e&&e<247.5,r=202.5<=e&&e<337.5;return{up:r,down:!r&&22.5<=e&&e<157.5,left:n,right:!n&&(292.5<=e||e<67.5),angle:e,speed:t.prevEvent.speed,velocity:{x:t.prevEvent.velocityX,y:t.prevEvent.velocityY}}}},{key:"preventDefault",value:function(){}},{key:"stopImmediatePropagation",value:function(){this.immediatePropagationStopped=this.propagationStopped=!0}},{key:"stopPropagation",value:function(){this.propagationStopped=!0}}])&&Ie(e.prototype,n),a}($.BaseEvent);je.InteractEvent=Fe,Object.defineProperties(Fe.prototype,{pageX:{get:function(){return this.page.x},set:function(t){this.page.x=t}},pageY:{get:function(){return this.page.y},set:function(t){this.page.y=t}},clientX:{get:function(){return this.client.x},set:function(t){this.client.x=t}},clientY:{get:function(){return this.client.y},set:function(t){this.client.y=t}},dx:{get:function(){return this.delta.x},set:function(t){this.delta.x=t}},dy:{get:function(){return this.delta.y},set:function(t){this.delta.y=t}},velocityX:{get:function(){return this.velocity.x},set:function(t){this.velocity.x=t}},velocityY:{get:function(){return this.velocity.y},set:function(t){this.velocity.y=t}}});var Xe={};function Ye(t,e,n){return e in t?Object.defineProperty(t,e,{value:n,enumerable:!0,configurable:!0,writable:!0}):t[e]=n,t}Object.defineProperty(Xe,"__esModule",{value:!0}),Xe.PointerInfo=void 0,Xe.PointerInfo=function t(e,n,r,o,i){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),Ye(this,"id",void 0),Ye(this,"pointer",void 0),Ye(this,"event",void 0),Ye(this,"downTime",void 0),Ye(this,"downTarget",void 0),this.id=e,this.pointer=n,this.event=r,this.downTime=o,this.downTarget=i};var Be,We,Le={};function Ue(t,e){for(var n=0;nthis.pointerMoveTolerance);var a=this.getPointerIndex(t),s={pointer:t,pointerIndex:a,pointerInfo:this.pointers[a],event:e,type:"move",eventTarget:n,dx:r,dy:o,duplicate:i,interaction:this};i||B.setCoordVelocity(this.coords.velocity,this.coords.delta),this._scopeFire("interactions:move",s),i||this.simulation||(this.interacting()&&(s.type=null,this.move(s)),this.pointerWasMoved&&B.copyCoords(this.coords.prev,this.coords.cur))}},{key:"move",value:function(t){t&&t.event||B.setZeroCoords(this.coords.delta),(t=(0,j.default)({pointer:this._latestPointer.pointer,event:this._latestPointer.event,eventTarget:this._latestPointer.eventTarget,interaction:this},t||{})).phase="move",this._doPhase(t)}},{key:"pointerUp",value:function(t,e,n,r){var o=this.getPointerIndex(t);-1===o&&(o=this.updatePointer(t,e,n,!1));var i=/cancel$/i.test(e.type)?"cancel":"up";this._scopeFire("interactions:".concat(i),{pointer:t,pointerIndex:o,pointerInfo:this.pointers[o],event:e,eventTarget:n,type:i,curEventTarget:r,interaction:this}),this.simulation||this.end(e),this.removePointer(t,e)}},{key:"documentBlur",value:function(t){this.end(t),this._scopeFire("interactions:blur",{event:t,type:"blur",interaction:this})}},{key:"end",value:function(t){var e;this._ending=!0,t=t||this._latestPointer.event,this.interacting()&&(e=this._doPhase({event:t,interaction:this,phase:"end"})),this._ending=!1,!0===e&&this.stop()}},{key:"currentAction",value:function(){return this._interacting?this.prepared.name:null}},{key:"interacting",value:function(){return this._interacting}},{key:"stop",value:function(){this._scopeFire("interactions:stop",{interaction:this}),this.interactable=this.element=null,this._interacting=!1,this._stopped=!0,this.prepared.name=this.prevEvent=null}},{key:"getPointerIndex",value:function(t){var e=B.getPointerId(t);return"mouse"===this.pointerType||"pen"===this.pointerType?this.pointers.length-1:Z.findIndex(this.pointers,(function(t){return t.id===e}))}},{key:"getPointerInfo",value:function(t){return this.pointers[this.getPointerIndex(t)]}},{key:"updatePointer",value:function(t,e,n,r){var o=B.getPointerId(t),i=this.getPointerIndex(t),a=this.pointers[i];return r=!1!==r&&(r||/(down|start)$/i.test(e.type)),a?a.pointer=t:(a=new Xe.PointerInfo(o,t,e,null,null),i=this.pointers.length,this.pointers.push(a)),B.setCoords(this.coords.cur,this.pointers.map((function(t){return t.pointer})),this._now()),B.setCoordDeltas(this.coords.delta,this.coords.prev,this.coords.cur),r&&(this.pointerIsDown=!0,a.downTime=this.coords.cur.timeStamp,a.downTarget=n,B.pointerExtend(this.downPointer,t),this.interacting()||(B.copyCoords(this.coords.start,this.coords.cur),B.copyCoords(this.coords.prev,this.coords.cur),this.downEvent=e,this.pointerWasMoved=!1)),this._updateLatestPointer(t,e,n),this._scopeFire("interactions:update-pointer",{pointer:t,event:e,eventTarget:n,down:r,pointerInfo:a,pointerIndex:i,interaction:this}),i}},{key:"removePointer",value:function(t,e){var n=this.getPointerIndex(t);if(-1!==n){var r=this.pointers[n];this._scopeFire("interactions:remove-pointer",{pointer:t,event:e,eventTarget:null,pointerIndex:n,pointerInfo:r,interaction:this}),this.pointers.splice(n,1),this.pointerIsDown=!1}}},{key:"_updateLatestPointer",value:function(t,e,n){this._latestPointer.pointer=t,this._latestPointer.event=e,this._latestPointer.eventTarget=n}},{key:"destroy",value:function(){this._latestPointer.pointer=null,this._latestPointer.event=null,this._latestPointer.eventTarget=null}},{key:"_createPreparedEvent",value:function(t,e,n,r){return new je.InteractEvent(this,t,this.prepared.name,e,this.element,n,r)}},{key:"_fireEvent",value:function(t){this.interactable.fire(t),(!this.prevEvent||t.timeStamp>=this.prevEvent.timeStamp)&&(this.prevEvent=t)}},{key:"_doPhase",value:function(t){var e=t.event,n=t.phase,r=t.preEnd,o=t.type,i=this.rect;if(i&&"move"===n&&(k.addEdges(this.edges,i,this.coords.delta[this.interactable.options.deltaSource]),i.width=i.right-i.left,i.height=i.bottom-i.top),!1===this._scopeFire("interactions:before-action-".concat(n),t))return!1;var a=t.iEvent=this._createPreparedEvent(e,n,r,o);return this._scopeFire("interactions:action-".concat(n),t),"start"===n&&(this.prevEvent=a),this._fireEvent(a),this._scopeFire("interactions:after-action-".concat(n),t),!0}},{key:"_now",value:function(){return Date.now()}}])&&Ue(e.prototype,n),t}();Le.Interaction=qe;var $e=qe;Le.default=$e;var Ge={};function He(t){t.pointerIsDown&&(Qe(t.coords.cur,t.offset.total),t.offset.pending.x=0,t.offset.pending.y=0)}function Ke(t){Ze(t.interaction)}function Ze(t){if(!function(t){return!(!t.offset.pending.x&&!t.offset.pending.y)}(t))return!1;var e=t.offset.pending;return Qe(t.coords.cur,e),Qe(t.coords.delta,e),k.addEdges(t.edges,t.rect,e),e.x=0,e.y=0,!0}function Je(t){var e=t.x,n=t.y;this.offset.pending.x+=e,this.offset.pending.y+=n,this.offset.total.x+=e,this.offset.total.y+=n}function Qe(t,e){var n=t.page,r=t.client,o=e.x,i=e.y;n.x+=o,n.y+=i,r.x+=o,r.y+=i}Object.defineProperty(Ge,"__esModule",{value:!0}),Ge.addTotal=He,Ge.applyPending=Ze,Ge.default=void 0,Le._ProxyMethods.offsetBy="";var tn={id:"offset",before:["modifiers","pointer-events","actions","inertia"],install:function(t){t.Interaction.prototype.offsetBy=Je},listeners:{"interactions:new":function(t){t.interaction.offset={total:{x:0,y:0},pending:{x:0,y:0}}},"interactions:update-pointer":function(t){return He(t.interaction)},"interactions:before-action-start":Ke,"interactions:before-action-move":Ke,"interactions:before-action-end":function(t){var e=t.interaction;if(Ze(e))return e.move({offset:!0}),e.end(),!1},"interactions:stop":function(t){var e=t.interaction;e.offset.total.x=0,e.offset.total.y=0,e.offset.pending.x=0,e.offset.pending.y=0}}};Ge.default=tn;var en={};function nn(t,e){for(var n=0;nn.minSpeed&&o>n.endSpeed)this.startInertia();else{if(i.result=i.setAll(this.modifierArg),!i.result.changed)return!1;this.startSmoothEnd()}return e.modification.result.rect=null,e.offsetBy(this.targetOffset),e._doPhase({interaction:e,event:t,phase:"inertiastart"}),e.offsetBy({x:-this.targetOffset.x,y:-this.targetOffset.y}),e.modification.result.rect=null,this.active=!0,e.simulation=this,!0}},{key:"startInertia",value:function(){var t=this,e=this.interaction.coords.velocity.client,n=an(this.interaction),r=n.resistance,o=-Math.log(n.endSpeed/this.v0)/r;this.targetOffset={x:(e.x-o)/r,y:(e.y-o)/r},this.te=o,this.lambda_v0=r/this.v0,this.one_ve_v0=1-n.endSpeed/this.v0;var i=this.modification,a=this.modifierArg;a.pageCoords={x:this.startCoords.x+this.targetOffset.x,y:this.startCoords.y+this.targetOffset.y},i.result=i.setAll(a),i.result.changed&&(this.isModified=!0,this.modifiedOffset={x:this.targetOffset.x+i.result.delta.x,y:this.targetOffset.y+i.result.delta.y}),this.onNextFrame((function(){return t.inertiaTick()}))}},{key:"startSmoothEnd",value:function(){var t=this;this.smoothEnd=!0,this.isModified=!0,this.targetOffset={x:this.modification.result.delta.x,y:this.modification.result.delta.y},this.onNextFrame((function(){return t.smoothEndTick()}))}},{key:"onNextFrame",value:function(t){var e=this;this.timeout=jt.default.request((function(){e.active&&t()}))}},{key:"inertiaTick",value:function(){var t,e,n,r,o,i=this,a=this.interaction,s=an(a).resistance,l=(a._now()-this.t0)/1e3;if(l=0;n--){var r=e[n],o=r.selector,a=r.context,s=r.listeners;o===this.target&&a===this._context&&e.splice(n,1);for(var l=s.length-1;l>=0;l--)this._scopeEvents.removeDelegate(this.target,this._context,t,s[l][0],s[l][1])}else this._scopeEvents.remove(this.target,"all")}}])&&mn(n.prototype,r),t}();yn.Interactable=xn;var wn={};function _n(t,e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=Array(e);n=0;a--){var p=f[a];if(p.selector===t&&p.context===e){for(var v=p.listeners,h=v.length-1;h>=0;h--){var g=Mn(v[h],2),y=g[0],m=g[1],b=m.capture,x=m.passive;if(y===o&&b===s.capture&&x===s.passive){v.splice(h,1),v.length||(f.splice(a,1),l(e,n,u),l(e,n,c,!0)),d=!0;break}}if(d)break}}},delegateListener:u,delegateUseCapture:c,delegatedEvents:r,documents:o,targets:n,supportsOptions:!1,supportsPassive:!1};function s(t,e,r,o){var i=In(o),s=Z.find(n,(function(e){return e.eventTarget===t}));s||(s={eventTarget:t,events:{}},n.push(s)),s.events[e]||(s.events[e]=[]),t.addEventListener&&!Z.contains(s.events[e],r)&&(t.addEventListener(e,r,a.supportsOptions?i:i.capture),s.events[e].push(r))}function l(t,e,r,o){var i=In(o),s=Z.findIndex(n,(function(e){return e.eventTarget===t})),u=n[s];if(u&&u.events)if("all"!==e){var c=!1,f=u.events[e];if(f){if("all"===r){for(var d=f.length-1;d>=0;d--)l(t,e,f[d],i);return}for(var p=0;p=2)continue;if(!o.interacting()&&e===o.pointerType)return o}return null}};function zn(t,e){return t.pointers.some((function(t){return t.id===e}))}var Cn=Rn;An.default=Cn;var Fn={};function Xn(t){return(Xn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Yn(t,e){return function(t){if(Array.isArray(t))return t}(t)||function(t,e){if("undefined"!=typeof Symbol&&Symbol.iterator in Object(t)){var n=[],r=!0,o=!1,i=void 0;try{for(var a,s=t[Symbol.iterator]();!(r=(a=s.next()).done)&&(n.push(a.value),!e||n.length!==e);r=!0);}catch(t){o=!0,i=t}finally{try{r||null==s.return||s.return()}finally{if(o)throw i}}return n}}(t,e)||function(t,e){if(t){if("string"==typeof t)return Bn(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);return"Object"===n&&t.constructor&&(n=t.constructor.name),"Map"===n||"Set"===n?Array.from(t):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Bn(t,e):void 0}}(t,e)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function Bn(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,r=Array(e);n=0;r--){var o=e.interactions.list[r];o.interactable===n&&(o.stop(),e.fire("interactions:destroy",{interaction:o}),o.destroy(),e.interactions.list.length>2&&e.interactions.list.splice(r,1))}}},onDocSignal:Hn,doOnInteractions:$n,methodNames:qn};Fn.default=Kn;var Zn={};function Jn(t){return(Jn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Qn(t,e,n){return(Qn="undefined"!=typeof Reflect&&Reflect.get?Reflect.get:function(t,e,n){var r=function(t,e){for(;!Object.prototype.hasOwnProperty.call(t,e)&&null!==(t=nr(t)););return t}(t,e);if(r){var o=Object.getOwnPropertyDescriptor(r,e);return o.get?o.get.call(n):o.value}})(t,e,n||t)}function tr(t,e){return(tr=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function er(t,e){return!e||"object"!==Jn(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function nr(t){return(nr=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}function rr(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function or(t,e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=Array(e);nMath.abs(l.y),s.coords,s.rect),(0,j.default)(r,s.coords)),s.eventProps},defaults:{ratio:"preserve",equalDelta:!1,modifiers:[],enabled:!1}};function Tr(t,e,n){var r=t.startCoords,o=t.edgeSign;e?n.y=r.y+(n.x-r.x)*o:n.x=r.x+(n.y-r.y)*o}function Mr(t,e,n,r){var o=t.startRect,i=t.startCoords,a=t.ratio,s=t.edgeSign;if(e){var l=r.width/a;n.y=i.y+(l-o.height)*s}else{var u=r.height*a;n.x=i.x+(u-o.width)*s}}_r.aspectRatio=Er;var jr=(0,Se.makeModifier)(Er,"aspectRatio");_r.default=jr;var kr={};Object.defineProperty(kr,"__esModule",{value:!0}),kr.default=void 0;var Ir=function(){};Ir._defaults={};var Dr=Ir;kr.default=Dr;var Ar={};Object.defineProperty(Ar,"__esModule",{value:!0}),Object.defineProperty(Ar,"default",{enumerable:!0,get:function(){return kr.default}});var Rr={};function zr(t,e,n){return i.default.func(t)?k.resolveRectLike(t,e.interactable,e.element,[n.x,n.y,e]):k.resolveRectLike(t,e.interactable,e.element)}Object.defineProperty(Rr,"__esModule",{value:!0}),Rr.getRestrictionRect=zr,Rr.restrict=Rr.default=void 0;var Cr={start:function(t){var e=t.rect,n=t.startOffset,r=t.state,o=t.interaction,i=t.pageCoords,a=r.options,s=a.elementRect,l=(0,j.default)({left:0,top:0,right:0,bottom:0},a.offset||{});if(e&&s){var u=zr(a.restriction,o,i);if(u){var c=u.right-u.left-e.width,f=u.bottom-u.top-e.height;c<0&&(l.left+=c,l.right+=c),f<0&&(l.top+=f,l.bottom+=f)}l.left+=n.left-e.width*s.left,l.top+=n.top-e.height*s.top,l.right+=n.right-e.width*(1-s.right),l.bottom+=n.bottom-e.height*(1-s.bottom)}r.offset=l},set:function(t){var e=t.coords,n=t.interaction,r=t.state,o=r.options,i=r.offset,a=zr(o.restriction,n,e);if(a){var s=k.xywhToTlbr(a);e.x=Math.max(Math.min(s.right-i.right,e.x),s.left+i.left),e.y=Math.max(Math.min(s.bottom-i.bottom,e.y),s.top+i.top)}},defaults:{restriction:null,elementRect:null,offset:null,endOnly:!1,enabled:!1}};Rr.restrict=Cr;var Fr=(0,Se.makeModifier)(Cr,"restrict");Rr.default=Fr;var Xr={};Object.defineProperty(Xr,"__esModule",{value:!0}),Xr.restrictEdges=Xr.default=void 0;var Yr={top:1/0,left:1/0,bottom:-1/0,right:-1/0},Br={top:-1/0,left:-1/0,bottom:1/0,right:1/0};function Wr(t,e){for(var n=["top","left","bottom","right"],r=0;rt.length)&&(e=t.length);for(var n=0,r=Array(e);n":">",'"':""","'":"'","/":"/"};return"string"!=typeof e?e:String(e).replace(/[&<>"'\/\\]/g,function(e){return t[e]})},i.appendMany=function(e,t){if("1.7"===o.fn.jquery.substr(0,3)){var n=o();o.map(t,function(e){n=n.add(e)}),t=n}e.append(t)},i.__cache={};var n=0;return i.GetUniqueElementId=function(e){var t=e.getAttribute("data-select2-id");return null==t&&(e.id?(t=e.id,e.setAttribute("data-select2-id",t)):(e.setAttribute("data-select2-id",++n),t=n.toString())),t},i.StoreData=function(e,t,n){var r=i.GetUniqueElementId(e);i.__cache[r]||(i.__cache[r]={}),i.__cache[r][t]=n},i.GetData=function(e,t){var n=i.GetUniqueElementId(e);return t?i.__cache[n]&&null!=i.__cache[n][t]?i.__cache[n][t]:o(e).data(t):i.__cache[n]},i.RemoveData=function(e){var t=i.GetUniqueElementId(e);null!=i.__cache[t]&&delete i.__cache[t],e.removeAttribute("data-select2-id")},i}),e.define("select2/results",["jquery","./utils"],function(h,f){function r(e,t,n){this.$element=e,this.data=n,this.options=t,r.__super__.constructor.call(this)}return f.Extend(r,f.Observable),r.prototype.render=function(){var e=h('');return this.options.get("multiple")&&e.attr("aria-multiselectable","true"),this.$results=e},r.prototype.clear=function(){this.$results.empty()},r.prototype.displayMessage=function(e){var t=this.options.get("escapeMarkup");this.clear(),this.hideLoading();var n=h(''),r=this.options.get("translations").get(e.message);n.append(t(r(e.args))),n[0].className+=" select2-results__message",this.$results.append(n)},r.prototype.hideMessages=function(){this.$results.find(".select2-results__message").remove()},r.prototype.append=function(e){this.hideLoading();var t=[];if(null!=e.results&&0!==e.results.length){e.results=this.sort(e.results);for(var n=0;n",{class:"select2-results__options select2-results__options--nested"});p.append(l),s.append(a),s.append(p)}else this.template(e,t);return f.StoreData(t,"data",e),t},r.prototype.bind=function(t,e){var l=this,n=t.id+"-results";this.$results.attr("id",n),t.on("results:all",function(e){l.clear(),l.append(e.data),t.isOpen()&&(l.setClasses(),l.highlightFirstItem())}),t.on("results:append",function(e){l.append(e.data),t.isOpen()&&l.setClasses()}),t.on("query",function(e){l.hideMessages(),l.showLoading(e)}),t.on("select",function(){t.isOpen()&&(l.setClasses(),l.options.get("scrollAfterSelect")&&l.highlightFirstItem())}),t.on("unselect",function(){t.isOpen()&&(l.setClasses(),l.options.get("scrollAfterSelect")&&l.highlightFirstItem())}),t.on("open",function(){l.$results.attr("aria-expanded","true"),l.$results.attr("aria-hidden","false"),l.setClasses(),l.ensureHighlightVisible()}),t.on("close",function(){l.$results.attr("aria-expanded","false"),l.$results.attr("aria-hidden","true"),l.$results.removeAttr("aria-activedescendant")}),t.on("results:toggle",function(){var e=l.getHighlightedResults();0!==e.length&&e.trigger("mouseup")}),t.on("results:select",function(){var e=l.getHighlightedResults();if(0!==e.length){var t=f.GetData(e[0],"data");"true"==e.attr("aria-selected")?l.trigger("close",{}):l.trigger("select",{data:t})}}),t.on("results:previous",function(){var e=l.getHighlightedResults(),t=l.$results.find("[aria-selected]"),n=t.index(e);if(!(n<=0)){var r=n-1;0===e.length&&(r=0);var i=t.eq(r);i.trigger("mouseenter");var o=l.$results.offset().top,s=i.offset().top,a=l.$results.scrollTop()+(s-o);0===r?l.$results.scrollTop(0):s-o<0&&l.$results.scrollTop(a)}}),t.on("results:next",function(){var e=l.getHighlightedResults(),t=l.$results.find("[aria-selected]"),n=t.index(e)+1;if(!(n>=t.length)){var r=t.eq(n);r.trigger("mouseenter");var i=l.$results.offset().top+l.$results.outerHeight(!1),o=r.offset().top+r.outerHeight(!1),s=l.$results.scrollTop()+o-i;0===n?l.$results.scrollTop(0):ithis.$results.outerHeight()||o<0)&&this.$results.scrollTop(i)}},r.prototype.template=function(e,t){var n=this.options.get("templateResult"),r=this.options.get("escapeMarkup"),i=n(e,t);null==i?t.style.display="none":"string"==typeof i?t.innerHTML=r(i):h(t).append(i)},r}),e.define("select2/keys",[],function(){return{BACKSPACE:8,TAB:9,ENTER:13,SHIFT:16,CTRL:17,ALT:18,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,DELETE:46}}),e.define("select2/selection/base",["jquery","../utils","../keys"],function(n,r,i){function o(e,t){this.$element=e,this.options=t,o.__super__.constructor.call(this)}return r.Extend(o,r.Observable),o.prototype.render=function(){var e=n('');return this._tabindex=0,null!=r.GetData(this.$element[0],"old-tabindex")?this._tabindex=r.GetData(this.$element[0],"old-tabindex"):null!=this.$element.attr("tabindex")&&(this._tabindex=this.$element.attr("tabindex")),e.attr("title",this.$element.attr("title")),e.attr("tabindex",this._tabindex),e.attr("aria-disabled","false"),this.$selection=e},o.prototype.bind=function(e,t){var n=this,r=e.id+"-results";this.container=e,this.$selection.on("focus",function(e){n.trigger("focus",e)}),this.$selection.on("blur",function(e){n._handleBlur(e)}),this.$selection.on("keydown",function(e){n.trigger("keypress",e),e.which===i.SPACE&&e.preventDefault()}),e.on("results:focus",function(e){n.$selection.attr("aria-activedescendant",e.data._resultId)}),e.on("selection:update",function(e){n.update(e.data)}),e.on("open",function(){n.$selection.attr("aria-expanded","true"),n.$selection.attr("aria-owns",r),n._attachCloseHandler(e)}),e.on("close",function(){n.$selection.attr("aria-expanded","false"),n.$selection.removeAttr("aria-activedescendant"),n.$selection.removeAttr("aria-owns"),n.$selection.trigger("focus"),n._detachCloseHandler(e)}),e.on("enable",function(){n.$selection.attr("tabindex",n._tabindex),n.$selection.attr("aria-disabled","false")}),e.on("disable",function(){n.$selection.attr("tabindex","-1"),n.$selection.attr("aria-disabled","true")})},o.prototype._handleBlur=function(e){var t=this;window.setTimeout(function(){document.activeElement==t.$selection[0]||n.contains(t.$selection[0],document.activeElement)||t.trigger("blur",e)},1)},o.prototype._attachCloseHandler=function(e){n(document.body).on("mousedown.select2."+e.id,function(e){var t=n(e.target).closest(".select2");n(".select2.select2-container--open").each(function(){this!=t[0]&&r.GetData(this,"element").select2("close")})})},o.prototype._detachCloseHandler=function(e){n(document.body).off("mousedown.select2."+e.id)},o.prototype.position=function(e,t){t.find(".selection").append(e)},o.prototype.destroy=function(){this._detachCloseHandler(this.container)},o.prototype.update=function(e){throw new Error("The `update` method must be defined in child classes.")},o.prototype.isEnabled=function(){return!this.isDisabled()},o.prototype.isDisabled=function(){return this.options.get("disabled")},o}),e.define("select2/selection/single",["jquery","./base","../utils","../keys"],function(e,t,n,r){function i(){i.__super__.constructor.apply(this,arguments)}return n.Extend(i,t),i.prototype.render=function(){var e=i.__super__.render.call(this);return e.addClass("select2-selection--single"),e.html(''),e},i.prototype.bind=function(t,e){var n=this;i.__super__.bind.apply(this,arguments);var r=t.id+"-container";this.$selection.find(".select2-selection__rendered").attr("id",r).attr("role","textbox").attr("aria-readonly","true"),this.$selection.attr("aria-labelledby",r),this.$selection.on("mousedown",function(e){1===e.which&&n.trigger("toggle",{originalEvent:e})}),this.$selection.on("focus",function(e){}),this.$selection.on("blur",function(e){}),t.on("focus",function(e){t.isOpen()||n.$selection.trigger("focus")})},i.prototype.clear=function(){var e=this.$selection.find(".select2-selection__rendered");e.empty(),e.removeAttr("title")},i.prototype.display=function(e,t){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(e,t))},i.prototype.selectionContainer=function(){return e("")},i.prototype.update=function(e){if(0!==e.length){var t=e[0],n=this.$selection.find(".select2-selection__rendered"),r=this.display(t,n);n.empty().append(r);var i=t.title||t.text;i?n.attr("title",i):n.removeAttr("title")}else this.clear()},i}),e.define("select2/selection/multiple",["jquery","./base","../utils"],function(i,e,l){function n(e,t){n.__super__.constructor.apply(this,arguments)}return l.Extend(n,e),n.prototype.render=function(){var e=n.__super__.render.call(this);return e.addClass("select2-selection--multiple"),e.html(''),e},n.prototype.bind=function(e,t){var r=this;n.__super__.bind.apply(this,arguments),this.$selection.on("click",function(e){r.trigger("toggle",{originalEvent:e})}),this.$selection.on("click",".select2-selection__choice__remove",function(e){if(!r.isDisabled()){var t=i(this).parent(),n=l.GetData(t[0],"data");r.trigger("unselect",{originalEvent:e,data:n})}})},n.prototype.clear=function(){var e=this.$selection.find(".select2-selection__rendered");e.empty(),e.removeAttr("title")},n.prototype.display=function(e,t){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(e,t))},n.prototype.selectionContainer=function(){return i('×')},n.prototype.update=function(e){if(this.clear(),0!==e.length){for(var t=[],n=0;n×');a.StoreData(r[0],"data",t),this.$selection.find(".select2-selection__rendered").prepend(r)}},e}),e.define("select2/selection/search",["jquery","../utils","../keys"],function(r,a,l){function e(e,t,n){e.call(this,t,n)}return e.prototype.render=function(e){var t=r('');this.$searchContainer=t,this.$search=t.find("input");var n=e.call(this);return this._transferTabIndex(),n},e.prototype.bind=function(e,t,n){var r=this,i=t.id+"-results";e.call(this,t,n),t.on("open",function(){r.$search.attr("aria-controls",i),r.$search.trigger("focus")}),t.on("close",function(){r.$search.val(""),r.$search.removeAttr("aria-controls"),r.$search.removeAttr("aria-activedescendant"),r.$search.trigger("focus")}),t.on("enable",function(){r.$search.prop("disabled",!1),r._transferTabIndex()}),t.on("disable",function(){r.$search.prop("disabled",!0)}),t.on("focus",function(e){r.$search.trigger("focus")}),t.on("results:focus",function(e){e.data._resultId?r.$search.attr("aria-activedescendant",e.data._resultId):r.$search.removeAttr("aria-activedescendant")}),this.$selection.on("focusin",".select2-search--inline",function(e){r.trigger("focus",e)}),this.$selection.on("focusout",".select2-search--inline",function(e){r._handleBlur(e)}),this.$selection.on("keydown",".select2-search--inline",function(e){if(e.stopPropagation(),r.trigger("keypress",e),r._keyUpPrevented=e.isDefaultPrevented(),e.which===l.BACKSPACE&&""===r.$search.val()){var t=r.$searchContainer.prev(".select2-selection__choice");if(0this.maximumInputLength?this.trigger("results:message",{message:"inputTooLong",args:{maximum:this.maximumInputLength,input:t.term,params:t}}):e.call(this,t,n)},e}),e.define("select2/data/maximumSelectionLength",[],function(){function e(e,t,n){this.maximumSelectionLength=n.get("maximumSelectionLength"),e.call(this,t,n)}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("select",function(){r._checkIfMaximumSelected()})},e.prototype.query=function(e,t,n){var r=this;this._checkIfMaximumSelected(function(){e.call(r,t,n)})},e.prototype._checkIfMaximumSelected=function(e,n){var r=this;this.current(function(e){var t=null!=e?e.length:0;0=r.maximumSelectionLength?r.trigger("results:message",{message:"maximumSelected",args:{maximum:r.maximumSelectionLength}}):n&&n()})},e}),e.define("select2/dropdown",["jquery","./utils"],function(t,e){function n(e,t){this.$element=e,this.options=t,n.__super__.constructor.call(this)}return e.Extend(n,e.Observable),n.prototype.render=function(){var e=t('');return e.attr("dir",this.options.get("dir")),this.$dropdown=e},n.prototype.bind=function(){},n.prototype.position=function(e,t){},n.prototype.destroy=function(){this.$dropdown.remove()},n}),e.define("select2/dropdown/search",["jquery","../utils"],function(o,e){function t(){}return t.prototype.render=function(e){var t=e.call(this),n=o('');return this.$searchContainer=n,this.$search=n.find("input"),t.prepend(n),t},t.prototype.bind=function(e,t,n){var r=this,i=t.id+"-results";e.call(this,t,n),this.$search.on("keydown",function(e){r.trigger("keypress",e),r._keyUpPrevented=e.isDefaultPrevented()}),this.$search.on("input",function(e){o(this).off("keyup")}),this.$search.on("keyup input",function(e){r.handleSearch(e)}),t.on("open",function(){r.$search.attr("tabindex",0),r.$search.attr("aria-controls",i),r.$search.trigger("focus"),window.setTimeout(function(){r.$search.trigger("focus")},0)}),t.on("close",function(){r.$search.attr("tabindex",-1),r.$search.removeAttr("aria-controls"),r.$search.removeAttr("aria-activedescendant"),r.$search.val(""),r.$search.trigger("blur")}),t.on("focus",function(){t.isOpen()||r.$search.trigger("focus")}),t.on("results:all",function(e){null!=e.query.term&&""!==e.query.term||(r.showSearch(e)?r.$searchContainer.removeClass("select2-search--hide"):r.$searchContainer.addClass("select2-search--hide"))}),t.on("results:focus",function(e){e.data._resultId?r.$search.attr("aria-activedescendant",e.data._resultId):r.$search.removeAttr("aria-activedescendant")})},t.prototype.handleSearch=function(e){if(!this._keyUpPrevented){var t=this.$search.val();this.trigger("query",{term:t})}this._keyUpPrevented=!1},t.prototype.showSearch=function(e,t){return!0},t}),e.define("select2/dropdown/hidePlaceholder",[],function(){function e(e,t,n,r){this.placeholder=this.normalizePlaceholder(n.get("placeholder")),e.call(this,t,n,r)}return e.prototype.append=function(e,t){t.results=this.removePlaceholder(t.results),e.call(this,t)},e.prototype.normalizePlaceholder=function(e,t){return"string"==typeof t&&(t={id:"",text:t}),t},e.prototype.removePlaceholder=function(e,t){for(var n=t.slice(0),r=t.length-1;0<=r;r--){var i=t[r];this.placeholder.id===i.id&&n.splice(r,1)}return n},e}),e.define("select2/dropdown/infiniteScroll",["jquery"],function(n){function e(e,t,n,r){this.lastParams={},e.call(this,t,n,r),this.$loadingMore=this.createLoadingMore(),this.loading=!1}return e.prototype.append=function(e,t){this.$loadingMore.remove(),this.loading=!1,e.call(this,t),this.showLoadingMore(t)&&(this.$results.append(this.$loadingMore),this.loadMoreIfNeeded())},e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("query",function(e){r.lastParams=e,r.loading=!0}),t.on("query:append",function(e){r.lastParams=e,r.loading=!0}),this.$results.on("scroll",this.loadMoreIfNeeded.bind(this))},e.prototype.loadMoreIfNeeded=function(){var e=n.contains(document.documentElement,this.$loadingMore[0]);if(!this.loading&&e){var t=this.$results.offset().top+this.$results.outerHeight(!1);this.$loadingMore.offset().top+this.$loadingMore.outerHeight(!1)<=t+50&&this.loadMore()}},e.prototype.loadMore=function(){this.loading=!0;var e=n.extend({},{page:1},this.lastParams);e.page++,this.trigger("query:append",e)},e.prototype.showLoadingMore=function(e,t){return t.pagination&&t.pagination.more},e.prototype.createLoadingMore=function(){var e=n(''),t=this.options.get("translations").get("loadingMore");return e.html(t(this.lastParams)),e},e}),e.define("select2/dropdown/attachBody",["jquery","../utils"],function(f,a){function e(e,t,n){this.$dropdownParent=f(n.get("dropdownParent")||document.body),e.call(this,t,n)}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("open",function(){r._showDropdown(),r._attachPositioningHandler(t),r._bindContainerResultHandlers(t)}),t.on("close",function(){r._hideDropdown(),r._detachPositioningHandler(t)}),this.$dropdownContainer.on("mousedown",function(e){e.stopPropagation()})},e.prototype.destroy=function(e){e.call(this),this.$dropdownContainer.remove()},e.prototype.position=function(e,t,n){t.attr("class",n.attr("class")),t.removeClass("select2"),t.addClass("select2-container--open"),t.css({position:"absolute",top:-999999}),this.$container=n},e.prototype.render=function(e){var t=f(""),n=e.call(this);return t.append(n),this.$dropdownContainer=t},e.prototype._hideDropdown=function(e){this.$dropdownContainer.detach()},e.prototype._bindContainerResultHandlers=function(e,t){if(!this._containerResultsHandlersBound){var n=this;t.on("results:all",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("results:append",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("results:message",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("select",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("unselect",function(){n._positionDropdown(),n._resizeDropdown()}),this._containerResultsHandlersBound=!0}},e.prototype._attachPositioningHandler=function(e,t){var n=this,r="scroll.select2."+t.id,i="resize.select2."+t.id,o="orientationchange.select2."+t.id,s=this.$container.parents().filter(a.hasScroll);s.each(function(){a.StoreData(this,"select2-scroll-position",{x:f(this).scrollLeft(),y:f(this).scrollTop()})}),s.on(r,function(e){var t=a.GetData(this,"select2-scroll-position");f(this).scrollTop(t.y)}),f(window).on(r+" "+i+" "+o,function(e){n._positionDropdown(),n._resizeDropdown()})},e.prototype._detachPositioningHandler=function(e,t){var n="scroll.select2."+t.id,r="resize.select2."+t.id,i="orientationchange.select2."+t.id;this.$container.parents().filter(a.hasScroll).off(n),f(window).off(n+" "+r+" "+i)},e.prototype._positionDropdown=function(){var e=f(window),t=this.$dropdown.hasClass("select2-dropdown--above"),n=this.$dropdown.hasClass("select2-dropdown--below"),r=null,i=this.$container.offset();i.bottom=i.top+this.$container.outerHeight(!1);var o={height:this.$container.outerHeight(!1)};o.top=i.top,o.bottom=i.top+o.height;var s=this.$dropdown.outerHeight(!1),a=e.scrollTop(),l=e.scrollTop()+e.height(),c=ai.bottom+s,d={left:i.left,top:o.bottom},p=this.$dropdownParent;"static"===p.css("position")&&(p=p.offsetParent());var h={top:0,left:0};(f.contains(document.body,p[0])||p[0].isConnected)&&(h=p.offset()),d.top-=h.top,d.left-=h.left,t||n||(r="below"),u||!c||t?!c&&u&&t&&(r="below"):r="above",("above"==r||t&&"below"!==r)&&(d.top=o.top-h.top-s),null!=r&&(this.$dropdown.removeClass("select2-dropdown--below select2-dropdown--above").addClass("select2-dropdown--"+r),this.$container.removeClass("select2-container--below select2-container--above").addClass("select2-container--"+r)),this.$dropdownContainer.css(d)},e.prototype._resizeDropdown=function(){var e={width:this.$container.outerWidth(!1)+"px"};this.options.get("dropdownAutoWidth")&&(e.minWidth=e.width,e.position="relative",e.width="auto"),this.$dropdown.css(e)},e.prototype._showDropdown=function(e){this.$dropdownContainer.appendTo(this.$dropdownParent),this._positionDropdown(),this._resizeDropdown()},e}),e.define("select2/dropdown/minimumResultsForSearch",[],function(){function e(e,t,n,r){this.minimumResultsForSearch=n.get("minimumResultsForSearch"),this.minimumResultsForSearch<0&&(this.minimumResultsForSearch=1/0),e.call(this,t,n,r)}return e.prototype.showSearch=function(e,t){return!(function e(t){for(var n=0,r=0;r');return e.attr("dir",this.options.get("dir")),this.$container=e,this.$container.addClass("select2-container--"+this.options.get("theme")),u.StoreData(e[0],"element",this.$element),e},d}),e.define("jquery-mousewheel",["jquery"],function(e){return e}),e.define("jquery.select2",["jquery","jquery-mousewheel","./select2/core","./select2/defaults","./select2/utils"],function(i,e,o,t,s){if(null==i.fn.select2){var a=["open","close","destroy"];i.fn.select2=function(t){if("object"==typeof(t=t||{}))return this.each(function(){var e=i.extend(!0,{},t);new o(i(this),e)}),this;if("string"!=typeof t)throw new Error("Invalid arguments for Select2: "+t);var n,r=Array.prototype.slice.call(arguments,1);return this.each(function(){var e=s.GetData(this,"select2");null==e&&window.console&&console.error&&console.error("The select2('"+t+"') method was called on an element that is not using Select2."),n=e[t].apply(e,r)}),-1.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--default .select2-results__option[role=group]{padding:0}.select2-container--default .select2-results__option[aria-disabled=true]{color:#999}.select2-container--default .select2-results__option[aria-selected=true]{background-color:#ddd}.select2-container--default .select2-results__option .select2-results__option{padding-left:1em}.select2-container--default .select2-results__option .select2-results__option .select2-results__group{padding-left:0}.select2-container--default .select2-results__option .select2-results__option .select2-results__option{margin-left:-1em;padding-left:2em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-2em;padding-left:3em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-3em;padding-left:4em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-4em;padding-left:5em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-5em;padding-left:6em}.select2-container--default .select2-results__option--highlighted[aria-selected]{background-color:#5897fb;color:white}.select2-container--default .select2-results__group{cursor:default;display:block;padding:6px}.select2-container--classic .select2-selection--single{background-color:#f7f7f7;border:1px solid #aaa;border-radius:4px;outline:0;background-image:-webkit-linear-gradient(top, #fff 50%, #eee 100%);background-image:-o-linear-gradient(top, #fff 50%, #eee 100%);background-image:linear-gradient(to bottom, #fff 50%, #eee 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#FFFFFFFF', endColorstr='#FFEEEEEE', GradientType=0)}.select2-container--classic .select2-selection--single:focus{border:1px solid #5897fb}.select2-container--classic .select2-selection--single .select2-selection__rendered{color:#444;line-height:28px}.select2-container--classic .select2-selection--single .select2-selection__clear{cursor:pointer;float:right;font-weight:bold;margin-right:10px}.select2-container--classic .select2-selection--single .select2-selection__placeholder{color:#999}.select2-container--classic .select2-selection--single .select2-selection__arrow{background-color:#ddd;border:none;border-left:1px solid #aaa;border-top-right-radius:4px;border-bottom-right-radius:4px;height:26px;position:absolute;top:1px;right:1px;width:20px;background-image:-webkit-linear-gradient(top, #eee 50%, #ccc 100%);background-image:-o-linear-gradient(top, #eee 50%, #ccc 100%);background-image:linear-gradient(to bottom, #eee 50%, #ccc 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#FFEEEEEE', endColorstr='#FFCCCCCC', GradientType=0)}.select2-container--classic .select2-selection--single .select2-selection__arrow b{border-color:#888 transparent transparent transparent;border-style:solid;border-width:5px 4px 0 4px;height:0;left:50%;margin-left:-4px;margin-top:-2px;position:absolute;top:50%;width:0}.select2-container--classic[dir="rtl"] .select2-selection--single .select2-selection__clear{float:left}.select2-container--classic[dir="rtl"] .select2-selection--single .select2-selection__arrow{border:none;border-right:1px solid #aaa;border-radius:0;border-top-left-radius:4px;border-bottom-left-radius:4px;left:1px;right:auto}.select2-container--classic.select2-container--open .select2-selection--single{border:1px solid #5897fb}.select2-container--classic.select2-container--open .select2-selection--single .select2-selection__arrow{background:transparent;border:none}.select2-container--classic.select2-container--open .select2-selection--single .select2-selection__arrow b{border-color:transparent transparent #888 transparent;border-width:0 4px 5px 4px}.select2-container--classic.select2-container--open.select2-container--above .select2-selection--single{border-top:none;border-top-left-radius:0;border-top-right-radius:0;background-image:-webkit-linear-gradient(top, #fff 0%, #eee 50%);background-image:-o-linear-gradient(top, #fff 0%, #eee 50%);background-image:linear-gradient(to bottom, #fff 0%, #eee 50%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#FFFFFFFF', endColorstr='#FFEEEEEE', GradientType=0)}.select2-container--classic.select2-container--open.select2-container--below .select2-selection--single{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0;background-image:-webkit-linear-gradient(top, #eee 50%, #fff 100%);background-image:-o-linear-gradient(top, #eee 50%, #fff 100%);background-image:linear-gradient(to bottom, #eee 50%, #fff 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#FFEEEEEE', endColorstr='#FFFFFFFF', GradientType=0)}.select2-container--classic .select2-selection--multiple{background-color:white;border:1px solid #aaa;border-radius:4px;cursor:text;outline:0}.select2-container--classic .select2-selection--multiple:focus{border:1px solid #5897fb}.select2-container--classic .select2-selection--multiple .select2-selection__rendered{list-style:none;margin:0;padding:0 5px}.select2-container--classic .select2-selection--multiple .select2-selection__clear{display:none}.select2-container--classic .select2-selection--multiple .select2-selection__choice{background-color:#e4e4e4;border:1px solid #aaa;border-radius:4px;cursor:default;float:left;margin-right:5px;margin-top:5px;padding:0 5px}.select2-container--classic .select2-selection--multiple .select2-selection__choice__remove{color:#888;cursor:pointer;display:inline-block;font-weight:bold;margin-right:2px}.select2-container--classic .select2-selection--multiple .select2-selection__choice__remove:hover{color:#555}.select2-container--classic[dir="rtl"] .select2-selection--multiple .select2-selection__choice{float:right;margin-left:5px;margin-right:auto}.select2-container--classic[dir="rtl"] .select2-selection--multiple .select2-selection__choice__remove{margin-left:2px;margin-right:auto}.select2-container--classic.select2-container--open .select2-selection--multiple{border:1px solid #5897fb}.select2-container--classic.select2-container--open.select2-container--above .select2-selection--multiple{border-top:none;border-top-left-radius:0;border-top-right-radius:0}.select2-container--classic.select2-container--open.select2-container--below .select2-selection--multiple{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0}.select2-container--classic .select2-search--dropdown .select2-search__field{border:1px solid #aaa;outline:0}.select2-container--classic .select2-search--inline .select2-search__field{outline:0;box-shadow:none}.select2-container--classic .select2-dropdown{background-color:#fff;border:1px solid transparent}.select2-container--classic .select2-dropdown--above{border-bottom:none}.select2-container--classic .select2-dropdown--below{border-top:none}.select2-container--classic .select2-results>.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--classic .select2-results__option[role=group]{padding:0}.select2-container--classic .select2-results__option[aria-disabled=true]{color:grey}.select2-container--classic .select2-results__option--highlighted[aria-selected]{background-color:#3875d7;color:#fff}.select2-container--classic .select2-results__group{cursor:default;display:block;padding:6px}.select2-container--classic.select2-container--open .select2-dropdown{border-color:#5897fb}
\ No newline at end of file
diff --git a/addons_extensions/ftp_custom_dashboards/static/src/lib/sortable/Sortable.min.js b/addons_extensions/ftp_custom_dashboards/static/src/lib/sortable/Sortable.min.js
new file mode 100644
index 000000000..17bb16c73
--- /dev/null
+++ b/addons_extensions/ftp_custom_dashboards/static/src/lib/sortable/Sortable.min.js
@@ -0,0 +1,2 @@
+/*! Sortable 1.15.0 - MIT | git://github.com/SortableJS/Sortable.git */
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t=t||self).Sortable=e()}(this,function(){"use strict";function e(e,t){var n,o=Object.keys(e);return Object.getOwnPropertySymbols&&(n=Object.getOwnPropertySymbols(e),t&&(n=n.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),o.push.apply(o,n)),o}function M(o){for(var t=1;tt.length)&&(e=t.length);for(var n=0,o=new Array(e);n"===e[0]&&(e=e.substring(1)),t))try{if(t.matches)return t.matches(e);if(t.msMatchesSelector)return t.msMatchesSelector(e);if(t.webkitMatchesSelector)return t.webkitMatchesSelector(e)}catch(t){return}}function N(t,e,n,o){if(t){n=n||document;do{if(null!=e&&(">"!==e[0]||t.parentNode===n)&&p(t,e)||o&&t===n)return t}while(t!==n&&(t=(i=t).host&&i!==document&&i.host.nodeType?i.host:i.parentNode))}var i;return null}var g,m=/\s+/g;function I(t,e,n){var o;t&&e&&(t.classList?t.classList[n?"add":"remove"](e):(o=(" "+t.className+" ").replace(m," ").replace(" "+e+" "," "),t.className=(o+(n?" "+e:"")).replace(m," ")))}function P(t,e,n){var o=t&&t.style;if(o){if(void 0===n)return document.defaultView&&document.defaultView.getComputedStyle?n=document.defaultView.getComputedStyle(t,""):t.currentStyle&&(n=t.currentStyle),void 0===e?n:n[e];o[e=!(e in o||-1!==e.indexOf("webkit"))?"-webkit-"+e:e]=n+("string"==typeof n?"":"px")}}function v(t,e){var n="";if("string"==typeof t)n=t;else do{var o=P(t,"transform")}while(o&&"none"!==o&&(n=o+" "+n),!e&&(t=t.parentNode));var i=window.DOMMatrix||window.WebKitCSSMatrix||window.CSSMatrix||window.MSCSSMatrix;return i&&new i(n)}function b(t,e,n){if(t){var o=t.getElementsByTagName(e),i=0,r=o.length;if(n)for(;i=n.left-e&&i<=n.right+e,e=r>=n.top-e&&r<=n.bottom+e;return o&&e?a=t:void 0}}),a);if(e){var n,o={};for(n in t)t.hasOwnProperty(n)&&(o[n]=t[n]);o.target=o.rootEl=e,o.preventDefault=void 0,o.stopPropagation=void 0,e[j]._onDragOver(o)}}var i,r,a}function Yt(t){q&&q.parentNode[j]._isOutsideThisEl(t.target)}function Bt(t,e){if(!t||!t.nodeType||1!==t.nodeType)throw"Sortable: `el` must be an HTMLElement, not ".concat({}.toString.call(t));this.el=t,this.options=e=a({},e),t[j]=this;var n,o,i={group:null,sort:!0,disabled:!1,store:null,handle:null,draggable:/^[uo]l$/i.test(t.nodeName)?">li":">*",swapThreshold:1,invertSwap:!1,invertedSwapThreshold:null,removeCloneOnHide:!0,direction:function(){return It(t,this.options)},ghostClass:"sortable-ghost",chosenClass:"sortable-chosen",dragClass:"sortable-drag",ignore:"a, img",filter:null,preventOnFilter:!0,animation:0,easing:null,setData:function(t,e){t.setData("Text",e.textContent)},dropBubble:!1,dragoverBubble:!1,dataIdAttr:"data-id",delay:0,delayOnTouchOnly:!1,touchStartThreshold:(Number.parseInt?Number:window).parseInt(window.devicePixelRatio,10)||1,forceFallback:!1,fallbackClass:"sortable-fallback",fallbackOnBody:!1,fallbackTolerance:0,fallbackOffset:{x:0,y:0},supportPointer:!1!==Bt.supportPointer&&"PointerEvent"in window&&!u,emptyInsertThreshold:5};for(n in K.initializePlugins(this,t,i),i)n in e||(e[n]=i[n]);for(o in Pt(e),this)"_"===o.charAt(0)&&"function"==typeof this[o]&&(this[o]=this[o].bind(this));this.nativeDraggable=!e.forceFallback&&Mt,this.nativeDraggable&&(this.options.touchStartThreshold=1),e.supportPointer?h(t,"pointerdown",this._onTapStart):(h(t,"mousedown",this._onTapStart),h(t,"touchstart",this._onTapStart)),this.nativeDraggable&&(h(t,"dragover",this),h(t,"dragenter",this)),Et.push(this.el),e.store&&e.store.get&&this.sort(e.store.get(this)||[]),a(this,x())}function Ft(t,e,n,o,i,r,a,l){var s,c,u=t[j],d=u.options.onMove;return!window.CustomEvent||y||w?(s=document.createEvent("Event")).initEvent("move",!0,!0):s=new CustomEvent("move",{bubbles:!0,cancelable:!0}),s.to=e,s.from=t,s.dragged=n,s.draggedRect=o,s.related=i||e,s.relatedRect=r||k(e),s.willInsertAfter=l,s.originalEvent=a,t.dispatchEvent(s),c=d?d.call(u,s,a):c}function jt(t){t.draggable=!1}function Ht(){Ct=!1}function Lt(t){return setTimeout(t,0)}function Kt(t){return clearTimeout(t)}Bt.prototype={constructor:Bt,_isOutsideThisEl:function(t){this.el.contains(t)||t===this.el||(gt=null)},_getDirection:function(t,e){return"function"==typeof this.options.direction?this.options.direction.call(this,t,e,q):this.options.direction},_onTapStart:function(e){if(e.cancelable){var n=this,o=this.el,t=this.options,i=t.preventOnFilter,r=e.type,a=e.touches&&e.touches[0]||e.pointerType&&"touch"===e.pointerType&&e,l=(a||e).target,s=e.target.shadowRoot&&(e.path&&e.path[0]||e.composedPath&&e.composedPath()[0])||l,c=t.filter;if(!function(t){Tt.length=0;var e=t.getElementsByTagName("input"),n=e.length;for(;n--;){var o=e[n];o.checked&&Tt.push(o)}}(o),!q&&!(/mousedown|pointerdown/.test(r)&&0!==e.button||t.disabled)&&!s.isContentEditable&&(this.nativeDraggable||!u||!l||"SELECT"!==l.tagName.toUpperCase())&&!((l=N(l,t.draggable,o,!1))&&l.animated||J===l)){if(nt=B(l),it=B(l,t.draggable),"function"==typeof c){if(c.call(this,e,l,this))return U({sortable:n,rootEl:s,name:"filter",targetEl:l,toEl:o,fromEl:o}),z("filter",n,{evt:e}),void(i&&e.cancelable&&e.preventDefault())}else if(c=c&&c.split(",").some(function(t){if(t=N(s,t.trim(),o,!1))return U({sortable:n,rootEl:t,name:"filter",targetEl:l,fromEl:o,toEl:o}),z("filter",n,{evt:e}),!0}))return void(i&&e.cancelable&&e.preventDefault());t.handle&&!N(s,t.handle,o,!1)||this._prepareDragStart(e,a,l)}}},_prepareDragStart:function(t,e,n){var o,i=this,r=i.el,a=i.options,l=r.ownerDocument;n&&!q&&n.parentNode===r&&(o=k(n),$=r,V=(q=n).parentNode,Q=q.nextSibling,J=n,at=a.group,st={target:Bt.dragged=q,clientX:(e||t).clientX,clientY:(e||t).clientY},ht=st.clientX-o.left,ft=st.clientY-o.top,this._lastX=(e||t).clientX,this._lastY=(e||t).clientY,q.style["will-change"]="all",o=function(){z("delayEnded",i,{evt:t}),Bt.eventCanceled?i._onDrop():(i._disableDelayedDragEvents(),!s&&i.nativeDraggable&&(q.draggable=!0),i._triggerDragStart(t,e),U({sortable:i,name:"choose",originalEvent:t}),I(q,a.chosenClass,!0))},a.ignore.split(",").forEach(function(t){b(q,t.trim(),jt)}),h(l,"dragover",Xt),h(l,"mousemove",Xt),h(l,"touchmove",Xt),h(l,"mouseup",i._onDrop),h(l,"touchend",i._onDrop),h(l,"touchcancel",i._onDrop),s&&this.nativeDraggable&&(this.options.touchStartThreshold=4,q.draggable=!0),z("delayStart",this,{evt:t}),!a.delay||a.delayOnTouchOnly&&!e||this.nativeDraggable&&(w||y)?o():Bt.eventCanceled?this._onDrop():(h(l,"mouseup",i._disableDelayedDrag),h(l,"touchend",i._disableDelayedDrag),h(l,"touchcancel",i._disableDelayedDrag),h(l,"mousemove",i._delayedDragTouchMoveHandler),h(l,"touchmove",i._delayedDragTouchMoveHandler),a.supportPointer&&h(l,"pointermove",i._delayedDragTouchMoveHandler),i._dragStartTimer=setTimeout(o,a.delay)))},_delayedDragTouchMoveHandler:function(t){t=t.touches?t.touches[0]:t;Math.max(Math.abs(t.clientX-this._lastX),Math.abs(t.clientY-this._lastY))>=Math.floor(this.options.touchStartThreshold/(this.nativeDraggable&&window.devicePixelRatio||1))&&this._disableDelayedDrag()},_disableDelayedDrag:function(){q&&jt(q),clearTimeout(this._dragStartTimer),this._disableDelayedDragEvents()},_disableDelayedDragEvents:function(){var t=this.el.ownerDocument;f(t,"mouseup",this._disableDelayedDrag),f(t,"touchend",this._disableDelayedDrag),f(t,"touchcancel",this._disableDelayedDrag),f(t,"mousemove",this._delayedDragTouchMoveHandler),f(t,"touchmove",this._delayedDragTouchMoveHandler),f(t,"pointermove",this._delayedDragTouchMoveHandler)},_triggerDragStart:function(t,e){e=e||"touch"==t.pointerType&&t,!this.nativeDraggable||e?this.options.supportPointer?h(document,"pointermove",this._onTouchMove):h(document,e?"touchmove":"mousemove",this._onTouchMove):(h(q,"dragend",this),h($,"dragstart",this._onDragStart));try{document.selection?Lt(function(){document.selection.empty()}):window.getSelection().removeAllRanges()}catch(t){}},_dragStarted:function(t,e){var n;yt=!1,$&&q?(z("dragStarted",this,{evt:e}),this.nativeDraggable&&h(document,"dragover",Yt),n=this.options,t||I(q,n.dragClass,!1),I(q,n.ghostClass,!0),Bt.active=this,t&&this._appendGhost(),U({sortable:this,name:"start",originalEvent:e})):this._nulling()},_emulateDragOver:function(){if(ct){this._lastX=ct.clientX,this._lastY=ct.clientY,kt();for(var t=document.elementFromPoint(ct.clientX,ct.clientY),e=t;t&&t.shadowRoot&&(t=t.shadowRoot.elementFromPoint(ct.clientX,ct.clientY))!==e;)e=t;if(q.parentNode[j]._isOutsideThisEl(t),e)do{if(e[j])if(e[j]._onDragOver({clientX:ct.clientX,clientY:ct.clientY,target:t,rootEl:e})&&!this.options.dragoverBubble)break}while(e=(t=e).parentNode);Rt()}},_onTouchMove:function(t){if(st){var e=this.options,n=e.fallbackTolerance,o=e.fallbackOffset,i=t.touches?t.touches[0]:t,r=Z&&v(Z,!0),a=Z&&r&&r.a,l=Z&&r&&r.d,e=Ot&&bt&&E(bt),a=(i.clientX-st.clientX+o.x)/(a||1)+(e?e[0]-_t[0]:0)/(a||1),l=(i.clientY-st.clientY+o.y)/(l||1)+(e?e[1]-_t[1]:0)/(l||1);if(!Bt.active&&!yt){if(n&&Math.max(Math.abs(i.clientX-this._lastX),Math.abs(i.clientY-this._lastY))n.right+10||t.clientX<=n.right&&t.clientY>n.bottom&&t.clientX>=n.left:t.clientX>n.right&&t.clientY>n.top||t.clientX<=n.right&&t.clientY>n.bottom+10}(n,r,this)&&!g.animated){if(g===q)return O(!1);if((l=g&&a===n.target?g:l)&&(w=k(l)),!1!==Ft($,a,q,o,l,w,n,!!l))return x(),g&&g.nextSibling?a.insertBefore(q,g.nextSibling):a.appendChild(q),V=a,A(),O(!0)}else if(g&&function(t,e,n){n=k(X(n.el,0,n.options,!0));return e?t.clientX>8&255]+st[t>>16&255]+st[t>>24&255]+"-"+st[255&e]+st[e>>8&255]+"-"+st[e>>16&15|64]+st[e>>24&255]+"-"+st[63&n|128]+st[n>>8&255]+"-"+st[n>>16&255]+st[n>>24&255]+st[255&i]+st[i>>8&255]+st[i>>16&255]+st[i>>24&255]).toUpperCase()}function ht(t,e,n){return Math.max(e,Math.min(n,t))}function ut(t,e){return(t%e+e)%e}function dt(t,e,n){return(1-n)*t+n*e}function pt(t){return 0==(t&t-1)&&0!==t}function mt(t){return Math.pow(2,Math.ceil(Math.log(t)/Math.LN2))}function ft(t){return Math.pow(2,Math.floor(Math.log(t)/Math.LN2))}var gt=Object.freeze({__proto__:null,DEG2RAD:ot,RAD2DEG:lt,generateUUID:ct,clamp:ht,euclideanModulo:ut,mapLinear:function(t,e,n,i,r){return i+(t-e)*(r-i)/(n-e)},inverseLerp:function(t,e,n){return t!==e?(n-t)/(e-t):0},lerp:dt,damp:function(t,e,n,i){return dt(t,e,1-Math.exp(-n*i))},pingpong:function(t,e=1){return e-Math.abs(ut(t,2*e)-e)},smoothstep:function(t,e,n){return t<=e?0:t>=n?1:(t=(t-e)/(n-e))*t*(3-2*t)},smootherstep:function(t,e,n){return t<=e?0:t>=n?1:(t=(t-e)/(n-e))*t*t*(t*(6*t-15)+10)},randInt:function(t,e){return t+Math.floor(Math.random()*(e-t+1))},randFloat:function(t,e){return t+Math.random()*(e-t)},randFloatSpread:function(t){return t*(.5-Math.random())},seededRandom:function(t){return void 0!==t&&(at=t%2147483647),at=16807*at%2147483647,(at-1)/2147483646},degToRad:function(t){return t*ot},radToDeg:function(t){return t*lt},isPowerOfTwo:pt,ceilPowerOfTwo:mt,floorPowerOfTwo:ft,setQuaternionFromProperEuler:function(t,e,n,i,r){const s=Math.cos,a=Math.sin,o=s(n/2),l=a(n/2),c=s((e+i)/2),h=a((e+i)/2),u=s((e-i)/2),d=a((e-i)/2),p=s((i-e)/2),m=a((i-e)/2);switch(r){case"XYX":t.set(o*h,l*u,l*d,o*c);break;case"YZY":t.set(l*d,o*h,l*u,o*c);break;case"ZXZ":t.set(l*u,l*d,o*h,o*c);break;case"XZX":t.set(o*h,l*m,l*p,o*c);break;case"YXY":t.set(l*p,o*h,l*m,o*c);break;case"ZYZ":t.set(l*m,l*p,o*h,o*c);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+r)}}});class vt{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){const e=this.x,n=this.y,i=t.elements;return this.x=i[0]*e+i[3]*n+i[6],this.y=i[1]*e+i[4]*n+i[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){const n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(e,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,n=this.y-t.y;return e*e+n*n}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,n){return this.x=t.x+(e.x-t.x)*n,this.y=t.y+(e.y-t.y)*n,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,n){return void 0!==n&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){const n=Math.cos(e),i=Math.sin(e),r=this.x-t.x,s=this.y-t.y;return this.x=r*n-s*i+t.x,this.y=r*i+s*n+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}}vt.prototype.isVector2=!0;class yt{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,n,i,r,s,a,o,l){const c=this.elements;return c[0]=t,c[1]=i,c[2]=a,c[3]=e,c[4]=r,c[5]=o,c[6]=n,c[7]=s,c[8]=l,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){const e=this.elements,n=t.elements;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],e[6]=n[6],e[7]=n[7],e[8]=n[8],this}extractBasis(t,e,n){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),n.setFromMatrix3Column(this,2),this}setFromMatrix4(t){const e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){const n=t.elements,i=e.elements,r=this.elements,s=n[0],a=n[3],o=n[6],l=n[1],c=n[4],h=n[7],u=n[2],d=n[5],p=n[8],m=i[0],f=i[3],g=i[6],v=i[1],y=i[4],x=i[7],_=i[2],w=i[5],b=i[8];return r[0]=s*m+a*v+o*_,r[3]=s*f+a*y+o*w,r[6]=s*g+a*x+o*b,r[1]=l*m+c*v+h*_,r[4]=l*f+c*y+h*w,r[7]=l*g+c*x+h*b,r[2]=u*m+d*v+p*_,r[5]=u*f+d*y+p*w,r[8]=u*g+d*x+p*b,this}multiplyScalar(t){const e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],s=t[4],a=t[5],o=t[6],l=t[7],c=t[8];return e*s*c-e*a*l-n*r*c+n*a*o+i*r*l-i*s*o}invert(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],s=t[4],a=t[5],o=t[6],l=t[7],c=t[8],h=c*s-a*l,u=a*o-c*r,d=l*r-s*o,p=e*h+n*u+i*d;if(0===p)return this.set(0,0,0,0,0,0,0,0,0);const m=1/p;return t[0]=h*m,t[1]=(i*l-c*n)*m,t[2]=(a*n-i*s)*m,t[3]=u*m,t[4]=(c*e-i*o)*m,t[5]=(i*r-a*e)*m,t[6]=d*m,t[7]=(n*o-l*e)*m,t[8]=(s*e-n*r)*m,this}transpose(){let t;const e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){const e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,n,i,r,s,a){const o=Math.cos(r),l=Math.sin(r);return this.set(n*o,n*l,-n*(o*s+l*a)+s+t,-i*l,i*o,-i*(-l*s+o*a)+a+e,0,0,1),this}scale(t,e){const n=this.elements;return n[0]*=t,n[3]*=t,n[6]*=t,n[1]*=e,n[4]*=e,n[7]*=e,this}rotate(t){const e=Math.cos(t),n=Math.sin(t),i=this.elements,r=i[0],s=i[3],a=i[6],o=i[1],l=i[4],c=i[7];return i[0]=e*r+n*o,i[3]=e*s+n*l,i[6]=e*a+n*c,i[1]=-n*r+e*o,i[4]=-n*s+e*l,i[7]=-n*a+e*c,this}translate(t,e){const n=this.elements;return n[0]+=t*n[2],n[3]+=t*n[5],n[6]+=t*n[8],n[1]+=e*n[2],n[4]+=e*n[5],n[7]+=e*n[8],this}equals(t){const e=this.elements,n=t.elements;for(let t=0;t<9;t++)if(e[t]!==n[t])return!1;return!0}fromArray(t,e=0){for(let n=0;n<9;n++)this.elements[n]=t[n+e];return this}toArray(t=[],e=0){const n=this.elements;return t[e]=n[0],t[e+1]=n[1],t[e+2]=n[2],t[e+3]=n[3],t[e+4]=n[4],t[e+5]=n[5],t[e+6]=n[6],t[e+7]=n[7],t[e+8]=n[8],t}clone(){return(new this.constructor).fromArray(this.elements)}}let xt;yt.prototype.isMatrix3=!0;class _t{static getDataURL(t){if(/^data:/i.test(t.src))return t.src;if("undefined"==typeof HTMLCanvasElement)return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{void 0===xt&&(xt=document.createElementNS("http://www.w3.org/1999/xhtml","canvas")),xt.width=t.width,xt.height=t.height;const n=xt.getContext("2d");t instanceof ImageData?n.putImageData(t,0,0):n.drawImage(t,0,0,t.width,t.height),e=xt}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}}let wt=0;class bt extends rt{constructor(t=bt.DEFAULT_IMAGE,e=bt.DEFAULT_MAPPING,n=1001,i=1001,r=1006,s=1008,a=1023,o=1009,l=1,c=3e3){super(),Object.defineProperty(this,"id",{value:wt++}),this.uuid=ct(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=n,this.wrapT=i,this.magFilter=r,this.minFilter=s,this.anisotropy=l,this.format=a,this.internalFormat=null,this.type=o,this.offset=new vt(0,0),this.repeat=new vt(1,1),this.center=new vt(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new yt,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=c,this.version=0,this.onUpdate=null}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return(new this.constructor).copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this}toJSON(t){const e=void 0===t||"string"==typeof t;if(!e&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];const n={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(void 0!==this.image){const i=this.image;if(void 0===i.uuid&&(i.uuid=ct()),!e&&void 0===t.images[i.uuid]){let e;if(Array.isArray(i)){e=[];for(let t=0,n=i.length;t1)switch(this.wrapS){case h:t.x=t.x-Math.floor(t.x);break;case u:t.x=t.x<0?0:1;break;case d:1===Math.abs(Math.floor(t.x)%2)?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case h:t.y=t.y-Math.floor(t.y);break;case u:t.y=t.y<0?0:1;break;case d:1===Math.abs(Math.floor(t.y)%2)?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){!0===t&&this.version++}}function Mt(t){return"undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap?_t.getDataURL(t):t.data?{data:Array.prototype.slice.call(t.data),width:t.width,height:t.height,type:t.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}bt.DEFAULT_IMAGE=void 0,bt.DEFAULT_MAPPING=i,bt.prototype.isTexture=!0;class St{constructor(t=0,e=0,n=0,i=1){this.x=t,this.y=e,this.z=n,this.w=i}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,n,i){return this.x=t,this.y=e,this.z=n,this.w=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){const e=this.x,n=this.y,i=this.z,r=this.w,s=t.elements;return this.x=s[0]*e+s[4]*n+s[8]*i+s[12]*r,this.y=s[1]*e+s[5]*n+s[9]*i+s[13]*r,this.z=s[2]*e+s[6]*n+s[10]*i+s[14]*r,this.w=s[3]*e+s[7]*n+s[11]*i+s[15]*r,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);const e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,n,i,r;const s=.01,a=.1,o=t.elements,l=o[0],c=o[4],h=o[8],u=o[1],d=o[5],p=o[9],m=o[2],f=o[6],g=o[10];if(Math.abs(c-u)o&&t>v?tv?o=0?1:-1,i=1-e*e;if(i>Number.EPSILON){const r=Math.sqrt(i),s=Math.atan2(r,e*n);t=Math.sin(t*s)/r,a=Math.sin(a*s)/r}const r=a*n;if(o=o*t+u*r,l=l*t+d*r,c=c*t+p*r,h=h*t+m*r,t===1-a){const t=1/Math.sqrt(o*o+l*l+c*c+h*h);o*=t,l*=t,c*=t,h*=t}}t[e]=o,t[e+1]=l,t[e+2]=c,t[e+3]=h}static multiplyQuaternionsFlat(t,e,n,i,r,s){const a=n[i],o=n[i+1],l=n[i+2],c=n[i+3],h=r[s],u=r[s+1],d=r[s+2],p=r[s+3];return t[e]=a*p+c*h+o*d-l*u,t[e+1]=o*p+c*u+l*h-a*d,t[e+2]=l*p+c*d+a*u-o*h,t[e+3]=c*p-a*h-o*u-l*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,n,i){return this._x=t,this._y=e,this._z=n,this._w=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!t||!t.isEuler)throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");const n=t._x,i=t._y,r=t._z,s=t._order,a=Math.cos,o=Math.sin,l=a(n/2),c=a(i/2),h=a(r/2),u=o(n/2),d=o(i/2),p=o(r/2);switch(s){case"XYZ":this._x=u*c*h+l*d*p,this._y=l*d*h-u*c*p,this._z=l*c*p+u*d*h,this._w=l*c*h-u*d*p;break;case"YXZ":this._x=u*c*h+l*d*p,this._y=l*d*h-u*c*p,this._z=l*c*p-u*d*h,this._w=l*c*h+u*d*p;break;case"ZXY":this._x=u*c*h-l*d*p,this._y=l*d*h+u*c*p,this._z=l*c*p+u*d*h,this._w=l*c*h-u*d*p;break;case"ZYX":this._x=u*c*h-l*d*p,this._y=l*d*h+u*c*p,this._z=l*c*p-u*d*h,this._w=l*c*h+u*d*p;break;case"YZX":this._x=u*c*h+l*d*p,this._y=l*d*h+u*c*p,this._z=l*c*p-u*d*h,this._w=l*c*h-u*d*p;break;case"XZY":this._x=u*c*h-l*d*p,this._y=l*d*h-u*c*p,this._z=l*c*p+u*d*h,this._w=l*c*h+u*d*p;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+s)}return!1!==e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){const n=e/2,i=Math.sin(n);return this._x=t.x*i,this._y=t.y*i,this._z=t.z*i,this._w=Math.cos(n),this._onChangeCallback(),this}setFromRotationMatrix(t){const e=t.elements,n=e[0],i=e[4],r=e[8],s=e[1],a=e[5],o=e[9],l=e[2],c=e[6],h=e[10],u=n+a+h;if(u>0){const t=.5/Math.sqrt(u+1);this._w=.25/t,this._x=(c-o)*t,this._y=(r-l)*t,this._z=(s-i)*t}else if(n>a&&n>h){const t=2*Math.sqrt(1+n-a-h);this._w=(c-o)/t,this._x=.25*t,this._y=(i+s)/t,this._z=(r+l)/t}else if(a>h){const t=2*Math.sqrt(1+a-n-h);this._w=(r-l)/t,this._x=(i+s)/t,this._y=.25*t,this._z=(o+c)/t}else{const t=2*Math.sqrt(1+h-n-a);this._w=(s-i)/t,this._x=(r+l)/t,this._y=(o+c)/t,this._z=.25*t}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let n=t.dot(e)+1;return nMath.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=n):(this._x=0,this._y=-t.z,this._z=t.y,this._w=n)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=n),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(ht(this.dot(t),-1,1)))}rotateTowards(t,e){const n=this.angleTo(t);if(0===n)return this;const i=Math.min(1,e/n);return this.slerp(t,i),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return void 0!==e?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){const n=t._x,i=t._y,r=t._z,s=t._w,a=e._x,o=e._y,l=e._z,c=e._w;return this._x=n*c+s*a+i*l-r*o,this._y=i*c+s*o+r*a-n*l,this._z=r*c+s*l+n*o-i*a,this._w=s*c-n*a-i*o-r*l,this._onChangeCallback(),this}slerp(t,e){if(0===e)return this;if(1===e)return this.copy(t);const n=this._x,i=this._y,r=this._z,s=this._w;let a=s*t._w+n*t._x+i*t._y+r*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=s,this._x=n,this._y=i,this._z=r,this;const o=1-a*a;if(o<=Number.EPSILON){const t=1-e;return this._w=t*s+e*this._w,this._x=t*n+e*this._x,this._y=t*i+e*this._y,this._z=t*r+e*this._z,this.normalize(),this._onChangeCallback(),this}const l=Math.sqrt(o),c=Math.atan2(l,a),h=Math.sin((1-e)*c)/l,u=Math.sin(e*c)/l;return this._w=s*h+this._w*u,this._x=n*h+this._x*u,this._y=i*h+this._y*u,this._z=r*h+this._z*u,this._onChangeCallback(),this}slerpQuaternions(t,e,n){this.copy(t).slerp(e,n)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}}At.prototype.isQuaternion=!0;class Lt{constructor(t=0,e=0,n=0){this.x=t,this.y=e,this.z=n}set(t,e,n){return void 0===n&&(n=this.z),this.x=t,this.y=e,this.z=n,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(Ct.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(Ct.setFromAxisAngle(t,e))}applyMatrix3(t){const e=this.x,n=this.y,i=this.z,r=t.elements;return this.x=r[0]*e+r[3]*n+r[6]*i,this.y=r[1]*e+r[4]*n+r[7]*i,this.z=r[2]*e+r[5]*n+r[8]*i,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){const e=this.x,n=this.y,i=this.z,r=t.elements,s=1/(r[3]*e+r[7]*n+r[11]*i+r[15]);return this.x=(r[0]*e+r[4]*n+r[8]*i+r[12])*s,this.y=(r[1]*e+r[5]*n+r[9]*i+r[13])*s,this.z=(r[2]*e+r[6]*n+r[10]*i+r[14])*s,this}applyQuaternion(t){const e=this.x,n=this.y,i=this.z,r=t.x,s=t.y,a=t.z,o=t.w,l=o*e+s*i-a*n,c=o*n+a*e-r*i,h=o*i+r*n-s*e,u=-r*e-s*n-a*i;return this.x=l*o+u*-r+c*-a-h*-s,this.y=c*o+u*-s+h*-r-l*-a,this.z=h*o+u*-a+l*-s-c*-r,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){const e=this.x,n=this.y,i=this.z,r=t.elements;return this.x=r[0]*e+r[4]*n+r[8]*i,this.y=r[1]*e+r[5]*n+r[9]*i,this.z=r[2]*e+r[6]*n+r[10]*i,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){const n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(e,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,n){return this.x=t.x+(e.x-t.x)*n,this.y=t.y+(e.y-t.y)*n,this.z=t.z+(e.z-t.z)*n,this}cross(t,e){return void 0!==e?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){const n=t.x,i=t.y,r=t.z,s=e.x,a=e.y,o=e.z;return this.x=i*o-r*a,this.y=r*s-n*o,this.z=n*a-i*s,this}projectOnVector(t){const e=t.lengthSq();if(0===e)return this.set(0,0,0);const n=t.dot(this)/e;return this.copy(t).multiplyScalar(n)}projectOnPlane(t){return Rt.copy(this).projectOnVector(t),this.sub(Rt)}reflect(t){return this.sub(Rt.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){const e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;const n=this.dot(t)/e;return Math.acos(ht(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,n=this.y-t.y,i=this.z-t.z;return e*e+n*n+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,n){const i=Math.sin(e)*t;return this.x=i*Math.sin(n),this.y=Math.cos(e)*t,this.z=i*Math.cos(n),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,n){return this.x=t*Math.sin(e),this.y=n,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){const e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){const e=this.setFromMatrixColumn(t,0).length(),n=this.setFromMatrixColumn(t,1).length(),i=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=n,this.z=i,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,n){return void 0!==n&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}}Lt.prototype.isVector3=!0;const Rt=new Lt,Ct=new At;class Pt{constructor(t=new Lt(1/0,1/0,1/0),e=new Lt(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,n=1/0,i=1/0,r=-1/0,s=-1/0,a=-1/0;for(let o=0,l=t.length;or&&(r=l),c>s&&(s=c),h>a&&(a=h)}return this.min.set(e,n,i),this.max.set(r,s,a),this}setFromBufferAttribute(t){let e=1/0,n=1/0,i=1/0,r=-1/0,s=-1/0,a=-1/0;for(let o=0,l=t.count;or&&(r=l),c>s&&(s=c),h>a&&(a=h)}return this.min.set(e,n,i),this.max.set(r,s,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,n=t.length;ethis.max.x||t.ythis.max.y||t.zthis.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return void 0===e&&(console.warn("THREE.Box3: .getParameter() target is now required"),e=new Lt),e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.xthis.max.x||t.max.ythis.max.y||t.max.zthis.max.z)}intersectsSphere(t){return this.clampPoint(t.center,It),It.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,n;return t.normal.x>0?(e=t.normal.x*this.min.x,n=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,n=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,n+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,n+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,n+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,n+=t.normal.z*this.min.z),e<=-t.constant&&n>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(Ut),kt.subVectors(this.max,Ut),Bt.subVectors(t.a,Ut),zt.subVectors(t.b,Ut),Ft.subVectors(t.c,Ut),Ot.subVectors(zt,Bt),Ht.subVectors(Ft,zt),Gt.subVectors(Bt,Ft);let e=[0,-Ot.z,Ot.y,0,-Ht.z,Ht.y,0,-Gt.z,Gt.y,Ot.z,0,-Ot.x,Ht.z,0,-Ht.x,Gt.z,0,-Gt.x,-Ot.y,Ot.x,0,-Ht.y,Ht.x,0,-Gt.y,Gt.x,0];return!!jt(e,Bt,zt,Ft,kt)&&(e=[1,0,0,0,1,0,0,0,1],!!jt(e,Bt,zt,Ft,kt)&&(Vt.crossVectors(Ot,Ht),e=[Vt.x,Vt.y,Vt.z],jt(e,Bt,zt,Ft,kt)))}clampPoint(t,e){return void 0===e&&(console.warn("THREE.Box3: .clampPoint() target is now required"),e=new Lt),e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return It.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return void 0===t&&console.error("THREE.Box3: .getBoundingSphere() target is now required"),this.getCenter(t.center),t.radius=.5*this.getSize(It).length(),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(Dt[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Dt[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Dt[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Dt[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Dt[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Dt[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Dt[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Dt[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Dt)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}}Pt.prototype.isBox3=!0;const Dt=[new Lt,new Lt,new Lt,new Lt,new Lt,new Lt,new Lt,new Lt],It=new Lt,Nt=new Pt,Bt=new Lt,zt=new Lt,Ft=new Lt,Ot=new Lt,Ht=new Lt,Gt=new Lt,Ut=new Lt,kt=new Lt,Vt=new Lt,Wt=new Lt;function jt(t,e,n,i,r){for(let s=0,a=t.length-3;s<=a;s+=3){Wt.fromArray(t,s);const a=r.x*Math.abs(Wt.x)+r.y*Math.abs(Wt.y)+r.z*Math.abs(Wt.z),o=e.dot(Wt),l=n.dot(Wt),c=i.dot(Wt);if(Math.max(-Math.max(o,l,c),Math.min(o,l,c))>a)return!1}return!0}const qt=new Pt,Xt=new Lt,Yt=new Lt,Zt=new Lt;class Jt{constructor(t=new Lt,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){const n=this.center;void 0!==e?n.copy(e):qt.setFromPoints(t).getCenter(n);let i=0;for(let e=0,r=t.length;ethis.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return void 0===t&&(console.warn("THREE.Sphere: .getBoundingBox() target is now required"),t=new Pt),this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){Zt.subVectors(t,this.center);const e=Zt.lengthSq();if(e>this.radius*this.radius){const t=Math.sqrt(e),n=.5*(t-this.radius);this.center.add(Zt.multiplyScalar(n/t)),this.radius+=n}return this}union(t){return Yt.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(Xt.copy(t.center).add(Yt)),this.expandByPoint(Xt.copy(t.center).sub(Yt)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return(new this.constructor).copy(this)}}const Qt=new Lt,Kt=new Lt,$t=new Lt,te=new Lt,ee=new Lt,ne=new Lt,ie=new Lt;class re{constructor(t=new Lt,e=new Lt(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return void 0===e&&(console.warn("THREE.Ray: .at() target is now required"),e=new Lt),e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Qt)),this}closestPointToPoint(t,e){void 0===e&&(console.warn("THREE.Ray: .closestPointToPoint() target is now required"),e=new Lt),e.subVectors(t,this.origin);const n=e.dot(this.direction);return n<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(n).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){const e=Qt.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Qt.copy(this.direction).multiplyScalar(e).add(this.origin),Qt.distanceToSquared(t))}distanceSqToSegment(t,e,n,i){Kt.copy(t).add(e).multiplyScalar(.5),$t.copy(e).sub(t).normalize(),te.copy(this.origin).sub(Kt);const r=.5*t.distanceTo(e),s=-this.direction.dot($t),a=te.dot(this.direction),o=-te.dot($t),l=te.lengthSq(),c=Math.abs(1-s*s);let h,u,d,p;if(c>0)if(h=s*o-a,u=s*a-o,p=r*c,h>=0)if(u>=-p)if(u<=p){const t=1/c;h*=t,u*=t,d=h*(h+s*u+2*a)+u*(s*h+u+2*o)+l}else u=r,h=Math.max(0,-(s*u+a)),d=-h*h+u*(u+2*o)+l;else u=-r,h=Math.max(0,-(s*u+a)),d=-h*h+u*(u+2*o)+l;else u<=-p?(h=Math.max(0,-(-s*r+a)),u=h>0?-r:Math.min(Math.max(-r,-o),r),d=-h*h+u*(u+2*o)+l):u<=p?(h=0,u=Math.min(Math.max(-r,-o),r),d=u*(u+2*o)+l):(h=Math.max(0,-(s*r+a)),u=h>0?r:Math.min(Math.max(-r,-o),r),d=-h*h+u*(u+2*o)+l);else u=s>0?-r:r,h=Math.max(0,-(s*u+a)),d=-h*h+u*(u+2*o)+l;return n&&n.copy(this.direction).multiplyScalar(h).add(this.origin),i&&i.copy($t).multiplyScalar(u).add(Kt),d}intersectSphere(t,e){Qt.subVectors(t.center,this.origin);const n=Qt.dot(this.direction),i=Qt.dot(Qt)-n*n,r=t.radius*t.radius;if(i>r)return null;const s=Math.sqrt(r-i),a=n-s,o=n+s;return a<0&&o<0?null:a<0?this.at(o,e):this.at(a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){const e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;const n=-(this.origin.dot(t.normal)+t.constant)/e;return n>=0?n:null}intersectPlane(t,e){const n=this.distanceToPlane(t);return null===n?null:this.at(n,e)}intersectsPlane(t){const e=t.distanceToPoint(this.origin);if(0===e)return!0;return t.normal.dot(this.direction)*e<0}intersectBox(t,e){let n,i,r,s,a,o;const l=1/this.direction.x,c=1/this.direction.y,h=1/this.direction.z,u=this.origin;return l>=0?(n=(t.min.x-u.x)*l,i=(t.max.x-u.x)*l):(n=(t.max.x-u.x)*l,i=(t.min.x-u.x)*l),c>=0?(r=(t.min.y-u.y)*c,s=(t.max.y-u.y)*c):(r=(t.max.y-u.y)*c,s=(t.min.y-u.y)*c),n>s||r>i?null:((r>n||n!=n)&&(n=r),(s=0?(a=(t.min.z-u.z)*h,o=(t.max.z-u.z)*h):(a=(t.max.z-u.z)*h,o=(t.min.z-u.z)*h),n>o||a>i?null:((a>n||n!=n)&&(n=a),(o=0?n:i,e)))}intersectsBox(t){return null!==this.intersectBox(t,Qt)}intersectTriangle(t,e,n,i,r){ee.subVectors(e,t),ne.subVectors(n,t),ie.crossVectors(ee,ne);let s,a=this.direction.dot(ie);if(a>0){if(i)return null;s=1}else{if(!(a<0))return null;s=-1,a=-a}te.subVectors(this.origin,t);const o=s*this.direction.dot(ne.crossVectors(te,ne));if(o<0)return null;const l=s*this.direction.dot(ee.cross(te));if(l<0)return null;if(o+l>a)return null;const c=-s*te.dot(ie);return c<0?null:this.at(c/a,r)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return(new this.constructor).copy(this)}}class se{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,n,i,r,s,a,o,l,c,h,u,d,p,m,f){const g=this.elements;return g[0]=t,g[4]=e,g[8]=n,g[12]=i,g[1]=r,g[5]=s,g[9]=a,g[13]=o,g[2]=l,g[6]=c,g[10]=h,g[14]=u,g[3]=d,g[7]=p,g[11]=m,g[15]=f,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new se).fromArray(this.elements)}copy(t){const e=this.elements,n=t.elements;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],e[6]=n[6],e[7]=n[7],e[8]=n[8],e[9]=n[9],e[10]=n[10],e[11]=n[11],e[12]=n[12],e[13]=n[13],e[14]=n[14],e[15]=n[15],this}copyPosition(t){const e=this.elements,n=t.elements;return e[12]=n[12],e[13]=n[13],e[14]=n[14],this}setFromMatrix3(t){const e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,n){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),n.setFromMatrixColumn(this,2),this}makeBasis(t,e,n){return this.set(t.x,e.x,n.x,0,t.y,e.y,n.y,0,t.z,e.z,n.z,0,0,0,0,1),this}extractRotation(t){const e=this.elements,n=t.elements,i=1/ae.setFromMatrixColumn(t,0).length(),r=1/ae.setFromMatrixColumn(t,1).length(),s=1/ae.setFromMatrixColumn(t,2).length();return e[0]=n[0]*i,e[1]=n[1]*i,e[2]=n[2]*i,e[3]=0,e[4]=n[4]*r,e[5]=n[5]*r,e[6]=n[6]*r,e[7]=0,e[8]=n[8]*s,e[9]=n[9]*s,e[10]=n[10]*s,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");const e=this.elements,n=t.x,i=t.y,r=t.z,s=Math.cos(n),a=Math.sin(n),o=Math.cos(i),l=Math.sin(i),c=Math.cos(r),h=Math.sin(r);if("XYZ"===t.order){const t=s*c,n=s*h,i=a*c,r=a*h;e[0]=o*c,e[4]=-o*h,e[8]=l,e[1]=n+i*l,e[5]=t-r*l,e[9]=-a*o,e[2]=r-t*l,e[6]=i+n*l,e[10]=s*o}else if("YXZ"===t.order){const t=o*c,n=o*h,i=l*c,r=l*h;e[0]=t+r*a,e[4]=i*a-n,e[8]=s*l,e[1]=s*h,e[5]=s*c,e[9]=-a,e[2]=n*a-i,e[6]=r+t*a,e[10]=s*o}else if("ZXY"===t.order){const t=o*c,n=o*h,i=l*c,r=l*h;e[0]=t-r*a,e[4]=-s*h,e[8]=i+n*a,e[1]=n+i*a,e[5]=s*c,e[9]=r-t*a,e[2]=-s*l,e[6]=a,e[10]=s*o}else if("ZYX"===t.order){const t=s*c,n=s*h,i=a*c,r=a*h;e[0]=o*c,e[4]=i*l-n,e[8]=t*l+r,e[1]=o*h,e[5]=r*l+t,e[9]=n*l-i,e[2]=-l,e[6]=a*o,e[10]=s*o}else if("YZX"===t.order){const t=s*o,n=s*l,i=a*o,r=a*l;e[0]=o*c,e[4]=r-t*h,e[8]=i*h+n,e[1]=h,e[5]=s*c,e[9]=-a*c,e[2]=-l*c,e[6]=n*h+i,e[10]=t-r*h}else if("XZY"===t.order){const t=s*o,n=s*l,i=a*o,r=a*l;e[0]=o*c,e[4]=-h,e[8]=l*c,e[1]=t*h+r,e[5]=s*c,e[9]=n*h-i,e[2]=i*h-n,e[6]=a*c,e[10]=r*h+t}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(le,t,ce)}lookAt(t,e,n){const i=this.elements;return de.subVectors(t,e),0===de.lengthSq()&&(de.z=1),de.normalize(),he.crossVectors(n,de),0===he.lengthSq()&&(1===Math.abs(n.z)?de.x+=1e-4:de.z+=1e-4,de.normalize(),he.crossVectors(n,de)),he.normalize(),ue.crossVectors(de,he),i[0]=he.x,i[4]=ue.x,i[8]=de.x,i[1]=he.y,i[5]=ue.y,i[9]=de.y,i[2]=he.z,i[6]=ue.z,i[10]=de.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){const n=t.elements,i=e.elements,r=this.elements,s=n[0],a=n[4],o=n[8],l=n[12],c=n[1],h=n[5],u=n[9],d=n[13],p=n[2],m=n[6],f=n[10],g=n[14],v=n[3],y=n[7],x=n[11],_=n[15],w=i[0],b=i[4],M=i[8],S=i[12],T=i[1],E=i[5],A=i[9],L=i[13],R=i[2],C=i[6],P=i[10],D=i[14],I=i[3],N=i[7],B=i[11],z=i[15];return r[0]=s*w+a*T+o*R+l*I,r[4]=s*b+a*E+o*C+l*N,r[8]=s*M+a*A+o*P+l*B,r[12]=s*S+a*L+o*D+l*z,r[1]=c*w+h*T+u*R+d*I,r[5]=c*b+h*E+u*C+d*N,r[9]=c*M+h*A+u*P+d*B,r[13]=c*S+h*L+u*D+d*z,r[2]=p*w+m*T+f*R+g*I,r[6]=p*b+m*E+f*C+g*N,r[10]=p*M+m*A+f*P+g*B,r[14]=p*S+m*L+f*D+g*z,r[3]=v*w+y*T+x*R+_*I,r[7]=v*b+y*E+x*C+_*N,r[11]=v*M+y*A+x*P+_*B,r[15]=v*S+y*L+x*D+_*z,this}multiplyScalar(t){const e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){const t=this.elements,e=t[0],n=t[4],i=t[8],r=t[12],s=t[1],a=t[5],o=t[9],l=t[13],c=t[2],h=t[6],u=t[10],d=t[14];return t[3]*(+r*o*h-i*l*h-r*a*u+n*l*u+i*a*d-n*o*d)+t[7]*(+e*o*d-e*l*u+r*s*u-i*s*d+i*l*c-r*o*c)+t[11]*(+e*l*h-e*a*d-r*s*h+n*s*d+r*a*c-n*l*c)+t[15]*(-i*a*c-e*o*h+e*a*u+i*s*h-n*s*u+n*o*c)}transpose(){const t=this.elements;let e;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,n){const i=this.elements;return t.isVector3?(i[12]=t.x,i[13]=t.y,i[14]=t.z):(i[12]=t,i[13]=e,i[14]=n),this}invert(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],s=t[4],a=t[5],o=t[6],l=t[7],c=t[8],h=t[9],u=t[10],d=t[11],p=t[12],m=t[13],f=t[14],g=t[15],v=h*f*l-m*u*l+m*o*d-a*f*d-h*o*g+a*u*g,y=p*u*l-c*f*l-p*o*d+s*f*d+c*o*g-s*u*g,x=c*m*l-p*h*l+p*a*d-s*m*d-c*a*g+s*h*g,_=p*h*o-c*m*o-p*a*u+s*m*u+c*a*f-s*h*f,w=e*v+n*y+i*x+r*_;if(0===w)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);const b=1/w;return t[0]=v*b,t[1]=(m*u*r-h*f*r-m*i*d+n*f*d+h*i*g-n*u*g)*b,t[2]=(a*f*r-m*o*r+m*i*l-n*f*l-a*i*g+n*o*g)*b,t[3]=(h*o*r-a*u*r-h*i*l+n*u*l+a*i*d-n*o*d)*b,t[4]=y*b,t[5]=(c*f*r-p*u*r+p*i*d-e*f*d-c*i*g+e*u*g)*b,t[6]=(p*o*r-s*f*r-p*i*l+e*f*l+s*i*g-e*o*g)*b,t[7]=(s*u*r-c*o*r+c*i*l-e*u*l-s*i*d+e*o*d)*b,t[8]=x*b,t[9]=(p*h*r-c*m*r-p*n*d+e*m*d+c*n*g-e*h*g)*b,t[10]=(s*m*r-p*a*r+p*n*l-e*m*l-s*n*g+e*a*g)*b,t[11]=(c*a*r-s*h*r-c*n*l+e*h*l+s*n*d-e*a*d)*b,t[12]=_*b,t[13]=(c*m*i-p*h*i+p*n*u-e*m*u-c*n*f+e*h*f)*b,t[14]=(p*a*i-s*m*i-p*n*o+e*m*o+s*n*f-e*a*f)*b,t[15]=(s*h*i-c*a*i+c*n*o-e*h*o-s*n*u+e*a*u)*b,this}scale(t){const e=this.elements,n=t.x,i=t.y,r=t.z;return e[0]*=n,e[4]*=i,e[8]*=r,e[1]*=n,e[5]*=i,e[9]*=r,e[2]*=n,e[6]*=i,e[10]*=r,e[3]*=n,e[7]*=i,e[11]*=r,this}getMaxScaleOnAxis(){const t=this.elements,e=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],n=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],i=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(e,n,i))}makeTranslation(t,e,n){return this.set(1,0,0,t,0,1,0,e,0,0,1,n,0,0,0,1),this}makeRotationX(t){const e=Math.cos(t),n=Math.sin(t);return this.set(1,0,0,0,0,e,-n,0,0,n,e,0,0,0,0,1),this}makeRotationY(t){const e=Math.cos(t),n=Math.sin(t);return this.set(e,0,n,0,0,1,0,0,-n,0,e,0,0,0,0,1),this}makeRotationZ(t){const e=Math.cos(t),n=Math.sin(t);return this.set(e,-n,0,0,n,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){const n=Math.cos(e),i=Math.sin(e),r=1-n,s=t.x,a=t.y,o=t.z,l=r*s,c=r*a;return this.set(l*s+n,l*a-i*o,l*o+i*a,0,l*a+i*o,c*a+n,c*o-i*s,0,l*o-i*a,c*o+i*s,r*o*o+n,0,0,0,0,1),this}makeScale(t,e,n){return this.set(t,0,0,0,0,e,0,0,0,0,n,0,0,0,0,1),this}makeShear(t,e,n){return this.set(1,e,n,0,t,1,n,0,t,e,1,0,0,0,0,1),this}compose(t,e,n){const i=this.elements,r=e._x,s=e._y,a=e._z,o=e._w,l=r+r,c=s+s,h=a+a,u=r*l,d=r*c,p=r*h,m=s*c,f=s*h,g=a*h,v=o*l,y=o*c,x=o*h,_=n.x,w=n.y,b=n.z;return i[0]=(1-(m+g))*_,i[1]=(d+x)*_,i[2]=(p-y)*_,i[3]=0,i[4]=(d-x)*w,i[5]=(1-(u+g))*w,i[6]=(f+v)*w,i[7]=0,i[8]=(p+y)*b,i[9]=(f-v)*b,i[10]=(1-(u+m))*b,i[11]=0,i[12]=t.x,i[13]=t.y,i[14]=t.z,i[15]=1,this}decompose(t,e,n){const i=this.elements;let r=ae.set(i[0],i[1],i[2]).length();const s=ae.set(i[4],i[5],i[6]).length(),a=ae.set(i[8],i[9],i[10]).length();this.determinant()<0&&(r=-r),t.x=i[12],t.y=i[13],t.z=i[14],oe.copy(this);const o=1/r,l=1/s,c=1/a;return oe.elements[0]*=o,oe.elements[1]*=o,oe.elements[2]*=o,oe.elements[4]*=l,oe.elements[5]*=l,oe.elements[6]*=l,oe.elements[8]*=c,oe.elements[9]*=c,oe.elements[10]*=c,e.setFromRotationMatrix(oe),n.x=r,n.y=s,n.z=a,this}makePerspective(t,e,n,i,r,s){void 0===s&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");const a=this.elements,o=2*r/(e-t),l=2*r/(n-i),c=(e+t)/(e-t),h=(n+i)/(n-i),u=-(s+r)/(s-r),d=-2*s*r/(s-r);return a[0]=o,a[4]=0,a[8]=c,a[12]=0,a[1]=0,a[5]=l,a[9]=h,a[13]=0,a[2]=0,a[6]=0,a[10]=u,a[14]=d,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,n,i,r,s){const a=this.elements,o=1/(e-t),l=1/(n-i),c=1/(s-r),h=(e+t)*o,u=(n+i)*l,d=(s+r)*c;return a[0]=2*o,a[4]=0,a[8]=0,a[12]=-h,a[1]=0,a[5]=2*l,a[9]=0,a[13]=-u,a[2]=0,a[6]=0,a[10]=-2*c,a[14]=-d,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){const e=this.elements,n=t.elements;for(let t=0;t<16;t++)if(e[t]!==n[t])return!1;return!0}fromArray(t,e=0){for(let n=0;n<16;n++)this.elements[n]=t[n+e];return this}toArray(t=[],e=0){const n=this.elements;return t[e]=n[0],t[e+1]=n[1],t[e+2]=n[2],t[e+3]=n[3],t[e+4]=n[4],t[e+5]=n[5],t[e+6]=n[6],t[e+7]=n[7],t[e+8]=n[8],t[e+9]=n[9],t[e+10]=n[10],t[e+11]=n[11],t[e+12]=n[12],t[e+13]=n[13],t[e+14]=n[14],t[e+15]=n[15],t}}se.prototype.isMatrix4=!0;const ae=new Lt,oe=new se,le=new Lt(0,0,0),ce=new Lt(1,1,1),he=new Lt,ue=new Lt,de=new Lt,pe=new se,me=new At;class fe{constructor(t=0,e=0,n=0,i=fe.DefaultOrder){this._x=t,this._y=e,this._z=n,this._order=i}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,n,i){return this._x=t,this._y=e,this._z=n,this._order=i||this._order,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e,n){const i=t.elements,r=i[0],s=i[4],a=i[8],o=i[1],l=i[5],c=i[9],h=i[2],u=i[6],d=i[10];switch(e=e||this._order){case"XYZ":this._y=Math.asin(ht(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-c,d),this._z=Math.atan2(-s,r)):(this._x=Math.atan2(u,l),this._z=0);break;case"YXZ":this._x=Math.asin(-ht(c,-1,1)),Math.abs(c)<.9999999?(this._y=Math.atan2(a,d),this._z=Math.atan2(o,l)):(this._y=Math.atan2(-h,r),this._z=0);break;case"ZXY":this._x=Math.asin(ht(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(-h,d),this._z=Math.atan2(-s,l)):(this._y=0,this._z=Math.atan2(o,r));break;case"ZYX":this._y=Math.asin(-ht(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(u,d),this._z=Math.atan2(o,r)):(this._x=0,this._z=Math.atan2(-s,l));break;case"YZX":this._z=Math.asin(ht(o,-1,1)),Math.abs(o)<.9999999?(this._x=Math.atan2(-c,l),this._y=Math.atan2(-h,r)):(this._x=0,this._y=Math.atan2(a,d));break;case"XZY":this._z=Math.asin(-ht(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(u,l),this._y=Math.atan2(a,r)):(this._x=Math.atan2(-c,d),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,!1!==n&&this._onChangeCallback(),this}setFromQuaternion(t,e,n){return pe.makeRotationFromQuaternion(t),this.setFromRotationMatrix(pe,e,n)}setFromVector3(t,e){return this.set(t.x,t.y,t.z,e||this._order)}reorder(t){return me.setFromEuler(this),this.setFromQuaternion(me,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new Lt(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}}fe.prototype.isEuler=!0,fe.DefaultOrder="XYZ",fe.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];class ge{constructor(){this.mask=1}set(t){this.mask=1<1){for(let t=0;t1){for(let t=0;t0){i.children=[];for(let e=0;e0){i.animations=[];for(let e=0;e0&&(n.geometries=e),i.length>0&&(n.materials=i),r.length>0&&(n.textures=r),a.length>0&&(n.images=a),o.length>0&&(n.shapes=o),l.length>0&&(n.skeletons=l),c.length>0&&(n.animations=c)}return n.object=i,n;function s(t){const e=[];for(const n in t){const i=t[n];delete i.metadata,e.push(i)}return e}}clone(t){return(new this.constructor).copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let e=0;e1?null:e.copy(n).multiplyScalar(r).add(t.start)}intersectsLine(t){const e=this.distanceToPoint(t.start),n=this.distanceToPoint(t.end);return e<0&&n>0||n<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return void 0===t&&(console.warn("THREE.Plane: .coplanarPoint() target is now required"),t=new Lt),t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){const n=e||Ie.getNormalMatrix(t),i=this.coplanarPoint(Pe).applyMatrix4(t),r=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(r),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return(new this.constructor).copy(this)}}Ne.prototype.isPlane=!0;const Be=new Lt,ze=new Lt,Fe=new Lt,Oe=new Lt,He=new Lt,Ge=new Lt,Ue=new Lt,ke=new Lt,Ve=new Lt,We=new Lt;class je{constructor(t=new Lt,e=new Lt,n=new Lt){this.a=t,this.b=e,this.c=n}static getNormal(t,e,n,i){void 0===i&&(console.warn("THREE.Triangle: .getNormal() target is now required"),i=new Lt),i.subVectors(n,e),Be.subVectors(t,e),i.cross(Be);const r=i.lengthSq();return r>0?i.multiplyScalar(1/Math.sqrt(r)):i.set(0,0,0)}static getBarycoord(t,e,n,i,r){Be.subVectors(i,e),ze.subVectors(n,e),Fe.subVectors(t,e);const s=Be.dot(Be),a=Be.dot(ze),o=Be.dot(Fe),l=ze.dot(ze),c=ze.dot(Fe),h=s*l-a*a;if(void 0===r&&(console.warn("THREE.Triangle: .getBarycoord() target is now required"),r=new Lt),0===h)return r.set(-2,-1,-1);const u=1/h,d=(l*o-a*c)*u,p=(s*c-a*o)*u;return r.set(1-d-p,p,d)}static containsPoint(t,e,n,i){return this.getBarycoord(t,e,n,i,Oe),Oe.x>=0&&Oe.y>=0&&Oe.x+Oe.y<=1}static getUV(t,e,n,i,r,s,a,o){return this.getBarycoord(t,e,n,i,Oe),o.set(0,0),o.addScaledVector(r,Oe.x),o.addScaledVector(s,Oe.y),o.addScaledVector(a,Oe.z),o}static isFrontFacing(t,e,n,i){return Be.subVectors(n,e),ze.subVectors(t,e),Be.cross(ze).dot(i)<0}set(t,e,n){return this.a.copy(t),this.b.copy(e),this.c.copy(n),this}setFromPointsAndIndices(t,e,n,i){return this.a.copy(t[e]),this.b.copy(t[n]),this.c.copy(t[i]),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Be.subVectors(this.c,this.b),ze.subVectors(this.a,this.b),.5*Be.cross(ze).length()}getMidpoint(t){return void 0===t&&(console.warn("THREE.Triangle: .getMidpoint() target is now required"),t=new Lt),t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return je.getNormal(this.a,this.b,this.c,t)}getPlane(t){return void 0===t&&(console.warn("THREE.Triangle: .getPlane() target is now required"),t=new Ne),t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return je.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,n,i,r){return je.getUV(t,this.a,this.b,this.c,e,n,i,r)}containsPoint(t){return je.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return je.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){void 0===e&&(console.warn("THREE.Triangle: .closestPointToPoint() target is now required"),e=new Lt);const n=this.a,i=this.b,r=this.c;let s,a;He.subVectors(i,n),Ge.subVectors(r,n),ke.subVectors(t,n);const o=He.dot(ke),l=Ge.dot(ke);if(o<=0&&l<=0)return e.copy(n);Ve.subVectors(t,i);const c=He.dot(Ve),h=Ge.dot(Ve);if(c>=0&&h<=c)return e.copy(i);const u=o*h-c*l;if(u<=0&&o>=0&&c<=0)return s=o/(o-c),e.copy(n).addScaledVector(He,s);We.subVectors(t,r);const d=He.dot(We),p=Ge.dot(We);if(p>=0&&d<=p)return e.copy(r);const m=d*l-o*p;if(m<=0&&l>=0&&p<=0)return a=l/(l-p),e.copy(n).addScaledVector(Ge,a);const f=c*p-d*h;if(f<=0&&h-c>=0&&d-p>=0)return Ue.subVectors(r,i),a=(h-c)/(h-c+(d-p)),e.copy(i).addScaledVector(Ue,a);const g=1/(f+m+u);return s=m*g,a=u*g,e.copy(n).addScaledVector(He,s).addScaledVector(Ge,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}}let qe=0;function Xe(){Object.defineProperty(this,"id",{value:qe++}),this.uuid=ct(),this.name="",this.type="Material",this.fog=!0,this.blending=1,this.side=0,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=204,this.blendDst=205,this.blendEquation=n,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=3,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=519,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=tt,this.stencilZFail=tt,this.stencilZPass=tt,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaTest=0,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0}Xe.prototype=Object.assign(Object.create(rt.prototype),{constructor:Xe,isMaterial:!0,onBuild:function(){},onBeforeCompile:function(){},customProgramCacheKey:function(){return this.onBeforeCompile.toString()},setValues:function(t){if(void 0!==t)for(const e in t){const n=t[e];if(void 0===n){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if("shading"===e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===n;continue}const i=this[e];void 0!==i?i&&i.isColor?i.set(n):i&&i.isVector3&&n&&n.isVector3?i.copy(n):this[e]=n:console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.")}},toJSON:function(t){const e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});const n={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};function i(t){const e=[];for(const n in t){const i=t[n];delete i.metadata,e.push(i)}return e}if(n.uuid=this.uuid,n.type=this.type,""!==this.name&&(n.name=this.name),this.color&&this.color.isColor&&(n.color=this.color.getHex()),void 0!==this.roughness&&(n.roughness=this.roughness),void 0!==this.metalness&&(n.metalness=this.metalness),this.sheen&&this.sheen.isColor&&(n.sheen=this.sheen.getHex()),this.emissive&&this.emissive.isColor&&(n.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(n.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(n.specular=this.specular.getHex()),void 0!==this.shininess&&(n.shininess=this.shininess),void 0!==this.clearcoat&&(n.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(n.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(n.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(n.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(n.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,n.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(n.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(n.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(n.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(n.lightMap=this.lightMap.toJSON(t).uuid,n.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(n.aoMap=this.aoMap.toJSON(t).uuid,n.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(n.bumpMap=this.bumpMap.toJSON(t).uuid,n.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(n.normalMap=this.normalMap.toJSON(t).uuid,n.normalMapType=this.normalMapType,n.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(n.displacementMap=this.displacementMap.toJSON(t).uuid,n.displacementScale=this.displacementScale,n.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(n.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(n.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(n.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(n.specularMap=this.specularMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(n.envMap=this.envMap.toJSON(t).uuid,void 0!==this.combine&&(n.combine=this.combine)),void 0!==this.envMapIntensity&&(n.envMapIntensity=this.envMapIntensity),void 0!==this.reflectivity&&(n.reflectivity=this.reflectivity),void 0!==this.refractionRatio&&(n.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(n.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.size&&(n.size=this.size),null!==this.shadowSide&&(n.shadowSide=this.shadowSide),void 0!==this.sizeAttenuation&&(n.sizeAttenuation=this.sizeAttenuation),1!==this.blending&&(n.blending=this.blending),0!==this.side&&(n.side=this.side),this.vertexColors&&(n.vertexColors=!0),this.opacity<1&&(n.opacity=this.opacity),!0===this.transparent&&(n.transparent=this.transparent),n.depthFunc=this.depthFunc,n.depthTest=this.depthTest,n.depthWrite=this.depthWrite,n.colorWrite=this.colorWrite,n.stencilWrite=this.stencilWrite,n.stencilWriteMask=this.stencilWriteMask,n.stencilFunc=this.stencilFunc,n.stencilRef=this.stencilRef,n.stencilFuncMask=this.stencilFuncMask,n.stencilFail=this.stencilFail,n.stencilZFail=this.stencilZFail,n.stencilZPass=this.stencilZPass,this.rotation&&0!==this.rotation&&(n.rotation=this.rotation),!0===this.polygonOffset&&(n.polygonOffset=!0),0!==this.polygonOffsetFactor&&(n.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(n.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&1!==this.linewidth&&(n.linewidth=this.linewidth),void 0!==this.dashSize&&(n.dashSize=this.dashSize),void 0!==this.gapSize&&(n.gapSize=this.gapSize),void 0!==this.scale&&(n.scale=this.scale),!0===this.dithering&&(n.dithering=!0),this.alphaTest>0&&(n.alphaTest=this.alphaTest),!0===this.alphaToCoverage&&(n.alphaToCoverage=this.alphaToCoverage),!0===this.premultipliedAlpha&&(n.premultipliedAlpha=this.premultipliedAlpha),!0===this.wireframe&&(n.wireframe=this.wireframe),this.wireframeLinewidth>1&&(n.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(n.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(n.wireframeLinejoin=this.wireframeLinejoin),!0===this.morphTargets&&(n.morphTargets=!0),!0===this.morphNormals&&(n.morphNormals=!0),!0===this.skinning&&(n.skinning=!0),!0===this.flatShading&&(n.flatShading=this.flatShading),!1===this.visible&&(n.visible=!1),!1===this.toneMapped&&(n.toneMapped=!1),"{}"!==JSON.stringify(this.userData)&&(n.userData=this.userData),e){const e=i(t.textures),r=i(t.images);e.length>0&&(n.textures=e),r.length>0&&(n.images=r)}return n},clone:function(){return(new this.constructor).copy(this)},copy:function(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;const e=t.clippingPlanes;let n=null;if(null!==e){const t=e.length;n=new Array(t);for(let i=0;i!==t;++i)n[i]=e[i].clone()}return this.clippingPlanes=n,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this},dispose:function(){this.dispatchEvent({type:"dispose"})}}),Object.defineProperty(Xe.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}});const Ye={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},Ze={h:0,s:0,l:0},Je={h:0,s:0,l:0};function Qe(t,e,n){return n<0&&(n+=1),n>1&&(n-=1),n<1/6?t+6*(e-t)*n:n<.5?e:n<2/3?t+6*(e-t)*(2/3-n):t}function Ke(t){return t<.04045?.0773993808*t:Math.pow(.9478672986*t+.0521327014,2.4)}function $e(t){return t<.0031308?12.92*t:1.055*Math.pow(t,.41666)-.055}class tn{constructor(t,e,n){return void 0===e&&void 0===n?this.set(t):this.setRGB(t,e,n)}set(t){return t&&t.isColor?this.copy(t):"number"==typeof t?this.setHex(t):"string"==typeof t&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(255&t)/255,this}setRGB(t,e,n){return this.r=t,this.g=e,this.b=n,this}setHSL(t,e,n){if(t=ut(t,1),e=ht(e,0,1),n=ht(n,0,1),0===e)this.r=this.g=this.b=n;else{const i=n<=.5?n*(1+e):n+e-n*e,r=2*n-i;this.r=Qe(r,i,t+1/3),this.g=Qe(r,i,t),this.b=Qe(r,i,t-1/3)}return this}setStyle(t){function e(e){void 0!==e&&parseFloat(e)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let n;if(n=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let t;const i=n[1],r=n[2];switch(i){case"rgb":case"rgba":if(t=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(r))return this.r=Math.min(255,parseInt(t[1],10))/255,this.g=Math.min(255,parseInt(t[2],10))/255,this.b=Math.min(255,parseInt(t[3],10))/255,e(t[4]),this;if(t=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(r))return this.r=Math.min(100,parseInt(t[1],10))/100,this.g=Math.min(100,parseInt(t[2],10))/100,this.b=Math.min(100,parseInt(t[3],10))/100,e(t[4]),this;break;case"hsl":case"hsla":if(t=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(r)){const n=parseFloat(t[1])/360,i=parseInt(t[2],10)/100,r=parseInt(t[3],10)/100;return e(t[4]),this.setHSL(n,i,r)}}}else if(n=/^\#([A-Fa-f\d]+)$/.exec(t)){const t=n[1],e=t.length;if(3===e)return this.r=parseInt(t.charAt(0)+t.charAt(0),16)/255,this.g=parseInt(t.charAt(1)+t.charAt(1),16)/255,this.b=parseInt(t.charAt(2)+t.charAt(2),16)/255,this;if(6===e)return this.r=parseInt(t.charAt(0)+t.charAt(1),16)/255,this.g=parseInt(t.charAt(2)+t.charAt(3),16)/255,this.b=parseInt(t.charAt(4)+t.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){const e=Ye[t.toLowerCase()];return void 0!==e?this.setHex(e):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copyGammaToLinear(t,e=2){return this.r=Math.pow(t.r,e),this.g=Math.pow(t.g,e),this.b=Math.pow(t.b,e),this}copyLinearToGamma(t,e=2){const n=e>0?1/e:1;return this.r=Math.pow(t.r,n),this.g=Math.pow(t.g,n),this.b=Math.pow(t.b,n),this}convertGammaToLinear(t){return this.copyGammaToLinear(this,t),this}convertLinearToGamma(t){return this.copyLinearToGamma(this,t),this}copySRGBToLinear(t){return this.r=Ke(t.r),this.g=Ke(t.g),this.b=Ke(t.b),this}copyLinearToSRGB(t){return this.r=$e(t.r),this.g=$e(t.g),this.b=$e(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){void 0===t&&(console.warn("THREE.Color: .getHSL() target is now required"),t={h:0,s:0,l:0});const e=this.r,n=this.g,i=this.b,r=Math.max(e,n,i),s=Math.min(e,n,i);let a,o;const l=(s+r)/2;if(s===r)a=0,o=0;else{const t=r-s;switch(o=l<=.5?t/(r+s):t/(2-r-s),r){case e:a=(n-i)/t+(ne&&(e=t[n]);return e}const vn={Int8Array:Int8Array,Uint8Array:Uint8Array,Uint8ClampedArray:Uint8ClampedArray,Int16Array:Int16Array,Uint16Array:Uint16Array,Int32Array:Int32Array,Uint32Array:Uint32Array,Float32Array:Float32Array,Float64Array:Float64Array};function yn(t,e){return new vn[t](e)}let xn=0;const _n=new se,wn=new Ce,bn=new Lt,Mn=new Pt,Sn=new Pt,Tn=new Lt;class En extends rt{constructor(){super(),Object.defineProperty(this,"id",{value:xn++}),this.uuid=ct(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(gn(t)>65535?dn:hn)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return void 0!==this.attributes[t]}addGroup(t,e,n=0){this.groups.push({start:t,count:e,materialIndex:n})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){const e=this.attributes.position;void 0!==e&&(e.applyMatrix4(t),e.needsUpdate=!0);const n=this.attributes.normal;if(void 0!==n){const e=(new yt).getNormalMatrix(t);n.applyNormalMatrix(e),n.needsUpdate=!0}const i=this.attributes.tangent;return void 0!==i&&(i.transformDirection(t),i.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}rotateX(t){return _n.makeRotationX(t),this.applyMatrix4(_n),this}rotateY(t){return _n.makeRotationY(t),this.applyMatrix4(_n),this}rotateZ(t){return _n.makeRotationZ(t),this.applyMatrix4(_n),this}translate(t,e,n){return _n.makeTranslation(t,e,n),this.applyMatrix4(_n),this}scale(t,e,n){return _n.makeScale(t,e,n),this.applyMatrix4(_n),this}lookAt(t){return wn.lookAt(t),wn.updateMatrix(),this.applyMatrix4(wn.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(bn).negate(),this.translate(bn.x,bn.y,bn.z),this}setFromPoints(t){const e=[];for(let n=0,i=t.length;n0&&(t.userData=this.userData),void 0!==this.parameters){const e=this.parameters;for(const n in e)void 0!==e[n]&&(t[n]=e[n]);return t}t.data={attributes:{}};const e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});const n=this.attributes;for(const e in n){const i=n[e];t.data.attributes[e]=i.toJSON(t.data)}const i={};let r=!1;for(const e in this.morphAttributes){const n=this.morphAttributes[e],s=[];for(let e=0,i=n.length;e0&&(i[e]=s,r=!0)}r&&(t.data.morphAttributes=i,t.data.morphTargetsRelative=this.morphTargetsRelative);const s=this.groups;s.length>0&&(t.data.groups=JSON.parse(JSON.stringify(s)));const a=this.boundingSphere;return null!==a&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return(new En).copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;const e={};this.name=t.name;const n=t.index;null!==n&&this.setIndex(n.clone(e));const i=t.attributes;for(const t in i){const n=i[t];this.setAttribute(t,n.clone(e))}const r=t.morphAttributes;for(const t in r){const n=[],i=r[t];for(let t=0,r=i.length;t0){const t=e[n[0]];if(void 0!==t){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let e=0,n=t.length;e0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){const n=this.geometry,i=this.material,r=this.matrixWorld;if(void 0===i)return;if(null===n.boundingSphere&&n.computeBoundingSphere(),Rn.copy(n.boundingSphere),Rn.applyMatrix4(r),!1===t.ray.intersectsSphere(Rn))return;if(An.copy(r).invert(),Ln.copy(t.ray).applyMatrix4(An),null!==n.boundingBox&&!1===Ln.intersectsBox(n.boundingBox))return;let s;if(n.isBufferGeometry){const r=n.index,a=n.attributes.position,o=n.morphAttributes.position,l=n.morphTargetsRelative,c=n.attributes.uv,h=n.attributes.uv2,u=n.groups,d=n.drawRange;if(null!==r)if(Array.isArray(i))for(let n=0,p=u.length;nn.far?null:{distance:c,point:Vn.clone(),object:t}}(t,e,n,i,Cn,Pn,Dn,kn);if(p){o&&(Hn.fromBufferAttribute(o,c),Gn.fromBufferAttribute(o,h),Un.fromBufferAttribute(o,u),p.uv=je.getUV(kn,Cn,Pn,Dn,Hn,Gn,Un,new vt)),l&&(Hn.fromBufferAttribute(l,c),Gn.fromBufferAttribute(l,h),Un.fromBufferAttribute(l,u),p.uv2=je.getUV(kn,Cn,Pn,Dn,Hn,Gn,Un,new vt));const t={a:c,b:h,c:u,normal:new Lt,materialIndex:0};je.getNormal(Cn,Pn,Dn,t.normal),p.face=t}return p}Wn.prototype.isMesh=!0;class qn extends En{constructor(t=1,e=1,n=1,i=1,r=1,s=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:n,widthSegments:i,heightSegments:r,depthSegments:s};const a=this;i=Math.floor(i),r=Math.floor(r),s=Math.floor(s);const o=[],l=[],c=[],h=[];let u=0,d=0;function p(t,e,n,i,r,s,p,m,f,g,v){const y=s/f,x=p/g,_=s/2,w=p/2,b=m/2,M=f+1,S=g+1;let T=0,E=0;const A=new Lt;for(let s=0;s0?1:-1,c.push(A.x,A.y,A.z),h.push(o/f),h.push(1-s/g),T+=1}}for(let t=0;t