diff --git a/vulnerabilities/templates/advisory_detail.html b/vulnerabilities/templates/advisory_detail.html index fea5afde4..65ae22bbc 100644 --- a/vulnerabilities/templates/advisory_detail.html +++ b/vulnerabilities/templates/advisory_detail.html @@ -25,7 +25,7 @@
-
+
@@ -458,7 +459,7 @@ {% endfor %} -
+
{% if epss_data %}
Exploit Prediction Scoring System (EPSS) @@ -518,6 +519,68 @@ {% endif %}
+ + {% if epss_history_data|length > 1 %} +
+ EPSS Score History +
+ +
+ + +
+ + + +
+
+ EPSS History Table +
+ + + + + + + + + + {% for row in epss_history_data reversed %} + + + + + + {% endfor %} + +
Published AtEPSS ScorePercentile
{{ row.published_at|date:"M d, Y" }}{{ row.score|default_if_none:"—" }}{{ row.percentile|default_if_none:"—" }}
+ + {% if epss_pagination_obj and epss_pagination_obj.has_other_pages %} + + {% endif %} +
+ {% endif %} {% else %}

No EPSS data available for this advisory.

{% endif %} @@ -684,7 +747,7 @@ {% endif %}
- +
{% endcomment %}
{% endif %} - + + +{% if 'epss_page' in request.GET or severities %} + + + +{% endif %} + +{{ epss_history_data|json_script:"epss-history-data" }} + + {% endblock %} \ No newline at end of file diff --git a/vulnerabilities/tests/test_data/epss/epss_history_expected.json b/vulnerabilities/tests/test_data/epss/epss_history_expected.json new file mode 100644 index 000000000..dbdce2699 --- /dev/null +++ b/vulnerabilities/tests/test_data/epss/epss_history_expected.json @@ -0,0 +1,152 @@ +[ + { + "score": 0.00048, + "percentile": 0.14616, + "published_at": "2026-05-02" + }, + { + "score": 0.00048, + "percentile": 0.14593, + "published_at": "2026-05-03" + }, + { + "score": 0.00048, + "percentile": 0.1453, + "published_at": "2026-05-04" + }, + { + "score": 0.00048, + "percentile": 0.1453, + "published_at": "2026-05-05" + }, + { + "score": 0.00048, + "percentile": 0.1453, + "published_at": "2026-05-06" + }, + { + "score": 0.00048, + "percentile": 0.14663, + "published_at": "2026-05-07" + }, + { + "score": 0.00048, + "percentile": 0.14697, + "published_at": "2026-05-08" + }, + { + "score": 0.00048, + "percentile": 0.14752, + "published_at": "2026-05-09" + }, + { + "score": 0.00048, + "percentile": 0.14765, + "published_at": "2026-05-10" + }, + { + "score": 0.00048, + "percentile": 0.14748, + "published_at": "2026-05-11" + }, + { + "score": 0.00048, + "percentile": 0.14793, + "published_at": "2026-05-12" + }, + { + "score": 0.00048, + "percentile": 0.14815, + "published_at": "2026-05-13" + }, + { + "score": 0.00048, + "percentile": 0.14874, + "published_at": "2026-05-14" + }, + { + "score": 0.00048, + "percentile": 0.14881, + "published_at": "2026-05-15" + }, + { + "score": 0.00048, + "percentile": 0.14905, + "published_at": "2026-05-16" + }, + { + "score": 0.00048, + "percentile": 0.14886, + "published_at": "2026-05-17" + }, + { + "score": 0.00048, + "percentile": 0.14837, + "published_at": "2026-05-18" + }, + { + "score": 0.00048, + "percentile": 0.14816, + "published_at": "2026-05-19" + }, + { + "score": 0.00048, + "percentile": 0.14827, + "published_at": "2026-05-20" + }, + { + "score": 0.00048, + "percentile": 0.14803, + "published_at": "2026-05-21" + }, + { + "score": 0.00048, + "percentile": 0.14978, + "published_at": "2026-05-22" + }, + { + "score": 0.00048, + "percentile": 0.14966, + "published_at": "2026-05-23" + }, + { + "score": 0.00048, + "percentile": 0.14918, + "published_at": "2026-05-24" + }, + { + "score": 0.00048, + "percentile": 0.14902, + "published_at": "2026-05-25" + }, + { + "score": 0.00048, + "percentile": 0.14898, + "published_at": "2026-05-26" + }, + { + "score": 0.00048, + "percentile": 0.14998, + "published_at": "2026-05-27" + }, + { + "score": 0.00048, + "percentile": 0.15143, + "published_at": "2026-05-28" + }, + { + "score": 0.00048, + "percentile": 0.15216, + "published_at": "2026-05-29" + }, + { + "score": 0.00048, + "percentile": 0.15204, + "published_at": "2026-05-30" + }, + { + "score": 0.00048, + "percentile": 0.15171, + "published_at": "2026-05-31" + } +] \ No newline at end of file diff --git a/vulnerabilities/tests/test_data/epss/epss_history_test_data.json b/vulnerabilities/tests/test_data/epss/epss_history_test_data.json new file mode 100644 index 000000000..6a1b4d62c --- /dev/null +++ b/vulnerabilities/tests/test_data/epss/epss_history_test_data.json @@ -0,0 +1,777 @@ +[ + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.000480000", + "scoring_elements": "0.151710000", + "published_at": "2026-05-31T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.000480000", + "scoring_elements": "0.152040000", + "published_at": "2026-05-30T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.15216000", + "published_at": "2026-05-29T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.15143000", + "published_at": "2026-05-28T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14998000", + "published_at": "2026-05-27T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14898000", + "published_at": "2026-05-26T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14902000", + "published_at": "2026-05-25T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14918000", + "published_at": "2026-05-24T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14966000", + "published_at": "2026-05-23T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14978000", + "published_at": "2026-05-22T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14803000", + "published_at": "2026-05-21T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14827000", + "published_at": "2026-05-20T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14816000", + "published_at": "2026-05-19T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14837000", + "published_at": "2026-05-18T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14886000", + "published_at": "2026-05-17T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14905000", + "published_at": "2026-05-16T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14881000", + "published_at": "2026-05-15T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14874000", + "published_at": "2026-05-14T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14815000", + "published_at": "2026-05-13T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14793000", + "published_at": "2026-05-12T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14748000", + "published_at": "2026-05-11T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14765000", + "published_at": "2026-05-10T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14752000", + "published_at": "2026-05-09T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14697000", + "published_at": "2026-05-08T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14663000", + "published_at": "2026-05-07T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14530000", + "published_at": "2026-05-06T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14530000", + "published_at": "2026-05-05T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14530000", + "published_at": "2026-05-04T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14593000", + "published_at": "2026-05-03T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14616000", + "published_at": "2026-05-02T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + }, + { + "advisory_id": "CVE-2022-25204", + "aliases": [], + "summary": "", + "affected_packages": [], + "references": [ + { + "reference_id": "", + "reference_type": "", + "url": "https://api.first.org/data/v1/epss?cve=CVE-2022-25204" + } + ], + "patches": [], + "severities": [ + { + "system": "epss", + "value": "0.00048000", + "scoring_elements": "0.14603000", + "published_at": "2026-05-01T00:00:00+00:00" + } + ], + "date_published": null, + "weaknesses": [], + "url": "https://epss.cyentia.com/epss_scores-current.csv.gz" + } +] \ No newline at end of file diff --git a/vulnerabilities/tests/test_epss_history.py b/vulnerabilities/tests/test_epss_history.py new file mode 100644 index 000000000..429bb5e2d --- /dev/null +++ b/vulnerabilities/tests/test_epss_history.py @@ -0,0 +1,89 @@ +# +# Copyright (c) nexB Inc. and others. All rights reserved. +# VulnerableCode is a trademark of nexB Inc. +# SPDX-License-Identifier: Apache-2.0 +# See http://www.apache.org/licenses/LICENSE-2.0 for the license text. +# See https://github.com/aboutcode-org/vulnerablecode for support or download. +# See https://aboutcode.org for more information about nexB OSS projects. +# + +import json +import time +import pytest +from pathlib import Path + +from django.test import TestCase +from django.urls import reverse + +from vulnerabilities.models import EPSS +from vulnerabilities.models import AdvisoryReference +from vulnerabilities.models import AdvisoryV2 +from vulnerabilities.pipelines.v2_importers.epss_importer_v2 import EPSSImporterPipeline +from vulnerabilities.tests.util_tests import check_results_against_json + + +class AdvisoryDetailsEpssTestCase(TestCase): + def setUp(self): + json_file = Path(__file__).parent / "test_data" / "epss" / "epss_history_test_data.json" + with open(json_file, "r") as f: + json_data = json.load(f) + + ref_obj = AdvisoryReference.objects.create(url=json_data[0]["references"][0]["url"]) + + for i, data in enumerate(json_data): + is_latest = i == 0 + + advisory = AdvisoryV2.objects.create( + avid=f"test_epss/advisory-{i}", + advisory_id="CVE-2022-25204", + url="https://epss.cyentia.com/epss_scores-current.csv.gz", + is_latest=is_latest, + datasource_id=EPSS.identifier, + pipeline_id=EPSSImporterPipeline.pipeline_id, + unique_content_id=f"hash_{i}", + ) + + advisory.references.add(ref_obj) + + for severity in data["severities"]: + advisory.severities.create( + scoring_system=severity["system"], + value=severity["value"], + scoring_elements=severity["scoring_elements"], + published_at=severity["published_at"], + ) + + if i == 0: + self.advisory = advisory + + @pytest.mark.ignore_template_errors() + def test_epss_history_context(self): + session = self.client.session + session["altcha_verified_at"] = time.time() + session.save() + + response = self.client.get(reverse("advisory_details", kwargs={"avid": self.advisory.avid})) + self.assertEqual(response.status_code, 200) + + expected_file = Path(__file__).parent / "test_data" / "epss" / "epss_history_expected.json" + history_data_for_json = [ + {**record, "published_at": record["published_at"].isoformat()} + for record in response.context["epss_history_data"] + ] + + check_results_against_json(history_data_for_json, expected_file) + + def test_get_epss_history(self): + from vulnerabilities.views import get_epss_history + + epss_history_data, epss_pagination_obj = get_epss_history(self.advisory, 1) + + expected_file = Path(__file__).parent / "test_data" / "epss" / "epss_history_expected.json" + history_data_for_json = [ + {**record, "published_at": record["published_at"].isoformat()} + for record in epss_history_data + ] + + check_results_against_json(history_data_for_json, expected_file) + self.assertEqual(epss_pagination_obj.number, 1) + self.assertTrue(epss_pagination_obj.has_next()) diff --git a/vulnerabilities/views.py b/vulnerabilities/views.py index abebb4f1c..7d29a27cf 100644 --- a/vulnerabilities/views.py +++ b/vulnerabilities/views.py @@ -7,6 +7,7 @@ # See https://aboutcode.org for more information about nexB OSS projects. # +import datetime import json import logging import time @@ -21,10 +22,16 @@ from django.core.cache import cache from django.core.exceptions import ValidationError from django.core.mail import send_mail +from django.core.paginator import Paginator from django.db.models import Exists +from django.db.models import FloatField +from django.db.models import Max from django.db.models import OuterRef from django.db.models import Prefetch +from django.core.paginator import Paginator from django.db.models import Q +from django.db.models.functions import Cast +from django.db.models.functions import TruncDate from django.http import HttpResponse from django.http.response import Http404 from django.shortcuts import get_object_or_404 @@ -580,6 +587,61 @@ def get_context_data(self, **kwargs): return context +def get_epss_history(advisory, epss_page_param): + """ + Fetch and return EPSS history data for an advisory. + """ + + epss_history_data = [] + epss_pagination_obj = None + + epss_scores_queryset = ( + models.AdvisorySeverity.objects.filter( + advisories__advisory_id=advisory.advisory_id, + advisories__datasource_id=EPSS.identifier, + scoring_system=EPSS.identifier, + published_at__isnull=False, + ) + .annotate(pub_date=TruncDate("published_at")) + .values("pub_date") + .annotate( + max_score=Max(Cast("value", FloatField())), + max_percentile=Max(Cast("scoring_elements", FloatField())), + ) + .order_by("-pub_date") + ) + + paginator = Paginator(epss_scores_queryset, 30) + epss_page = epss_page_param or 1 + epss_pagination_obj = paginator.get_page(epss_page) + + if epss_pagination_obj.object_list: + records = list(epss_pagination_obj.object_list) + newest_date = records[0]["pub_date"] + oldest_date = records[-1]["pub_date"] + + records_by_date = { + record["pub_date"]: { + "score": record["max_score"], + "percentile": record["max_percentile"], + "published_at": record["pub_date"], + } + for record in records + } + + total_days = (newest_date - oldest_date).days + all_dates = [oldest_date + datetime.timedelta(days=i) for i in range(total_days + 1)] + + # Handle missing dates + for date in all_dates: + if date in records_by_date: + epss_history_data.append(records_by_date[date]) + else: + epss_history_data.append({"published_at": date, "score": None, "percentile": None}) + + return epss_history_data, epss_pagination_obj + + class AdvisoryDetails(VulnerableCodeDetailView): model = models.AdvisoryV2 template_name = "advisory_detail.html" @@ -739,6 +801,11 @@ def add_ssvc(ssvc): add_ssvc(ssvc) context["ssvcs"] = ssvc_entries + + epss_history_data, epss_pagination_obj = get_epss_history( + advisory, self.request.GET.get("epss_page") + ) + context.update( { "advisory": advisory, @@ -750,6 +817,8 @@ def add_ssvc(ssvc): "weaknesses": weaknesses_present_in_db, "status": advisory.get_status_label, "epss_data": epss_data, + "epss_history_data": epss_history_data, + "epss_pagination_obj": epss_pagination_obj, } ) return context diff --git a/vulnerablecode/static/css/billboard.css b/vulnerablecode/static/css/billboard.css new file mode 100644 index 000000000..d06a126c6 --- /dev/null +++ b/vulnerablecode/static/css/billboard.css @@ -0,0 +1,317 @@ +/*! + * Copyright (c) 2017 ~ present NAVER Corp. + * billboard.js project is licensed under the MIT license + * + * billboard.js, JavaScript chart library + * https://naver.github.io/billboard.js/ + * + * @version 3.18.0 + */ +/*-- Chart --*/ +.bb svg { + font: 10px sans-serif; + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); +} +.bb path, .bb line { + fill: none; + stroke: #000; +} +.bb text, .bb .bb-button { + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} + +.bb-legend-item-tile, +.bb-xgrid-focus, +.bb-ygrid-focus, +.bb-ygrid { + shape-rendering: crispEdges; +} + +.bb-chart-arcs .bb-needle { + fill: #000; +} + +.bb-chart-arc .bb-gauge-value { + fill: #000; +} +.bb-chart-arc path { + stroke: #fff; +} +.bb-chart-arc rect { + stroke: #fff; + stroke-width: 1; +} +.bb-chart-arc text { + fill: #fff; + font-size: 13px; +} +.bb-chart-arc { + /* Connector line base styles */ +} +.bb-chart-arc .bb-arc-label-line { + fill: none; + stroke-width: 1px; + pointer-events: none; +} +.bb-chart-arc .bb-arc-label-line { + stroke: #7f7f7f; +} +.bb-chart-arc > text.bb-arc-label-line-text { + fill: #000; +} + +/*-- Funnel --*/ +.bb-chart-funnels path { + stroke-width: 0; +} +.bb-chart-funnels + .bb-chart-texts text { + font-size: 13px; + fill: #fff; +} + +/*-- Axis --*/ +.bb-axis { + shape-rendering: crispEdges; +} +.bb-axis .bb-axis-x-tooltip, .bb-axis .bb-axis-y-tooltip, .bb-axis .bb-axis-y2-tooltip { + font-size: 1em; + fill: #fff; + white-space: nowrap; +} + +/*-- Grid --*/ +.bb-grid { + pointer-events: none; +} +.bb-grid line { + stroke: #aaa; +} +.bb-grid text { + fill: #aaa; +} + +.bb-xgrid, .bb-ygrid { + stroke-dasharray: 3 3; +} + +/*-- Text on Chart --*/ +.bb-text.bb-empty { + fill: #808080; + font-size: 2em; +} + +/*-- Line --*/ +.bb-line { + stroke-width: 1px; +} + +/*-- Point --*/ +.bb-circle._expanded_ { + stroke-width: 1px; + stroke: white; +} + +.bb-selected-circle { + fill: white; + stroke-width: 2px; +} + +/*-- Bar --*/ +.bb-bar { + stroke-width: 0; +} +.bb-bar._expanded_ { + fill-opacity: 0.75; +} + +/*-- Candlestick --*/ +.bb-candlestick { + stroke-width: 1px; +} +.bb-candlestick._expanded_ { + fill-opacity: 0.75; +} + +/*-- Focus --*/ +.bb-target.bb-focused, .bb-circles.bb-focused { + opacity: 1; +} +.bb-target.bb-focused path.bb-line, .bb-target.bb-focused path.bb-step, .bb-circles.bb-focused path.bb-line, .bb-circles.bb-focused path.bb-step { + stroke-width: 2px; +} +.bb-target.bb-defocused, .bb-circles.bb-defocused { + opacity: 0.3 !important; +} +.bb-target.bb-defocused .text-overlapping, .bb-circles.bb-defocused .text-overlapping { + opacity: 0.05 !important; +} + +/*-- Region --*/ +.bb-region { + fill: steelblue; +} +.bb-region rect { + fill-opacity: 0.1; +} + +/*-- Zoom region --*/ +.bb-zoom-brush { + fill-opacity: 0.1; +} + +/*-- Brush --*/ +.bb-brush .extent { + fill-opacity: 0.1; +} + +/*-- Legend --*/ +.bb-legend-item { + font-size: 12px; + user-select: none; +} + +.bb-legend-item-hidden { + opacity: 0.15; +} + +.bb-legend-background { + opacity: 0.75; + fill: white; + stroke: lightgray; + stroke-width: 1; +} + +/*-- Title --*/ +.bb-title { + font: 14px sans-serif; +} + +/*-- Treemap --*/ +.bb-chart-treemaps rect { + stroke: #fff; + stroke-width: 1px; +} + +/*-- Tooltip --*/ +.bb-tooltip-container { + z-index: 10; + user-select: none; + transform: translateZ(0); +} + +.bb-tooltip { + border-collapse: collapse; + border-spacing: 0; + background-color: #fff; + empty-cells: show; + opacity: 0.9; + box-shadow: 7px 7px 12px -9px rgb(119, 119, 119); + white-space: nowrap; +} +.bb-tooltip tr { + border: 1px solid #CCC; +} +.bb-tooltip th { + background-color: #aaa; + font-size: 14px; + padding: 2px 5px; + text-align: left; + color: #FFF; +} +.bb-tooltip td { + font-size: 13px; + padding: 3px 6px; + background-color: #fff; + border-left: 1px dotted #999; +} +.bb-tooltip td > span, .bb-tooltip td > svg { + display: inline-block; + width: 10px; + height: 10px; + margin-right: 6px; +} +.bb-tooltip.value { + text-align: right; +} + +/*-- Area --*/ +.bb-area { + stroke-width: 0; + opacity: 0.2; +} + +/*-- Arc --*/ +.bb-chart-arcs-title { + dominant-baseline: middle; + font-size: 1.3em; +} + +text.bb-chart-arcs-gauge-title { + dominant-baseline: middle; + font-size: 2.7em; +} + +.bb-chart-arcs .bb-chart-arcs-background { + fill: #e0e0e0; + stroke: #fff; +} +.bb-chart-arcs .bb-chart-arcs-gauge-unit { + fill: #000; + font-size: 16px; +} +.bb-chart-arcs .bb-chart-arcs-gauge-max { + fill: #777; +} +.bb-chart-arcs .bb-chart-arcs-gauge-min { + fill: #777; +} +.bb-chart-arcs { + /*-- Polar --*/ +} +.bb-chart-arcs .bb-levels circle { + fill: none; + stroke: #848282; + stroke-width: 0.5px; +} +.bb-chart-arcs .bb-levels text { + fill: #848282; +} + +/*-- Radar --*/ +.bb-chart-radars .bb-levels polygon { + fill: none; + stroke: #848282; + stroke-width: 0.5px; +} +.bb-chart-radars .bb-levels text { + fill: #848282; +} +.bb-chart-radars .bb-axis line { + stroke: #848282; + stroke-width: 0.5px; +} +.bb-chart-radars .bb-axis text { + font-size: 1.15em; + cursor: default; +} +.bb-chart-radars .bb-shapes polygon { + fill-opacity: 0.2; + stroke-width: 1px; +} + +/*-- Button --*/ +.bb-button { + position: absolute; + top: 10px; + right: 10px; +} +.bb-button .bb-zoom-reset { + font-size: 11px; + border: solid 1px #ccc; + background-color: #fff; + padding: 5px; + border-radius: 5px; + cursor: pointer; +} diff --git a/vulnerablecode/static/css/billboard.css.ABOUT b/vulnerablecode/static/css/billboard.css.ABOUT new file mode 100644 index 000000000..a6f40f5d1 --- /dev/null +++ b/vulnerablecode/static/css/billboard.css.ABOUT @@ -0,0 +1,14 @@ +about_resource: billboard.css +name: billboard.js +version: 3.18.0 +download_url: https://registry.npmjs.org/billboard.js/-/billboard.js-3.18.0.tgz +description: Re-usable easy interface JavaScript chart library, based on D3 v4+ +license_expression: mit +homepage_url: https://naver.github.io/billboard.js/ +owner: NAVER Corp. +attribute: yes +package_url: pkg:npm/billboard.js@3.18.0 +licenses: + - key: mit + name: MIT License + file: billboard.css.LICENSE diff --git a/vulnerablecode/static/css/billboard.css.LICENSE b/vulnerablecode/static/css/billboard.css.LICENSE new file mode 100644 index 000000000..7252101c5 --- /dev/null +++ b/vulnerablecode/static/css/billboard.css.LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2017 ~ present NAVER Corp. +Copyright (c) 2013 Masayuki Tanaka + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vulnerablecode/static/css/custom.css b/vulnerablecode/static/css/custom.css index 6d8918a8f..9410c73c9 100644 --- a/vulnerablecode/static/css/custom.css +++ b/vulnerablecode/static/css/custom.css @@ -655,3 +655,4 @@ ul.fixed_by_bullet li li li { box-shadow: none; } } + diff --git a/vulnerablecode/static/js/advisory_detail.js b/vulnerablecode/static/js/advisory_detail.js new file mode 100644 index 000000000..e69fafbfa --- /dev/null +++ b/vulnerablecode/static/js/advisory_detail.js @@ -0,0 +1,73 @@ +// +// Copyright (c) nexB Inc. and others. All rights reserved. +// VulnerableCode is a trademark of nexB Inc. +// SPDX-License-Identifier: Apache-2.0 +// See http://www.apache.org/licenses/LICENSE-2.0 for the license text. +// See https://github.com/aboutcode-org/vulnerablecode for support or download. +// See https://aboutcode.org for more information about nexB OSS projects. +// + +(function () { + let epssChartInstance = null; + + const [btnChart, btnTable, chartContainer, tableContainer] = + ["btn-load-epss-chart", "btn-load-epss-table", "epss-chart-container", "epss-history-table-container"] + .map(id => document.getElementById(id)); + + const getHistoryData = () => JSON.parse(document.getElementById('epss-history-data')?.textContent || "[]"); + const toggleDisplay = (el) => el.style.display = el.style.display === "none" ? "block" : "none"; + + const updateBtn = (btn, container) => { + if (!btn || !container) return; + const isHidden = container.style.display === "none"; + btn.textContent = btn.textContent.replace(isHidden ? "Hide" : "See", isHidden ? "See" : "Hide"); + }; + + function renderChart() { + const history = getHistoryData(); + if (!history.length) return; + + toggleDisplay(chartContainer); + updateBtn(btnChart, chartContainer); + + if (chartContainer.style.display === "none" || epssChartInstance) return; + + try { + epssChartInstance = bb.generate({ + bindto: "#epss-chart", + size: { height: 260 }, padding: { right: 25 }, + data: { + x: "Date", xFormat: "%Y-%m-%d", + columns: [ + ["Date", ...history.map(h => h.published_at || "")], + ["Score", ...history.map(h => h.score === null ? null : parseFloat(h.score))], + ["Percentile", ...history.map(h => h.percentile === null ? null : parseFloat(h.percentile))], + ], + type: "line", colors: { Score: "#df25e6ff", Percentile: "#00d1b2" }, + }, + //Handles missing dates + line: { connectNull: false }, + axis: { + x: { type: "timeseries", tick: { format: "%b %d", count: Math.min(history.length, 6), fit: true } }, + y: { min: 0, max: 1, padding: { top: 10, bottom: 0 }, tick: { format: v => v.toFixed(4) } }, + }, + point: { r: 3 }, legend: { show: true }, + tooltip: { + format: { + title: d => d instanceof Date ? `${d.toLocaleString('en-us', {month: 'short'})} ${String(d.getDate()).padStart(2, '0')}, ${d.getFullYear()}` : String(d), + value: v => v.toFixed(5), + }, + }, + }); + } catch (e) { console.error("[epss-chart]", e); } + } + + btnChart?.addEventListener("click", renderChart); + btnTable?.addEventListener("click", () => { + toggleDisplay(tableContainer); + updateBtn(btnTable, tableContainer); + }); + + updateBtn(btnChart, chartContainer); + updateBtn(btnTable, tableContainer); +})(); diff --git a/vulnerablecode/static/js/billboard.js b/vulnerablecode/static/js/billboard.js new file mode 100644 index 000000000..5b33b498d --- /dev/null +++ b/vulnerablecode/static/js/billboard.js @@ -0,0 +1,23774 @@ +/*! + * Copyright (c) 2017 ~ present NAVER Corp. + * billboard.js project is licensed under the MIT license + * + * billboard.js, JavaScript chart library + * https://naver.github.io/billboard.js/ + * + * @version 3.18.0 + */ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("d3-axis"), require("d3-brush"), require("d3-drag"), require("d3-dsv"), require("d3-ease"), require("d3-hierarchy"), require("d3-interpolate"), require("d3-scale"), require("d3-selection"), require("d3-shape"), require("d3-time-format"), require("d3-transition"), require("d3-zoom")); + else if(typeof define === 'function' && define.amd) + define(["d3-axis", "d3-brush", "d3-drag", "d3-dsv", "d3-ease", "d3-hierarchy", "d3-interpolate", "d3-scale", "d3-selection", "d3-shape", "d3-time-format", "d3-transition", "d3-zoom"], factory); + else { + var a = typeof exports === 'object' ? factory(require("d3-axis"), require("d3-brush"), require("d3-drag"), require("d3-dsv"), require("d3-ease"), require("d3-hierarchy"), require("d3-interpolate"), require("d3-scale"), require("d3-selection"), require("d3-shape"), require("d3-time-format"), require("d3-transition"), require("d3-zoom")) : factory(root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"], root["d3"]); + for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i]; + } +})(this, function(__WEBPACK_EXTERNAL_MODULE__11__, __WEBPACK_EXTERNAL_MODULE__4__, __WEBPACK_EXTERNAL_MODULE__6__, __WEBPACK_EXTERNAL_MODULE__5__, __WEBPACK_EXTERNAL_MODULE__12__, __WEBPACK_EXTERNAL_MODULE__14__, __WEBPACK_EXTERNAL_MODULE__13__, __WEBPACK_EXTERNAL_MODULE__7__, __WEBPACK_EXTERNAL_MODULE__2__, __WEBPACK_EXTERNAL_MODULE__9__, __WEBPACK_EXTERNAL_MODULE__3__, __WEBPACK_EXTERNAL_MODULE__8__, __WEBPACK_EXTERNAL_MODULE__10__) { +return /******/ (function() { // webpackBootstrap +/******/ "use strict"; +/******/ var __webpack_modules__ = ([ +/* 0 */, +/* 1 */, +/* 2 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__2__; + +/***/ }), +/* 3 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__3__; + +/***/ }), +/* 4 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__4__; + +/***/ }), +/* 5 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__5__; + +/***/ }), +/* 6 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__6__; + +/***/ }), +/* 7 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__7__; + +/***/ }), +/* 8 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__8__; + +/***/ }), +/* 9 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__9__; + +/***/ }), +/* 10 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__10__; + +/***/ }), +/* 11 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__11__; + +/***/ }), +/* 12 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__12__; + +/***/ }), +/* 13 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__13__; + +/***/ }), +/* 14 */ +/***/ (function(module) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__14__; + +/***/ }) +/******/ ]); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/define property getters */ +/******/ !function() { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = function(exports, definition) { +/******/ for(var key in definition) { +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ !function() { +/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } +/******/ }(); +/******/ +/******/ /* webpack/runtime/make namespace object */ +/******/ !function() { +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ }(); +/******/ +/************************************************************************/ +var __webpack_exports__ = {}; +// This entry needs to be wrapped in an IIFE because it needs to be isolated against other entry modules. +!function() { +// extracted by mini-css-extract-plugin + +}(); +// This entry needs to be wrapped in an IIFE because it needs to be isolated against other entry modules. +!function() { +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + bb: function() { return /* reexport */ bb; }, + "default": function() { return /* reexport */ bb; } +}); + +// NAMESPACE OBJECT: ./src/config/resolver/interaction.ts +var resolver_interaction_namespaceObject = {}; +__webpack_require__.r(resolver_interaction_namespaceObject); +__webpack_require__.d(resolver_interaction_namespaceObject, { + selection: function() { return selectionModule; }, + subchart: function() { return subchartModule; }, + zoom: function() { return zoomModule; } +}); + +// NAMESPACE OBJECT: ./src/config/resolver/shape.ts +var resolver_shape_namespaceObject = {}; +__webpack_require__.r(resolver_shape_namespaceObject); +__webpack_require__.d(resolver_shape_namespaceObject, { + area: function() { return resolver_shape_area; }, + areaLineRange: function() { return areaLineRange; }, + areaSpline: function() { return areaSpline; }, + areaSplineRange: function() { return areaSplineRange; }, + areaStep: function() { return areaStep; }, + areaStepRange: function() { return areaStepRange; }, + bar: function() { return resolver_shape_bar; }, + bubble: function() { return resolver_shape_bubble; }, + candlestick: function() { return resolver_shape_candlestick; }, + donut: function() { return shape_donut; }, + funnel: function() { return resolver_shape_funnel; }, + gauge: function() { return resolver_shape_gauge; }, + line: function() { return resolver_shape_line; }, + pie: function() { return shape_pie; }, + polar: function() { return resolver_shape_polar; }, + radar: function() { return resolver_shape_radar; }, + scatter: function() { return shape_scatter; }, + spline: function() { return shape_spline; }, + step: function() { return step; }, + treemap: function() { return resolver_shape_treemap; } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-selection","commonjs2":"d3-selection","amd":"d3-selection","root":"d3"} +var external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_ = __webpack_require__(2); +// EXTERNAL MODULE: external {"commonjs":"d3-time-format","commonjs2":"d3-time-format","amd":"d3-time-format","root":"d3"} +var external_commonjs_d3_time_format_commonjs2_d3_time_format_amd_d3_time_format_root_d3_ = __webpack_require__(3); +;// ./src/config/classes.ts +var __defProp = Object.defineProperty; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +const $COMMON = { + button: "bb-button", + chart: "bb-chart", + empty: "bb-empty", + main: "bb-main", + target: "bb-target", + EXPANDED: "_expanded_", + dummy: "_dummy_" +}; +const $ARC = { + arc: "bb-arc", + arcLabelLine: "bb-arc-label-line", + arcLabelLineText: "bb-arc-label-line-text", + arcRange: "bb-arc-range", + arcs: "bb-arcs", + chartArc: "bb-chart-arc", + chartArcs: "bb-chart-arcs", + chartArcsBackground: "bb-chart-arcs-background", + chartArcsTitle: "bb-chart-arcs-title", + needle: "bb-needle" +}; +const $AREA = { + area: "bb-area", + areas: "bb-areas" +}; +const $AXIS = { + axis: "bb-axis", + axisX: "bb-axis-x", + axisXLabel: "bb-axis-x-label", + axisY: "bb-axis-y", + axisY2: "bb-axis-y2", + axisY2Label: "bb-axis-y2-label", + axisYLabel: "bb-axis-y-label", + axisXTooltip: "bb-axis-x-tooltip", + axisYTooltip: "bb-axis-y-tooltip", + axisY2Tooltip: "bb-axis-y2-tooltip", + axisTooltipX: "bb-axis-tooltip-x", + axisTooltipY: "bb-axis-tooltip-y" +}; +const $BAR = { + bar: "bb-bar", + bars: "bb-bars", + chartBar: "bb-chart-bar", + chartBars: "bb-chart-bars", + barConnectLine: "bb-bar-connectLine" +}; +const $CANDLESTICK = { + candlestick: "bb-candlestick", + candlesticks: "bb-candlesticks", + chartCandlestick: "bb-chart-candlestick", + chartCandlesticks: "bb-chart-candlesticks", + valueDown: "bb-value-down", + valueUp: "bb-value-up" +}; +const $CIRCLE = { + chartCircles: "bb-chart-circles", + circle: "bb-circle", + circles: "bb-circles" +}; +const $COLOR = { + colorPattern: "bb-color-pattern", + colorScale: "bb-colorscale" +}; +const $DRAG = { + dragarea: "bb-dragarea", + INCLUDED: "_included_" +}; +const $FUNNEL = { + funnel: "bb-funnel", + chartFunnel: "bb-chart-funnel", + chartFunnels: "bb-chart-funnels", + funnelBackground: "bb-funnel-background" +}; +const $GAUGE = { + chartArcsGaugeMax: "bb-chart-arcs-gauge-max", + chartArcsGaugeMin: "bb-chart-arcs-gauge-min", + chartArcsGaugeUnit: "bb-chart-arcs-gauge-unit", + chartArcsGaugeTitle: "bb-chart-arcs-gauge-title", + gaugeValue: "bb-gauge-value" +}; +const $LEGEND = { + legend: "bb-legend", + legendBackground: "bb-legend-background", + legendItem: "bb-legend-item", + legendItemEvent: "bb-legend-item-event", + legendItemHidden: "bb-legend-item-hidden", + legendItemPoint: "bb-legend-item-point", + legendItemTile: "bb-legend-item-tile" +}; +const $LINE = { + chartLine: "bb-chart-line", + chartLines: "bb-chart-lines", + line: "bb-line", + lines: "bb-lines" +}; +const $EVENT = { + eventRect: "bb-event-rect", + eventRects: "bb-event-rects", + eventRectsMultiple: "bb-event-rects-multiple", + eventRectsSingle: "bb-event-rects-single" +}; +const $FOCUS = { + focused: "bb-focused", + defocused: "bb-defocused", + legendItemFocused: "bb-legend-item-focused", + xgridFocus: "bb-xgrid-focus", + ygridFocus: "bb-ygrid-focus" +}; +const $GRID = { + grid: "bb-grid", + gridLines: "bb-grid-lines", + xgrid: "bb-xgrid", + xgridLine: "bb-xgrid-line", + xgridLines: "bb-xgrid-lines", + xgrids: "bb-xgrids", + ygrid: "bb-ygrid", + ygridLine: "bb-ygrid-line", + ygridLines: "bb-ygrid-lines", + ygrids: "bb-ygrids" +}; +const $LEVEL = { + level: "bb-level", + levels: "bb-levels" +}; +const $RADAR = { + chartRadar: "bb-chart-radar", + chartRadars: "bb-chart-radars" +}; +const $REGION = { + region: "bb-region", + regions: "bb-regions" +}; +const $SELECT = { + selectedCircle: "bb-selected-circle", + selectedCircles: "bb-selected-circles", + SELECTED: "_selected_" +}; +const $SHAPE = { + shape: "bb-shape", + shapes: "bb-shapes" +}; +const $SUBCHART = { + brush: "bb-brush", + subchart: "bb-subchart" +}; +const $TEXT = { + chartText: "bb-chart-text", + chartTexts: "bb-chart-texts", + text: "bb-text", + texts: "bb-texts", + title: "bb-title", + textBorderRect: "bb-text-border", + textLabelImage: "bb-text-label-image", + TextOverlapping: "text-overlapping" +}; +const $TOOLTIP = { + tooltip: "bb-tooltip", + tooltipContainer: "bb-tooltip-container", + tooltipName: "bb-tooltip-name" +}; +const $TREEMAP = { + treemap: "bb-treemap", + chartTreemap: "bb-chart-treemap", + chartTreemaps: "bb-chart-treemaps" +}; +const $ZOOM = { + buttonZoomReset: "bb-zoom-reset", + zoomBrush: "bb-zoom-brush" +}; +/* harmony default export */ var classes = (__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, $COMMON), $ARC), $AREA), $AXIS), $BAR), $CANDLESTICK), $CIRCLE), $COLOR), $DRAG), $GAUGE), $LEGEND), $LINE), $EVENT), $FOCUS), $FUNNEL), $GRID), $RADAR), $REGION), $SELECT), $SHAPE), $SUBCHART), $TEXT), $TOOLTIP), $TREEMAP), $ZOOM)); + +;// ./src/config/Options/common/boost.ts +/* harmony default export */ var boost = ({ + /** + * Set boost options + * @name boost + * @memberof Options + * @type {object} + * @property {object} boost boost object + * @property {boolean} [boost.useCssRule=false] Avoid setting inline styles for each shape elements. + * - **NOTE:** + * - Will append <style> to the head tag and will add shpes' CSS rules dynamically. + * - For now, covers colors related properties (fill, stroke, etc.) only. + * @property {boolean} [boost.useWorker=false] Use Web Worker as possible for processing. + * - **NOTE:** + * - For now, only applies for data conversion at the initial time. + * - As of Web Worker's async nature, handling chart instance synchrously is not recommended. + * - When given data is empty, useWorker will be ignored. + * @example + * boost: { + * useCssRule: true, + * useWorker: false + * } + */ + boost_useCssRule: false, + boost_useWorker: false +}); + +;// ./src/config/Options/common/color.ts +/* harmony default export */ var color = ({ + /** + * Set color of the data values + * @name color + * @memberof Options + * @type {object} + * @property {object} color color object + * @property {string|object|((this: Chart, d: DataItem) => string)} [color.onover] Set the color value for each data point when mouse/touch onover event occurs. + * @property {Array|null} [color.pattern=[]] Set custom color pattern. Passing `null` will not set a color for these elements, which requires the usage of custom CSS-based theming to work. + * @property {(this: Chart) => SVGPathElement[]} [color.tiles] if defined, allows use svg's patterns to fill data area. It should return an array of [SVGPatternElement](https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement). + * - **NOTE:** The pattern element's id will be defined as `bb-colorize-pattern-$COLOR-VALUE`.
+ * ex. When color pattern value is `['red', '#fff']` and defined 2 patterns,then ids for pattern elements are:
+ * - `bb-colorize-pattern-red` + * - `bb-colorize-pattern-fff` + * @property {object} [color.threshold] color threshold for gauge and tooltip color + * @property {string} [color.threshold.unit] If set to `value`, the threshold will be based on the data value. Otherwise it'll be based on equation of the `threshold.max` option value. + * @property {Array} [color.threshold.values] Threshold values for each steps + * @property {number} [color.threshold.max=100] The base value to determine threshold step value condition. When the given value is 15 and max 10, then the value for threshold is `15*100/10`. + * @example + * color: { + * pattern: ["#1f77b4", "#aec7e8", ...], + * + * // Set colors' patterns + * // it should return an array of SVGPatternElement + * tiles: function() { + * var pattern = document.createElementNS("http://www.w3.org/2000/svg", "pattern"); + * var g = document.createElementNS("http://www.w3.org/2000/svg", "g"); + * var circle1 = document.createElementNS("http://www.w3.org/2000/svg", "circle"); + * + * pattern.setAttribute("patternUnits", "userSpaceOnUse"); + * pattern.setAttribute("width", "32"); + * pattern.setAttribute("height", "32"); + * + * g.style.fill = "#000"; + * g.style.opacity = "0.2"; + * + * circle1.setAttribute("cx", "3"); + * circle1.setAttribute("cy", "3"); + * circle1.setAttribute("r", "3"); + * + * g.appendChild(circle1); + * pattern.appendChild(g); + * + * return [pattern]; + * }, + * + * // for threshold usage, pattern values should be set for each steps + * pattern: ["grey", "green", "yellow", "orange", "red"], + * threshold: { + * unit: "value", + * + * // when value is 20 => 'green', value is 40 => 'orange' will be set. + * values: [10, 20, 30, 40, 50], + * + * // the equation for max: + * // - unit == 'value': max => 30 + * // - unit != 'value': max => value*100/30 + * max: 30 + * }, + * + * // set all data to 'red' + * onover: "red", + * + * // set different color for data + * onover: { + * data1: "red", + * data2: "yellow" + * }, + * + * // will pass data object to the callback + * onover: function(d) { + * return d.id === "data1" ? "red" : "green"; + * } + * } + */ + color_pattern: [], + color_tiles: void 0, + color_threshold: {}, + color_onover: void 0 +}); + +;// ./src/config/Options/common/legend.ts +/* harmony default export */ var legend = ({ + /** + * Legend options + * @name legend + * @memberof Options + * @type {object} + * @property {object} legend Legend object + * @property {boolean} [legend.show=true] Show or hide legend. + * @property {boolean} [legend.hide=false] Hide legend + * If true given, all legend will be hidden. If string or array given, only the legend that has the id will be hidden. + * @property {string|HTMLElement} [legend.contents.bindto=undefined] Set CSS selector or element reference to bind legend items. + * - **NOTE:** Should be used along with `legend.contents.template`. + * @property {string|function} [legend.contents.template="{=TITLE}"] Set item's template.
+ * - **NOTE:** Only common HTML tags are allowed to prevent XSS attacks. If creating charts from user input, it is recommended to sanitize input values to avoid potential vulnerabilities. + * - If set `string` value, within template the 'color' and 'title' can be replaced using template-like syntax string: + * - {=COLOR}: data color value + * - {=TITLE}: data title value + * - If set `function` value, will pass following arguments to the given function: + * - title {string}: data's id value + * - color {string}: color string + * - data {Array}: data array + * - **NOTE:** While basic XSS sanitization is applied, if you're allowing user-provided chart options in a service exposed to other users, you should implement additional security measures to prevent sophisticated XSS attacks. + * @property {string} [legend.position=bottom] Change the position of legend.
+ * Available values are: `bottom`, `right` and `inset` are supported. + * @property {object} [legend.inset={anchor: 'top-left',x: 10,y: 0,step: undefined}] Change inset legend attributes.
+ * This option accepts object that has the keys `anchor`, `x`, `y` and `step`. + * - **anchor** decides the position of the legend: + * - top-left + * - top-right + * - bottom-left + * - bottom-right + * - **x** and **y**: + * - set the position of the legend based on the anchor. + * - **step**: + * - defines the max step the legend has (e.g. If 2 set and legend has 3 legend item, the legend 2 columns). + * @property {boolean} [legend.equally=false] Set to all items have same width size. + * @property {number} [legend.padding=0] Set padding value + * @property {boolean} [legend.item.interaction=true] Set legend item interaction. + * - **NOTE:** + * - This setting will not have effect on `.toggle()` method. + * - `legend.item.onXXX` listener options will work if set, regardless of this option value. + * @property {boolean} [legend.item.interaction.dblclick=false] Set legend item to interact on double click. + * - **NOTE:** + * - Double clicking will make focused clicked dataseries only, hiding all others. + * - for single click case, `click + altKey(Win)/optionKey(Mac OS)` to have same effect. + * - To return initial state(which all dataseries are showing), double click current focused legend item again. + * - for single click case, `click + altKey(Win)/optionKey(Mac OS)` to have same effect. + * - In this case, default `click` interaction will be disabled. + * @property {function} [legend.item.onclick=undefined] Set click event handler to the legend item. + * - **NOTE:** + * - When set, default `click` interaction will be disabled. + * - When `interaction.dblclick=true` is set, will be called on double click. + * @property {function} [legend.item.onover=undefined] Set mouse/touch over event handler to the legend item. + * - **NOTE:** When set, default `mouseover` interaction will be disabled. + * @property {function} [legend.item.onout=undefined] Set mouse/touch out event handler to the legend item. + * - **NOTE:** When set, default `mouseout` interaction will be disabled. + * @property {number} [legend.item.tile.width=10] Set width for 'rectangle' legend item tile element. + * @property {number} [legend.item.tile.height=10] Set height for 'rectangle' legend item tile element. + * @property {number} [legend.item.tile.r=5] Set the radius for 'circle' legend item tile type. + * @property {string} [legend.item.tile.type="rectangle"] Set legend item shape type.
+ * - **Available Values:** + * - circle + * - rectangle + * @property {boolean} [legend.format] Set formatter function for legend text. + * The argument:
+ * - `id`: Legend text value. When `data.names` is specified, will pass from it, otherwise will pass data id. + * - `dataId`: When `data.names` specified, will pass the original data id. Otherwise will be undefined. + * @property {boolean} [legend.tooltip=false] Show full legend text value using system tooltip(via `` element). + * @property {boolean} [legend.usePoint=false] Whether to use custom points in legend. + * @see [Demo: format](https://naver.github.io/billboard.js/demo/#Legend.LegendFormat) + * @see [Demo: item.interaction](https://naver.github.io/billboard.js/demo/#Legend.LegendItemInteraction) + * @see [Demo: item.tile.type](https://naver.github.io/billboard.js/demo/#Legend.LegendItemTileType) + * @see [Demo: position](https://naver.github.io/billboard.js/demo/#Legend.LegendPosition) + * @see [Demo: contents.template](https://naver.github.io/billboard.js/demo/#Legend.LegendTemplate1) + * @see [Demo: usePoint](https://naver.github.io/billboard.js/demo/#Legend.usePoint) + * @example + * legend: { + * show: true, + * hide: true, + * //or hide: "data1" + * //or hide: ["data1", "data2"] + * contents: { + * bindto: "#legend", // <ul id='legend'></ul> + * + * // will be as: <li style='background-color:#1f77b4'>data1</li> + * template: "<li style='background-color:{=COLOR}'>{=TITLE}</li>" + * + * // or using function + * template: function(id, color, data) { + * // if you want omit some legend, return falsy value + * if (id !== "data1") { + * return "<li style='background-color:"+ color +">"+ id +"</li>"; + * } + * } + * }, + * position: "bottom", // bottom, right, inset + * inset: { + * anchor: "top-right" // top-left, top-right, bottom-left, bottom-right + * x: 20, + * y: 10, + * step: 2 + * }, + * equally: false, + * padding: 10, + * item: { + * // will disable default interaction + * interaction: false, + * + * // set legend interact on double click + * // by double clicking, will make focused clicked dataseries only, hiding all others. + * interaction: { + * dblclick: true + * } + * + * // when set below callback, will disable corresponding default interactions + * onclick: function(id, visible) { + * // toggle based on the data visibility + * this[visible ? "hide" : "show"](id); + * }, + * onover: function(id, visible) { ... }, + * onout: function(id, visible) { ... }, + * + * // set tile's size + * tile: { + * // set tile type + * type: "circle" // or "rectangle" (default) + * + * // width & height, are only applicable for 'rectangle' legend type + * width: 15, + * height: 15 + * + * // radius is only applicable for 'circle' legend type + * r: 10 + * } + * }, + * format: function(id, dataId) { + * // set ellipsis string when length is > 5 + * // to get full legend value, combine with 'legend.tooltip=true' + * if (id.length > 5) { + * id = id.substr(0, 5) + "..."; + * } + * + * return id; + * }, + * tooltip: true, + * usePoint: true + * } + */ + legend_contents_bindto: void 0, + legend_contents_template: "<span style='color:#fff;padding:5px;background-color:{=COLOR}'>{=TITLE}</span>", + legend_equally: false, + legend_hide: false, + legend_inset_anchor: "top-left", + legend_inset_x: 10, + legend_inset_y: 0, + legend_inset_step: void 0, + legend_item_interaction: true, + legend_item_dblclick: false, + legend_item_onclick: void 0, + legend_item_onover: void 0, + legend_item_onout: void 0, + legend_item_tile_width: 10, + legend_item_tile_height: 10, + legend_item_tile_r: 5, + legend_item_tile_type: "rectangle", + legend_format: void 0, + legend_padding: 0, + legend_position: "bottom", + legend_show: true, + legend_tooltip: false, + legend_usePoint: false +}); + +;// ./src/config/Options/common/main.ts +/* harmony default export */ var main = ({ + /** + * Specify the CSS selector or the element which the chart will be set to. D3 selection object can be specified also.<br> + * If another chart is already set, it will be replaced with the new one (only one chart can be set in one element). + * - **NOTE:** In case the element doesn't exist or not specified, will add a `<div>` element to the body. + * @name bindto + * @memberof Options + * @property {string|HTMLElement|d3.selection|object} [bindto="#chart"] Specify the element where chart will be drawn. + * @property {string|HTMLElement|d3.selection} bindto.element="#chart" Specify the element where chart will be drawn. + * @property {string} [bindto.classname=bb] Specify the class name of bind element.<br> + * **NOTE:** When the class name isn't `bb`, then you also need to update the default CSS to be rendered correctly. + * @default #chart + * @example + * bindto: "#myContainer" + * + * // or HTMLElement + * bindto: document.getElementById("myContainer") + * + * // or D3 selection object + * bindto: d3.select("#myContainer") + * + * // or to change default classname + * bindto: { + * element: "#chart", + * classname: "bill-board" // ex) <div id='chart' class='bill-board'> + * } + */ + bindto: "#chart", + /** + * Set chart background. + * @name background + * @memberof Options + * @property {object} background background object + * @property {string} background.class Specify the class name for background element. + * @property {string} background.color Specify the fill color for background element.<br>**NOTE:** Will be ignored if `imgUrl` option is set. + * @property {string} background.imgUrl Specify the image url string for background. + * @see [Demo](https://naver.github.io/billboard.js/demo/#ChartOptions.Background) + * @example + * background: { + * class: "myClass", + * color: "red", + * + * // Set image url for background. + * // If specified, 'color' option will be ignored. + * imgUrl: "https://naver.github.io/billboard.js/img/logo/billboard.js.svg", + * } + */ + background: {}, + /** + * Set 'clip-path' attribute for chart element + * - **NOTE:** + * > When false, chart node element is positioned after the axis node in DOM tree hierarchy. + * > This is to make the chart element positioned over axis element. + * @name clipPath + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#ChartOptions.clipPath) + * @example + * // don't set 'clip-path' attribute + * clipPath: false + */ + clipPath: true, + /** + * Set svg element's class name + * @name svg + * @memberof Options + * @type {object} + * @property {object} [svg] svg object + * @property {string} [svg.classname] class name for svg element + * @example + * svg: { + * classname: "test_class" + * } + */ + svg_classname: void 0, + /** + * The desired size of the chart element. + * If the value is not specified, the width of the chart will be calculated by the size of the parent element it's appended to. + * @name size + * @memberof Options + * @type {object} + * @property {object} [size] size object + * @property {number} [size.width] width of the chart element + * @property {number} [size.height] height of the chart element + * @see [Demo](https://naver.github.io/billboard.js/demo/#ChartOptions.ChartSize) + * @example + * size: { + * width: 640, + * height: 480 + * } + */ + size_width: void 0, + size_height: void 0, + /** + * The padding of the chart element. + * - **NOTE:** for more information, see the "[`Understanding padding`](https://github.com/naver/billboard.js/wiki/Understanding-padding)" wiki documentation. + * @name padding + * @memberof Options + * @type {object} + * @property {object|boolean} [padding=true] Set padding of chart, and accepts object or boolean type. + * - `Object`: Specify each side's padding. + * - `false`: Remove padding completely and make the shape fully occupy the container element. + * - In this case, axes and subchart will be hidden. + * - To adjust some padding from this state, use `axis.[x|y].padding` option. + * @property {string} [padding.mode] padding mode + * - `"fit"`: Reduce padding as much as possible to make chart fit to the container element for chart types w/axis.<br>When specified, all padding values will be relative from fitted value. + * @property {number} [padding.top] padding on the top of chart + * @property {number} [padding.right] padding on the right of chart + * @property {number} [padding.bottom] padding on the bottom of chart + * @property {number} [padding.left] padding on the left of chart + * @see [Demo](https://naver.github.io/billboard.js/demo/#ChartOptions.Padding) + * @see [Demo: Fit padding](https://naver.github.io/billboard.js/demo/#ChartOptions.FitPadding) + * @example + * // remove padding completely. + * padding: false, + * + * padding: { + * // specifying mode value, will reduce padding and make fit to the container element. + * mode: "fit" + * + * // when mode is "fit", all padding values will be relative from fitted value. + * // so, 0 will be initial fitted value. + * top: 20, + * right: 20, + * bottom: 20, + * left: 20 + * } + * + * // or specify padding value for each side + * padding: { + * top: 20, + * right: 20, + * bottom: 20, + * left: 20 + * } + */ + padding: true, + padding_mode: void 0, + padding_left: void 0, + padding_right: void 0, + padding_top: void 0, + padding_bottom: void 0, + /** + * Set chart resize options + * @name resize + * @memberof Options + * @type {object} + * @property {object} [resize] resize object + * @property {boolean|string} [resize.auto=true] Set chart resize automatically on viewport changes. + * - **NOTE:** Available options + * - true: Enables automatic resize. + * - false: Disables automatic resize. + * - "parent": Enables automatic resize when the parent node is resized. + * - "viewBox": Enables automatic resize, and size will be fixed based on the viewbox. + * @property {boolean|number} [resize.timer=true] Set resize timer option. + * - **NOTE:** Available options + * - The resize function will be called using: + * - true: `setTimeout()` + * - false: `requestIdleCallback()` + * - Given number(delay in ms) value, resize function will be triggered using `setTimeout()` with given delay. + * @see [Demo: resize "parent"](https://naver.github.io/billboard.js/demo/#ChartOptions.resizeParent) + * @see [Demo: resize "viewBox"](https://naver.github.io/billboard.js/demo/#ChartOptions.resizeViewBox) + * @example + * resize: { + * auto: false, + * + * // set resize based on parent node width value + * auto: "parent", + * + * // set resize based on viewBox value + * auto: "viewBox", + * + * // set resize function will be triggered using `setTimeout()` + * timer: true, + * + * // set resize function will be triggered using `requestIdleCallback()` + * timer: false, + * + * // set resize function will be triggered using `setTimeout()` with a delay of `100ms`. + * timer: 100 + * } + */ + resize_auto: true, + resize_timer: true, + /** + * Set a callback to execute when the chart is clicked. + * @name onclick + * @memberof Options + * @type {function} + * @default undefined + * @example + * onclick: function(event) { + * this; // chart instance itself + * event; // native event object + * ... + * } + */ + onclick: void 0, + /** + * Set a callback to execute when mouse/touch enters the chart. + * @name onover + * @memberof Options + * @type {function} + * @default undefined + * @example + * onover: function(event) { + * this; // chart instance itself + * event; // native event object + * ... + * } + */ + onover: void 0, + /** + * Set a callback to execute when mouse/touch leaves the chart. + * @name onout + * @memberof Options + * @type {function} + * @default undefined + * @example + * onout: function(event) { + * this; // chart instance itself + * event; // native event object + * ... + * } + */ + onout: void 0, + /** + * Set a callback to execute when user resizes the screen. + * @name onresize + * @memberof Options + * @type {function} + * @default undefined + * @example + * onresize: function() { + * this; // chart instance itself + * ... + * } + */ + onresize: void 0, + /** + * Set a callback to execute when screen resize finished. + * @name onresized + * @memberof Options + * @type {function} + * @default undefined + * @example + * onresized: function() { + * this; // chart instance itself + * ... + * } + */ + onresized: void 0, + /** + * Set a callback to execute before the chart is initialized + * @name onbeforeinit + * @memberof Options + * @type {function} + * @default undefined + * @example + * onbeforeinit: function() { + * this; // chart instance itself + * ... + * } + */ + onbeforeinit: void 0, + /** + * Set a callback to execute when the chart is initialized. + * @name oninit + * @memberof Options + * @type {function} + * @default undefined + * @example + * oninit: function() { + * this; // chart instance itself + * ... + * } + */ + oninit: void 0, + /** + * Set a callback to execute after the chart is initialized + * @name onafterinit + * @memberof Options + * @type {function} + * @default undefined + * @example + * onafterinit: function() { + * this; // chart instance itself + * ... + * } + */ + onafterinit: void 0, + /** + * Set a callback which is executed when the chart is rendered. Basically, this callback will be called in each time when the chart is redrawn. + * @name onrendered + * @memberof Options + * @type {function} + * @default undefined + * @example + * onrendered: function() { + * this; // chart instance itself + * ... + * } + */ + onrendered: void 0, + /** + * Set duration of transition (in milliseconds) for chart animation.<br><br> + * - **NOTE:** If `0` or `null` is set, transition will be skipped. So, this makes initial rendering faster especially in case you have a lot of data. + * @name transition + * @memberof Options + * @type {object} + * @property {object} [transition] transition object + * @property {number} [transition.duration=350] duration in milliseconds + * @example + * transition: { + * duration: 500 + * } + */ + transition_duration: 250, + /** + * Set plugins + * @name plugins + * @memberof Options + * @type {Array} + * @example + * plugins: [ + * new bb.plugin.stanford({ ... }), + * new PluginA(), + * ... + * ] + */ + plugins: [], + /** + * Control the render timing + * @name render + * @memberof Options + * @type {object} + * @property {object} [render] render object + * @property {boolean} [render.lazy=true] Make it not render at initialization. + * - **NOTE**: + * - Enabled by default when bind element's visibility is hidden. + * - When set to `false`, will initialize the chart regardless the bind element's visibility state, but in this case chart can't be guaranteed to be rendered properly. + * @property {boolean} [render.observe=true] Observe bind element's visibility(`display` or `visibility` inline css property or class value) & render when it is visible automatically (for IEs, only works IE11+). When set to **false**, call [`.flush()`](./Chart.html#flush) to render. + * @see [Demo](https://naver.github.io/billboard.js/demo/#ChartOptions.LazyRender) + * @example + * render: { + * lazy: true, + * observe: true + * } + * + * @example + * // <!-- render.lazy will detect visibility defined --> + * // (a) <div id='chart' class='hide'></div> + * // (b) <div id='chart' style='display:none'></div> + * + * // render.lazy enabled by default when element is hidden + * var chart = bb.generate({ ... }); + * + * // chart will be rendered automatically when element's visibility changes + * // Note: works only for inlined css property or class attribute changes + * document.getElementById('chart').classList.remove('hide') // (a) + * document.getElementById('chart').style.display = 'block'; // (b) + * + * @example + * // chart won't be rendered and not observing bind element's visibility changes + * var chart = bb.generate({ + * render: { + * lazy: true, + * observe: false + * } + * }); + * + * // call at any point when you want to render + * chart.flush(); + */ + render: {}, + /** + * Show rectangles inside the chart.<br><br> + * - **NOTE:**<br> + * - axis must be x, y or y2. start and end should be the value where regions start and end. + * - If not specified, the edge values will be used. + * - If timeseries x axis, date string, Date object and unixtime integer can be used. + * - If category x axis, category name can be used for start and end. + * - If class is set, the region element will have it as class. + * + * This option accept array of object with below values: + * - `axis {string}`: 'x', 'y', or 'y2' + * - `[start] {number|Date|string}`: Start position of the region. If not set, the start will be the edge of the chart. + * - `[end] {number|Date|string}`: End position of the region. If not set, the end will be the edge of the chart. + * - `[class] {string}`: Class value to apply to the region. + * - `[label] {object}` Label text option. + * - `text {string}`: Text value. + * - `x {number}`: x Position. + * - `y {number}`: y Position. + * - `center {string}`: Align label at the center. Allowed values are 'x', 'y', 'xy'. + * - `color {string}`: Color string. + * - `rotated (boolean)`: Whether rotate label or not. + * @name regions + * @memberof Options + * @type {Array} + * @default [] + * @see [Demo: Regions](https://naver.github.io/billboard.js/demo/#Region.Region) + * @see [Demo: Regions Timeseries](https://naver.github.io/billboard.js/demo/#Region.RegionWithTimeseries) + * @see [Demo: Regions Label](https://naver.github.io/billboard.js/demo/#Region.RegionLabel) + * @example + * regions: [ + * { + * axis: "x", + * start: 1, + * end: 4, + * class: "region-1-4", + * label: { + * text: "Region Text", + * x: 5, // position relative of the initial x coordinate + * y: 5, // position relative of the initial y coordinate + * center: "xy", // center text label in both direction. + * color: "red", // color string + * rotated: true // make text to show in vertical or horizontal + * } + * } + * ] + */ + regions: [] +}); + +;// ./src/config/Options/common/title.ts +/* harmony default export */ var title = ({ + /** + * Set title options + * @name title + * @memberof Options + * @type {object} + * @property {object} title Title object + * @property {string} [title.text] Title text. If contains `\n`, it's used as line break allowing multiline title. + * @property {number} [title.padding.top=0] Top padding value. + * @property {number} [title.padding.right=0] Right padding value. + * @property {number} [title.padding.bottom=0] Bottom padding value. + * @property {number} [title.padding.left=0] Left padding value. + * @property {string} [title.position=center] Available values are: 'center', 'right' and 'left'. + * @see [Demo](https://naver.github.io/billboard.js/demo/#Title.MultilinedTitle) + * @example + * title: { + * text: "Title Text", + * + * // or Multiline title text + * text: "Main title text\nSub title text", + * + * padding: { + * top: 10, + * right: 10, + * bottom: 10, + * left: 10 + * }, + * position: "center" + * } + */ + title_text: void 0, + title_padding: { + top: 0, + right: 0, + bottom: 0, + left: 0 + }, + title_position: "center" +}); + +;// ./src/config/Options/common/tooltip.ts +/* harmony default export */ var tooltip = ({ + /** + * Tooltip options + * @name tooltip + * @memberof Options + * @type {object} + * @property {object} tooltip Tooltip object + * @property {boolean} [tooltip.show=true] Show or hide tooltip. + * @property {boolean} [tooltip.doNotHide=false] Make tooltip keep showing not hiding on interaction. + * @property {boolean} [tooltip.grouped=true] Set if tooltip is grouped or not for the data points. + * - **NOTE:** The overlapped data points will be displayed as grouped even if set false. + * @property {boolean} [tooltip.linked=false] Set if tooltips on all visible charts with like x points are shown together when one is shown. + * @property {string} [tooltip.linked.name=""] Groping name for linked tooltip.<br>If specified, linked tooltip will be groped interacting to be worked only with the same name. + * @property {function} [tooltip.format.title] Set format for the title of tooltip.<br> + * Specified function receives x of the data point to show. + * @property {function} [tooltip.format.name] Set format for the name of each data in tooltip.<br> + * Specified function receives name, ratio, id and index of the data point to show. ratio will be undefined if the chart is not donut/pie/gauge. + * @property {function} [tooltip.format.value] Set format for the value of each data value in tooltip. If undefined returned, the row of that value will be skipped to be called. + * - Will pass following arguments to the given function: + * - `value {string}`: Value of the data point. If data row contains multiple or ranged(ex. candlestick, area range, etc.) value, formatter will be called as value length. + * - `ratio {number}`: Ratio of the data point in the `pie/donut/gauge` and `area/bar` when contains grouped data. Otherwise is `undefined`. + * - `id {string}`: id of the data point + * - `index {number}`: Index of the data point + * @property {function} [tooltip.position] Set custom position function for the tooltip.<br> + * This option can be used to modify the tooltip position by returning object that has top and left. + * - Will pass following arguments to the given function: + * - `data {Array}`: Current selected data array object. + * - `width {number}`: Width of tooltip. + * - `height {number}`: Height of tooltip. + * - `element {SVGElement}`: Tooltip event bound element + * - `pos {object}`: Current position of the tooltip. + * @property {function|object} [tooltip.contents] Set custom HTML for the tooltip.<br> + * If tooltip.grouped is true, data includes multiple data points.<br><br> + * Specified function receives `data` array and `defaultTitleFormat`, `defaultValueFormat` and `color` functions of the data point to show. + * - **Note:** + * - Only common HTML tags are allowed to prevent XSS attacks. If creating charts from user input, it is recommended to sanitize input values to avoid potential vulnerabilities.<br><br> + * - defaultTitleFormat: + * - if `axis.x.tick.format` option will be used if set. + * - otherwise, will return function based on tick format type(category, timeseries). + * - defaultValueFormat: + * - for Arc type (except gauge, radar), the function will return value from `(ratio * 100).toFixed(1)`. + * - for Axis based types, will be used `axis.[y|y2].tick.format` option value if is set. + * - otherwise, will parse value and return as number. + * @property {string|HTMLElement} [tooltip.contents.bindto=undefined] Set CSS selector or element reference to bind tooltip. + * - **NOTE:** When is specified, will not be updating tooltip's position. + * @property {string} [tooltip.contents.template=undefined] Set tooltip's template. + * - **NOTE:** Only common HTML tags are allowed to prevent XSS attacks. If creating charts from user input, it is recommended to sanitize input values to avoid potential vulnerabilities.<br><br> + * Within template, below syntax will be replaced using template-like syntax string: + * - **{{ ... }}**: the doubly curly brackets indicate loop block for data rows. + * - **{=CLASS_TOOLTIP}**: default tooltip class name `bb-tooltip`. + * - **{=CLASS_TOOLTIP_NAME}**: default tooltip data class name (ex. `bb-tooltip-name-data1`) + * - **{=TITLE}**: title value. + * - **{=COLOR}**: data color. + * - **{=NAME}**: data id value. + * - **{=VALUE}**: data value. + * - **NOTE:** While basic XSS sanitization is applied, if you're allowing user-provided chart options in a service exposed to other users, you should implement additional security measures to prevent sophisticated XSS attacks. + * @property {object} [tooltip.contents.text=undefined] Set additional text content within data loop, using template syntax. + * - **NOTE:** It should contain `{ key: Array, ... }` value + * - 'key' name is used as substitution within template as '{=KEY}' + * - The value array length should match with the data length + * @property {boolean} [tooltip.init.show=false] Show tooltip at the initialization. + * @property {number} [tooltip.init.x=0] Set x Axis index(or index for Arc(donut, gauge, pie) types) to be shown at the initialization. + * @property {object} [tooltip.init.position] Set the position of tooltip at the initialization. + * @property {function} [tooltip.onshow] Set a callback that will be invoked before the tooltip is shown. + * @property {function} [tooltip.onhide] Set a callback that will be invoked before the tooltip is hidden. + * @property {function} [tooltip.onshown] Set a callback that will be invoked after the tooltip is shown + * @property {function} [tooltip.onhidden] Set a callback that will be invoked after the tooltip is hidden. + * @property {string|function|null} [tooltip.order=null] Set tooltip data display order.<br><br> + * **Available Values:** + * - `desc`: In descending data value order + * - `asc`: In ascending data value order + * - `null`: It keeps the data display order<br> + * **NOTE:** When `data.groups` is set, the order will follow as the stacked graph order.<br> + * If want to order as data bound, set any value rather than asc, desc or null. (ex. empty string "") + * - `function(data1, data2) { ... }`: [Array.sort compareFunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters) + * @see [Demo: Hide Tooltip](https://naver.github.io/billboard.js/demo/#Tooltip.HideTooltip) + * @see [Demo: Tooltip Grouping](https://naver.github.io/billboard.js/demo/#Tooltip.TooltipGrouping) + * @see [Demo: Tooltip Format](https://naver.github.io/billboard.js/demo/#Tooltip.TooltipFormat) + * @see [Demo: Linked Tooltip](https://naver.github.io/billboard.js/demo/#Tooltip.LinkedTooltips) + * @see [Demo: Tooltip Position](https://naver.github.io/billboard.js/demo/#Tooltip.TooltipPosition) + * @see [Demo: Tooltip Template](https://naver.github.io/billboard.js/demo/#Tooltip.TooltipTemplate) + * @example + * tooltip: { + * show: true, + * doNotHide: true, + * grouped: false, + * format: { + * title: function(x) { return "Data " + x; }, + * name: function(name, ratio, id, index) { return name; }, + * + * // If data row contains multiple or ranged(ex. candlestick, area range, etc.) value, + * // formatter will be called as value length times. + * value: function(value, ratio, id, index) { return ratio; } + * }, + * position: function(data, width, height, element, pos) { + * // data: [{x, index, id, name, value}, ...] + * // width: Tooltip width + * // height: Tooltip height + * // element: Tooltip event bound element + * // pos: { + * // x: Current mouse event x position, + * // y: Current mouse event y position, + * // xAxis: Current x Axis position (the value is given for axis based chart type only) + * // yAxis: Current y Axis position value or function(the value is given for axis based chart type only) + * // } + * + * // yAxis will work differently per data lengths + * // - a) Single data: `yAxis` will return `number` value + * // - b) Multiple data: `yAxis` will return a function with property value + * + * // a) Single data: + * // Get y coordinate + * pos.yAxis; // y axis coordinate value of current data point + * + * // b) Multiple data: + * // Get y coordinate of value 500, where 'data1' scales(y or y2). + * // When 'data.axes' option is used, data can bound to different axes. + * // - when "data.axes={data1: 'y'}", will return y value from y axis scale. + * // - when "data.axes={data1: 'y2'}", will return y value from y2 axis scale. + * pos.yAxis(500, "data1"); // will return y coordinate value of data1 + * + * pos.yAxis(500); // get y coordinate with value of 500, using y axis scale + * pos.yAxis(500, null, "y2"); // get y coordinate with value of 500, using y2 axis scale + * + * return { + * top: 0, + * left: 0 + * } + * }, + * + * contents: function(d, defaultTitleFormat, defaultValueFormat, color) { + * return ... // formatted html as you want + * }, + * + * // specify tooltip contents using template + * // - example of HTML returned: + * // <ul class="bb-tooltip"> + * // <li class="bb-tooltip-name-data1"><span>250</span><br><span style="color:#00c73c">data1</span></li> + * // <li class="bb-tooltip-name-data2"><span>50</span><br><span style="color:#fa7171">data2</span></li> + * // </ul> + * contents: { + * bindto: "#tooltip", + * template: '<ul class={=CLASS_TOOLTIP}>{{' + + * '<li class="{=CLASS_TOOLTIP_NAME}"><span>{=VALUE}</span><br>' + + * '<span style=color:{=COLOR}>{=NAME}</span></li>' + + * '}}</ul>' + * } + * + * // with additional text value + * // - example of HTML returned: + * // <ul class="bb-tooltip"> + * // <li class="bb-tooltip-name-data1"><span>250</span><br>comment1<span style="color:#00c73c">data1</span>text1</li> + * // <li class="bb-tooltip-name-data2"><span>50</span><br>comment2<span style="color:#fa7171">data2</span>text2</li> + * // </ul> + * contents: { + * bindto: "#tooltip", + * text: { + * // a) 'key' name is used as substitution within template as '{=KEY}' + * // b) the length should match with the data length + * VAR1: ["text1", "text2"], + * VAR2: ["comment1", "comment2"], + * }, + * template: '<ul class={=CLASS_TOOLTIP}>{{' + + * '<li class="{=CLASS_TOOLTIP_NAME}"><span>{=VALUE}</span>{=VAR2}<br>' + + * '<span style=color:{=COLOR}>{=NAME}</span>{=VAR1}</li>' + + * '}}</ul>' + * } + * + * // sort tooltip data value display in ascending order + * order: "asc", + * + * // specifying sort function + * order: function(a, b) { + * // param data passed format + * {x: 5, value: 250, id: "data1", index: 5, name: "data1"} + * ... + * }, + * + * // show at the initialization + * init: { + * show: true, + * x: 2, // x Axis index (or index for Arc(donut, gauge, pie) types) + * position: { + * top: "150px", // specify as number or as string with 'px' unit string + * left: 250 // specify as number or as string with 'px' unit string + * } + * }, + * + * // fires prior tooltip is shown + * onshow: function(selectedData) { + * // current dataset selected + * // ==> [{x: 4, value: 150, id: "data2", index: 4, name: "data2"}, ...] + * selectedData; + * }, + * + * // fires prior tooltip is hidden + * onhide: function(selectedData) { + * // current dataset selected + * // ==> [{x: 4, value: 150, id: "data2", index: 4, name: "data2"}, ...] + * selectedData; + * }, + * + * // fires after tooltip is shown + * onshown: function(selectedData) { + * // current dataset selected + * // ==> [{x: 4, value: 150, id: "data2", index: 4, name: "data2"}, ...] + * selectedData; + * }, + * + * // fires after tooltip is hidden + * onhidden: function(selectedData) { + * // current dataset selected + * // ==> [{x: 4, value: 150, id: "data2", index: 4, name: "data2"}, ...] + * selectedData; + * }, + * + * // Link any tooltips when multiple charts are on the screen where same x coordinates are available + * // Useful for timeseries correlation + * linked: true, + * + * // Specify name to interact those with the same name only. + * linked: { + * name: "some-group" + * } + * } + */ + tooltip_show: true, + tooltip_doNotHide: false, + tooltip_grouped: true, + tooltip_format_title: void 0, + tooltip_format_name: void 0, + tooltip_format_value: void 0, + tooltip_position: void 0, + tooltip_contents: {}, + tooltip_init_show: false, + tooltip_init_x: 0, + tooltip_init_position: void 0, + tooltip_linked: false, + tooltip_linked_name: "", + tooltip_onshow: () => { + }, + tooltip_onhide: () => { + }, + tooltip_onshown: () => { + }, + tooltip_onhidden: () => { + }, + tooltip_order: null +}); + +;// ./src/config/Options/data/data.ts +/* harmony default export */ var data = ({ + /** + * Specify the key of x values in the data.<br><br> + * We can show the data with non-index x values by this option. This option is required when the type of x axis is timeseries. If this option is set on a category axis, the values of the data on the key will be used for category names. + * @name data․x + * @memberof Options + * @type {string} + * @default undefined + * @example + * data: { + * x: "date" + * } + */ + data_x: void 0, + /** + * Converts data id value + * @name data․idConverter + * @memberof Options + * @type {function} + * @default function(id) { return id; } + * @example + * data: { + * idConverter: function(id) { + * // when id is 'data1', converts to be 'data2' + * // 'data2' should be given as the initial data value + * if (id === "data1") { + * return "data2"; + * } else { + * return id; + * } + * } + * } + */ + data_idConverter: (id) => id, + /** + * Set custom data name. + * If a name is set to `null`, the series is omitted from the legend. + * @name data․names + * @memberof Options + * @type {object} + * @default {} + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.DataName) + * @example + * data: { + * names: { + * data1: "Data Name 1", + * data2: "Data Name 2" + * } + * } + */ + data_names: {}, + /** + * Set custom data class.<br><br> + * If this option is specified, the element g for the data has an additional class that has the prefix 'bb-target-' (eg. bb-target-additional-data1-class). + * @name data․classes + * @memberof Options + * @type {object} + * @default {} + * @example + * data: { + * classes: { + * data1: "additional-data1-class", + * data2: "additional-data2-class" + * } + * } + */ + data_classes: {}, + /** + * Set chart type at once.<br><br> + * If this option is specified, the type will be applied to every data. This setting can be overwritten by data.types.<br><br> + * **Available Values:** + * - area + * - area-line-range + * - area-spline + * - area-spline-range + * - area-step + * - area-step-range + * - bar + * - bubble + * - candlestick + * - donut + * - funnel + * - gauge + * - line + * - pie + * - polar + * - radar + * - scatter + * - spline + * - step + * - treemap + * @name data․type + * @memberof Options + * @type {string} + * @default "line"<br>NOTE: When importing shapes by ESM, `line()` should be specified for type. + * @example + * data: { + * type: "bar" + * } + * @example + * // Generate chart by importing ESM + * // Import types to be used only, where this will make smaller bundle size. + * import bb, { + * area, + * areaLineRange, + * areaSpline, + * areaSplineRange, + * areaStep, + * areaStepRange, + * bar, + * bubble, + * candlestick, + * donut, + * funnel, + * gauge, + * line, + * pie, + * polar, + * radar, + * scatter, + * spline, + * step, + * treemap + * } + * + * bb.generate({ + * ..., + * data: { + * type: bar() + * } + * }); + */ + data_type: void 0, + /** + * Set chart type for each data.<br> + * This setting overwrites data.type setting. + * - **NOTE:** `radar` and `treemap` type can't be combined with other types. + * @name data․types + * @memberof Options + * @type {object} + * @default {} + * @example + * data: { + * types: { + * data1: "bar", + * data2: "spline" + * } + * } + * @example + * // Generate chart by importing ESM + * // Import types to be used only, where this will make smaller bundle size. + * import bb, { + * area, + * areaLineRange, + * areaSpline, + * areaSplineRange, + * areaStep, + * areaStepRange, + * bar, + * bubble, + * candlestick, + * donut, + * funnel, + * gauge, + * line, + * pie, + * polar, + * radar, + * scatter, + * spline, + * step, + * treemap + * } + * + * bb.generate({ + * ..., + * data: { + * types: { + * data1: bar(), + * data1: spline() + * } + * } + * }); + */ + data_types: {}, + /** + * This option changes the order of stacking data and pieces of pie/donut. + * - If `null` specified, it will be the order in which the data is loaded. + * - If a function is specified, it will be used as [Array.sort compareFunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters)<br><br> + * + * **Available Values:** + * - `desc`: In descending order + * - `asc`: In ascending order + * - `null`: It keeps the data load order + * - `function(data1, data2) { ... }`: Array.sort compareFunction + * + * **NOTE**: order function only works for Axis based types & Arc types, except `Radar` type. + * @name data․order + * @memberof Options + * @type {string|function|null} + * @default desc + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.DataOrder) + * @example + * data: { + * // in descending order (default) + * order: "desc" + * + * // in ascending order + * order: "asc" + * + * // keeps data input order + * order: null + * + * // specifying sort function + * order: function(a, b) { + * // param data passed format + * // { + * // id: "data1", id_org: "data1", values: [ + * // {x: 5, value: 250, id: "data1", index: 5, name: "data1"}, + * // ... + * // ] + * // } + * + * const reducer = (p, c) => p + Math.abs(c.value); + * const aSum = a.values.reduce(reducer, 0); + * const bSum = b.values.reduce(reducer, 0); + * + * // ascending order + * return aSum - bSum; + * + * // descending order + * // return bSum - aSum; + * } + * } + */ + data_order: "desc", + /** + * Set groups for the data for stacking. + * @name data․groups + * @memberof Options + * @type {Array} + * @default [] + * @example + * data: { + * groups: [ + * ["data1", "data2"], + * ["data3"] + * ] + * } + */ + data_groups: [], + /** + * Set how zero value will be treated on groups.<br> + * Possible values: + * - `zero`: 0 will be positioned at the absolute axis zero point. + * - `positive`: 0 will be positioned at the top of a stack. + * - `negative`: 0 will be positioned at the bottom of a stack. + * @name data․groupsZeroAs + * @memberof Options + * @type {string} + * @default "positive" + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.Groups) + * @example + * data: { + * groupsZeroAs: "zero" // "positive" or "negative" + * } + */ + data_groupsZeroAs: "positive", + /** + * Set color converter function.<br><br> + * This option should be a function and the specified function receives color (e.g. '#ff0000') and d that has data parameters like id, value, index, etc. And it must return a string that represents color (e.g. '#00ff00'). + * @name data․color + * @memberof Options + * @type {function} + * @default undefined + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.DataColor) + * @example + * data: { + * color: function(color, d) { ... } + * } + */ + data_color: void 0, + /** + * Set color for each data. + * @name data․colors + * @memberof Options + * @type {object} + * @default {} + * @example + * data: { + * colors: { + * data1: "#ff0000", + * data2: function(d) { + * return "#000"; + * } + * ... + * } + * } + */ + data_colors: {}, + /** + * Set labels options + * @name data․labels + * @memberof Options + * @type {object} + * @property {object} data Data object + * @property {boolean} [data.labels=false] Show or hide labels on each data point + * @property {boolean} [data.labels.centered=false] Centerize labels on `bar` shape. (**NOTE:** works only for 'bar' type) + * @property {function} [data.labels.format] Set formatter function for data labels.<br> + * The formatter function receives 4 arguments such as `v, id, i, texts` and it **must return a string** (`\n` character will be used as line break) that will be shown as the label.<br><br> + * The arguments are:<br> + * - `v` is the value of the data point where the label is shown. + * - `id` is the id of the data where the label is shown. + * - `i` is the index of the data series point where the label is shown. + * - `texts` is an array of whole corresponding data series' text labels.<br><br> + * Formatter function can be defined for each data by specifying as an object and D3 formatter function can be set (ex. d3.format('$')) + * @property {string|object|function} [data.labels.backgroundColors] Set label text background colors.<br><br> + * - **NOTE**: When a function is set, background colors can be specified one color per dataset. + * - Within the function, the last returned color for dataset will be used. + * - Only can control set or unset background color for each values. + * @property {string|object|function} [data.labels.colors] Set label text colors. + * @property {object|function} [data.labels.position] Set each dataset position, relative to the original.<br><br> + * When a function is specified, it will receive 5 arguments such as `type, v, id, i, texts` and it must return a position number.<br><br> + * The arguments are:<br> + * - `type` coordinate type string, which will be 'x' or 'y'. + * - `v` is the value of the data point where the label is shown. + * - `id` is the id of the data where the label is shown. + * - `i` is the index of the data series point where the label is shown. + * - `texts` is an array of whole corresponding data series' text labels.<br><br> + * @property {number} [data.labels.position.x=0] x coordinate position, relative to the original. + * @property {number} [data.labels.position.y=0] y coordinate position, relative to the original. + * @property {object} [data.labels.rotate] Rotate label text. Specify degree value in a range of `0 ~ 360`. + * - **NOTE:** Depending on the rotate value, the text position needs to be adjusted manually(using `data.labels.position` option) to be shown nicely. + * @property {boolean|object} [data.labels.border=false] Add border to data label text. NOTE: When set as `true`, styling isn't applied. Hence, you need to set it using `.bb-text-border` class. + * @property {number|string|object} [data.labels.border.padding="3 5"] Border padding. Can be a single number, string or object with top, bottom, left, right properties. + * @property {number} [data.labels.border.radius=10] Border radius value. + * @property {number} [data.labels.border.strokeWidth=1] Border stroke width. + * @property {string} [data.labels.border.stroke="#000"] Border stroke color. + * @property {string} [data.labels.border.fill="none"] Border fill color. + * @property {object|function} [data.labels.image] Set image to be displayed next to the label text.<br><br> + * When a function is specified, it will receive 3 arguments such as `v, id, i` and it must return an image object with `url`, `width`, `height`, and optional `pos` properties.<br><br> + * The arguments are:<br> + * - `v` is the value of the data point where the label is shown. + * - `id` is the id of the data where the label is shown. + * - `i` is the index of the data series point where the label is shown. + * @property {string} data.labels.image.url Image URL path. Can use placeholder `{=ID}` which will be replaced with the data ID. + * @property {number} data.labels.image.width Image width in pixels. + * @property {number} data.labels.image.height Image height in pixels. + * @property {object} [data.labels.image.pos] Image position relative to the label text. + * @property {number} [data.labels.image.pos.x=0] x coordinate position, relative to the original. + * @property {number} [data.labels.image.pos.y=0] y coordinate position, relative to the original. + * @memberof Options + * @type {object} + * @default {} + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.DataLabel) + * @see [Demo: label border](https://naver.github.io/billboard.js/demo/#Data.DataLabelBorder) + * @see [Demo: label colors](https://naver.github.io/billboard.js/demo/#Data.DataLabelColors) + * @see [Demo: label format](https://naver.github.io/billboard.js/demo/#Data.DataLabelFormat) + * @see [Demo: label image](https://naver.github.io/billboard.js/demo/#Data.DataLabelImage) + * @see [Demo: label multiline](https://naver.github.io/billboard.js/demo/#Data.DataLabelMultiline) + * @see [Demo: label overlap](https://naver.github.io/billboard.js/demo/#Data.DataLabelOverlap) + * @see [Demo: label position](https://naver.github.io/billboard.js/demo/#Data.DataLabelPosition) + * @see [Demo: label rotate](https://naver.github.io/billboard.js/demo/#Data.DataLabelRotate) + * @example + * data: { + * labels: true, + * + * // or set specific options + * labels: { + * format: function(v, id, i, texts) { + * ... + * // to multiline, return with '\n' character + * return "Line1\nLine2"; + * }, + * + * // it's possible to set for each data + * format: { + * data1: function(v, id, i, texts) { ... }, + * ... + * }, + * + * // align text to center of the 'bar' shape (works only for 'bar' type) + * centered: true, + * + * // apply background color for label texts + * backgroundColors: "red", + * + * // set different background colors per dataset + * backgroundColors: { + * data1: "green", + * data2: "yellow" + * }, + * + * // call back for label text background color + * backgroundColors: function(color, d) { + * // color: the default data label color string + * // data: ex) {x: 0, value: 200, id: "data3", index: 0} + * .... + * return d.value > 200 ? "cyan" : "red"; + * }, + * + * // apply for all label texts + * colors: "red", + * + * // set different colors per dataset + * // for not specified dataset, will have the default color value + * colors: { + * data1: "yellow", + * data3: "green" + * }, + * + * // call back for label text color + * colors: function(color, d) { + * // color: the default data label color string + * // data: ex) {x: 0, value: 200, id: "data3", index: 0} + * .... + * return d.value > 200 ? "cyan" : color; + * }, + * + * // return x, y coordinate position + * // apt to handle each text position manually + * position: function(type, v, id, i, texts) { + * ... + * return type == "x" ? 10 : 20; + * }, + * + * // set x, y coordinate position + * position: { + * x: -10, + * y: 10 + * }, + * + * // or set x, y coordinate position by each dataset + * position: { + * data1: {x: 5, y: 5}, + * data2: {x: 10, y: -20} + * }, + * + * // rotate degree for label text + * rotate: 90, + * + * // add border to data label text + * // NOTE: When set as `true`, styling aren't applied. Hence, need to set using '.bb-text-border' class. + * // ex. ".bb-text-border { fill: red; stroke: #000; stroke-width: 2px; rx: 10px; ry: 10px; }" + * border: true, + * + * // or set detailed border options + * border: { + * padding: 10, // set all padding to 10 + * padding: "5 10", // set top and bottom padding to 5, left and right padding to 10 + * padding: { // specify each padding + * top: 3, + * bottom: 5, + * left: 10, + * right: 13 + * }, + * radius: 10, + * strokeWidth: 2, + * stroke: "#000", + * fill: "red" + * }, + * + * // set image to be displayed next to the label text + * image: { + * url: "./sample.svg", + * + * // use placeholder to dynamically set image URL based on data ID + * url: "./images/{=ID}.svg", // will be replaced to "./images/data1.svg", "./images/data2.svg", etc. + * width: 35, + * height: 35, + * pos: { + * x: 0, + * y: 0 + * } + * }, + * + * // or use function to return image configuration dynamically + * image: function(v, id, i) { + * // v is the value of the data point where the label is shown. + * // id is the id of the data where the label is shown. + * // i is the index of the data series point where the label is shown. + * + * // Return different images based on value + * if (v > 500) { + * return { + * url: "./high-value.svg", + * width: 40, + * height: 40, + * pos: { x: 0, y: 0 } + * }; + * } else if (v > 100) { + * return { + * url: "./medium-value.svg", + * width: 30, + * height: 30, + * pos: { x: 0, y: 0 } + * }; + * } else if(v < 5) { + * // Return falsy value in case you don't want to show image + * return null; + * } else { + * return { + * url: "./low-value.svg", + * width: 20, + * height: 20, + * pos: { x: 0, y: 0 } + * }; + * } + * } + * } + * } + */ + data_labels: {}, + data_labels_backgroundColors: void 0, + data_labels_colors: void 0, + data_labels_position: {}, + data_labels_imgUrl: void 0, + /** + * Hide each data when the chart appears.<br><br> + * If true is specified, all of data will be hidden. If multiple ids are specified as an array, those will be hidden. + * @name data․hide + * @memberof Options + * @type {boolean|Array} + * @default false + * @example + * data: { + * // all of data will be hidden + * hide: true + * + * // specified data will be hidden + * hide: ["data1", ...] + * } + */ + data_hide: false, + /** + * Filter values to be shown + * The data value is the same as the returned by `.data()`. + * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter + * @name data․filter + * @memberof Options + * @type {function} + * @default undefined + * @example + * data: { + * // filter for id value + * filter: function(v) { + * // v: [{id: "data1", id_org: "data1", values: [ + * // {x: 0, value: 130, id: "data2", index: 0}, ...] + * // }, ...] + * return v.id !== "data1"; + * } + */ + data_filter: void 0, + /** + * Set a callback for click event on each data point.<br><br> + * This callback will be called when each data point is clicked and will receive `d` and element as the arguments. + * - `d` is the data clicked and element is the element clicked. + * - `element` is the current interacting svg element. + * - In this callback, `this` will be the Chart object. + * @name data․onclick + * @memberof Options + * @type {function} + * @default function() {} + * @example + * data: { + * onclick: function(d, element) { + * // d - ex) {x: 4, value: 150, id: "data1", index: 4, name: "data1"} + * // element - <circle> + * ... + * } + * } + */ + data_onclick: () => { + }, + /** + * Set a callback for mouse/touch over event on each data point.<br><br> + * This callback will be called when the mouse cursor or touch moves onto each data point and will receive `d` and `element` as the argument. + * - `d` is the data where mouse cursor moves onto. + * - `element` is the current interacting svg element. + * - In this callback, `this` will be the Chart object. + * @name data․onover + * @memberof Options + * @type {function} + * @default function() {} + * @example + * data: { + * onover: function(d, element) { + * // d - ex) {x: 4, value: 150, id: "data1", index: 4} + * // element - <circle> + * ... + * } + * } + */ + data_onover: () => { + }, + /** + * Set a callback for mouse/touch out event on each data point.<br><br> + * This callback will be called when the mouse cursor or touch moves out each data point and will receive `d` as the argument. + * - `d` is the data where mouse cursor moves out. + * - `element` is the current interacting svg element. + * - In this callback, `this` will be the Chart object. + * @name data․onout + * @memberof Options + * @type {function} + * @default function() {} + * @example + * data: { + * onout: function(d, element) { + * // d - ex) {x: 4, value: 150, id: "data1", index: 4} + * // element - <circle> + * ... + * } + * } + */ + data_onout: () => { + }, + /** + * Set a callback for when data is shown.<br> + * The callback will receive shown data ids in array. + * @name data․onshown + * @memberof Options + * @type {function} + * @default undefined + * @example + * data: { + * onshown: function(ids) { + * // ids - ["data1", "data2", ...] + * ... + * } + * } + */ + data_onshown: void 0, + /** + * Set a callback for when data is hidden.<br> + * The callback will receive hidden data ids in array. + * @name data․onhidden + * @memberof Options + * @type {function} + * @default undefined + * @example + * data: { + * onhidden: function(ids) { + * // ids - ["data1", "data2", ...] + * ... + * } + * } + */ + data_onhidden: void 0, + /** + * Set a callback for minimum data + * - **NOTE:** For 'area-line-range', 'area-step-range' and 'area-spline-range', `mid` data will be taken for the comparison + * @name data․onmin + * @memberof Options + * @type {function} + * @default undefined + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.OnMinMaxCallback) + * @example + * onmin: function(data) { + * // data - ex) [{x: 3, value: 400, id: "data1", index: 3}, ... ] + * ... + * } + */ + data_onmin: void 0, + /** + * Set a callback for maximum data + * - **NOTE:** For 'area-line-range', 'area-step-range' and 'area-spline-range', `mid` data will be taken for the comparison + * @name data․onmax + * @memberof Options + * @type {function} + * @default undefined + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.OnMinMaxCallback) + * @example + * onmax: function(data) { + * // data - ex) [{x: 3, value: 400, id: "data1", index: 3}, ... ] + * ... + * } + */ + data_onmax: void 0, + /** + * Load a CSV or JSON file from a URL. NOTE that this will not work if loading via the "file://" protocol as most browsers will block XMLHTTPRequests. + * @name data․url + * @memberof Options + * @type {string} + * @default undefined + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.LoadData) + * @example + * data: { + * url: "/data/test.csv" + * } + */ + data_url: void 0, + /** + * XHR header value + * - **NOTE:** Should be used with `data.url` option + * @name data․headers + * @memberof Options + * @type {string} + * @default undefined + * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader + * @example + * data: { + * url: "/data/test.csv", + * headers: { + * "Content-Type": "text/xml", + * ... + * } + * } + */ + data_headers: void 0, + /** + * Parse a JSON object for data. See also data.keys. + * @name data․json + * @memberof Options + * @type {Array} + * @default undefined + * @see [data․keys](#.data%25E2%2580%25A4keys) + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.JSONData) + * @example + * data: { + * json: [ + * {name: "www.site1.com", upload: 200, download: 200, total: 400}, + * {name: "www.site2.com", upload: 100, download: 300, total: 400}, + * {name: "www.site3.com", upload: 300, download: 200, total: 500}, + * {name: "www.site4.com", upload: 400, download: 100, total: 500} + * ], + * keys: { + * // case 1: specify 'x' key for category axis + * x: "name", // 'name' key will be used as category x axis values + * value: ["upload", "download"] + * + * // case 2: without 'x' key for non-category axis + * value: ["upload", "download"] + * } + * } + */ + data_json: void 0, + /** + * Load data from a multidimensional array, with the first element containing the data names, the following containing related data in that order. + * @name data․rows + * @memberof Options + * @type {Array} + * @default undefined + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.RowOrientedData) + * @example + * data: { + * rows: [ + * ["A", "B", "C"], + * [90, 120, 300], + * [40, 160, 240], + * [50, 200, 290], + * [120, 160, 230], + * [80, 130, 300], + * [90, 220, 320] + * ] + * } + * + * // for 'bar' type, data can contain: + * // - an array of [start, end] data following the order + * data: { + * rows: [ + * ["data1", "data2"], + * [[100, 150], 120], + * [[200, 300], 55], + * [[-400, 500], 60] + * ], + * type: "bar" + * } + * + * // for 'range' types('area-line-range' or 'area-step-range' or 'area-spline-range'), data should contain: + * // - an array of [high, mid, low] data following the order + * // - or an object with 'high', 'mid' and 'low' key value + * data: { + * rows: [ + * ["data1", "data2"], + * [ + * // or {high:150, mid: 140, low: 110}, 120 + * [150, 140, 110], 120 + * ], + * [[155, 130, 115], 55], + * [[160, 135, 120], 60] + * ], + * types: { + * data1: "area-line-range", + * data2: "line" + * } + * } + * + * // for 'bubble' type, data can contain dimension value: + * // - an array of [y, z] data following the order + * // - or an object with 'y' and 'z' key value + * // 'y' is for y axis coordination and 'z' is the bubble radius value + * data: { + * rows: [ + * ["data1", "data2"], + * [ + * // or {y:10, z: 140}, 120 + * [10, 140], 120 + * ], + * [[100, 30], 55], + * [[50, 100], 60] + * ], + * types: { + * data1: "bubble", + * data2: "line" + * } + * } + * + * // for 'candlestick' type, data should contain: + * // - an array of [open, high, low, close, volume(optional)] data following the order + * // - or an object with 'open', 'high', 'low', 'close' and 'value'(optional) key value + * data: { + * rows: [ + * ["data1", "data2"], + * [ + * // open, high, low, close, volume (optional) + * {open: 1300, high: 1369, low: 1200, close: 1339, volume: 100}, + * [1000, 1100, 850, 870] + * ], + * [ + * {open: 1348, high: 1371, low: 1271, close: 1320}, + * [870, 1250, 830, 1200, 50] + * ] + * ], + * type: "candlestick" + * } + */ + data_rows: void 0, + /** + * Load data from a multidimensional array, with each element containing an array consisting of a datum name and associated data values. + * @name data․columns + * @memberof Options + * @type {Array} + * @default undefined + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.ColumnOrientedData) + * @example + * data: { + * columns: [ + * ["data1", 30, 20, 50, 40, 60, 50], + * ["data2", 200, 130, 90, 240, 130, 220], + * ["data3", 300, 200, 160, 400, 250, 250] + * ] + * } + * + * // for 'bar' type, data can contain: + * // - an array of [start, end] data following the order + * data: { + * columns: [ + * ["data1", -100, 50, [100, 200], [200, 300]], + * ["data2", -200, 300, [-100, 100], [-50, -30]], + * ], + * type: "bar" + * } + * + * // for 'range' types('area-line-range' or 'area-step-range' or 'area-spline-range'), data should contain: + * // - an array of [high, mid, low] data following the order + * // - or an object with 'high', 'mid' and 'low' key value + * data: { + * columns: [ + * ["data1", + * [150, 140, 110], // or {high:150, mid: 140, low: 110} + * [150, 140, 110], + * [150, 140, 110] + * ] + * ], + * type: "area-line-range" + * } + * + * // for 'bubble' type, data can contain dimension value: + * // - an array of [y, z] data following the order + * // - or an object with 'y' and 'z' key value + * // 'y' is for y axis coordination and 'z' is the bubble radius value + * data: { + * columns: [ + * ["data1", + * [10, 140], // or {y:10, z: 140} + * [100, 30], + * [50, 100] + * ] + * ], + * type: "bubble" + * } + * + * // for 'candlestick' type, data should contain: + * // - an array of [open, high, low, close, volume(optional)] data following the order + * // - or an object with 'open', 'high', 'low', 'close' and 'value'(optional) key value + * data: { + * columns: [ + * ["data1", + * [1000, 1100, 850, 870, 100], // or {open:1000, high: 1100, low: 870, volume: 100} + * [870, 1250, 830, 1200] // 'volume' can be omitted + * ] + * ], + * type: "candlestick" + * } + */ + data_columns: void 0, + /** + * Used if loading JSON via data.url. + * - **Available Values:** + * - json + * - csv + * - tsv + * @name data․mimeType + * @memberof Options + * @type {string} + * @default csv + * @example + * data: { + * mimeType: "json" + * } + */ + data_mimeType: "csv", + /** + * Choose which JSON object keys correspond to desired data. + * - **NOTE:** Only for JSON object given as array. + * @name data․keys + * @memberof Options + * @type {string} + * @default undefined + * @example + * data: { + * json: [ + * {name: "www.site1.com", upload: 200, download: 200, total: 400}, + * {name: "www.site2.com", upload: 100, download: 300, total: 400}, + * {name: "www.site3.com", upload: 300, download: 200, total: 500}, + * {name: "www.site4.com", upload: 400, download: 100, total: 500} + * ], + * keys: { + * // case 1: specify 'x' key for category axis + * x: "name", // 'name' key will be used as category x axis values + * value: ["upload", "download"] + * + * // case 2: without 'x' key for non-category axis + * value: ["upload", "download"] + * } + * } + */ + data_keys: void 0, + /** + * Set text label to be displayed when there's no data to show. + * - ex. Toggling all visible data to not be shown, unloading all current data, etc. + * @name data․empty․label․text + * @memberof Options + * @type {string} + * @default "" + * @example + * data: { + * empty: { + * label: { + * text: "No Data" + * } + * } + * } + */ + data_empty_label_text: "" +}); + +;// ./src/config/Options/interaction/interaction.ts +/* harmony default export */ var interaction = ({ + /** + * Interaction options + * @name interaction + * @memberof Options + * @type {object} + * @property {object} interaction Intersection object + * @property {boolean} [interaction.enabled=true] Indicate if the chart should have interactions.<br> + * If `false` is set, all of interactions (showing/hiding tooltip, selection, mouse events, etc) will be disabled. + * @property {boolean} [interaction.brighten=true] Make brighter for the selected area (ex. 'pie' type data selected area) + * @property {boolean} [interaction.inputType.mouse=true] enable or disable mouse interaction + * @property {boolean} [interaction.inputType.touch=true] enable or disable touch interaction + * @property {boolean|number} [interaction.inputType.touch.preventDefault=false] enable or disable to call event.preventDefault on touchstart & touchmove event. It's usually used to prevent document scrolling.<br> + * - **NOTE**: When `true` is set, touch events are bound with [`{passive: false}`](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#using_passive_listeners) option. + * @property {boolean} [interaction.onout=true] Enable or disable "onout" event.<br> + * When is disabled, defocus(hiding tooltip, focused gridline, etc.) event won't work. + * @see [Demo: touch.preventDefault](https://naver.github.io/billboard.js/demo/#Interaction.PreventScrollOnTouch) + * @example + * interaction: { + * enabled: false, + * brighten: false, + * inputType: { + * mouse: true, + * touch: false + * + * // or declare preventDefault explicitly. + * // In this case touch inputType is enabled by default + * touch: { + * preventDefault: true + * + * // or threshold pixel value (pixel moved from touchstart to touchmove) + * preventDefault: 5 + * } + * }, + * + * // disable "onout" event + * onout: false + * } + */ + interaction_enabled: true, + interaction_brighten: true, + interaction_inputType_mouse: true, + interaction_inputType_touch: {}, + interaction_onout: true +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-brush","commonjs2":"d3-brush","amd":"d3-brush","root":"d3"} +var external_commonjs_d3_brush_commonjs2_d3_brush_amd_d3_brush_root_d3_ = __webpack_require__(4); +;// ./src/module/browser.ts +function getGlobal() { + return typeof globalThis === "object" && globalThis !== null && globalThis.Object === Object && globalThis || typeof global === "object" && global !== null && global.Object === Object && global || typeof self === "object" && self !== null && self.Object === Object && self || Function("return this")(); +} +function getFallback(w) { + const hasRAF = typeof (w == null ? void 0 : w.requestAnimationFrame) === "function" && typeof (w == null ? void 0 : w.cancelAnimationFrame) === "function"; + const hasRIC = typeof (w == null ? void 0 : w.requestIdleCallback) === "function" && typeof (w == null ? void 0 : w.cancelIdleCallback) === "function"; + const request = (cb) => setTimeout(cb, 1); + const cancel = (id) => clearTimeout(id); + return [ + hasRAF ? w.requestAnimationFrame : request, + hasRAF ? w.cancelAnimationFrame : cancel, + hasRIC ? w.requestIdleCallback : request, + hasRIC ? w.cancelIdleCallback : cancel + ]; +} +const win = getGlobal(); +const browser_doc = win == null ? void 0 : win.document; +const [ + requestAnimationFrame, + cancelAnimationFrame, + requestIdleCallback, + cancelIdleCallback +] = getFallback(win); + + +;// ./src/module/sanitize.ts +const ALLOWED_TAGS = /* @__PURE__ */ new Set([ + // HTML tags for tooltip/legend templates + "span", + "div", + "p", + "br", + "b", + "i", + "em", + "strong", + "u", + "s", + "sub", + "sup", + "ul", + "ol", + "li", + "dl", + "dt", + "dd", + "table", + "thead", + "tbody", + "tfoot", + "tr", + "th", + "td", + "caption", + "colgroup", + "col", + "hr", + "pre", + "code", + "blockquote", + "a", + "img", + // SVG tags for point patterns + "svg", + "g", + "path", + "circle", + "ellipse", + "rect", + "line", + "polyline", + "polygon", + "text", + "tspan", + "textPath", + "use", + "defs", + "symbol", + "clipPath", + "mask", + "linearGradient", + "radialGradient", + "stop", + "pattern", + "marker", + "title", + "desc" +]); +const ALLOWED_ATTRS = /* @__PURE__ */ new Set([ + // Common attributes + "class", + "id", + "style", + "title", + "lang", + "dir", + // HTML specific + "href", + "src", + "alt", + "width", + "height", + "colspan", + "rowspan", + "scope", + "headers", + // SVG presentation attributes + "d", + "points", + "x", + "y", + "x1", + "x2", + "y1", + "y2", + "cx", + "cy", + "r", + "rx", + "ry", + "dx", + "dy", + "viewBox", + "preserveAspectRatio", + "transform", + "fill", + "fill-opacity", + "fill-rule", + "stroke", + "stroke-width", + "stroke-opacity", + "stroke-linecap", + "stroke-linejoin", + "stroke-dasharray", + "stroke-dashoffset", + "opacity", + "clip-path", + "clip-rule", + "mask", + "font-family", + "font-size", + "font-weight", + "font-style", + "text-anchor", + "dominant-baseline", + "offset", + "stop-color", + "stop-opacity", + "gradientUnits", + "gradientTransform", + "spreadMethod", + "patternUnits", + "patternTransform", + "marker-start", + "marker-mid", + "marker-end", + "markerWidth", + "markerHeight", + "refX", + "refY", + "xlink:href" +]); +const ALLOWED_URI_PROTOCOLS = /* @__PURE__ */ new Set([ + "http:", + "https:", + "mailto:" +]); +const URI_ATTRS = /* @__PURE__ */ new Set(["href", "src", "xlink:href"]); +const TAG_NAME_REGEX = /^<\/?([a-zA-Z][a-zA-Z0-9]*)/; +const CLOSING_TAG_REGEX = /^<\/([a-zA-Z][a-zA-Z0-9]*)\s*>$/; +const OPENING_TAG_REGEX = /^<([a-zA-Z][a-zA-Z0-9]*)([\s\S]*?)(\/?)>$/; +const ATTR_REGEX = /([a-zA-Z][\w:-]*)\s*(?:=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g; +const URL_IN_STYLE_REGEX = /url\s*\(\s*["']?([^"')]+)["']?\s*\)/gi; +const DANGEROUS_CSS_PATTERNS = [ + "expression(", + "behavior:", + "binding:", + "@import", + "@charset", + "-moz-binding:" +]; +function decodeHTMLEntities(str) { + return str.replace(/:/gi, ":").replace(/&newline;/gi, "\n").replace(/&tab;/gi, " ").replace(/ /gi, " ").replace(/</gi, "<").replace(/>/gi, ">").replace(/&/gi, "&").replace(/"/gi, '"').replace(/'/gi, "'").replace(/&#(\d+);/gi, (_, code) => String.fromCharCode(parseInt(code, 10))).replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCharCode(parseInt(code, 16))); +} +function isSafeURI(uri) { + const decoded = decodeHTMLEntities(uri).trim(); + const normalized = decoded.replace(/[\s\u0000-\u001f]/g, "").toLowerCase(); + if (!normalized || normalized.startsWith("#")) { + return true; + } + if (normalized.startsWith("/") || normalized.startsWith("./") || normalized.startsWith("../") || !normalized.includes(":")) { + return true; + } + const colonIndex = normalized.indexOf(":"); + if (colonIndex > 0) { + const protocol = normalized.substring(0, colonIndex + 1); + return ALLOWED_URI_PROTOCOLS.has(protocol); + } + return false; +} +function sanitizeStyleValue(style) { + const decoded = decodeHTMLEntities(style); + const cleaned = decoded.replace(/[\u0000-\u001f]/g, ""); + URL_IN_STYLE_REGEX.lastIndex = 0; + let match; + while ((match = URL_IN_STYLE_REGEX.exec(cleaned)) !== null) { + if (!isSafeURI(match[1])) { + return null; + } + } + const normalizedLower = cleaned.toLowerCase().replace(/\s/g, ""); + for (const pattern of DANGEROUS_CSS_PATTERNS) { + if (normalizedLower.includes(pattern)) { + return null; + } + } + return style; +} +const ATTR_ENCODE_MAP = { + '"': """, + "'": "'", + "`": "`" +}; +const ATTR_ENCODE_REGEX = /["'`]/g; +function encodeAttrValue(value) { + return value.replace(ATTR_ENCODE_REGEX, (char) => ATTR_ENCODE_MAP[char]); +} +function sanitizeAttrValue(name, value, wasUnquoted = false) { + if (URI_ATTRS.has(name)) { + if (!isSafeURI(value)) { + return null; + } + return wasUnquoted ? encodeAttrValue(value) : value; + } + if (name === "style") { + const sanitizedStyle = sanitizeStyleValue(value); + if (sanitizedStyle === null) { + return null; + } + return wasUnquoted ? encodeAttrValue(sanitizedStyle) : sanitizedStyle; + } + const decoded = decodeHTMLEntities(value).toLowerCase().replace(/\s/g, ""); + if (/\bon\w+=/.test(decoded)) { + return null; + } + return wasUnquoted ? encodeAttrValue(value) : value; +} +function extractTagName(tag) { + const match = tag.match(TAG_NAME_REGEX); + return match ? match[1].toLowerCase() : null; +} +function isAllowedTag(tag) { + const tagName = extractTagName(tag); + return tagName !== null && ALLOWED_TAGS.has(tagName); +} +function sanitizeTag(fullTag) { + const closingMatch = fullTag.match(CLOSING_TAG_REGEX); + if (closingMatch) { + return `</${closingMatch[1].toLowerCase()}>`; + } + const openingMatch = fullTag.match(OPENING_TAG_REGEX); + if (!openingMatch) { + return ""; + } + const [, tagName, attrString, selfClose] = openingMatch; + const lowerTagName = tagName.toLowerCase(); + const allowedAttrs = []; + ATTR_REGEX.lastIndex = 0; + let attrMatch; + while ((attrMatch = ATTR_REGEX.exec(attrString)) !== null) { + const attrName = attrMatch[1].toLowerCase(); + const doubleQuotedValue = attrMatch[2]; + const singleQuotedValue = attrMatch[3]; + const unquotedValue = attrMatch[4]; + if (attrName.startsWith("on")) { + continue; + } + let attrValue; + let quoteChar; + if (doubleQuotedValue !== void 0) { + attrValue = doubleQuotedValue; + quoteChar = '"'; + } else if (singleQuotedValue !== void 0) { + attrValue = singleQuotedValue; + quoteChar = "'"; + } else if (unquotedValue !== void 0) { + attrValue = unquotedValue; + quoteChar = '"'; + } else { + if (ALLOWED_ATTRS.has(attrName)) { + allowedAttrs.push(attrName); + } + continue; + } + if (ALLOWED_ATTRS.has(attrName)) { + const wasUnquoted = unquotedValue !== void 0; + const sanitizedValue = sanitizeAttrValue(attrName, attrValue, wasUnquoted); + if (sanitizedValue !== null) { + allowedAttrs.push(`${attrName}=${quoteChar}${sanitizedValue}${quoteChar}`); + } + } + } + const attrsStr = allowedAttrs.length > 0 ? ` ${allowedAttrs.join(" ")}` : ""; + const selfCloseStr = selfClose ? "/>" : ">"; + return `<${lowerTagName}${attrsStr}${selfCloseStr}`; +} +function sanitize(str) { + if (typeof str !== "string" || !str || str.indexOf("<") === -1) { + return str; + } + return str.replace( + /<\/?[^>]*>|[^<>\s]+>/g, + (match) => { + if (match.startsWith("<!--")) { + return ""; + } + if (!match.startsWith("<")) { + return match.slice(0, -1) + ">"; + } + if (isAllowedTag(match)) { + return sanitizeTag(match); + } + return match.replace(/</g, "<"); + } + ); +} + +;// ./src/module/util.ts +var util_defProp = Object.defineProperty; +var util_getOwnPropSymbols = Object.getOwnPropertySymbols; +var util_hasOwnProp = Object.prototype.hasOwnProperty; +var util_propIsEnum = Object.prototype.propertyIsEnumerable; +var util_defNormalProp = (obj, key, value) => key in obj ? util_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var util_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (util_hasOwnProp.call(b, prop)) + util_defNormalProp(a, prop, b[prop]); + if (util_getOwnPropSymbols) + for (var prop of util_getOwnPropSymbols(b)) { + if (util_propIsEnum.call(b, prop)) + util_defNormalProp(a, prop, b[prop]); + } + return a; +}; + + + + +function _getRect(relativeViewport, node, forceEval = false) { + const _ = (n) => n[relativeViewport ? "getBoundingClientRect" : "getBBox"](); + if (forceEval) { + return _(node); + } else { + const needEvaluate = !("rect" in node) || "rect" in node && node.hasAttribute("width") && node.rect.width !== +(node.getAttribute("width") || 0); + return needEvaluate ? node.rect = _(node) : node.rect; + } +} +function _forEachValidItem(items, callback) { + for (let i = 0; i < items.length; i++) { + const item = items[i]; + if (item) { + callback(item, i); + } + } +} +const isValue = (v) => v || v === 0; +const isFunction = (v) => typeof v === "function"; +const isString = (v) => typeof v === "string"; +const isNumber = (v) => typeof v === "number"; +const isUndefined = (v) => typeof v === "undefined"; +const isDefined = (v) => typeof v !== "undefined"; +const isBoolean = (v) => typeof v === "boolean"; +const ceil10 = (v) => Math.ceil(v / 10) * 10; +const asHalfPixel = (n) => Math.ceil(n) + 0.5; +const diffDomain = (d) => d[1] - d[0]; +const isObjectType = (v) => typeof v === "object"; +const isEmptyObject = (obj) => { + for (const x in obj) { + return false; + } + return true; +}; +const isEmpty = (o) => isUndefined(o) || o === null || isString(o) && o.length === 0 || isObjectType(o) && !(o instanceof Date) && isEmptyObject(o) || isNumber(o) && isNaN(o); +const notEmpty = (o) => !isEmpty(o); +const isArray = (arr) => Array.isArray(arr); +const isObject = (obj) => obj && !(obj == null ? void 0 : obj.nodeType) && isObjectType(obj) && !isArray(obj); +function getOption(options, key, defaultValue) { + return isDefined(options[key]) ? options[key] : defaultValue; +} +function hasValue(dict, value) { + let found = false; + Object.keys(dict).forEach((key) => dict[key] === value && (found = true)); + return found; +} +function callFn(fn, thisArg, ...args) { + const isFn = isFunction(fn); + isFn && fn.call(thisArg, ...args); + return isFn; +} +function endall(transition, cb) { + let n = 0; + const end = function(...args) { + !--n && cb.apply(this, ...args); + }; + if ("duration" in transition) { + transition.each(() => ++n).on("end", end); + } else { + ++n; + transition.call(end); + } +} +function setTextValue(node, text, dy = [-1, 1], toMiddle = false) { + if (!node || !isString(text)) { + return; + } + if (text.indexOf("\n") === -1) { + node.text(text); + } else { + const diff = [node.text(), text].map((v) => v.replace(/[\s\n]/g, "")); + if (diff[0] !== diff[1]) { + const multiline = text.split("\n"); + const len = toMiddle ? multiline.length - 1 : 1; + node.html(""); + multiline.forEach((v, i) => { + node.append("tspan").attr("x", 0).attr("dy", `${i === 0 ? dy[0] * len : dy[1]}em`).text(v); + }); + } + } +} +function getRectSegList(path) { + const { x, y, width, height } = path.getBBox(); + return [ + { x, y: y + height }, + // seg0 + { x, y }, + // seg1 + { x: x + width, y }, + // seg2 + { x: x + width, y: y + height } + // seg3 + ]; +} +function getPathBox(path) { + const { width, height } = getBoundingRect(path); + const items = getRectSegList(path); + const x = items[0].x; + const y = Math.min(items[0].y, items[1].y); + return { + x, + y, + width, + height + }; +} +function getPointer(event, element) { + var _a; + const touches = event && ((_a = event.touches || event.sourceEvent && event.sourceEvent.touches) == null ? void 0 : _a[0]); + let pointer = [0, 0]; + try { + pointer = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.pointer)(touches || event, element); + } catch (e) { + } + return pointer.map((v) => isNaN(v) ? 0 : v); +} +function getBrushSelection(ctx) { + const { event, $el } = ctx; + const main = $el.subchart.main || $el.main; + let selection; + if (event && event.type === "brush") { + selection = event.selection; + } else if (main && (selection = main.select(".bb-brush").node())) { + selection = (0,external_commonjs_d3_brush_commonjs2_d3_brush_amd_d3_brush_root_d3_.brushSelection)(selection); + } + return selection; +} +function getBoundingRect(node, forceEval = false) { + return _getRect(true, node, forceEval); +} +function getBBox(node, forceEval = false) { + return _getRect(false, node, forceEval); +} +function getRandom(asStr = true, min = 0, max = 1e4) { + const crpt = win.crypto || win.msCrypto; + const rand = crpt ? min + crpt.getRandomValues(new Uint32Array(1))[0] % (max - min + 1) : Math.floor(Math.random() * (max - min) + min); + return asStr ? String(rand) : rand; +} +function findIndex(arr, v, start, end, isRotated) { + if (start > end) { + return -1; + } + const mid = Math.floor((start + end) / 2); + let { x, w = 0 } = arr[mid]; + if (isRotated) { + x = arr[mid].y; + w = arr[mid].h; + } + if (v >= x && v <= x + w) { + return mid; + } + return v < x ? findIndex(arr, v, start, mid - 1, isRotated) : findIndex(arr, v, mid + 1, end, isRotated); +} +function brushEmpty(ctx) { + const selection = getBrushSelection(ctx); + if (selection) { + return selection[0] === selection[1]; + } + return true; +} +function deepClone(...objectN) { + const clone = (v) => { + if (isObject(v) && v.constructor) { + const r = new v.constructor(); + for (const k in v) { + r[k] = clone(v[k]); + } + return r; + } + return v; + }; + return objectN.map((v) => clone(v)).reduce((a, c) => util_spreadValues(util_spreadValues({}, a), c)); +} +function extend(target = {}, source) { + if (isArray(source)) { + source.forEach((v) => extend(target, v)); + } + for (const p in source) { + if (/^\d+$/.test(p) || p in target) { + continue; + } + target[p] = source[p]; + } + return target; +} +const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1); +function camelize(str, separator = "-") { + return str.split(separator).map((v, i) => i ? v.charAt(0).toUpperCase() + v.slice(1).toLowerCase() : v.toLowerCase()).join(""); +} +const toArray = (v) => [].slice.call(v); +function addCssRules(style, selector, prop) { + const { rootSelector = "", sheet } = style; + const getSelector = (s) => s.replace(/\s?(bb-)/g, ".$1").replace(/\.+/g, "."); + const rule = `${rootSelector} ${getSelector(selector)} {${prop.join(";")}}`; + return sheet[sheet.insertRule ? "insertRule" : "addRule"]( + rule, + sheet.cssRules.length + ); +} +function getCssRules(styleSheets) { + let rules = []; + styleSheets.forEach((sheet) => { + var _a; + try { + if (sheet.cssRules && sheet.cssRules.length) { + rules = rules.concat(toArray(sheet.cssRules)); + } + } catch (e) { + (_a = win.console) == null ? void 0 : _a.warn(`Error while reading rules from ${sheet.href}: ${e.toString()}`); + } + }); + return rules; +} +function getScrollPosition(node) { + var _a, _b, _c, _d, _e, _f; + return { + x: ((_b = (_a = win.pageXOffset) != null ? _a : win.scrollX) != null ? _b : 0) + ((_c = node.scrollLeft) != null ? _c : 0), + y: ((_e = (_d = win.pageYOffset) != null ? _d : win.scrollY) != null ? _e : 0) + ((_f = node.scrollTop) != null ? _f : 0) + }; +} +function getTransformCTM(node, x = 0, y = 0, inverse = true) { + const point = new DOMPoint(x, y); + const screen = node.getScreenCTM(); + const res = point.matrixTransform( + inverse ? screen == null ? void 0 : screen.inverse() : screen + ); + if (inverse === false) { + const rect = getBoundingRect(node); + res.x -= rect.x; + res.y -= rect.y; + } + return res; +} +function getTranslation(node) { + const transform = node ? node.transform : null; + const baseVal = transform && transform.baseVal; + return baseVal && baseVal.numberOfItems ? baseVal.getItem(0).matrix : { a: 0, b: 0, c: 0, d: 0, e: 0, f: 0 }; +} +function getUnique(data) { + const isDate = data[0] instanceof Date; + const d = (isDate ? data.map(Number) : data).filter((v, i, self) => self.indexOf(v) === i); + return isDate ? d.map((v) => new Date(v)) : d; +} +function mergeArray(arr) { + return arr && arr.length ? arr.reduce((p, c) => p.concat(c)) : []; +} +function mergeObj(target, ...objectN) { + if (!objectN.length || objectN.length === 1 && !objectN[0]) { + return target; + } + const source = objectN.shift(); + if (isObject(target) && isObject(source)) { + Object.keys(source).forEach((key) => { + if (!/^(__proto__|constructor|prototype)$/i.test(key)) { + const value = source[key]; + if (isObject(value)) { + !target[key] && (target[key] = {}); + target[key] = mergeObj(target[key], value); + } else { + target[key] = isArray(value) ? value.concat() : value; + } + } + }); + } + return mergeObj(target, ...objectN); +} +function sortValue(data, isAsc = true) { + let fn; + if (data[0] instanceof Date) { + fn = isAsc ? (a, b) => a - b : (a, b) => b - a; + } else { + if (isAsc && !data.every(isNaN)) { + fn = (a, b) => a - b; + } else if (!isAsc) { + fn = (a, b) => a > b && -1 || a < b && 1 || a === b && 0; + } + } + return data.concat().sort(fn); +} +function getMinMax(type, data) { + let res = data.filter((v) => notEmpty(v)); + if (res.length) { + if (isNumber(res[0])) { + res = Math[type](...res); + } else if (res[0] instanceof Date) { + res = sortValue(res, type === "min")[0]; + } + } else { + res = void 0; + } + return res; +} +const getRange = (start, end, step = 1) => { + const res = []; + const n = Math.max(0, Math.ceil((end - start) / step)) | 0; + for (let i = start; i < n; i++) { + res.push(start + i * step); + } + return res; +}; +const emulateEvent = { + mouse: (() => { + const getParams = () => ({ + bubbles: false, + cancelable: false, + screenX: 0, + screenY: 0, + clientX: 0, + clientY: 0 + }); + try { + new MouseEvent("t"); + return (el, eventType, params = getParams()) => { + el.dispatchEvent(new MouseEvent(eventType, params)); + }; + } catch (e) { + return (el, eventType, params = getParams()) => { + const mouseEvent = browser_doc.createEvent("MouseEvent"); + mouseEvent.initMouseEvent( + eventType, + params.bubbles, + params.cancelable, + win, + 0, + // the event's mouse click count + params.screenX, + params.screenY, + params.clientX, + params.clientY, + false, + false, + false, + false, + 0, + null + ); + el.dispatchEvent(mouseEvent); + }; + } + })(), + touch: (el, eventType, params) => { + const touchObj = new Touch(mergeObj({ + identifier: Date.now(), + target: el, + radiusX: 2.5, + radiusY: 2.5, + rotationAngle: 10, + force: 0.5 + }, params)); + el.dispatchEvent(new TouchEvent(eventType, { + cancelable: true, + bubbles: true, + shiftKey: true, + touches: [touchObj], + targetTouches: [], + changedTouches: [touchObj] + })); + } +}; +function tplProcess(tpl, data) { + let res = tpl; + for (const x in data) { + res = res.replace(new RegExp(`{=${x}}`, "g"), data[x]); + } + return sanitize(res); +} +function parseDate(date) { + var _a; + let parsedDate; + if (date instanceof Date) { + parsedDate = date; + } else if (isString(date)) { + const { config, format } = this; + parsedDate = (_a = format.dataTime(config.data_xFormat)(date)) != null ? _a : new Date(date); + } else if (isNumber(date) && !isNaN(date)) { + parsedDate = /* @__PURE__ */ new Date(+date); + } + if (!parsedDate || isNaN(+parsedDate)) { + console && console.error && console.error(`Failed to parse x '${date}' to Date object`); + } + return parsedDate; +} +function hasViewBox(svg) { + const attr = svg.attr("viewBox"); + return attr ? /(\d+(\.\d+)?){3}/.test(attr) : false; +} +function hasStyle(node, condition, all = false) { + const isD3Node = !!node.node; + let has = false; + for (const [key, value] of Object.entries(condition)) { + has = isD3Node ? node.style(key) === value : node.style[key] === value; + if (all === false && has) { + break; + } + } + return has; +} +function isTabVisible() { + var _a, _b; + return ((_a = browser_doc) == null ? void 0 : _a.hidden) === false || ((_b = browser_doc) == null ? void 0 : _b.visibilityState) === "visible"; +} +function convertInputType(mouse, touch) { + const { DocumentTouch, matchMedia, navigator } = win; + const hasPointerCoarse = matchMedia == null ? void 0 : matchMedia("(pointer:coarse)").matches; + let hasTouch = false; + if (touch) { + if (navigator && "maxTouchPoints" in navigator) { + hasTouch = navigator.maxTouchPoints > 0; + } else if ("ontouchmove" in win || DocumentTouch && browser_doc instanceof DocumentTouch) { + hasTouch = true; + } else { + if (hasPointerCoarse) { + hasTouch = true; + } else { + const UA = navigator.userAgent; + hasTouch = /\b(BlackBerry|webOS|iPhone|IEMobile)\b/i.test(UA) || /\b(Android|Windows Phone|iPad|iPod)\b/i.test(UA); + } + } + } + const hasMouse = mouse && !hasPointerCoarse && (matchMedia == null ? void 0 : matchMedia("(pointer:fine)").matches); + return hasMouse && "mouse" || hasTouch && "touch" || "mouse"; +} +function runUntil(fn, conditionFn) { + if (conditionFn() === false) { + requestAnimationFrame(() => runUntil(fn, conditionFn)); + } else { + fn(); + } +} +function parseShorthand(value) { + if (isObject(value) && !isString(value)) { + const obj = value; + return { + top: obj.top || 0, + right: obj.right || 0, + bottom: obj.bottom || 0, + left: obj.left || 0 + }; + } + const values = (isString(value) ? value.trim().split(/\s+/) : [value]).map((v) => +v || 0); + const [a, b = a, c = a, d = b] = values; + return { top: a, right: b, bottom: c, left: d }; +} +function scheduleRAFUpdate(rafState, callback) { + if (rafState.pendingRaf !== null) { + win.cancelAnimationFrame(rafState.pendingRaf); + rafState.pendingRaf = win.requestAnimationFrame(() => { + rafState.pendingRaf = null; + callback(); + }); + } else { + rafState.pendingRaf = win.requestAnimationFrame(() => { + rafState.pendingRaf = null; + }); + callback(); + } +} +function toSet(items, keyFn = ((item) => item)) { + const set = /* @__PURE__ */ new Set(); + _forEachValidItem(items, (item, i) => { + set.add(keyFn(item, i)); + }); + return set; +} +function toMap(items, keyFn, valueFn = ((item) => item)) { + const map = /* @__PURE__ */ new Map(); + _forEachValidItem(items, (item, i) => { + map.set(keyFn(item, i), valueFn(item, i)); + }); + return map; +} + + +;// ./src/config/Options/Options.ts +var Options_defProp = Object.defineProperty; +var Options_getOwnPropSymbols = Object.getOwnPropertySymbols; +var Options_hasOwnProp = Object.prototype.hasOwnProperty; +var Options_propIsEnum = Object.prototype.propertyIsEnumerable; +var Options_defNormalProp = (obj, key, value) => key in obj ? Options_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var Options_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (Options_hasOwnProp.call(b, prop)) + Options_defNormalProp(a, prop, b[prop]); + if (Options_getOwnPropSymbols) + for (var prop of Options_getOwnPropSymbols(b)) { + if (Options_propIsEnum.call(b, prop)) + Options_defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __publicField = (obj, key, value) => Options_defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + + + + + + + + + +const _Options = class _Options { + static setOptions(options) { + this.data = options.reduce((a, c) => Options_spreadValues(Options_spreadValues({}, a), c), this.data); + } + constructor() { + return deepClone( + main, + boost, + data, + color, + interaction, + legend, + title, + tooltip, + _Options.data + ); + } +}; +__publicField(_Options, "data", {}); +let Options = _Options; + + +;// ./src/config/Store/Element.ts +class Element { + constructor() { + const element = { + chart: null, + main: null, + svg: null, + axis: { + // axes + x: null, + y: null, + y2: null, + subX: null + }, + axisTooltip: { + x: null, + y: null, + y2: null + }, + defs: null, + tooltip: null, + legend: null, + title: null, + subchart: { + main: null, + // $$.context + bar: null, + // $$.contextBar + line: null, + // $$.contextLine + area: null + // $$.contextArea + }, + arcs: null, + bar: null, + // mainBar, + candlestick: null, + line: null, + // mainLine, + area: null, + // mainArea, + circle: null, + // mainCircle, + radar: null, + text: null, + // mainText, + grid: { + main: null, + // grid (also focus) + x: null, + // xgrid, + y: null + // ygrid, + }, + gridLines: { + main: null, + // gridLines + x: null, + // xgridLines, + y: null + // ygridLines + }, + region: { + main: null, + // region + list: null + // mainRegion + }, + eventRect: null, + zoomResetBtn: null + // drag zoom reset button + }; + return element; + } +} + +;// ./src/config/Store/State.ts +class State { + constructor() { + return { + // chart drawn area dimension, excluding axes + width: 0, + width2: 0, + height: 0, + height2: 0, + margin: { + top: 0, + bottom: 0, + left: 0, + right: 0 + }, + margin2: { + top: 0, + bottom: 0, + left: 0, + right: 0 + }, + margin3: { + top: 0, + bottom: 0, + left: 0, + right: 0 + }, + arcWidth: 0, + arcHeight: 0, + xAxisHeight: 0, + hasAxis: false, + hasFunnel: false, + hasRadar: false, + hasTreemap: false, + // for data CSS rule index (used when boost.useCssRule is true) + cssRule: {}, + // Data loading state (used in scale calculation) + loading: void 0, + // Zoom/subchart domain (different from current.domain which is for rendering) + domain: void 0, + current: { + // current domain value. Assigned when is zoom is called + domain: void 0, + // chart whole dimension + width: 0, + height: 0, + dataMax: 0, + maxTickSize: { + x: { + width: 0, + height: 0, + ticks: [], + clipPath: 0, + domain: "" + }, + y: { width: 0, height: 0, domain: "" }, + y2: { width: 0, height: 0, domain: "" } + }, + // current used chart type list + types: [], + needle: void 0, + // arc needle current value + zoomDomain: null + // zoomed domain value + }, + // legend + isLegendRight: false, + isLegendInset: false, + isLegendTop: false, + isLegendLeft: false, + legendStep: 0, + legendItemWidth: 0, + legendItemHeight: 0, + legendHasRendered: false, + eventReceiver: { + currentIdx: -1, + // current event interaction index + rect: {}, + // event rect's clientBoundingRect + data: [], + // event data bound of previoous eventRect + coords: [] + // coordination value of previous eventRect + }, + axis: { + x: { + padding: { left: 0, right: 0 }, + tickCount: 0 + } + }, + rotatedPadding: { + left: 30, + right: 0, + top: 5 + }, + withoutFadeIn: {}, + inputType: "", + datetimeId: "", + // clip id string + clip: { + id: "", + idXAxis: "", + idYAxis: "", + idXAxisTickTexts: "", + idGrid: "", + idSubchart: "", + // clipIdForSubchart + path: "", + pathXAxis: "", + pathYAxis: "", + pathXAxisTickTexts: "", + pathGrid: "" + }, + // state + event: null, + // event object + dragStart: null, + dragging: false, + flowing: false, + cancelClick: false, + mouseover: false, + rendered: false, + transiting: false, + redrawing: false, + // if redraw() is on process + resizing: false, + // resize event called + toggling: false, + // legend toggle + zooming: false, + hasNegativeValue: false, + hasPositiveValue: true, + orgAreaOpacity: "0.2", + orgConfig: {}, + // user original genration config + // ID strings + hiddenTargetIds: [], + hiddenLegendIds: [], + focusedTargetIds: [], + defocusedTargetIds: [], + // value for Arc + radius: 0, + innerRadius: 0, + outerRadius: void 0, + innerRadiusRatio: 0, + gaugeArcWidth: 0, + radiusExpanded: 0, + // xgrid attribute + xgridAttr: { + x1: null, + x2: null, + y1: null, + y2: null + }, + // RAF batching for zoom/drag interactions + pendingRaf: null, + rafBatchQueue: [] + }; + } +} + +;// ./src/config/Store/Store.ts + + +const Store_classes = { + element: Element, + state: State +}; +class Store { + constructor() { + Object.keys(Store_classes).forEach((v) => { + this[v] = new Store_classes[v](); + }); + } + getStore(name) { + return this[name]; + } +} + +;// ./src/module/Cache.ts +var Cache_defProp = Object.defineProperty; +var Cache_defNormalProp = (obj, key, value) => key in obj ? Cache_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var Cache_publicField = (obj, key, value) => Cache_defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + +const KEY = { + bubbleBaseLength: "$baseLength", + colorPattern: "__colorPattern__", + dataMinMax: "$dataMinMax", + dataTotalSum: "$dataTotalSum", + dataTotalPerIndex: "$totalPerIndex", + domainMinMax: "$domainMinMax", + filteredTargets: "$filteredTargets", + filteredNullish: "$filteredNullish", + visibilityChecksum: "visibilityChecksum", + legendItemTextBox: "legendItemTextBox", + legendItemMap: "$legendItemMap", + radarPoints: "$radarPoints", + radarTextWidth: "$radarTextWidth", + setOverOut: "setOverOut", + callOverOutForTouch: "callOverOutForTouch", + textRect: "textRect", + shapeOffset: "$shapeOffset" +}; +class Cache { + constructor() { + Cache_publicField(this, "cache", {}); + } + /** + * Add cache + * @param {string} key Cache key + * @param {string|number|boolean|object|Array|function|null|undefined} value Value to be stored + * @param {boolean} isDataType Weather the cache is data typed '{id:'data', id_org: 'data', values: [{x:0, index:0,...}, ...]}' + * @returns {string|number|boolean|object|Array|function|null|undefined} Added data value + * @private + */ + add(key, value, isDataType = false) { + this.cache[key] = isDataType ? this.cloneTarget(value) : value; + return this.cache[key]; + } + /** + * Remove cache + * @param {string|Array} key Cache key + * @private + */ + remove(key) { + (isString(key) ? [key] : key).forEach((v) => delete this.cache[v]); + } + /** + * Get cahce + * @param {string|Array} key Cache key + * @param {boolean} isDataType Weather the cache is data typed '{id:'data', id_org: 'data', values: [{x:0, index:0,...}, ...]}' + * @returns {string|number|boolean|object|Array|function|null} Cached value + * @private + */ + get(key, isDataType = false) { + if (isDataType && Array.isArray(key)) { + const targets = []; + for (let i = 0, id; id = key[i]; i++) { + if (id in this.cache) { + targets.push(this.cloneTarget(this.cache[id])); + } + } + return targets; + } else { + const value = this.cache[key]; + return isValue(value) ? value : null; + } + } + /** + * Check if cache key exists + * @param {string} key Cache key + * @returns {boolean} True if key exists in cache + * @private + */ + has(key) { + return key in this.cache && this.cache[key] !== null; + } + /** + * Get all cache keys + * @returns {string[]} Array of cache keys + * @private + */ + getKeys() { + return Object.keys(this.cache); + } + /** + * Reset cached data + * @param {boolean} all true: reset all data, false: reset only '$' prefixed key data + * @private + */ + reset(all) { + const $$ = this; + for (const x in $$.cache) { + if (all || /^\$/.test(x)) { + $$.cache[x] = null; + } + } + } + /** + * Clone data target object + * @param {object} target Data object + * @returns {object} + * @private + */ + cloneTarget(target) { + return { + id: target.id, + id_org: target.id_org, + values: target.values.map((d) => ({ x: d.x, value: d.value, id: d.id })) + }; + } +} + +;// ./src/config/const.ts +const TYPE = { + AREA: "area", + AREA_LINE_RANGE: "area-line-range", + AREA_SPLINE: "area-spline", + AREA_SPLINE_RANGE: "area-spline-range", + AREA_STEP: "area-step", + AREA_STEP_RANGE: "area-step-range", + BAR: "bar", + BUBBLE: "bubble", + CANDLESTICK: "candlestick", + DONUT: "donut", + FUNNEL: "funnel", + GAUGE: "gauge", + LINE: "line", + PIE: "pie", + POLAR: "polar", + RADAR: "radar", + SCATTER: "scatter", + SPLINE: "spline", + STEP: "step", + TREEMAP: "treemap" +}; +const TYPE_METHOD_NEEDED = { + AREA: "initArea", + AREA_LINE_RANGE: "initArea", + AREA_SPLINE: "initArea", + AREA_SPLINE_RANGE: "initArea", + AREA_STEP: "initArea", + AREA_STEP_RANGE: "initArea", + BAR: "initBar", + BUBBLE: "initCircle", + CANDLESTICK: "initCandlestick", + DONUT: "initArc", + FUNNEL: "initFunnel", + GAUGE: "initArc", + LINE: "initLine", + PIE: "initArc", + POLAR: "initPolar", + RADAR: "initCircle", + SCATTER: "initCircle", + SPLINE: "initLine", + STEP: "initLine", + TREEMAP: "initTreemap" +}; +const TYPE_BY_CATEGORY = { + Area: [ + TYPE.AREA, + TYPE.AREA_SPLINE, + TYPE.AREA_SPLINE_RANGE, + TYPE.AREA_LINE_RANGE, + TYPE.AREA_STEP, + TYPE.AREA_STEP_RANGE + ], + AreaRange: [ + TYPE.AREA_SPLINE_RANGE, + TYPE.AREA_LINE_RANGE, + TYPE.AREA_STEP_RANGE + ], + Arc: [ + TYPE.PIE, + TYPE.DONUT, + TYPE.GAUGE, + TYPE.POLAR, + TYPE.RADAR + ], + Line: [ + TYPE.LINE, + TYPE.SPLINE, + TYPE.AREA, + TYPE.AREA_SPLINE, + TYPE.AREA_SPLINE_RANGE, + TYPE.AREA_LINE_RANGE, + TYPE.STEP, + TYPE.AREA_STEP, + TYPE.AREA_STEP_RANGE + ], + Step: [ + TYPE.STEP, + TYPE.AREA_STEP, + TYPE.AREA_STEP_RANGE + ], + Spline: [ + TYPE.SPLINE, + TYPE.AREA_SPLINE, + TYPE.AREA_SPLINE_RANGE + ] +}; + +;// ./src/module/error.ts + + + + +function checkModuleImport(ctx) { + const $$ = ctx; + const { config } = $$; + let type = ""; + if (isEmpty(config.data_type || config.data_types) && !$$[TYPE_METHOD_NEEDED.LINE]) { + type = "line"; + } else { + for (const x in TYPE_METHOD_NEEDED) { + const t = TYPE[x]; + if ($$.hasType(t) && !$$[TYPE_METHOD_NEEDED[x]]) { + type = t; + break; + } + } + } + type && logError( + `Please, make sure if %c${camelize(type)}`, + "module has been imported and specified correctly.", + "https://github.com/naver/billboard.js/wiki/CHANGELOG-v2#modularization-by-its-functionality" + ); +} +function logError(head, tail, info) { + var _a; + const prefix = "[billboard.js]"; + const hasConsole = (_a = win.console) == null ? void 0 : _a.error; + if (hasConsole) { + const tailMsg = tail ? ["background:red;color:white;display:block;font-size:15px", tail] : []; + console.error( + `\u274C ${prefix} ${head}`, + "background:red;color:white;display:block;font-size:15px", + ...tailMsg + ); + info && console.info("%c\u2139\uFE0F", "font-size:15px", info); + } + throw Error(`${prefix} ${head.replace(/\%c([a-z-]+)/i, "'$1' ")} ${tail != null ? tail : ""}`); +} + +;// ./src/module/generator.ts + + +const { setTimeout: generator_setTimeout, clearTimeout: generator_clearTimeout } = win; +function generateResize(option) { + const fn = []; + let timeout; + const callResizeFn = function() { + callResizeFn.clear(); + if (option === false) { + requestIdleCallback(() => { + fn.forEach((f) => f()); + }, { timeout: 200 }); + } else { + timeout = generator_setTimeout(() => { + fn.forEach((f) => f()); + }, isNumber(option) ? option : 200); + } + }; + callResizeFn.clear = () => { + if (timeout) { + generator_clearTimeout(timeout); + timeout = null; + } + }; + callResizeFn.add = (f) => fn.push(f); + callResizeFn.remove = (f) => fn.splice(fn.indexOf(f), 1); + return callResizeFn; +} +function generateWait() { + let transitionsToWait = []; + const f = function(selection, callback) { + function loop() { + var _a; + let done = 0; + for (let i = 0, t; t = transitionsToWait[i]; i++) { + if (t === true || ((_a = t.empty) == null ? void 0 : _a.call(t))) { + done++; + continue; + } + if (isTabVisible() === false) { + done = transitionsToWait.length; + break; + } + try { + t.transition(); + } catch (e) { + done++; + } + } + return done === transitionsToWait.length; + } + runUntil(() => { + callback == null ? void 0 : callback(); + }, loop); + }; + f.add = function(t) { + isArray(t) ? transitionsToWait = transitionsToWait.concat(t) : transitionsToWait.push(t); + }; + return f; +} + +;// ./src/module/worker.ts + +const blob = {}; +function getObjectURL(fn, depsFn) { + var _a; + const fnString = fn.toString(); + const key = fnString.replace(/(function|[\s\W\n])/g, "").substring(0, 15); + if (!(key in blob)) { + blob[key] = new win.Blob([ + `${(_a = depsFn == null ? void 0 : depsFn.map(String).join(";")) != null ? _a : ""} + + self.onmessage=function({data}) { + const result = (${fnString}).apply(null, data); + self.postMessage(result); + };` + ], { + type: "text/javascript" + }); + } + return win.URL.createObjectURL(blob[key]); +} +function getWorker(src) { + const worker = new win.Worker(src); + worker.onerror = function(e) { + console.error ? console.error(e) : console.log(e); + }; + return worker; +} +function runWorker(useWorker = true, fn, callback, depsFn) { + let runFn = function(...args) { + const res = fn(...args); + callback(res); + }; + if (win.Worker && useWorker) { + const src = getObjectURL(fn, depsFn); + const worker = getWorker(src); + runFn = function(...args) { + worker.postMessage(args); + worker.onmessage = function(e) { + win.URL.revokeObjectURL(src); + return callback(e.data); + }; + }; + } + return runFn; +} + +// EXTERNAL MODULE: external {"commonjs":"d3-dsv","commonjs2":"d3-dsv","amd":"d3-dsv","root":"d3"} +var external_commonjs_d3_dsv_commonjs2_d3_dsv_amd_d3_dsv_root_d3_ = __webpack_require__(5); +;// ./src/ChartInternal/data/convert.helper.ts + + +function columns(columns2) { + const newRows = []; + columns2.forEach(function(col, i) { + const key = col[0]; + col.forEach(function(v, j) { + if (j > 0) { + if (typeof newRows[j - 1] === "undefined") { + newRows[j - 1] = {}; + } + if (typeof v === "undefined") { + throw new Error(`Source data is missing a component at (${i}, ${j})!`); + } + newRows[j - 1][key] = v; + } + }); + }); + return newRows; +} +function rows(rows2) { + const keys = rows2[0]; + const newRows = []; + rows2.forEach(function(row, i) { + if (i > 0) { + const newRow = {}; + row.forEach(function(v, j) { + if (typeof v === "undefined") { + throw new Error(`Source data is missing a component at (${i}, ${j})!`); + } + newRow[keys[j]] = v; + }); + newRows.push(newRow); + } + }); + return newRows; +} +function json(json2, keysParam) { + const newRows = []; + let targetKeys; + let data; + if (Array.isArray(json2)) { + const findValueInJson = function(object, path) { + if (object[path] !== void 0) { + return object[path]; + } + const convertedPath = path.replace(/\[(\w+)\]/g, ".$1"); + const pathArray = convertedPath.replace(/^\./, "").split("."); + let target = object; + pathArray.some(function(k) { + return !(target = target && k in target ? target[k] : void 0); + }); + return target; + }; + if (keysParam.x) { + targetKeys = keysParam.value.concat(keysParam.x); + } else { + targetKeys = keysParam.value; + } + newRows.push(targetKeys); + json2.forEach(function(o) { + const newRow = targetKeys.map(function(key) { + let v = findValueInJson(o, key); + if (typeof v === "undefined") { + v = null; + } + return v; + }); + newRows.push(newRow); + }); + data = rows(newRows); + } else { + Object.keys(json2).forEach(function(key) { + var _a; + const tmp = json2[key].concat(); + (_a = tmp.unshift) == null ? void 0 : _a.call(tmp, key); + newRows.push(tmp); + }); + data = columns(newRows); + } + return data; +} +function url(url2, mimeType = "csv", headers, keys, done) { + const req = new XMLHttpRequest(); + const converter = { csv, tsv, json }; + req.open("GET", url2); + if (headers) { + Object.keys(headers).forEach(function(key) { + req.setRequestHeader(key, headers[key]); + }); + } + req.onreadystatechange = function() { + if (req.readyState === 4) { + if (req.status === 200) { + const response = req.responseText; + response && done.call(this, converter[mimeType]( + mimeType === "json" ? JSON.parse(response) : response, + keys + )); + } else { + throw new Error(`${url2}: Something went wrong loading!`); + } + } + }; + req.send(); +} +function convertCsvTsvToData(parser, xsv) { + const rows2 = parser.rows(xsv); + let d; + if (rows2.length === 1) { + d = [{}]; + rows2[0].forEach((id) => { + d[0][id] = null; + }); + } else { + d = parser.parse(xsv); + } + return d; +} +function csv(xsv) { + return convertCsvTsvToData({ + rows: external_commonjs_d3_dsv_commonjs2_d3_dsv_amd_d3_dsv_root_d3_.csvParseRows, + parse: external_commonjs_d3_dsv_commonjs2_d3_dsv_amd_d3_dsv_root_d3_.csvParse + }, xsv); +} +function tsv(tsv2) { + return convertCsvTsvToData({ + rows: external_commonjs_d3_dsv_commonjs2_d3_dsv_amd_d3_dsv_root_d3_.tsvParseRows, + parse: external_commonjs_d3_dsv_commonjs2_d3_dsv_amd_d3_dsv_root_d3_.tsvParse + }, tsv2); +} + +;// ./src/ChartInternal/data/convert.ts + + + +function _getDataKeyForJson(keysParam, config) { + const keys = keysParam || (config == null ? void 0 : config.data_keys); + if (keys == null ? void 0 : keys.x) { + config.data_x = keys.x; + } + return keys; +} +function _setXS(ids, data, params) { + const $$ = this; + const { config } = $$; + let xsData; + ids.forEach((id) => { + const xKey = $$.getXKey(id); + if (params.customX || params.timeSeries) { + if (params.xs.indexOf(xKey) >= 0) { + xsData = (params.appendXs && $$.data.xs[id] || []).concat( + data.map((d, i) => { + const rawX = isValue(d[xKey]); + return rawX ? $$.generateTargetX(rawX, id, i) : false; + }).filter((v) => v !== false) + ); + } else if (config.data_x) { + xsData = this.getOtherTargetXs(); + } else if (notEmpty(config.data_xs)) { + xsData = $$.getXValuesOfXKey(xKey, $$.data.targets); + } + } else { + xsData = data.map((d, i) => i); + } + if (xsData) { + $$.data.xs[id] = xsData; + } else { + throw new Error(`x is not defined for id = "${id}".`); + } + }); +} +/* harmony default export */ var convert = ({ + /** + * Convert data according its type + * @param {object} args data object + * @param {function} [callback] callback for url(XHR) type loading + * @private + */ + convertData(args, callback) { + const { config } = this; + const useWorker = (d) => (d == null ? void 0 : d.length) && !isEmpty(d[0]) ? config.boost_useWorker : false; + let data = args; + if (args.bindto) { + data = {}; + ["url", "mimeType", "headers", "keys", "json", "keys", "rows", "columns"].forEach((v) => { + const key = `data_${v}`; + if (key in args) { + data[v] = args[key]; + } + }); + } + if (data.url && callback) { + url( + data.url, + data.mimeType, + data.headers, + _getDataKeyForJson(data.keys, config), + callback + ); + } else if (data.json) { + runWorker(useWorker(data.json), json, callback, [columns, rows])( + data.json, + _getDataKeyForJson(data.keys, config) + ); + } else if (data.rows) { + runWorker(useWorker(data.rows), rows, callback)(data.rows); + } else if (data.columns) { + runWorker(useWorker(data.columns), columns, callback)(data.columns); + } else if (args.bindto) { + throw Error("url or json or rows or columns is required."); + } + }, + /** + * Convert data to targets + * @param {object[]} data Data to convert + * @param {boolean} appendXs Whether to append xs + * @returns {IData[]} Converted targets + * @private + */ + convertDataToTargets(data, appendXs) { + const $$ = this; + const { axis, config, state } = $$; + const chartType = config.data_type; + const dataKeys = Object.keys(data[0] || {}); + const { ids, xs } = dataKeys.length ? dataKeys.reduce((acc, key) => { + if ($$.isX.call($$, key)) { + acc.xs.push(key); + } else if ($$.isNotX.call($$, key)) { + acc.ids.push(key); + } + return acc; + }, { ids: [], xs: [] }) : { ids: [], xs: [] }; + const params = { + appendXs, + xs, + idConverter: config.data_idConverter.bind($$.api), + categorized: axis == null ? void 0 : axis.isCategorized(), + timeSeries: axis == null ? void 0 : axis.isTimeSeries(), + customX: axis == null ? void 0 : axis.isCustomX() + }; + _setXS.bind($$)(ids, data, params); + const targets = ids.map((id, index) => { + const convertedId = config.data_idConverter.bind($$.api)(id); + const xKey = $$.getXKey(id); + const isCategory = params.customX && params.categorized; + const hasCategory = isCategory && (() => { + const categorySet = toSet(config.axis_x_categories); + return data.every((v) => categorySet.has(v.x)); + })(); + const isDataAppend = data.__append__; + const xIndex = xKey === null && isDataAppend ? $$.api.data.values(id).length : 0; + return { + id: convertedId, + id_org: id, + values: data.map((d, i) => { + const rawX = d[xKey]; + let value = d[id]; + let x; + value = value !== null && !isNaN(value) && !isObject(value) ? +value : isArray(value) || isObject(value) ? value : null; + if ((isCategory || state.hasRadar) && index === 0 && !isUndefined(rawX)) { + if (!hasCategory && index === 0 && i === 0 && !isDataAppend) { + config.axis_x_categories = []; + } + x = config.axis_x_categories.indexOf(rawX); + if (x === -1) { + x = config.axis_x_categories.length; + config.axis_x_categories.push(rawX); + } + } else { + x = $$.generateTargetX(rawX, id, xIndex + i); + } + if (isUndefined(value) || $$.data.xs[id].length <= i) { + x = void 0; + } + return { + x, + value, + id: convertedId, + index: -1 + }; + }).filter((v) => isDefined(v.x)) + }; + }); + targets.forEach((t) => { + var _a; + if (config.data_xSort) { + t.values = t.values.sort((v1, v2) => { + const x1 = v1.x || v1.x === 0 ? v1.x : Infinity; + const x2 = v2.x || v2.x === 0 ? v2.x : Infinity; + return x1 - x2; + }); + } + t.values.forEach((v, i) => v.index = i); + (_a = $$.data.xs[t.id]) == null ? void 0 : _a.sort((v1, v2) => v1 - v2); + }); + state.hasNegativeValue = $$.hasNegativeValueInTargets(targets); + state.hasPositiveValue = $$.hasPositiveValueInTargets(targets); + if (chartType && $$.isValidChartType(chartType)) { + const targetIds = $$.mapToIds(targets).filter( + (id) => !(id in config.data_types) || !$$.isValidChartType(config.data_types[id]) + ); + $$.setTargetType(targetIds, chartType); + } + targets.forEach((d) => $$.cache.add(d.id_org, d, true)); + return targets; + } +}); + +;// ./src/ChartInternal/data/data.ts + + + + +/* harmony default export */ var data_data = ({ + isX(key) { + const $$ = this; + const { config } = $$; + const dataKey = config.data_x && key === config.data_x; + const existValue = notEmpty(config.data_xs) && hasValue(config.data_xs, key); + return dataKey || existValue; + }, + isNotX(key) { + return !this.isX(key); + }, + isStackNormalized() { + const { config } = this; + return !!((config.data_stack_normalize === true || isObjectType(config.data_stack_normalize)) && config.data_groups.length); + }, + /** + * Check if stack normalization should be applied per group + * @returns {boolean} + * @private + */ + isStackNormalizedPerGroup() { + var _a; + const { config } = this; + return !!(isObjectType(config.data_stack_normalize) && ((_a = config.data_stack_normalize) == null ? void 0 : _a.perGroup) && config.data_groups.length); + }, + /** + * Check if given id is grouped data or has grouped data + * @param {string} id Data id value + * @returns {boolean} is grouped data or has grouped data + * @private + */ + isGrouped(id) { + const groups = this.config.data_groups; + return id ? groups.some((v) => v.indexOf(id) >= 0 && v.length > 1) : groups.length > 0; + }, + /** + * Check if the given axis has any grouped data + * @param {string} axisId Axis ID (e.g., "y", "y2") + * @returns {boolean} true if axis has grouped data + * @private + */ + hasAxisGroupedData(axisId) { + const $$ = this; + const { axis } = $$; + const targets = $$.data.targets; + const axisDataIds = targets.filter((t) => axis.getId(t.id) === axisId).map((t) => t.id); + return axisDataIds.some((id) => $$.isGrouped(id)); + }, + getXKey(id) { + const $$ = this; + const { config } = $$; + return config.data_x ? config.data_x : notEmpty(config.data_xs) ? config.data_xs[id] : null; + }, + getXValuesOfXKey(key, targets) { + const $$ = this; + const ids = targets && notEmpty(targets) ? $$.mapToIds(targets) : []; + let xValues; + ids.forEach((id) => { + if ($$.getXKey(id) === key) { + xValues = $$.data.xs[id]; + } + }); + return xValues; + }, + /** + * Get index number based on given x Axis value + * @param {Date|number|string} x x Axis to be compared + * @param {Array} basedX x Axis list to be based on + * @returns {number} index number + * @private + */ + getIndexByX(x, basedX) { + const $$ = this; + return basedX ? basedX.indexOf(isString(x) ? x : +x) : ($$.filterByX($$.data.targets, x)[0] || { index: null }).index; + }, + getXValue(id, i) { + const $$ = this; + return id in $$.data.xs && $$.data.xs[id] && isValue($$.data.xs[id][i]) ? $$.data.xs[id][i] : i; + }, + getOtherTargetXs() { + const $$ = this; + const idsForX = Object.keys($$.data.xs); + return idsForX.length ? $$.data.xs[idsForX[0]] : null; + }, + getOtherTargetX(index) { + const xs = this.getOtherTargetXs(); + return xs && index < xs.length ? xs[index] : null; + }, + addXs(xs) { + const $$ = this; + const { config } = $$; + Object.keys(xs).forEach((id) => { + config.data_xs[id] = xs[id]; + }); + }, + /** + * Determine if x axis is multiple + * @returns {boolean} true: multiple, false: single + * @private + */ + isMultipleX() { + return !this.config.axis_x_forceAsSingle && (notEmpty(this.config.data_xs) || this.hasType("bubble") || this.hasType("scatter")); + }, + addName(data) { + const $$ = this; + const { config } = $$; + let name; + if (data) { + name = config.data_names[data.id]; + data.name = name !== void 0 ? name : data.id; + } + return data; + }, + /** + * Get all values on given index + * @param {number} index Index + * @param {boolean} filterNull Filter nullish value + * @returns {Array} + * @private + */ + getAllValuesOnIndex(index, filterNull = false) { + const $$ = this; + let value = $$.filterTargetsToShow($$.data.targets).map((t) => $$.addName($$.getValueOnIndex(t.values, index))); + if (filterNull) { + value = value.filter((v) => v && "value" in v && isValue(v.value)); + } + return value; + }, + getValueOnIndex(values, index) { + const valueOnIndex = values.filter((v) => v.index === index); + return valueOnIndex.length ? valueOnIndex[0] : null; + }, + updateTargetX(targets, x) { + const $$ = this; + targets.forEach((t) => { + t.values.forEach((v, i) => { + v.x = $$.generateTargetX(x[i], t.id, i); + }); + $$.data.xs[t.id] = x; + }); + }, + updateTargetXs(targets, xs) { + const $$ = this; + targets.forEach((t) => { + xs[t.id] && $$.updateTargetX([t], xs[t.id]); + }); + }, + generateTargetX(rawX, id, index) { + const $$ = this; + const { axis } = $$; + let x = (axis == null ? void 0 : axis.isCategorized()) ? index : rawX || index; + if (axis == null ? void 0 : axis.isTimeSeries()) { + const fn = parseDate.bind($$); + x = rawX ? fn(rawX) : fn($$.getXValue(id, index)); + } else if ((axis == null ? void 0 : axis.isCustomX()) && !(axis == null ? void 0 : axis.isCategorized())) { + x = isValue(rawX) ? +rawX : $$.getXValue(id, index); + } + return x; + }, + updateXs(values) { + if (values.length) { + this.axis.xs = values.map((v) => v.x); + } + }, + getPrevX(i) { + const x = this.axis.xs[i - 1]; + return isDefined(x) ? x : null; + }, + getNextX(i) { + const x = this.axis.xs[i + 1]; + return isDefined(x) ? x : null; + }, + /** + * Get base value isAreaRangeType + * @param {object} data Data object + * @returns {number} + * @private + */ + getBaseValue(data) { + const $$ = this; + const { hasAxis } = $$.state; + let { value } = data; + if (value && hasAxis) { + if ($$.isAreaRangeType(data)) { + value = $$.getRangedData(data, "mid"); + } else if ($$.isBubbleZType(data)) { + value = $$.getBubbleZData(value, "y"); + } + } + return value; + }, + /** + * Get min/max value from the data + * @private + * @param {Array} data array data to be evaluated + * @returns {{min: {number}, max: {number}}} + */ + getMinMaxValue(data) { + const getBaseValue = this.getBaseValue.bind(this); + let min; + let max; + (data || this.data.targets.map((t) => t.values)).forEach((v, i) => { + const value = v.map(getBaseValue).filter(isNumber); + min = Math.min(i ? min : Infinity, ...value); + max = Math.max(i ? max : -Infinity, ...value); + }); + return { min, max }; + }, + /** + * Get the min/max data + * @private + * @returns {{min: Array, max: Array}} + */ + getMinMaxData() { + const $$ = this; + const cacheKey = KEY.dataMinMax; + let minMaxData = $$.cache.get(cacheKey); + if (!minMaxData) { + const data = $$.data.targets.map((t) => t.values); + const minMax = $$.getMinMaxValue(data); + let min = []; + let max = []; + const { min: minVal, max: maxVal } = minMax; + data.forEach((v) => { + const minData = $$.getFilteredDataByValue(v, minVal); + const maxData = $$.getFilteredDataByValue(v, maxVal); + if (minData.length) { + min = min.concat(minData); + } + if (maxData.length) { + max = max.concat(maxData); + } + }); + $$.cache.add(cacheKey, minMaxData = { min, max }); + } + return minMaxData; + }, + /** + * Get sum of data per index + * @param {string} targetId Target ID to get total for (only for normalized stack per group) + * @private + * @returns {Array} + */ + getTotalPerIndex(targetId) { + const $$ = this; + const { config } = $$; + const cacheKey = targetId ? `${KEY.dataTotalPerIndex}-${targetId}` : KEY.dataTotalPerIndex; + let sum = $$.cache.get(cacheKey); + if (($$.config.data_groups.length || $$.isStackNormalized()) && !sum) { + sum = []; + let { targets } = $$.data; + if ($$.isStackNormalizedPerGroup() && targetId) { + const group = config.data_groups.find((g) => g.indexOf(targetId) >= 0); + if (group) { + targets = targets.filter((t) => group.indexOf(t.id) >= 0); + } else { + return null; + } + } + targets.forEach((row) => { + row.values.forEach((v, i) => { + if (!sum[i]) { + sum[i] = 0; + } + sum[i] += ~~v.value; + }); + }); + $$.cache.add(cacheKey, sum); + } + return sum; + }, + /** + * Get total data sum + * @param {boolean} subtractHidden Subtract hidden data from total + * @returns {number} + * @private + */ + getTotalDataSum(subtractHidden) { + const $$ = this; + const cacheKey = KEY.dataTotalSum; + let total = $$.cache.get(cacheKey); + if (!isNumber(total)) { + total = $$.data.targets.reduce((acc, t) => { + return acc + t.values.reduce((sum, v) => { + var _a; + return sum + ((_a = v.value) != null ? _a : 0); + }, 0); + }, 0); + $$.cache.add(cacheKey, total); + } + if (subtractHidden) { + total -= $$.getHiddenTotalDataSum(); + } + return total; + }, + /** + * Get total hidden data sum + * @returns {number} + * @private + */ + getHiddenTotalDataSum() { + const $$ = this; + const { api, state: { hiddenTargetIds } } = $$; + let total = 0; + if (hiddenTargetIds.length) { + total = api.data.values.bind(api)(hiddenTargetIds).reduce((p, c) => p + c); + } + return total; + }, + /** + * Get filtered data by value + * @param {object} data Data + * @param {number} value Value to be filtered + * @returns {Array} filtered array data + * @private + */ + getFilteredDataByValue(data, value) { + return data.filter((t) => this.getBaseValue(t) === value); + }, + /** + * Return the max length of the data + * @returns {number} max data length + * @private + */ + getMaxDataCount() { + return Math.max(...this.data.targets.map((t) => t.values.length), 0); + }, + getMaxDataCountTarget() { + let target = this.filterTargetsToShow() || []; + const length = target.length; + const isInverted = this.config.axis_x_inverted; + if (length > 1) { + target = target.map((t) => t.values).reduce((a, b) => a.concat(b)).map((v) => v.x); + target = sortValue(getUnique(target)).map((x, index, array) => ({ + x, + index: isInverted ? array.length - index - 1 : index + })); + } else if (length) { + target = target[0].values.concat(); + } + return target; + }, + mapToIds(targets) { + return targets.map((d) => d.id); + }, + mapToTargetIds(ids) { + const $$ = this; + return ids ? isArray(ids) ? ids.concat() : [ids] : $$.mapToIds($$.data.targets); + }, + hasTarget(targets, id) { + const ids = this.mapToIds(targets); + for (let i = 0, val; val = ids[i]; i++) { + if (val === id) { + return true; + } + } + return false; + }, + isTargetToShow(targetId) { + return this.state.hiddenTargetIds.indexOf(targetId) < 0; + }, + isLegendToShow(targetId) { + return this.state.hiddenLegendIds.indexOf(targetId) < 0; + }, + filterTargetsToShow(targets) { + const $$ = this; + if (!targets) { + const { cache, data, state } = $$; + const cacheKey = KEY.filteredTargets; + const visibilityChecksum = state.hiddenTargetIds.join(","); + const storedChecksum = cache.get(KEY.visibilityChecksum); + if (visibilityChecksum !== storedChecksum) { + cache.remove(cacheKey); + cache.add(KEY.visibilityChecksum, visibilityChecksum); + } + if (cache.has(cacheKey)) { + return cache.get(cacheKey); + } + const filtered = data.targets.filter((t) => $$.isTargetToShow(t.id)); + cache.add(cacheKey, filtered); + return filtered; + } + return targets.filter((t) => $$.isTargetToShow(t.id)); + }, + mapTargetsToUniqueXs(targets) { + const $$ = this; + const { axis } = $$; + let xs = []; + if (targets == null ? void 0 : targets.length) { + xs = getUnique( + mergeArray(targets.map((t) => t.values.map((v) => +v.x))) + ); + xs = (axis == null ? void 0 : axis.isTimeSeries()) ? xs.map((x) => /* @__PURE__ */ new Date(+x)) : xs.map(Number); + } + return sortValue(xs); + }, + /** + * Add to thetarget Ids + * @param {string} type State's prop name + * @param {Array|string} targetIds Target ids array + * @private + */ + addTargetIds(type, targetIds) { + const { state } = this; + const ids = isArray(targetIds) ? targetIds : [targetIds]; + ids.forEach((v) => { + state[type].indexOf(v) < 0 && state[type].push(v); + }); + }, + /** + * Remove from the state target Ids + * @param {string} type State's prop name + * @param {Array|string} targetIds Target ids array + * @private + */ + removeTargetIds(type, targetIds) { + const { state } = this; + const ids = isArray(targetIds) ? targetIds : [targetIds]; + ids.forEach((v) => { + const index = state[type].indexOf(v); + index >= 0 && state[type].splice(index, 1); + }); + }, + addHiddenTargetIds(targetIds) { + this.addTargetIds("hiddenTargetIds", targetIds); + }, + removeHiddenTargetIds(targetIds) { + this.removeTargetIds("hiddenTargetIds", targetIds); + }, + addHiddenLegendIds(targetIds) { + this.addTargetIds("hiddenLegendIds", targetIds); + }, + removeHiddenLegendIds(targetIds) { + this.removeTargetIds("hiddenLegendIds", targetIds); + }, + getValuesAsIdKeyed(targets) { + const $$ = this; + const { hasAxis } = $$.state; + const ys = {}; + const isMultipleX = $$.isMultipleX(); + const xs = isMultipleX ? $$.mapTargetsToUniqueXs(targets).map((v) => isString(v) ? v : +v) : null; + const xIndexMap = xs ? new Map(xs.map((x, i) => [x, i])) : null; + targets.forEach((t) => { + const data = []; + t.values.filter(({ value }) => isValue(value) || value === null).forEach((v) => { + let { value } = v; + if (value !== null && $$.isCandlestickType(v)) { + value = isArray(value) ? value.slice(0, 4) : [value.open, value.high, value.low, value.close]; + } + if (isArray(value)) { + data.push(...value); + } else if (isObject(value) && "high" in value) { + data.push(...Object.values(value)); + } else if ($$.isBubbleZType(v)) { + data.push(hasAxis && $$.getBubbleZData(value, "y")); + } else { + if (isMultipleX && xIndexMap) { + const xKey = isString(v.x) ? v.x : +v.x; + const index = xIndexMap.get(xKey); + if (index !== void 0) { + data[index] = value; + } + } else { + data.push(value); + } + } + }); + ys[t.id] = data; + }); + return ys; + }, + checkValueInTargets(targets, checker) { + return Object.keys(targets).some((id) => targets[id].values.some((v) => checker(v.value))); + }, + hasMultiTargets() { + return this.filterTargetsToShow().length > 1; + }, + hasNegativeValueInTargets(targets) { + return this.checkValueInTargets(targets, (v) => v < 0); + }, + hasPositiveValueInTargets(targets) { + return this.checkValueInTargets(targets, (v) => v > 0); + }, + /** + * Sort targets data + * Note: For stacked bar, will sort from the total sum of data series, not for each stacked bar + * @param {Array} targetsValue Target value + * @returns {Array} + * @private + */ + orderTargets(targetsValue) { + const $$ = this; + const targets = [...targetsValue]; + const fn = $$.getSortCompareFn(); + fn && targets.sort(fn); + return targets; + }, + /** + * Get data.order compare function + * @param {boolean} isReversed for Arc & Treemap type sort order needs to be reversed + * @returns {function} compare function + * @private + */ + getSortCompareFn(isReversed = false) { + const $$ = this; + const { config } = $$; + const order = config.data_order; + const orderAsc = /asc/i.test(order); + const orderDesc = /desc/i.test(order); + let fn; + if (orderAsc || orderDesc) { + const reducer = (p, c) => p + Math.abs(c.value); + const sum = (v) => isNumber(v) ? v : "values" in v ? v.values.reduce(reducer, 0) : v.value; + fn = (t1, t2) => { + const t1Sum = sum(t1); + const t2Sum = sum(t2); + return isReversed ? orderAsc ? t1Sum - t2Sum : t2Sum - t1Sum : orderAsc ? t2Sum - t1Sum : t1Sum - t2Sum; + }; + } else if (isFunction(order)) { + fn = order.bind($$.api); + } + return fn || null; + }, + filterByX(targets, x) { + return mergeArray(targets.map((t) => t.values)).filter((v) => v.x - x === 0); + }, + filterNullish(data) { + const filter = (v) => isValue(v.value); + return data ? data.filter( + (v) => "value" in v ? filter(v) : v.values.some(filter) + ) : data; + }, + filterRemoveNull(data) { + return data.filter((d) => isValue(this.getBaseValue(d))); + }, + filterByXDomain(targets, xDomain) { + return targets.map((t) => ({ + id: t.id, + id_org: t.id_org, + values: t.values.filter((v) => xDomain[0] <= v.x && v.x <= xDomain[1]) + })); + }, + hasDataLabel() { + const dataLabels = this.config.data_labels; + return isBoolean(dataLabels) && dataLabels || isObjectType(dataLabels) && notEmpty(dataLabels); + }, + /** + * Determine if has null value + * @param {Array} targets Data array to be evaluated + * @returns {boolean} + * @private + */ + hasNullDataValue(targets) { + return targets.some(({ value }) => value === null); + }, + /** + * Get data index from the event coodinates + * @param {Event} event Event object + * @returns {number} + * @private + */ + getDataIndexFromEvent(event) { + const $$ = this; + const { + $el, + config, + state: { hasRadar, inputType, eventReceiver: { coords, rect } } + } = $$; + let index; + if (hasRadar) { + let target = event.target; + if (/tspan/i.test(target.tagName)) { + target = target.parentNode; + } + const d = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(target).datum(); + index = d && Object.keys(d).length === 1 ? d.index : void 0; + } else { + const isRotated = config.axis_rotated; + const scrollPos = getScrollPosition($el.chart.node()); + const e = inputType === "touch" && event.changedTouches ? event.changedTouches[0] : event; + let point = isRotated ? e.clientY + scrollPos.y : e.clientX + scrollPos.x; + if (hasViewBox($el.svg)) { + const pos = [point, 0]; + isRotated && pos.reverse(); + point = getTransformCTM($el.eventRect.node(), ...pos)[isRotated ? "y" : "x"]; + } else { + point -= isRotated ? rect.top : rect.left; + } + index = findIndex( + coords, + point, + 0, + coords.length - 1, + isRotated + ); + } + return index; + }, + getDataLabelLength(min, max, key) { + var _a; + const $$ = this; + const paddingCoef = 1.3; + return ((_a = $$.getTextRect( + [min, max].map((v) => $$.dataLabelFormat()(v)) + )) == null ? void 0 : _a.map((rect) => rect[key] * paddingCoef)) || [0, 0]; + }, + isNoneArc(d) { + return this.hasTarget(this.data.targets, d.id); + }, + isArc(d) { + return "data" in d && this.hasTarget(this.data.targets, d.data.id); + }, + findSameXOfValues(values, index) { + const targetX = values[index].x; + const sames = []; + let i; + for (i = index - 1; i >= 0; i--) { + if (targetX !== values[i].x) { + break; + } + sames.push(values[i]); + } + for (i = index; i < values.length; i++) { + if (targetX !== values[i].x) { + break; + } + sames.push(values[i]); + } + return sames; + }, + findClosestFromTargets(targets, pos) { + const $$ = this; + const candidates = targets.map((target) => $$.findClosest(target.values, pos)); + return $$.findClosest(candidates, pos); + }, + findClosest(values, pos) { + const $$ = this; + const { $el: { main } } = $$; + const data = values.filter((v) => v && isValue(v.value)); + let minDist; + let closest; + data.filter((v) => $$.isBarType(v.id) || $$.isCandlestickType(v.id)).forEach((v) => { + const selector = $$.isBarType(v.id) ? `.${$BAR.chartBar}.${$COMMON.target}${$$.getTargetSelectorSuffix(v.id)} .${$BAR.bar}-${v.index}` : `.${$CANDLESTICK.chartCandlestick}.${$COMMON.target}${$$.getTargetSelectorSuffix(v.id)} .${$CANDLESTICK.candlestick}-${v.index} path`; + if (!closest && $$.isWithinBar(main.select(selector).node())) { + closest = v; + } + }); + data.filter((v) => !$$.isBarType(v.id) && !$$.isCandlestickType(v.id)).forEach((v) => { + const d = $$.dist(v, pos); + minDist = $$.getPointSensitivity(v); + if (d < minDist) { + minDist = d; + closest = v; + } + }); + return closest; + }, + dist(data, pos) { + const $$ = this; + const { config: { axis_rotated: isRotated }, scale } = $$; + const xIndex = +isRotated; + const yIndex = +!isRotated; + const y = $$.circleY(data, data.index); + const x = (scale.zoom || scale.x)(data.x); + return Math.sqrt(Math.pow(x - pos[xIndex], 2) + Math.pow(y - pos[yIndex], 2)); + }, + /** + * Convert data for step type + * @param {Array} values Object data values + * @returns {Array} + * @private + */ + convertValuesToStep(values) { + const $$ = this; + const { axis, config } = $$; + const stepType = config.line_step_type; + const isCategorized = axis ? axis.isCategorized() : false; + const converted = isArray(values) ? values.concat() : [values]; + if (!(isCategorized || /step\-(after|before)/.test(stepType))) { + return values; + } + if (converted.length) { + const head = converted[0]; + const tail = converted[converted.length - 1]; + const { id } = head; + let { x } = head; + converted.unshift({ x: --x, value: head.value, id }); + isCategorized && stepType === "step-after" && converted.unshift({ x: --x, value: head.value, id }); + x = tail.x; + converted.push({ x: ++x, value: tail.value, id }); + isCategorized && stepType === "step-before" && converted.push({ x: ++x, value: tail.value, id }); + } + return converted; + }, + convertValuesToRange(values) { + const converted = isArray(values) ? values.concat() : [values]; + const ranges = []; + converted.forEach((range) => { + const { x, id } = range; + ranges.push({ + x, + id, + value: range.value[0] + }); + ranges.push({ + x, + id, + value: range.value[2] + }); + }); + return ranges; + }, + updateDataAttributes(name, attrs) { + const $$ = this; + const { config } = $$; + const current = config[`data_${name}`]; + if (isUndefined(attrs)) { + return current; + } + Object.keys(attrs).forEach((id) => { + current[id] = attrs[id]; + }); + $$.redraw({ withLegend: true }); + return current; + }, + getRangedData(d, key = "", type = "areaRange") { + const value = d == null ? void 0 : d.value; + if (isArray(value)) { + if (type === "bar") { + return value.reduce((a, c) => c - a); + } else { + const index = { + areaRange: ["high", "mid", "low"], + candlestick: ["open", "high", "low", "close", "volume"] + }[type].indexOf(key); + return index >= 0 && value ? value[index] : void 0; + } + } else if (value && key) { + return value[key]; + } + return value; + }, + /** + * Set ratio for grouped data + * @param {Array} data Data array + * @private + */ + setRatioForGroupedData(data) { + const $$ = this; + const { config } = $$; + if (config.data_groups.length && data.some((d) => $$.isGrouped(d.id))) { + const setter = (d) => $$.getRatio("index", d, true); + data.forEach((v) => { + "values" in v ? v.values.forEach(setter) : setter(v); + }); + } + }, + /** + * Get ratio value + * @param {string} type Ratio for given type + * @param {object} d Data value object + * @param {boolean} asPercent Convert the return as percent or not + * @returns {number} Ratio value + * @private + */ + getRatio(type, d, asPercent = false) { + const $$ = this; + const { config, state } = $$; + const api = $$.api; + let ratio = 0; + if (d && api.data.shown().length) { + ratio = d.ratio || d.value; + if (type === "arc") { + if ($$.pie.padAngle()()) { + ratio = d.value / $$.getTotalDataSum(true); + } else { + const gaugeArcLength = config.gauge_fullCircle ? $$.getArcLength() : $$.getStartingAngle() * -2; + const arcLength = $$.hasType("gauge") ? gaugeArcLength : Math.PI * 2; + ratio = (d.endAngle - d.startAngle) / arcLength; + } + } else if (type === "index") { + const dataValues = api.data.values.bind(api); + const { hiddenTargetIds } = state; + let total = this.getTotalPerIndex( + $$.isStackNormalizedPerGroup() ? d.id : void 0 + ); + if (total === null) { + return ratio; + } + if (hiddenTargetIds.length) { + let hiddenIds = hiddenTargetIds; + if ($$.isStackNormalizedPerGroup() && d.id) { + const group = config.data_groups.find((g) => g.indexOf(d.id) >= 0); + if (group) { + hiddenIds = hiddenIds.filter((id) => group.indexOf(id) >= 0); + } + } + if (hiddenIds.length) { + let hiddenSum = dataValues(hiddenIds, false); + if (hiddenSum.length) { + hiddenSum = hiddenSum.reduce((acc, curr) => acc.map((v, i) => ~~v + curr[i])); + total = total.map((v, i) => v - hiddenSum[i]); + } + } + } + const divisor = total[d.index]; + d.ratio = isNumber(d.value) && total && divisor ? d.value / divisor : 0; + ratio = d.ratio; + } else if (type === "radar") { + ratio = parseFloat(String(Math.max(d.value, 0))) / state.current.dataMax * config.radar_size_ratio; + } else if (type === "bar") { + const yScale = $$.getYScaleById.bind($$)(d.id); + const max = yScale.domain().reduce((a, c) => c - a); + ratio = max === 0 ? 0 : Math.abs( + $$.getRangedData(d, null, type) / max + ); + } else if (type === "treemap") { + ratio /= $$.getTotalDataSum(true); + } + } + return asPercent && ratio ? ratio * 100 : ratio; + }, + /** + * Sort data index to be aligned with x axis. + * @param {Array} tickValues Tick array values + * @private + */ + updateDataIndexByX(tickValues) { + const $$ = this; + const tickValueMap = tickValues.reduce((out, tick, index) => { + out[Number(tick.x)] = index; + return out; + }, {}); + $$.data.targets.forEach((t) => { + t.values.forEach((value, valueIndex) => { + let index = tickValueMap[Number(value.x)]; + if (index === void 0) { + index = valueIndex; + } + value.index = index; + }); + }); + }, + /** + * Determine if bubble has dimension data + * @param {object|Array} d data value + * @returns {boolean} + * @private + */ + isBubbleZType(d) { + const $$ = this; + return $$.isBubbleType(d) && (isObject(d.value) && ("z" in d.value || "y" in d.value) || isArray(d.value) && d.value.length >= 2); + }, + /** + * Determine if bar has ranged data + * @param {Array} d data value + * @returns {boolean} + * @private + */ + isBarRangeType(d) { + const $$ = this; + const { value } = d; + return $$.isBarType(d) && isArray(value) && value.length >= 2 && value.every(isNumber); + }, + /** + * Get data object by id + * @param {string} id data id + * @returns {object} + * @private + */ + getDataById(id) { + var _a; + const d = this.cache.get(id) || this.api.data(id); + return (_a = d == null ? void 0 : d[0]) != null ? _a : d; + } +}); + +;// ./src/ChartInternal/data/load.ts + + +function callDone(fn, resizeAfter = false) { + const $$ = this; + const { api } = $$; + resizeAfter && $$.api.flush(true); + fn == null ? void 0 : fn.call(api); +} +/* harmony default export */ var load = ({ + load(rawTargets, args) { + const $$ = this; + const { axis, data, org, scale } = $$; + const { append } = args; + const zoomState = { + domain: null, + currentDomain: null, + x: null + }; + let targets = rawTargets; + if (targets) { + if (args.filter) { + targets = targets.filter(args.filter); + } + if (args.type || args.types) { + targets.forEach((t) => { + var _a; + const type = ((_a = args.types) == null ? void 0 : _a[t.id]) || args.type; + $$.setTargetType(t.id, type); + }); + } + data.targets.forEach((d) => { + for (let i = 0; i < targets.length; i++) { + if (d.id === targets[i].id) { + d.values = append ? d.values.concat(targets[i].values) : targets[i].values; + targets.splice(i, 1); + break; + } + } + }); + data.targets = data.targets.concat(targets); + } + $$.updateTargets(data.targets); + if (scale.zoom) { + zoomState.x = axis.isCategorized() ? scale.x.orgScale() : (org.xScale || scale.x).copy(); + zoomState.domain = $$.getXDomain(data.targets); + zoomState.x.domain(zoomState.domain); + zoomState.currentDomain = $$.zoom.getDomain(); + if (!$$.withinRange(zoomState.currentDomain, void 0, zoomState.domain)) { + scale.x.domain(zoomState.domain); + scale.zoom = null; + $$.$el.eventRect.property("__zoom", null); + } + } + $$.redraw({ + withUpdateOrgXDomain: true, + withUpdateXDomain: true, + withLegend: true + }); + if (scale.zoom) { + org.xDomain = zoomState.domain; + org.xScale = zoomState.x; + if (axis.isCategorized()) { + zoomState.currentDomain = $$.getZoomDomainValue(zoomState.currentDomain); + org.xDomain = $$.getZoomDomainValue(org.xDomain); + org.xScale = zoomState.x.domain(org.xDomain); + } + $$.updateCurrentZoomTransform(zoomState.x, zoomState.currentDomain); + } else if (org.xScale) { + org.xScale.domain(org.xDomain); + } + $$.updateTypesElements(); + callDone.call($$, args.done, args.resizeAfter); + }, + loadFromArgs(args) { + const $$ = this; + if (!$$.config) { + return; + } + $$.cache.reset(); + $$.convertData(args, (d) => { + const data = args.data || d; + args.append && (data.__append__ = true); + data && $$.load($$.convertDataToTargets.call($$, data), args); + }); + }, + unload(rawTargetIds, customDoneCb) { + var _a; + const $$ = this; + const { state, $el, $T } = $$; + const hasLegendDefsPoint = !!((_a = $$.hasLegendDefsPoint) == null ? void 0 : _a.call($$)); + let done = customDoneCb; + let targetIds = rawTargetIds; + $$.cache.reset(); + if (!done) { + done = () => { + }; + } + targetIds = targetIds.filter((id) => $$.hasTarget($$.data.targets, id)); + if (!targetIds || targetIds.length === 0) { + done(); + return; + } + targetIds.forEach((id) => { + var _a2; + const suffixId = $$.getTargetSelectorSuffix(id); + state.withoutFadeIn[id] = false; + if ($el.legend) { + $el.legend.selectAll(`.${$LEGEND.legendItem}${suffixId}`).remove(); + } + $$.data.targets = $$.data.targets.filter((t) => t.id !== id); + hasLegendDefsPoint && ((_a2 = $el.defs) == null ? void 0 : _a2.select(`#${$$.getDefsPointId(suffixId)}`).remove()); + }); + state.hasFunnel && $$.updateFunnel($$.data.targets); + state.hasTreemap && $$.updateTargetsForTreemap($$.data.targets); + $$.updateTypesElements(); + const targets = $el.svg.selectAll(targetIds.map((id) => $$.selectorTarget(id))); + $T(targets).style("opacity", "0").remove().call(endall, done); + } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-drag","commonjs2":"d3-drag","amd":"d3-drag","root":"d3"} +var external_commonjs_d3_drag_commonjs2_d3_drag_amd_d3_drag_root_d3_ = __webpack_require__(6); +;// ./src/ChartInternal/interactions/interaction.ts + + + + + +/* harmony default export */ var interactions_interaction = ({ + /** + * Expand data shape/point + * @param {number} index Index number + * @param {string} id Data id + * @param {boolean} reset Reset expand state + * @private + */ + setExpand(index, id, reset) { + const $$ = this; + const { config, $el: { circle } } = $$; + circle && config.point_focus_expand_enabled && $$.expandCircles(index, id, reset); + $$.expandBarTypeShapes(true, index, id, reset); + }, + /** + * Expand/Unexpand bar type shapes + * @param {boolean} expand Expand or unexpand + * @param {number} i Shape index + * @param {string} id Data id + * @param {boolean} reset Reset expand style + * @private + */ + expandBarTypeShapes(expand = true, i, id, reset) { + const $$ = this; + ["bar", "candlestick"].filter((v) => $$.$el[v]).forEach((v) => { + reset && $$.$el[v].classed($COMMON.EXPANDED, false); + $$.getShapeByIndex(v, i, id).classed($COMMON.EXPANDED, expand); + }); + }, + /** + * Handle data.onover/out callback options + * @param {boolean} isOver Over or not + * @param {number|object} d data object + * @private + */ + setOverOut(isOver, d) { + const $$ = this; + const { config, state: { hasFunnel, hasRadar, hasTreemap }, $el: { main } } = $$; + const isArcishData = isObject(d); + if (isArcishData || d !== -1) { + const callback = config[isOver ? "data_onover" : "data_onout"].bind($$.api); + config.color_onover && $$.setOverColor(isOver, d, isArcishData); + if (isArcishData) { + const suffix = $$.getTargetSelectorSuffix(d.id); + const selector = hasFunnel || hasTreemap ? `${$COMMON.target + suffix} .${$SHAPE.shape}` : $ARC.arc + suffix; + callback(d, main.select(`.${selector}`).node()); + } else if (!config.tooltip_grouped) { + const last = $$.cache.get(KEY.setOverOut) || []; + const shapesAtIndex = main.selectAll(`.${$SHAPE.shape}-${d}`).filter(function(d2) { + return $$.isWithinShape(this, d2); + }); + const shape = shapesAtIndex.filter(function() { + return last.every((v) => v !== this); + }); + if (!isOver || shapesAtIndex.empty() || last.length === shape.size() && shape.nodes().every((v, i) => v !== last[i])) { + while (last.length) { + const target = last.pop(); + config.data_onout.bind($$.api)((0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(target).datum(), target); + } + } + shape.each(function() { + if (isOver) { + callback((0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).datum(), this); + last.push(this); + } + }); + $$.cache.add(KEY.setOverOut, last); + } else { + if (isOver) { + hasRadar && $$.isPointFocusOnly() ? $$.showCircleFocus($$.getAllValuesOnIndex(d, true)) : $$.setExpand(d, null, true); + } + !$$.isMultipleX() && main.selectAll(`.${$SHAPE.shape}-${d}`).each(function(d2) { + callback(d2, this); + }); + } + } + }, + /** + * Call data.onover/out callback for touch event + * @param {number|object} d target index or data object for Arc type + * @private + */ + callOverOutForTouch(d) { + const $$ = this; + const last = $$.cache.get(KEY.callOverOutForTouch); + if (isObject(d) && last ? d.id !== last.id : d !== last) { + (last || isNumber(last)) && $$.setOverOut(false, last); + (d || isNumber(d)) && $$.setOverOut(true, d); + $$.cache.add(KEY.callOverOutForTouch, d); + } + }, + /** + * Return draggable selection function + * @returns {function} + * @private + */ + getDraggableSelection() { + const $$ = this; + const { config, state } = $$; + return config.interaction_enabled && config.data_selection_draggable && $$.drag ? (0,external_commonjs_d3_drag_commonjs2_d3_drag_amd_d3_drag_root_d3_.drag)().on("drag", function(event) { + state.event = event; + $$.drag(getPointer(event, this)); + }).on("start", function(event) { + state.event = event; + $$.dragstart(getPointer(event, this)); + }).on("end", (event) => { + state.event = event; + $$.dragend(); + }) : () => { + }; + }, + /** + * Dispatch a mouse event. + * @private + * @param {string} type event type + * @param {number} index Index of eventRect + * @param {Array} mouse x and y coordinate value + */ + dispatchEvent(type, index, mouse) { + var _a, _b, _c; + const $$ = this; + const { + config, + state: { + eventReceiver, + hasAxis, + hasFunnel, + hasRadar, + hasTreemap + }, + $el: { eventRect, funnel, radar, svg, treemap } + } = $$; + let element = (_c = (_b = (hasFunnel || hasTreemap) && eventReceiver.rect || hasRadar && radar.axes.select(`.${$AXIS.axis}-${index} text`) || (eventRect || ((_a = $$.getArcElementByIdOrIndex) == null ? void 0 : _a.call($$, index)))) == null ? void 0 : _b.node) == null ? void 0 : _c.call(_b); + if (element) { + const isMultipleX = $$.isMultipleX(); + const isRotated = config.axis_rotated; + let { width, left, top } = getBoundingRect(element); + if (hasAxis && !hasRadar && !isMultipleX) { + const coords = eventReceiver.coords[index]; + if (coords) { + width = coords.w; + left += coords.x; + top += coords.y; + } else { + width = 0; + left = 0; + top = 0; + } + } + let x = left + (mouse ? mouse[0] : 0) + (isMultipleX || isRotated ? 0 : width / 2); + let y = top + (mouse ? mouse[1] : 0) + (isRotated ? 4 : 0); + if (hasViewBox(svg)) { + const ctm = getTransformCTM($$.$el.eventRect.node(), x, y, false); + x = ctm.x; + y = ctm.y; + } + const params = { + screenX: x, + screenY: y, + clientX: x, + clientY: y, + bubbles: hasRadar + // radar type needs to bubble up event + }; + if (hasFunnel || hasTreemap) { + element = (funnel != null ? funnel : treemap).node(); + } + emulateEvent[/^(mouse|click)/.test(type) ? "mouse" : "touch"]( + element, + type, + params + ); + } + }, + setDragStatus(isDragging) { + this.state.dragging = isDragging; + }, + /** + * Unbind zoom events + * @private + */ + unbindZoomEvent() { + const $$ = this; + const { $el: { eventRect, zoomResetBtn } } = $$; + eventRect == null ? void 0 : eventRect.on(".zoom wheel.zoom .drag", null); + zoomResetBtn == null ? void 0 : zoomResetBtn.on("click", null).style("display", "none"); + }, + /** + * Unbind all attached events + * @private + */ + unbindAllEvents() { + var _a; + const $$ = this; + const { $el: { arcs, eventRect, legend, region, svg, treemap }, brush } = $$; + const list = [ + "wheel", + "click", + "mouseover", + "mousemove", + "mouseout", + "touchstart", + "touchmove", + "touchend", + "touchstart.eventRect", + "touchmove.eventRect", + "touchend.eventRect", + ".brush", + ".drag", + ".zoom", + "wheel.zoom", + "dblclick.zoom" + ].join(" "); + [ + svg, + eventRect, + region == null ? void 0 : region.list, + brush == null ? void 0 : brush.getSelection(), + arcs == null ? void 0 : arcs.selectAll("path"), + legend == null ? void 0 : legend.selectAll("g"), + treemap + ].forEach((v) => v == null ? void 0 : v.on(list, null)); + (_a = $$.unbindZoomEvent) == null ? void 0 : _a.call($$); + } +}); + +;// ./src/ChartInternal/internals/category.ts +/* harmony default export */ var category = ({ + /** + * Category Name + * @param {number} i Index number + * @returns {string} category Name + * @private + */ + categoryName(i) { + var _a; + const { axis_x_categories } = this.config; + return (_a = axis_x_categories == null ? void 0 : axis_x_categories[i]) != null ? _a : i; + } +}); + +;// ./src/ChartInternal/internals/class.ts + +/* harmony default export */ var internals_class = ({ + generateClass(prefix, targetId) { + return ` ${prefix} ${prefix + this.getTargetSelectorSuffix(targetId)}`; + }, + /** + * Get class string + * @param {string} type Shape type + * @param {boolean} withShape Get with shape prefix + * @returns {string} Class string + * @private + */ + getClass(type, withShape) { + const isPlural = /s$/.test(type); + const useIdKey = /^(area|arc|line|funnel|treemap)s?$/.test(type); + const key = isPlural ? "id" : "index"; + return (d) => { + const data = d.data || d; + const result = (withShape ? this.generateClass(classes[isPlural ? "shapes" : "shape"], data[key]) : "") + this.generateClass(classes[type], data[useIdKey ? "id" : key]); + return result.trim(); + }; + }, + /** + * Get chart class string + * @param {string} type Shape type + * @returns {string} Class string + * @private + */ + getChartClass(type) { + return (d) => classes[`chart${type}`] + this.classTarget((d.data ? d.data : d).id); + }, + generateExtraLineClass() { + const $$ = this; + const classes = $$.config.line_classes || []; + const ids = []; + return function(d) { + var _a; + const id = d.id || ((_a = d.data) == null ? void 0 : _a.id) || d; + if (ids.indexOf(id) < 0) { + ids.push(id); + } + return classes[ids.indexOf(id) % classes.length]; + }; + }, + classRegion(d, i) { + return `${this.generateClass(classes.region, i)} ${"class" in d ? d.class : ""}`; + }, + classTarget(id) { + const additionalClassSuffix = this.config.data_classes[id]; + let additionalClass = ""; + if (additionalClassSuffix) { + additionalClass = ` ${classes.target}-${additionalClassSuffix}`; + } + return this.generateClass(classes.target, id) + additionalClass; + }, + classFocus(d) { + return this.classFocused(d) + this.classDefocused(d); + }, + classFocused(d) { + return ` ${this.state.focusedTargetIds.indexOf(d.id) >= 0 ? classes.focused : ""}`; + }, + classDefocused(d) { + return ` ${this.state.defocusedTargetIds.indexOf(d.id) >= 0 ? classes.defocused : ""}`; + }, + getTargetSelectorSuffix(targetId) { + const targetStr = targetId || targetId === 0 ? `-${targetId}` : ""; + return targetStr.replace(/[\x00-\x20\x7F-\xA0\s?!@#$%^&*()_=+,.<>'":;\[\]\/|~`{}\\]/g, "-"); + }, + selectorTarget(id, prefix = "", postfix = "") { + const target = this.getTargetSelectorSuffix(id); + return `${prefix}.${classes.target + target} ${postfix}, ${prefix}.${classes.circles + target} ${postfix}`; + }, + selectorTargets(idsValue, prefix) { + const ids = idsValue || []; + return ids.length ? ids.map((id) => this.selectorTarget(id, prefix)) : null; + }, + selectorLegend(id) { + return `.${classes.legendItem + this.getTargetSelectorSuffix(id)}`; + }, + selectorLegends(ids) { + return (ids == null ? void 0 : ids.length) ? ids.map((id) => this.selectorLegend(id)) : null; + } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-scale","commonjs2":"d3-scale","amd":"d3-scale","root":"d3"} +var external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_ = __webpack_require__(7); +;// ./src/ChartInternal/internals/color.ts + + + + + + +const _colorizePattern = (pattern, color, id) => { + const node = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(pattern.cloneNode(true)); + node.attr("id", id).insert("rect", ":first-child").attr("width", node.attr("width")).attr("height", node.attr("height")).style("fill", color); + return { + id, + node: node.node() + }; +}; +function _getColorFromCss(element) { + const cacheKey = KEY.colorPattern; + const { body } = browser_doc; + let pattern = body[cacheKey]; + if (!pattern) { + const delimiter = ";"; + const content = element.classed($COLOR.colorPattern, true).style("background-image"); + element.classed($COLOR.colorPattern, false); + if (content.indexOf(delimiter) > -1) { + pattern = content.replace(/url[^#]*|["'()]|(\s|%20)/g, "").split(delimiter).map((v) => v.trim().replace(/[\"'\s]/g, "")).filter(Boolean); + body[cacheKey] = pattern; + } + } + return pattern; +} +const schemeCategory10 = [ + "#1f77b4", + "#ff7f0e", + "#2ca02c", + "#d62728", + "#9467bd", + "#8c564b", + "#e377c2", + "#7f7f7f", + "#bcbd22", + "#17becf" +]; +/* harmony default export */ var internals_color = ({ + generateColor() { + const $$ = this; + const { $el, config } = $$; + const ids = []; + const hasGradient = config.area_linearGradient || config.bar_linearGradient || config.point_radialGradient; + let pattern = notEmpty(config.color_pattern) ? config.color_pattern : (0,external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleOrdinal)(_getColorFromCss($el.chart) || schemeCategory10).range(); + const originalColorPattern = pattern; + if (isFunction(config.color_tiles)) { + const tiles = config.color_tiles.bind($$.api)(); + const colorizedPatterns = pattern.map((p, index) => { + const color = p.replace(/[#\(\)\s,]/g, ""); + const id = `${$$.state.datetimeId}-pattern-${color}-${index}`; + return _colorizePattern(tiles[index % tiles.length], p, id); + }); + pattern = colorizedPatterns.map((p) => `url(#${p.id})`); + $$.patterns = colorizedPatterns; + } + return function(d) { + var _a; + const colors = config.data_colors; + const callback = config.data_color; + const id = d.id || ((_a = d.data) == null ? void 0 : _a.id) || d; + const isLine = $$.isTypeOf(id, ["line", "spline", "step"]) || !config.data_types[id]; + let color; + if (isFunction(colors[id])) { + color = colors[id].bind($$.api)(d); + } else if (colors[id]) { + color = colors[id]; + } else { + if (ids.indexOf(id) < 0) { + ids.push(id); + } + color = isLine ? originalColorPattern[ids.indexOf(id) % originalColorPattern.length] : pattern[ids.indexOf(id) % pattern.length]; + colors[id] = color; + } + color = isFunction(callback) ? callback.call($$.api, color, d) : color; + if (hasGradient) { + const stop = $$.$el.defs.selectAll( + `[id$='-gradient${$$.getTargetSelectorSuffix(id)}'] stop` + ); + let hasSameColor; + stop.each(function(d2, i) { + hasSameColor = i === 0 ? this.style.stopColor : this.style.stopColor === hasSameColor; + }); + hasSameColor === true && stop.attr("stop-color", color); + } + return color; + }; + }, + generateLevelColor() { + const $$ = this; + const { config } = $$; + const colors = config.color_pattern; + const threshold = config.color_threshold; + const asValue = threshold.unit === "value"; + const max = threshold.max || 100; + const values = threshold.values && threshold.values.length ? threshold.values : []; + return notEmpty(threshold) ? function(value) { + const v = asValue ? value : value * 100 / max; + let color = colors[colors.length - 1]; + for (let i = 0, l = values.length; i < l; i++) { + if (v <= values[i]) { + color = colors[i]; + break; + } + } + return color; + } : null; + }, + /** + * Append data backgound color filter definition + * @param {string|object|function} color Color string, object, or function + * @param {object} attr filter attribute + * @private + */ + generateTextBGColorFilter(color, attr = { + x: 0, + y: 0, + width: 1, + height: 1 + }) { + const $$ = this; + const { $el: { defs }, state } = $$; + if (color) { + let ids = []; + if (isString(color)) { + ids.push(""); + } else if (isObject(color)) { + ids = Object.keys(color); + } else if (isFunction(color)) { + ids = $$.mapToTargetIds(); + } + ids.forEach((v) => { + const id = `${state.datetimeId}-labels-bg${$$.getTargetSelectorSuffix(v)}${isString(color) ? $$.getTargetSelectorSuffix(color) : ""}`; + const colorValue = sanitize(v === "" ? color : (color == null ? void 0 : color[v]) || ""); + if (defs.select(`#${id}`).empty()) { + defs.append("filter").attr("x", attr.x).attr("y", attr.y).attr("width", attr.width).attr("height", attr.height).attr("id", id).html(`<feFlood flood-color="${colorValue}" /> + <feComposite in="SourceGraphic" />`); + } + }); + } + }, + /** + * Get data gradient color url + * @param {string} id Data id + * @returns {string} + * @private + */ + getGradienColortUrl(id) { + return `url(#${this.state.datetimeId}-gradient${this.getTargetSelectorSuffix(id)})`; + }, + /** + * Update linear/radial gradient definition + * - linear: area & bar only + * - radial: type which has data points only + * @private + */ + updateLinearGradient() { + const $$ = this; + const { config, data: { targets }, state: { datetimeId }, $el: { defs } } = $$; + targets.forEach((d) => { + const id = `${datetimeId}-gradient${$$.getTargetSelectorSuffix(d.id)}`; + const radialGradient = $$.hasPointType() && config.point_radialGradient; + const supportedType = $$.isAreaType(d) && "area" || $$.isBarType(d) && "bar"; + if ((radialGradient || supportedType) && defs.select(`#${id}`).empty()) { + const color = $$.color(d); + const gradient = { + defs: null, + stops: [] + }; + if (radialGradient) { + const { + cx = 0.3, + cy = 0.3, + r = 0.7, + stops = [[0.1, color, 0], [0.9, color, 1]] + } = radialGradient; + gradient.stops = stops; + gradient.defs = defs.append("radialGradient").attr("id", `${id}`).attr("cx", cx).attr("cy", cy).attr("r", r); + } else { + const isRotated = config.axis_rotated; + const { + x = isRotated ? [1, 0] : [0, 0], + y = isRotated ? [0, 0] : [0, 1], + stops = [[0, color, 1], [1, color, 0]] + } = config[`${supportedType}_linearGradient`]; + gradient.stops = stops; + gradient.defs = defs.append("linearGradient").attr("id", `${id}`).attr("x1", x[0]).attr("x2", x[1]).attr("y1", y[0]).attr("y2", y[1]); + } + gradient.stops.forEach((v) => { + const [offset, stopColor, stopOpacity] = v; + const colorValue = isFunction(stopColor) ? stopColor.bind($$.api)(d.id) : stopColor; + gradient.defs && gradient.defs.append("stop").attr("offset", offset).attr("stop-color", colorValue || color).attr("stop-opacity", stopOpacity); + }); + } + }); + }, + /** + * Set the data over color. + * When is out, will restate in its previous color value + * @param {boolean} isOver true: set overed color, false: restore + * @param {number|object} d target index or data object for Arc type + * @private + */ + setOverColor(isOver, d) { + const $$ = this; + const { config, $el: { main } } = $$; + const onover = config.color_onover; + let color = isOver ? onover : $$.color; + if (isObject(color)) { + color = ({ id }) => id in onover ? onover[id] : $$.color(id); + } else if (isString(color)) { + color = () => onover; + } else if (isFunction(onover)) { + color = color.bind($$.api); + } + main.selectAll( + isObject(d) ? ( + // when is Arc type + `.${$ARC.arc}${$$.getTargetSelectorSuffix(d.id)}` + ) : `.${$SHAPE.shape}-${d}` + ).style("fill", color); + } +}); + +;// ./src/ChartInternal/internals/domain.ts + + +/* harmony default export */ var domain = ({ + getYDomainMinMax(targets, type) { + const $$ = this; + const { axis, config } = $$; + const isMin = type === "min"; + const dataGroups = config.data_groups; + const ids = $$.mapToIds(targets); + const idsSet = toSet(ids); + const ys = $$.getValuesAsIdKeyed(targets); + if (dataGroups.length > 0) { + const hasValue = $$[`has${isMin ? "Negative" : "Positive"}ValueInTargets`](targets); + const axisIdMap = new Map(ids.map((id) => [id, axis.getId(id)])); + dataGroups.forEach((groupIds) => { + const idsInGroup = groupIds.filter((v) => idsSet.has(v)); + if (idsInGroup.length) { + const baseId = idsInGroup[0]; + const baseAxisId = axisIdMap.get(baseId); + if (hasValue && ys[baseId]) { + ys[baseId] = ys[baseId].map((v) => (isMin ? v < 0 : v > 0) ? v : 0); + } + idsInGroup.filter((v, i) => i > 0).forEach((id) => { + if (ys[id]) { + const axisId = axisIdMap.get(id); + ys[id].forEach((v, i) => { + const val = +v; + const meetCondition = isMin ? val > 0 : val < 0; + if (axisId === baseAxisId && !(hasValue && meetCondition)) { + ys[baseId][i] += val; + } + }); + } + }); + } + }); + } + return getMinMax(type, Object.keys(ys).map((key) => getMinMax(type, ys[key]))); + }, + /** + * Check if hidden targets bound to the given axis id + * @param {string} id ID to be checked + * @returns {boolean} + * @private + */ + isHiddenTargetWithYDomain(id) { + const $$ = this; + return $$.state.hiddenTargetIds.some((v) => $$.axis.getId(v) === id); + }, + getYDomain(targets, axisId, xDomain) { + const $$ = this; + const { axis, config, scale } = $$; + const pfx = `axis_${axisId}`; + if ($$.isStackNormalized()) { + const axisDataIds = targets.filter((t) => axis.getId(t.id) === axisId).map((t) => t.id); + const hasGroupedData = axisDataIds.some((id) => $$.isGrouped(id)); + if (hasGroupedData) { + return [0, 100]; + } + } + const isLog = (scale == null ? void 0 : scale[axisId]) && scale[axisId].type === "log"; + const targetsByAxisId = targets.filter((t) => axis.getId(t.id) === axisId); + const yTargets = xDomain ? $$.filterByXDomain(targetsByAxisId, xDomain) : targetsByAxisId; + if (yTargets.length === 0) { + if ($$.isHiddenTargetWithYDomain(axisId)) { + return scale[axisId].domain(); + } else { + return axisId === "y2" ? scale.y.domain() : ( + // When all data bounds to y2, y Axis domain is called prior y2. + // So, it needs to call to get y2 domain here + $$.getYDomain(targets, "y2", xDomain) + ); + } + } + const yMin = config[`${pfx}_min`]; + const yMax = config[`${pfx}_max`]; + const center = config[`${pfx}_center`]; + const isInverted = config[`${pfx}_inverted`]; + const showHorizontalDataLabel = $$.hasDataLabel() && config.axis_rotated; + const showVerticalDataLabel = $$.hasDataLabel() && !config.axis_rotated; + let yDomainMin = $$.getYDomainMinMax(yTargets, "min"); + let yDomainMax = $$.getYDomainMinMax(yTargets, "max"); + let isZeroBased = [TYPE.BAR, TYPE.BUBBLE, TYPE.SCATTER, ...TYPE_BY_CATEGORY.Line].some((v) => { + const type = v.indexOf("area") > -1 ? "area" : v; + return $$.hasType(v, yTargets, true) && config[`${type}_zerobased`]; + }); + yDomainMin = isValue(yMin) ? yMin : isValue(yMax) ? yDomainMin <= yMax ? yDomainMin : yMax - 10 : yDomainMin; + yDomainMax = isValue(yMax) ? yMax : isValue(yMin) ? yMin <= yDomainMax ? yDomainMax : yMin + 10 : yDomainMax; + if (isNaN(yDomainMin)) { + yDomainMin = 0; + } + if (isNaN(yDomainMax)) { + yDomainMax = yDomainMin; + } + if (yDomainMin === yDomainMax) { + yDomainMin < 0 ? yDomainMax = 0 : yDomainMin = 0; + } + const isAllPositive = yDomainMin >= 0 && yDomainMax >= 0; + const isAllNegative = yDomainMin <= 0 && yDomainMax <= 0; + if (isValue(yMin) && isAllPositive || isValue(yMax) && isAllNegative) { + isZeroBased = false; + } + if (isZeroBased) { + isAllPositive && (yDomainMin = 0); + isAllNegative && (yDomainMax = 0); + } + const domainLength = Math.abs(yDomainMax - yDomainMin); + let padding = { top: domainLength * 0.1, bottom: domainLength * 0.1 }; + if (isDefined(center)) { + const yDomainAbs = Math.max(Math.abs(yDomainMin), Math.abs(yDomainMax)); + yDomainMax = center + yDomainAbs; + yDomainMin = center - yDomainAbs; + } + if (showHorizontalDataLabel) { + const diff = diffDomain(scale.y.range()); + const ratio = $$.getDataLabelLength(yDomainMin, yDomainMax, "width").map((v) => { + const result = v / diff; + return isFinite(result) ? result : 0; + }); + ["bottom", "top"].forEach((v, i) => { + padding[v] += domainLength * (ratio[i] / (1 - ratio[0] - ratio[1])); + }); + } else if (showVerticalDataLabel) { + const lengths = $$.getDataLabelLength(yDomainMin, yDomainMax, "height"); + ["bottom", "top"].forEach((v, i) => { + padding[v] += $$.convertPixelToScale("y", lengths[i], domainLength); + }); + } + padding = $$.getResettedPadding(padding); + const p = config[`${pfx}_padding`]; + if (notEmpty(p)) { + ["bottom", "top"].forEach((v) => { + padding[v] = axis.getPadding(p, v, padding[v], domainLength); + }); + } + if (isZeroBased) { + isAllPositive && (padding.bottom = yDomainMin); + isAllNegative && (padding.top = -yDomainMax); + } + const domain = isLog ? [yDomainMin, yDomainMax].map((v) => v < 0 ? 0 : v) : [yDomainMin - padding.bottom, yDomainMax + padding.top]; + return isInverted ? domain.reverse() : domain; + }, + getXDomainMinMax(targets, type) { + var _a; + const $$ = this; + const configValue = $$.config[`axis_x_${type}`]; + const dataValue = getMinMax( + type, + targets.map((t) => getMinMax(type, t.values.map((v) => v.x))) + ); + let value = isObject(configValue) ? configValue.value : configValue; + value = isDefined(value) && ((_a = $$.axis) == null ? void 0 : _a.isTimeSeries()) ? parseDate.bind(this)(value) : value; + if (isObject(configValue) && configValue.fit && (type === "min" && value < dataValue || type === "max" && value > dataValue)) { + value = void 0; + } + return isDefined(value) ? value : dataValue; + }, + /** + * Get x Axis padding + * @param {Array} domain x Axis domain + * @param {number} tickCount Tick count + * @returns {object} Padding object values with 'left' & 'right' key + * @private + */ + getXDomainPadding(domain, tickCount) { + const $$ = this; + const { axis, config } = $$; + const padding = config.axis_x_padding; + const isTimeSeriesTickCount = axis.isTimeSeries() && tickCount; + const diff = diffDomain(domain); + let defaultValue; + if (axis.isCategorized() || isTimeSeriesTickCount) { + defaultValue = 0; + } else if ($$.hasType("bar")) { + const maxDataCount = $$.getMaxDataCount(); + defaultValue = maxDataCount > 1 ? diff / (maxDataCount - 1) / 2 : 0.5; + } else { + defaultValue = $$.getResettedPadding(diff * 0.01); + } + let { left = defaultValue, right = defaultValue } = isNumber(padding) ? { left: padding, right: padding } : padding; + if (padding.unit === "px") { + const domainLength = Math.abs(diff + diff * 0.2); + left = axis.getPadding(padding, "left", defaultValue, domainLength); + right = axis.getPadding(padding, "right", defaultValue, domainLength); + } else { + const range = diff + left + right; + if (isTimeSeriesTickCount && range) { + const relativeTickWidth = diff / tickCount / range; + left = left / range / relativeTickWidth; + right = right / range / relativeTickWidth; + } + } + return { left, right }; + }, + /** + * Get x Axis domain + * @param {Array} targets targets + * @returns {Array} x Axis domain + * @private + */ + getXDomain(targets) { + const $$ = this; + const { axis, config, scale: { x } } = $$; + const isInverted = config.axis_x_inverted; + const domain = [ + $$.getXDomainMinMax(targets, "min"), + $$.getXDomainMinMax(targets, "max") + ]; + let [min = 0, max = 0] = domain; + if (x.type !== "log") { + const isCategorized = axis.isCategorized(); + const isTimeSeries = axis.isTimeSeries(); + const padding = $$.getXDomainPadding(domain); + let [firstX, lastX] = domain; + if (firstX - lastX === 0 && !isCategorized) { + if (isTimeSeries) { + firstX = new Date(firstX.getTime() * 0.5); + lastX = new Date(lastX.getTime() * 1.5); + } else { + firstX = firstX === 0 ? 1 : firstX * 0.5; + lastX = lastX === 0 ? -1 : lastX * 1.5; + } + } + if (firstX || firstX === 0) { + min = isTimeSeries ? new Date(firstX.getTime() - padding.left) : firstX - padding.left; + } + if (lastX || lastX === 0) { + max = isTimeSeries ? new Date(lastX.getTime() + padding.right) : lastX + padding.right; + } + } + return isInverted ? [max, min] : [min, max]; + }, + updateXDomain(targets, withUpdateXDomain, withUpdateOrgXDomain, withTrim, domain) { + var _a; + const $$ = this; + const { config, org, scale: { x, subX } } = $$; + const zoomEnabled = config.zoom_enabled; + if (withUpdateOrgXDomain) { + x.domain(domain || sortValue($$.getXDomain(targets), !config.axis_x_inverted)); + org.xDomain = x.domain(); + subX.domain(x.domain()); + (_a = $$.brush) == null ? void 0 : _a.scale(subX); + } + if (withUpdateXDomain) { + const domainValue = domain || (!$$.brush || brushEmpty($$)) ? org.xDomain : getBrushSelection($$).map(subX.invert); + x.domain(domainValue); + } + if (withUpdateOrgXDomain || withUpdateXDomain) { + zoomEnabled && $$.zoom.updateScaleExtent(); + } + withTrim && x.domain($$.trimXDomain(x.orgDomain())); + return x.domain(); + }, + /** + * Trim x domain when given domain surpasses the range + * @param {Array} domain Domain value + * @returns {Array} Trimed domain if given domain is out of range + * @private + */ + trimXDomain(domain) { + const $$ = this; + const isInverted = $$.config.axis_x_inverted; + const zoomDomain = $$.getZoomDomain(); + const [min, max] = zoomDomain; + if (isInverted ? domain[0] >= min : domain[0] <= min) { + domain[1] = +domain[1] + (min - domain[0]); + domain[0] = min; + } + if (isInverted ? domain[1] <= max : domain[1] >= max) { + domain[0] = +domain[0] - (domain[1] - max); + domain[1] = max; + } + return domain; + }, + /** + * Get subchart/zoom domain + * @param {string} type "subX" or "zoom" + * @param {boolean} getCurrent Get current domain if true + * @returns {Array} zoom domain + * @private + */ + getZoomDomain(type = "zoom", getCurrent = false) { + const $$ = this; + const { config, scale, org } = $$; + let [min, max] = getCurrent && scale[type] ? scale[type].domain() : org.xDomain; + if (type === "zoom") { + if (isDefined(config.zoom_x_min)) { + min = getMinMax("min", [min, config.zoom_x_min]); + } + if (isDefined(config.zoom_x_max)) { + max = getMinMax("max", [max, config.zoom_x_max]); + } + } + return [min, max]; + }, + /** + * Return zoom domain from given domain + * - 'category' type need to add offset to original value + * @param {Array} domainValue domain value + * @returns {Array} Zoom domain + * @private + */ + getZoomDomainValue(domainValue) { + const $$ = this; + const { config, axis } = $$; + if (axis.isCategorized() && Array.isArray(domainValue)) { + const isInverted = config.axis_x_inverted; + const domain = domainValue.map( + (v, i) => Number(v) + (i === 0 ? +isInverted : +!isInverted) + ); + return domain; + } + return domainValue; + }, + /** + * Converts pixels to axis' scale values + * @param {string} type Axis type + * @param {number} pixels Pixels + * @param {number} domainLength Domain length + * @returns {number} + * @private + */ + convertPixelToScale(type, pixels, domainLength) { + const $$ = this; + const { config, state } = $$; + const isRotated = config.axis_rotated; + let length; + if (type === "x") { + length = isRotated ? "height" : "width"; + } else { + length = isRotated ? "width" : "height"; + } + return domainLength * (pixels / state[length]); + }, + /** + * Check if the given domain is within subchart/zoom range + * @param {Array} domain Target domain value + * @param {Array} current Current subchart/zoom domain value + * @param {Array} range subchart/zoom range value + * @returns {boolean} + * @private + */ + withinRange(domain, current = [0, 0], range) { + const $$ = this; + const isInverted = $$.config.axis_x_inverted; + const [min, max] = range; + if (Array.isArray(domain)) { + const target = [...domain]; + isInverted && target.reverse(); + if (target[0] < target[1]) { + return domain.every( + (v, i) => (i === 0 ? isInverted ? +v <= min : +v >= min : isInverted ? +v >= max : +v <= max) && !domain.every((v2, i2) => v2 === current[i2]) + ); + } + } + return false; + } +}); + +;// ./src/ChartInternal/internals/format.ts + +function _getFormat($$, typeValue, v) { + const { config } = $$; + const type = `axis_${typeValue}_tick_format`; + const format = config[type] ? config[type] : $$.defaultValueFormat; + return format.call($$.api, v); +} +/* harmony default export */ var format = ({ + yFormat(v) { + return _getFormat(this, "y", v); + }, + y2Format(v) { + return _getFormat(this, "y2", v); + }, + /** + * Get default value format function + * @returns {function} formatter function + * @private + */ + getDefaultValueFormat() { + const $$ = this; + const { defaultArcValueFormat, yFormat, y2Format } = $$; + const hasArc = $$.hasArcType(null, ["gauge", "polar", "radar"]); + return function(v, ratio, id) { + const format = hasArc ? defaultArcValueFormat : $$.axis && $$.axis.getId(id) === "y2" ? y2Format : yFormat; + return format.call($$, v, ratio); + }; + }, + defaultValueFormat(v) { + return isArray(v) ? v.join("~") : isValue(v) ? +v : ""; + }, + defaultArcValueFormat(v, ratio) { + return `${(ratio * 100).toFixed(1)}%`; + }, + defaultPolarValueFormat(v) { + return `${v}`; + }, + dataLabelFormat(targetId) { + const $$ = this; + const dataLabels = $$.config.data_labels; + const defaultFormat = (v) => { + const delimiter = "~"; + let res = v; + if (isArray(v)) { + res = v.join(delimiter); + } else if (isObject(v)) { + res = Object.values(v).join(delimiter); + } + return res; + }; + let format = defaultFormat; + if (isFunction(dataLabels.format)) { + format = dataLabels.format; + } else if (isObjectType(dataLabels.format)) { + if (dataLabels.format[targetId]) { + format = dataLabels.format[targetId] === true ? defaultFormat : dataLabels.format[targetId]; + } else { + format = () => ""; + } + } + return format.bind($$.api); + } +}); + +;// ./src/ChartInternal/internals/legend.ts + + + + + +function _getLegendColor(id) { + const $$ = this; + const data = $$.getDataById(id); + const color = $$.levelColor ? $$.levelColor(data.values[0].value) : $$.color(data); + return color; +} +function _getFormattedText(id, formatted = true) { + var _a; + const { config } = this; + let text = (_a = config.data_names[id]) != null ? _a : id; + if (formatted && isFunction(config.legend_format)) { + text = config.legend_format(text, id !== text ? id : void 0); + } + return text; +} +function _buildLegendItemMap($$, legendItems) { + if (!legendItems || legendItems.empty()) { + return; + } + const items = []; + legendItems.each(function(id) { + items.push({ id, node: this }); + }); + const itemMap = toMap( + items, + (item) => item.id, + (item) => item.node + ); + $$.cache.add(KEY.legendItemMap, itemMap); +} +/* harmony default export */ var internals_legend = ({ + /** + * Initialize the legend. + * @private + */ + initLegend() { + const $$ = this; + const { config, $el } = $$; + $$.legendItemTextBox = {}; + $$.state.legendHasRendered = false; + if (config.legend_show) { + if (!config.legend_contents_bindto) { + $el.legend = $$.$el.svg.append("g").classed($LEGEND.legend, true).attr("transform", $$.getTranslate("legend")); + } + $$.updateLegend(); + } else { + $$.state.hiddenLegendIds = $$.mapToIds($$.data.targets); + } + }, + /** + * Update legend element + * @param {Array} targetIds ID's of target + * @param {object} options withTransform : Whether to use the transform property / withTransitionForTransform: Whether transition is used when using the transform property / withTransition : whether or not to transition. + * @param {object} transitions Return value of the generateTransitions + * @private + */ + updateLegend(targetIds, options, transitions) { + var _a; + const $$ = this; + const { config, state, scale, $el } = $$; + const optionz = options || { + withTransform: false, + withTransitionForTransform: false, + withTransition: false + }; + optionz.withTransition = getOption(optionz, "withTransition", true); + optionz.withTransitionForTransform = getOption(optionz, "withTransitionForTransform", true); + if (config.legend_contents_bindto && config.legend_contents_template) { + $$.updateLegendTemplate(); + } else if (!state.hasTreemap) { + $$.updateLegendElement( + targetIds || $$.mapToIds($$.data.targets), + optionz, + transitions + ); + } + (_a = $el.legend) == null ? void 0 : _a.selectAll(`.${$LEGEND.legendItem}`).classed($LEGEND.legendItemHidden, function(id) { + const hide = !$$.isTargetToShow(id); + if (hide) { + this.style.opacity = null; + } + return hide; + }); + $$.updateScales(false, !scale.zoom); + $$.updateSvgSize(); + $$.transformAll(optionz.withTransitionForTransform, transitions); + state.legendHasRendered = true; + }, + /** + * Update legend using template option + * @private + */ + updateLegendTemplate() { + const $$ = this; + const { config, $el } = $$; + const wrapper = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(config.legend_contents_bindto); + const template = config.legend_contents_template; + if (!wrapper.empty()) { + const targets = $$.mapToIds($$.data.targets); + const ids = []; + let html = ""; + targets.forEach((v) => { + const content = isFunction(template) ? sanitize(template.call($$.api, v, $$.color(v), $$.api.data(v)[0].values)) : tplProcess(template, { + COLOR: $$.color(v), + TITLE: v + }); + if (content) { + ids.push(v); + html += content; + } + }); + const legendItem = wrapper.html(html).selectAll(function() { + return this.childNodes; + }).data(ids); + $$.setLegendItem(legendItem); + $el.legend = wrapper; + } + }, + /** + * Update the size of the legend. + * @param {Obejct} size Size object + * @private + */ + updateSizeForLegend(size) { + const $$ = this; + const { + config, + state: { + isLegendTop, + isLegendLeft, + isLegendRight, + isLegendInset, + current + } + } = $$; + const { width, height } = size; + const insetLegendPosition = { + top: isLegendTop ? $$.getCurrentPaddingByDirection("top") + config.legend_inset_y + 5.5 : current.height - height - $$.getCurrentPaddingByDirection("bottom") - config.legend_inset_y, + left: isLegendLeft ? $$.getCurrentPaddingByDirection("left") + config.legend_inset_x + 0.5 : current.width - width - $$.getCurrentPaddingByDirection("right") - config.legend_inset_x + 0.5 + }; + $$.state.margin3 = { + top: isLegendRight ? 0 : isLegendInset ? insetLegendPosition.top : current.height - height, + right: NaN, + bottom: 0, + left: isLegendRight ? current.width - width : isLegendInset ? insetLegendPosition.left : 0 + }; + }, + /** + * Transform Legend + * @param {boolean} withTransition whether or not to transition. + * @private + */ + transformLegend(withTransition) { + const $$ = this; + const { $el: { legend }, $T } = $$; + $T(legend, withTransition).attr("transform", $$.getTranslate("legend")); + }, + /** + * Update the legend step + * @param {number} step Step value + * @private + */ + updateLegendStep(step) { + this.state.legendStep = step; + }, + /** + * Update legend item width + * @param {number} width Width value + * @private + */ + updateLegendItemWidth(width) { + this.state.legendItemWidth = width; + }, + /** + * Update legend item height + * @param {number} height Height value + * @private + */ + updateLegendItemHeight(height) { + this.state.legendItemHeight = height; + }, + /** + * Update legend item color + * @param {string} id Corresponding data ID value + * @param {string} color Color value + * @private + */ + updateLegendItemColor(id, color) { + const $$ = this; + const { legend } = $$.$el; + if (legend) { + const legendItem = $$.getLegendItemById(id); + if (legendItem) { + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(legendItem).select("line").style("stroke", color); + } + } + }, + /** + * Get the width of the legend + * @returns {number} width + * @private + */ + getLegendWidth() { + const $$ = this; + const { current: { width }, isLegendRight, isLegendInset, legendItemWidth, legendStep } = $$.state; + return $$.config.legend_show ? isLegendRight || isLegendInset ? legendItemWidth * (legendStep + 1) : width : 0; + }, + /** + * Get the height of the legend + * @returns {number} height + * @private + */ + getLegendHeight() { + var _a; + const $$ = this; + const { current, isLegendRight, legendItemHeight, legendStep } = $$.state; + const isFitPadding = ((_a = $$.config.padding) == null ? void 0 : _a.mode) === "fit"; + const height = $$.config.legend_show ? isLegendRight ? current.height : Math.max(isFitPadding ? 10 : 20, legendItemHeight) * (legendStep + 1) : 0; + return height; + }, + /** + * Get the opacity of the legend that is unfocused + * @param {d3.selection} legendItem Legend item node + * @returns {string|null} opacity + * @private + */ + opacityForUnfocusedLegend(legendItem) { + return legendItem.classed($LEGEND.legendItemHidden) ? null : "0.3"; + }, + /** + * Toggles the focus of the legend + * @param {Array} targetIds ID's of target + * @param {boolean} focus whether or not to focus. + * @private + */ + toggleFocusLegend(targetIds, focus) { + const $$ = this; + const { $el: { legend }, $T } = $$; + const targetIdz = $$.mapToTargetIds(targetIds); + legend && $T(legend.selectAll(`.${$LEGEND.legendItem}`).filter((id) => targetIdz.indexOf(id) >= 0).classed($FOCUS.legendItemFocused, focus)).style("opacity", function() { + return focus ? null : $$.opacityForUnfocusedLegend.call($$, (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this)); + }); + }, + /** + * Revert the legend to its default state + * @private + */ + revertLegend() { + const $$ = this; + const { $el: { legend }, $T } = $$; + legend && $T(legend.selectAll(`.${$LEGEND.legendItem}`).classed($FOCUS.legendItemFocused, false)).style("opacity", null); + }, + /** + * Shows the legend + * @param {Array} targetIds ID's of target + * @private + */ + showLegend(targetIds) { + const $$ = this; + const { config, $el, $T } = $$; + if (!config.legend_show) { + config.legend_show = true; + $el.legend ? $el.legend.style("visibility", null) : $$.initLegend(); + !$$.state.legendHasRendered && $$.updateLegend(); + } + $$.removeHiddenLegendIds(targetIds); + $T( + $el.legend.selectAll($$.selectorLegends(targetIds)).style("visibility", null) + ).style("opacity", null); + }, + /** + * Hide the legend + * @param {Array} targetIds ID's of target + * @private + */ + hideLegend(targetIds) { + const $$ = this; + const { config, $el: { legend } } = $$; + if (config.legend_show && isEmpty(targetIds)) { + config.legend_show = false; + legend.style("visibility", "hidden"); + } + $$.addHiddenLegendIds(targetIds); + legend.selectAll($$.selectorLegends(targetIds)).style("opacity", "0").style("visibility", "hidden"); + }, + /** + * Get legend item textbox dimension + * @param {string} id Data ID + * @param {HTMLElement|d3.selection} textElement Text node element + * @returns {object} Bounding rect + * @private + */ + getLegendItemTextBox(id, textElement) { + const $$ = this; + const { cache, state } = $$; + let data; + const cacheKey = KEY.legendItemTextBox; + if (id) { + data = !state.redrawing && cache.get(cacheKey) || {}; + if (!data[id]) { + data[id] = $$.getTextRect(textElement, $LEGEND.legendItem); + cache.add(cacheKey, data); + } + data = data[id]; + } + return data; + }, + /** + * Set legend item style & bind events + * @param {d3.selection} item Item node + * @private + */ + setLegendItem(item) { + const $$ = this; + const { $el, api, config, state } = $$; + const isTouch = state.inputType === "touch"; + const hasGauge = $$.hasType("gauge"); + const useCssRule = config.boost_useCssRule; + const interaction = config.legend_item_interaction; + item.attr("class", function(id) { + const node = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const itemClass = !node.empty() && node.attr("class") || ""; + return itemClass + $$.generateClass($LEGEND.legendItem, id); + }).style("visibility", (id) => $$.isLegendToShow(id) ? null : "hidden"); + if (config.interaction_enabled) { + if (useCssRule) { + [ + [`.${$LEGEND.legendItem}`, "cursor:pointer"], + [`.${$LEGEND.legendItem} text`, "pointer-events:none"], + [`.${$LEGEND.legendItemPoint} text`, "pointer-events:none"], + [`.${$LEGEND.legendItemTile}`, "pointer-events:none"], + [`.${$LEGEND.legendItemEvent}`, "fill-opacity:0"] + ].forEach((v) => { + const [selector, props] = v; + $$.setCssRule(false, selector, [props])($el.legend); + }); + } + item.on( + interaction.dblclick ? "dblclick" : "click", + interaction || isFunction(config.legend_item_onclick) ? function(event, id) { + if (!callFn( + config.legend_item_onclick, + api, + id, + !state.hiddenTargetIds.includes(id) + )) { + const { altKey, target, type } = event; + if (type === "dblclick" || altKey) { + if (state.hiddenTargetIds.length && target.parentNode.getAttribute("class").indexOf( + $LEGEND.legendItemHidden + ) === -1) { + api.show(); + } else { + api.hide(); + api.show(id); + } + } else { + api.toggle(id); + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).classed($FOCUS.legendItemFocused, false); + } + } + isTouch && $$.hideTooltip(); + } : null + ); + !isTouch && item.on("mouseout", interaction || isFunction(config.legend_item_onout) ? function(event, id) { + if (!callFn( + config.legend_item_onout, + api, + id, + !state.hiddenTargetIds.includes(id) + )) { + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).classed($FOCUS.legendItemFocused, false); + if (hasGauge) { + $$.undoMarkOverlapped($$, `.${$GAUGE.gaugeValue}`); + } + $$.api.revert(); + } + } : null).on("mouseover", interaction || isFunction(config.legend_item_onover) ? function(event, id) { + if (!callFn( + config.legend_item_onover, + api, + id, + !state.hiddenTargetIds.includes(id) + )) { + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).classed($FOCUS.legendItemFocused, true); + if (hasGauge) { + $$.markOverlapped(id, $$, `.${$GAUGE.gaugeValue}`); + } + if (!state.transiting && $$.isTargetToShow(id)) { + api.focus(id); + } + } + } : null); + !item.empty() && item.on("click mouseout mouseover") && item.style("cursor", $$.getStylePropValue("pointer")); + } + _buildLegendItemMap($$, item); + }, + /** + * Get legend item node by ID using cached Map for O(1) lookup + * Falls back to D3 selection if map is not available + * @param {string} id Data ID + * @returns {HTMLElement | null} Legend item node + * @private + */ + getLegendItemById(id) { + var _a; + const $$ = this; + const itemMap = $$.cache.get(KEY.legendItemMap); + if (itemMap && itemMap instanceof Map) { + return itemMap.get(id) || null; + } + const item = (_a = $$.$el.legend) == null ? void 0 : _a.selectAll(`.${$LEGEND.legendItem}`).filter((d) => d === id); + return (item == null ? void 0 : item.node()) || null; + }, + /** + * Update the legend + * @param {Array} targetIds ID's of target + * @param {object} options withTransform : Whether to use the transform property / withTransitionForTransform: Whether transition is used when using the transform property / withTransition : whether or not to transition. + * @private + */ + updateLegendElement(targetIds, options) { + const $$ = this; + const { config, state, $el: { legend }, $T } = $$; + const legendType = config.legend_item_tile_type; + const isRectangle = legendType !== "circle"; + const legendItemR = config.legend_item_tile_r; + const itemTileSize = { + width: isRectangle ? config.legend_item_tile_width : legendItemR * 2, + height: isRectangle ? config.legend_item_tile_height : legendItemR * 2 + }; + const dimension = { + padding: { + top: 4, + right: 10 + }, + max: { + width: 0, + height: 0 + }, + posMin: 10, + step: 0, + tileWidth: itemTileSize.width + 5, + totalLength: 0 + }; + const sizes = { + offsets: {}, + widths: {}, + heights: {}, + margins: [0], + steps: {} + }; + let xForLegend; + let yForLegend; + let background; + const targetIdz = targetIds.filter((id) => !isDefined(config.data_names[id]) || config.data_names[id] !== null); + const withTransition = options.withTransition; + const updatePositions = $$.getUpdateLegendPositions(targetIdz, dimension, sizes); + if (state.isLegendInset) { + dimension.step = config.legend_inset_step ? config.legend_inset_step : targetIdz.length; + $$.updateLegendStep(dimension.step); + } + if (state.isLegendRight) { + xForLegend = (id) => dimension.max.width * sizes.steps[id]; + yForLegend = (id) => sizes.margins[sizes.steps[id]] + sizes.offsets[id]; + } else if (state.isLegendInset) { + xForLegend = (id) => dimension.max.width * sizes.steps[id] + 10; + yForLegend = (id) => sizes.margins[sizes.steps[id]] + sizes.offsets[id]; + } else { + xForLegend = (id) => sizes.margins[sizes.steps[id]] + sizes.offsets[id]; + yForLegend = (id) => dimension.max.height * sizes.steps[id]; + } + const posFn = { + xText: (id, i) => xForLegend(id, i) + 4 + itemTileSize.width, + xRect: (id, i) => xForLegend(id, i), + x1Tile: (id, i) => xForLegend(id, i) - 2, + x2Tile: (id, i) => xForLegend(id, i) - 2 + itemTileSize.width, + yText: (id, i) => yForLegend(id, i) + 9, + yRect: (id, i) => yForLegend(id, i) - 5, + yTile: (id, i) => yForLegend(id, i) + 4 + }; + $$.generateLegendItem(targetIdz, itemTileSize, updatePositions, posFn); + background = legend.select(`.${$LEGEND.legendBackground} rect`); + if (state.isLegendInset && dimension.max.width > 0 && background.size() === 0) { + background = legend.insert("g", `.${$LEGEND.legendItem}`).attr("class", $LEGEND.legendBackground).append("rect"); + } + if (config.legend_tooltip) { + legend.selectAll("title").data(targetIdz).text((id) => _getFormattedText.bind($$)(id, false)); + } + const texts = legend.selectAll("text").data(targetIdz).text((id) => _getFormattedText.bind($$)(id)).each(function(id, i) { + updatePositions(this, id, i); + }); + $T(texts, withTransition).attr("x", posFn.xText).attr("y", posFn.yText); + const rects = legend.selectAll(`rect.${$LEGEND.legendItemEvent}`).data(targetIdz); + $T(rects, withTransition).attr("width", (id) => sizes.widths[id]).attr("height", (id) => sizes.heights[id]).attr("x", posFn.xRect).attr("y", posFn.yRect); + $$.updateLegendItemPos(targetIdz, withTransition, posFn); + if (background) { + $T(background, withTransition).attr("height", $$.getLegendHeight() - 12).attr("width", dimension.max.width * (dimension.step + 1) + 10); + } + $$.updateLegendItemWidth(dimension.max.width); + $$.updateLegendItemHeight(dimension.max.height); + $$.updateLegendStep(dimension.step); + }, + /** + * Get position update function + * @param {Array} targetIdz Data ids + * @param {object} dimension Dimension object + * @param {object} sizes Size object + * @returns {function} Update position function + * @private + */ + getUpdateLegendPositions(targetIdz, dimension, sizes) { + const $$ = this; + const { config, state } = $$; + const isLegendRightOrInset = state.isLegendRight || state.isLegendInset; + return function(textElement, id, index) { + const reset = index === 0; + const isLast = index === targetIdz.length - 1; + const box = $$.getLegendItemTextBox(id, textElement); + const itemWidth = box.width + dimension.tileWidth + (isLast && !isLegendRightOrInset ? 0 : dimension.padding.right) + config.legend_padding; + const itemHeight = box.height + dimension.padding.top; + const itemLength = isLegendRightOrInset ? itemHeight : itemWidth; + const areaLength = isLegendRightOrInset ? $$.getLegendHeight() : $$.getLegendWidth(); + let margin; + const updateValues = function(id2, withoutStep) { + if (!withoutStep) { + margin = (areaLength - dimension.totalLength - itemLength) / 2; + if (margin < dimension.posMin) { + margin = (areaLength - itemLength) / 2; + dimension.totalLength = 0; + dimension.step++; + } + } + sizes.steps[id2] = dimension.step; + sizes.margins[dimension.step] = state.isLegendInset ? 10 : margin; + sizes.offsets[id2] = dimension.totalLength; + dimension.totalLength += itemLength; + }; + if (reset) { + dimension.totalLength = 0; + dimension.step = 0; + dimension.max.width = 0; + dimension.max.height = 0; + } + if (config.legend_show && !$$.isLegendToShow(id)) { + sizes.widths[id] = 0; + sizes.heights[id] = 0; + sizes.steps[id] = 0; + sizes.offsets[id] = 0; + return; + } + sizes.widths[id] = itemWidth; + sizes.heights[id] = itemHeight; + if (!dimension.max.width || itemWidth >= dimension.max.width) { + dimension.max.width = itemWidth; + } + if (!dimension.max.height || itemHeight >= dimension.max.height) { + dimension.max.height = itemHeight; + } + const maxLength = isLegendRightOrInset ? dimension.max.height : dimension.max.width; + if (config.legend_equally) { + Object.keys(sizes.widths).forEach((id2) => sizes.widths[id2] = dimension.max.width); + Object.keys(sizes.heights).forEach( + (id2) => sizes.heights[id2] = dimension.max.height + ); + margin = (areaLength - maxLength * targetIdz.length) / 2; + if (margin < dimension.posMin) { + dimension.totalLength = 0; + dimension.step = 0; + targetIdz.forEach((id2) => updateValues(id2)); + } else { + updateValues(id, true); + } + } else { + updateValues(id); + } + }; + }, + /** + * Generate legend item elements + * @param {Array} targetIdz Data ids + * @param {object} itemTileSize Item tile size {width, height} + * @param {function} updatePositions Update position function + * @param {object} posFn Position functions + * @private + */ + generateLegendItem(targetIdz, itemTileSize, updatePositions, posFn) { + const $$ = this; + const { config, state, $el: { legend } } = $$; + const usePoint = config.legend_usePoint; + const legendItemR = config.legend_item_tile_r; + const legendType = config.legend_item_tile_type; + const isRectangle = legendType !== "circle"; + const isLegendRightOrInset = state.isLegendRight || state.isLegendInset; + const pos = -200; + const l = legend.selectAll(`.${$LEGEND.legendItem}`).data(targetIdz).enter().append("g"); + $$.setLegendItem(l); + if (config.legend_tooltip) { + l.append("title").text((id) => id); + } + l.append("text").text((id) => _getFormattedText.bind($$)(id)).each(function(id, i) { + updatePositions(this, id, i); + }).style("pointer-events", $$.getStylePropValue("none")).attr("x", isLegendRightOrInset ? posFn.xText : pos).attr("y", isLegendRightOrInset ? pos : posFn.yText); + l.append("rect").attr("class", $LEGEND.legendItemEvent).style("fill-opacity", $$.getStylePropValue("0")).attr("x", isLegendRightOrInset ? posFn.xRect : pos).attr("y", isLegendRightOrInset ? pos : posFn.yRect); + if (usePoint) { + const ids = []; + const pattern = $$.getValidPointPattern(); + l.append((d) => { + ids.indexOf(d) === -1 && ids.push(d); + let point = pattern[ids.indexOf(d) % pattern.length]; + if (point === "rectangle") { + point = "rect"; + } + return browser_doc.createElementNS( + external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.namespaces.svg, + "hasValidPointType" in $$ && $$.hasValidPointType(point) ? point : "use" + ); + }).attr("class", $LEGEND.legendItemPoint).style("fill", _getLegendColor.bind($$)).style("pointer-events", $$.getStylePropValue("none")).attr("href", (data, idx, selection) => { + const node = selection[idx]; + const nodeName = node.nodeName.toLowerCase(); + const id = $$.getTargetSelectorSuffix(data); + return nodeName === "use" ? `#${state.datetimeId}-point${id}` : void 0; + }); + } else { + l.append(isRectangle ? "line" : legendType).attr("class", $LEGEND.legendItemTile).style("stroke", _getLegendColor.bind($$)).style("pointer-events", $$.getStylePropValue("none")).call((selection) => { + if (legendType === "circle") { + selection.attr("r", legendItemR).style("fill", _getLegendColor.bind($$)).attr("cx", isLegendRightOrInset ? posFn.x2Tile : pos).attr("cy", isLegendRightOrInset ? pos : posFn.yTile); + } else if (isRectangle) { + selection.attr("stroke-width", itemTileSize.height).attr("x1", isLegendRightOrInset ? posFn.x1Tile : pos).attr("y1", isLegendRightOrInset ? pos : posFn.yTile).attr("x2", isLegendRightOrInset ? posFn.x2Tile : pos).attr("y2", isLegendRightOrInset ? pos : posFn.yTile); + } + }); + } + }, + /** + * Update legend item position + * @param {Array} targetIdz Data ids + * @param {boolean} withTransition Whether or not to apply transition + * @param {object} posFn Position functions + * @private + */ + updateLegendItemPos(targetIdz, withTransition, posFn) { + const $$ = this; + const { config, $el: { legend }, $T } = $$; + const usePoint = config.legend_usePoint; + const legendType = config.legend_item_tile_type; + const isRectangle = legendType !== "circle"; + if (usePoint) { + const tiles = legend.selectAll(`.${$LEGEND.legendItemPoint}`).data(targetIdz); + $T(tiles, withTransition).each(function() { + const nodeName = this.nodeName.toLowerCase(); + const pointR = config.point_r; + let x = "x"; + let y = "y"; + let xOffset = 2; + let yOffset = 2.5; + let radius = null; + let width = null; + let height = null; + if (nodeName === "circle") { + const size = pointR * 0.2; + x = "cx"; + y = "cy"; + radius = pointR + size; + xOffset = pointR * 2; + yOffset = -size; + } else if (nodeName === "rect") { + const size = pointR * 2.5; + width = size; + height = size; + yOffset = 3; + } + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).attr(x, (d) => posFn.x1Tile(d) + xOffset).attr(y, (d) => posFn.yTile(d) - yOffset).attr("r", radius).attr("width", width).attr("height", height); + }); + } else { + const tiles = legend.selectAll(`.${$LEGEND.legendItemTile}`).data(targetIdz); + $T(tiles, withTransition).style("stroke", _getLegendColor.bind($$)).call((selection) => { + if (legendType === "circle") { + selection.attr("cx", (d) => { + const x2 = posFn.x2Tile(d); + return x2 - (x2 - posFn.x1Tile(d)) / 2; + }).attr("cy", posFn.yTile); + } else if (isRectangle) { + selection.attr("x1", posFn.x1Tile).attr("y1", posFn.yTile).attr("x2", posFn.x2Tile).attr("y2", posFn.yTile); + } + }); + } + } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-transition","commonjs2":"d3-transition","amd":"d3-transition","root":"d3"} +var external_commonjs_d3_transition_commonjs2_d3_transition_amd_d3_transition_root_d3_ = __webpack_require__(8); +;// ./src/ChartInternal/internals/redraw.ts + + + + +/* harmony default export */ var redraw = ({ + redraw(options = {}) { + var _a, _b, _c, _d; + const $$ = this; + const { config, state, $el } = $$; + const { main, treemap } = $el; + state.redrawing = true; + const targetsToShow = $$.filterTargetsToShow($$.data.targets); + const { flow, initializing } = options; + const wth = $$.getWithOption(options); + const duration = wth.Transition ? config.transition_duration : 0; + const durationForExit = wth.TransitionForExit ? duration : 0; + const durationForAxis = wth.TransitionForAxis ? duration : 0; + const transitions = (_a = $$.axis) == null ? void 0 : _a.generateTransitions(durationForAxis); + $$.updateSizes(initializing); + if (wth.Legend && config.legend_show) { + options.withTransition = !!duration; + !treemap && $$.updateLegend($$.mapToIds($$.data.targets), options, transitions); + } else if (wth.Dimension) { + $$.updateDimension(true); + } + config.data_empty_label_text && main.select(`text.${$TEXT.text}.${$COMMON.empty}`).attr("x", state.width / 2).attr("y", state.height / 2).text(config.data_empty_label_text).style("display", targetsToShow.length ? "none" : null); + if (state.hasAxis) { + $$.axis.redrawAxis(targetsToShow, wth, transitions, flow, initializing); + $$.hasGrid() && $$.updateGrid(); + config.regions.length && $$.updateRegion(); + ["bar", "candlestick", "line", "area"].forEach((v) => { + const name = capitalize(v); + if (/^(line|area)$/.test(v) && $$.hasTypeOf(name) || $$.hasType(v)) { + $$[`update${name}`](wth.TransitionForExit); + } + }); + $el.text && main.selectAll(`.${$SELECT.selectedCircles}`).filter($$.isBarType.bind($$)).selectAll("circle").remove(); + if (config.interaction_enabled && !flow && wth.EventRect) { + $$.redrawEventRect(); + (_b = $$.bindZoomEvent) == null ? void 0 : _b.call($$); + } + } else { + $el.arcs && $$.redrawArc(duration, durationForExit, wth.Transform); + $el.radar && $$.redrawRadar(); + $el.polar && $$.redrawPolar(); + $el.funnel && $$.redrawFunnel(); + treemap && $$.updateTreemap(durationForExit); + } + if (!state.resizing && !treemap && ($$.hasPointType() || state.hasRadar)) { + $$.updateCircle(); + } else if ((_c = $$.hasLegendDefsPoint) == null ? void 0 : _c.call($$)) { + $$.data.targets.forEach($$.point("create", this)); + } + $$.hasDataLabel() && !$$.hasArcType(null, ["radar"]) && $$.updateText(); + (_d = $$.redrawTitle) == null ? void 0 : _d.call($$); + initializing && $$.updateTypesElements(); + $$.generateRedrawList(targetsToShow, flow, duration, wth.Subchart); + $$.updateTooltipOnRedraw(); + $$.callPluginHook("$redraw", options, duration); + }, + /** + * Generate redraw list + * @param {object} targets targets data to be shown + * @param {object} flow flow object + * @param {number} duration duration value + * @param {boolean} withSubchart whether or not to show subchart + * @private + */ + generateRedrawList(targets, flow, duration, withSubchart) { + const $$ = this; + const { config, state } = $$; + const shape = $$.getDrawShape(); + if (state.hasAxis) { + config.subchart_show && $$.redrawSubchart(withSubchart, duration, shape); + } + const flowFn = flow && $$.generateFlow({ + targets, + flow, + duration: flow.duration, + shape, + xv: $$.xv.bind($$) + }); + const withTransition = (duration || flowFn) && isTabVisible(); + const redrawList = $$.getRedrawList(shape, flow, flowFn, withTransition); + const afterRedraw = () => { + flowFn && flowFn(); + state.redrawing = false; + callFn(config.onrendered, $$.api); + }; + if (afterRedraw) { + if (withTransition && redrawList.length) { + const waitForDraw = generateWait(); + (0,external_commonjs_d3_transition_commonjs2_d3_transition_amd_d3_transition_root_d3_.transition)().duration(duration).each(() => { + redrawList.reduce((acc, t1) => acc.concat(t1), []).forEach((t) => waitForDraw.add(t)); + }).call(waitForDraw, afterRedraw); + } else if (!state.transiting) { + afterRedraw(); + } + } + $$.mapToIds($$.data.targets).forEach((id) => { + state.withoutFadeIn[id] = true; + }); + }, + getRedrawList(shape, flow, flowFn, withTransition) { + const $$ = this; + const { config, state: { hasAxis, hasRadar, hasTreemap }, $el: { grid } } = $$; + const { cx, cy, xForText, yForText } = shape.pos; + const list = []; + if (hasAxis) { + if (config.grid_x_lines.length || config.grid_y_lines.length) { + list.push($$.redrawGrid(withTransition)); + } + if (config.regions.length) { + list.push($$.redrawRegion(withTransition)); + } + Object.keys(shape.type).forEach((v) => { + const name = capitalize(v); + const drawFn = shape.type[v]; + if (/^(area|line)$/.test(v) && $$.hasTypeOf(name) || $$.hasType(v)) { + list.push($$[`redraw${name}`](drawFn, withTransition)); + } + }); + !flow && grid.main && list.push($$.updateGridFocus()); + } + if (!$$.hasArcType() || hasRadar) { + notEmpty(config.data_labels) && config.data_labels !== false && list.push($$.redrawText(xForText, yForText, flow, withTransition)); + } + if (($$.hasPointType() || hasRadar) && !$$.isPointFocusOnly()) { + $$.redrawCircle && list.push($$.redrawCircle(cx, cy, withTransition, flowFn)); + } + if (hasTreemap) { + list.push($$.redrawTreemap(withTransition)); + } + return list; + }, + updateAndRedraw(options = {}) { + const $$ = this; + const { config, state } = $$; + let transitions; + options.withTransition = getOption(options, "withTransition", true); + options.withTransform = getOption(options, "withTransform", false); + options.withLegend = getOption(options, "withLegend", false); + options.withUpdateXDomain = true; + options.withUpdateOrgXDomain = true; + options.withTransitionForExit = false; + options.withTransitionForTransform = getOption( + options, + "withTransitionForTransform", + options.withTransition + ); + if (!(options.withLegend && config.legend_show)) { + if (state.hasAxis) { + transitions = $$.axis.generateTransitions( + options.withTransitionForAxis ? config.transition_duration : 0 + ); + } + $$.updateScales(); + $$.updateSvgSize(); + $$.transformAll(options.withTransitionForTransform, transitions); + } + $$.redraw(options, transitions); + } +}); + +;// ./src/ChartInternal/internals/scale.ts + + +function getScale(type = "linear", min, max) { + const scale = { + linear: external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleLinear, + log: external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleSymlog, + _log: external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleLog, + time: external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleTime, + utc: external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleUtc + }[type](); + scale.type = type; + /_?log/.test(type) && scale.clamp(true); + return scale.range([min != null ? min : 0, max != null ? max : 1]); +} +/* harmony default export */ var scale = ({ + /** + * Get x Axis scale function + * @param {number} min Min range value + * @param {number} max Max range value + * @param {Array} domain Domain value + * @param {function} offset The offset getter to be sum + * @returns {function} scale + * @private + */ + getXScale(min, max, domain, offset) { + const $$ = this; + const scale = $$.state.loading !== "append" && $$.scale.zoom || getScale($$.axis.getAxisType("x"), min, max); + return $$.getCustomizedXScale( + domain ? scale.domain(domain) : scale, + offset + ); + }, + /** + * Get y Axis scale function + * @param {string} id Axis id: 'y' or 'y2' + * @param {number} min Min value + * @param {number} max Max value + * @param {Array} domain Domain value + * @returns {function} Scale function + * @private + */ + getYScale(id, min, max, domain) { + const $$ = this; + const scale = getScale($$.axis.getAxisType(id), min, max); + domain && scale.domain(domain); + return scale; + }, + /** + * Get y Axis scale + * @param {string} id Axis id + * @param {boolean} isSub Weather is sub Axis + * @returns {function} Scale function + * @private + */ + getYScaleById(id, isSub = false) { + var _a; + const isY2 = ((_a = this.axis) == null ? void 0 : _a.getId(id)) === "y2"; + const key = isSub ? isY2 ? "subY2" : "subY" : isY2 ? "y2" : "y"; + return this.scale[key]; + }, + /** + * Get customized x axis scale + * @param {d3.scaleLinear|d3.scaleTime} scaleValue Scale function + * @param {function} offsetValue Offset getter to be sum + * @returns {function} Scale function + * @private + */ + getCustomizedXScale(scaleValue, offsetValue) { + const $$ = this; + const offset = offsetValue || (() => $$.axis.x.tickOffset()); + const isInverted = $$.config.axis_x_inverted; + const scale = function(d) { + return scaleValue(d) + offset(); + }; + for (const key in scaleValue) { + scale[key] = scaleValue[key]; + } + scale.orgDomain = () => scaleValue.domain(); + scale.orgScale = () => scaleValue; + if ($$.axis.isCategorized()) { + scale.domain = function(domainValue) { + let domain = domainValue; + if (!arguments.length) { + domain = this.orgDomain(); + return isInverted ? [domain[0] + 1, domain[1]] : [domain[0], domain[1] + 1]; + } + scaleValue.domain(domain); + return scale; + }; + } + return scale; + }, + /** + * Update scale + * @param {boolean} isInit Param is given at the init rendering + * @param {boolean} updateXDomain If update x domain + * @private + */ + updateScales(isInit, updateXDomain = true) { + var _a, _b; + const $$ = this; + const { + axis, + config, + format, + org, + scale, + state: { current, width, height, width2, height2, hasAxis, hasTreemap } + } = $$; + if (hasAxis) { + const isRotated = config.axis_rotated; + const resettedPadding = $$.getResettedPadding(1); + const min = { + x: isRotated ? resettedPadding : 0, + y: isRotated ? 0 : height, + subX: isRotated ? 1 : 0, + subY: isRotated ? 0 : height2 + }; + const max = { + x: isRotated ? height : width, + y: isRotated ? width : resettedPadding, + subX: isRotated ? height : width, + subY: isRotated ? width2 : 1 + }; + const xDomain = updateXDomain && ((_a = scale.x) == null ? void 0 : _a.orgDomain()); + const xSubDomain = updateXDomain && org.xDomain; + scale.x = $$.getXScale(min.x, max.x, xDomain, () => axis.x.tickOffset()); + scale.subX = $$.getXScale(min.x, max.x, xSubDomain, (d) => { + var _a2; + return d % 1 ? 0 : ((_a2 = axis.subX) != null ? _a2 : axis.x).tickOffset(); + }); + format.xAxisTick = axis.getXAxisTickFormat(); + format.subXAxisTick = axis.getXAxisTickFormat(true); + axis.setAxis("x", scale.x, config.axis_x_tick_outer, isInit); + if (config.subchart_show) { + axis.setAxis("subX", scale.subX, config.axis_x_tick_outer, isInit); + } + scale.y = $$.getYScale( + "y", + min.y, + max.y, + scale.y ? scale.y.domain() : config.axis_y_default + ); + scale.subY = $$.getYScale( + "y", + min.subY, + max.subY, + scale.subY ? scale.subY.domain() : config.axis_y_default + ); + axis.setAxis("y", scale.y, config.axis_y_tick_outer, isInit); + if (config.axis_y2_show) { + scale.y2 = $$.getYScale( + "y2", + min.y, + max.y, + scale.y2 ? scale.y2.domain() : config.axis_y2_default + ); + scale.subY2 = $$.getYScale( + "y2", + min.subY, + max.subY, + scale.subY2 ? scale.subY2.domain() : config.axis_y2_default + ); + axis.setAxis("y2", scale.y2, config.axis_y2_tick_outer, isInit); + } + } else if (hasTreemap) { + const padding = $$.getCurrentPadding(); + scale.x = (0,external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleLinear)().rangeRound([padding.left, current.width - padding.right]); + scale.y = (0,external_commonjs_d3_scale_commonjs2_d3_scale_amd_d3_scale_root_d3_.scaleLinear)().rangeRound([padding.top, current.height - padding.bottom]); + } else { + (_b = $$.updateArc) == null ? void 0 : _b.call($$); + } + }, + /** + * Get the zoom or unzoomed scaled value + * @param {Date|number|object} d Data value + * @returns {number|null} + * @private + */ + xx(d) { + const $$ = this; + const { config, scale: { x, zoom } } = $$; + const fn = config.zoom_enabled && zoom ? zoom : x; + return d ? fn(isValue(d.x) ? d.x : d) : null; + }, + xv(d) { + const $$ = this; + const { axis, config, scale: { x, zoom } } = $$; + const fn = config.zoom_enabled && zoom ? zoom : x; + let value = $$.getBaseValue(d); + if (axis.isTimeSeries()) { + value = parseDate.call($$, value); + } else if (axis.isCategorized() && isString(value)) { + value = config.axis_x_categories.indexOf(value); + } + return fn(value); + }, + yv(d) { + const $$ = this; + const { scale: { y, y2 } } = $$; + const yScale = d.axis && d.axis === "y2" ? y2 : y; + return yScale($$.getBaseValue(d)); + }, + subxx(d) { + return d ? this.scale.subX(d.x) : null; + } +}); + +;// ./src/ChartInternal/internals/size.ts + + + + +/* harmony default export */ var size = ({ + /** + * Update container size + * @private + */ + setContainerSize() { + const $$ = this; + const { state } = $$; + state.current.width = $$.getCurrentWidth(); + state.current.height = $$.getCurrentHeight(); + }, + getCurrentWidth() { + const $$ = this; + return $$.config.size_width || $$.getParentWidth(); + }, + getCurrentHeight() { + const $$ = this; + const { config } = $$; + const h = config.size_height || $$.getParentHeight(); + return h > 0 ? h : 320 / ($$.hasType("gauge") && !config.gauge_fullCircle ? 2 : 1); + }, + /** + * Get the parent rect element's size + * @param {string} key property/attribute name + * @returns {number} + * @private + */ + getParentRectValue(key) { + const offsetName = `offset${capitalize(key)}`; + let parent = this.$el.chart.node(); + let v = 0; + while (v < 30 && parent && parent.tagName !== "BODY") { + try { + v = getBoundingRect(parent, true)[key]; + } catch (e) { + if (offsetName in parent) { + v = parent[offsetName]; + } + } + parent = parent.parentNode; + } + const bodySize = browser_doc.body[offsetName]; + v > bodySize && (v = bodySize); + return v; + }, + getParentWidth() { + return this.getParentRectValue("width"); + }, + getParentHeight() { + const h = this.$el.chart.style("height"); + let height = 0; + if (h) { + height = /px$/.test(h) ? parseInt(h, 10) : this.getParentRectValue("height"); + } + return height; + }, + getSvgLeft(withoutRecompute) { + const $$ = this; + const { config, state: { hasAxis }, $el } = $$; + const isRotated = config.axis_rotated; + const hasLeftAxisRect = isRotated || !isRotated && !config.axis_y_inner; + const leftAxisClass = isRotated ? $AXIS.axisX : $AXIS.axisY; + const leftAxis = $el.main.select(`.${leftAxisClass}`).node(); + const leftLabel = hasAxis && config[`axis_${isRotated ? "x" : "y"}_label`]; + let labelWidth = 0; + if (hasAxis && (isString(leftLabel) || isString(leftLabel.text) || /^inner-/.test(leftLabel == null ? void 0 : leftLabel.position))) { + const label = $el.main.select(`.${leftAxisClass}-label`); + if (!label.empty()) { + labelWidth = getBoundingRect(label.node()).left; + } + } + const svgRect = leftAxis && hasLeftAxisRect ? getBoundingRect(leftAxis, !withoutRecompute) : { right: 0 }; + const chartRectLeft = getBoundingRect($el.chart.node(), !withoutRecompute).left + labelWidth; + const hasArc = $$.hasArcType(); + const svgLeft = svgRect.right - chartRectLeft - (hasArc ? 0 : $$.getCurrentPaddingByDirection("left", withoutRecompute)); + return svgLeft > 0 ? svgLeft : 0; + }, + updateDimension(withoutAxis) { + var _a; + const $$ = this; + const { config, state: { hasAxis }, $el } = $$; + if (hasAxis && !withoutAxis && $$.axis.x && config.axis_rotated) { + (_a = $$.axis.subX) == null ? void 0 : _a.create($el.axis.subX); + } + $$.updateScales(withoutAxis); + $$.updateSvgSize(); + $$.transformAll(false); + }, + updateSvgSize() { + const $$ = this; + const { config, state: { clip, current, hasAxis, width, height }, $el: { svg } } = $$; + if (config.resize_auto === "viewBox") { + svg.attr("viewBox", `0 0 ${current.width} ${current.height}`); + } else { + svg.attr("width", current.width).attr("height", current.height); + } + if (hasAxis) { + const brush = svg.select(`.${$SUBCHART.brush} .overlay`); + const brushSize = { width: 0, height: 0 }; + if (brush.size()) { + brushSize.width = +brush.attr("width"); + brushSize.height = +brush.attr("height"); + } + svg.selectAll([`#${clip.id}`, `#${clip.idGrid}`]).select("rect").attr("width", width).attr("height", height); + svg.select(`#${clip.idXAxis}`).select("rect").call($$.setXAxisClipPath.bind($$)); + svg.select(`#${clip.idYAxis}`).select("rect").call($$.setYAxisClipPath.bind($$)); + clip.idSubchart && svg.select(`#${clip.idSubchart}`).select("rect").attr("width", width).attr("height", brushSize.height); + } + }, + /** + * Get padding by the direction. + * @param {string} type "top" | "bottom" | "left" | "right" + * @param {boolean} [withoutRecompute=false] If set true, do not recompute the padding value. + * @param {boolean} [withXAxisTickTextOverflow=false] If set true, calculate x axis tick text overflow. + * @returns {number} padding value + * @private + */ + getCurrentPaddingByDirection(type, withoutRecompute = false, withXAxisTickTextOverflow = false) { + var _a; + const $$ = this; + const { config, $el, state: { hasAxis } } = $$; + const isRotated = config.axis_rotated; + const isFitPadding = ((_a = config.padding) == null ? void 0 : _a.mode) === "fit"; + const paddingOption = isNumber(config[`padding_${type}`]) ? config[`padding_${type}`] : void 0; + const axisId = hasAxis ? { + top: isRotated ? "y2" : null, + bottom: isRotated ? "y" : "x", + left: isRotated ? "x" : "y", + right: isRotated ? null : "y2" + }[type] : null; + const isLeftRight = /^(left|right)$/.test(type); + const isAxisInner = axisId && config[`axis_${axisId}_inner`]; + const isAxisShow = axisId && config[`axis_${axisId}_show`]; + const axesLen = axisId ? config[`axis_${axisId}_axes`].length : 0; + let axisSize = axisId ? isLeftRight ? $$.getAxisWidthByAxisId(axisId, withoutRecompute) : $$.getHorizontalAxisHeight(axisId) : 0; + const defaultPadding = 20; + let gap = 0; + if (!isFitPadding && isLeftRight) { + axisSize = ceil10(axisSize); + } + let padding = hasAxis && isLeftRight && (isAxisInner || isUndefined(paddingOption) && !isAxisShow) ? 0 : isFitPadding ? (isAxisShow ? axisSize : 0) + (paddingOption != null ? paddingOption : 0) : isUndefined(paddingOption) ? axisSize : paddingOption; + if (isLeftRight && hasAxis) { + if (axisId && (isFitPadding || isAxisInner) && config[`axis_${axisId}_label`].text) { + padding += $$.axis.getAxisLabelPosition(axisId).isOuter ? defaultPadding : 0; + } + if (type === "right") { + padding += isRotated ? !isFitPadding && isUndefined(paddingOption) ? 10 : 2 : !isAxisShow || isAxisInner ? isFitPadding ? 2 : 1 : 0; + padding += withXAxisTickTextOverflow ? $$.axis.getXAxisTickTextY2Overflow(defaultPadding) : 0; + } else if (type === "left" && isRotated && isUndefined(paddingOption)) { + padding = !config.axis_x_show ? 1 : isFitPadding ? axisSize : Math.max(axisSize, 40); + } + } else { + if (type === "top") { + if ($el.title && $el.title.node()) { + padding += $$.getTitlePadding(); + } + gap = isRotated && !isAxisInner ? axesLen : 0; + } else if (type === "bottom" && hasAxis && isRotated && !isAxisShow) { + padding += 1; + } + } + return padding + axisSize * axesLen - gap; + }, + getCurrentPadding(withXAxisTickTextOverflow = false) { + const $$ = this; + const [top, bottom, left, right] = ["top", "bottom", "left", "right"].map((v) => $$.getCurrentPaddingByDirection(v, null, withXAxisTickTextOverflow)); + return { top, bottom, left, right }; + }, + /** + * Get resetted padding values when 'padding=false' option is set + * https://github.com/naver/billboard.js/issues/2367 + * @param {number|object} v Padding values to be resetted + * @returns {number|object} Padding value + * @private + */ + getResettedPadding(v) { + const $$ = this; + const { config } = $$; + const isNum = isNumber(v); + let p = isNum ? 0 : {}; + if (config.padding === false) { + !isNum && Object.keys(v).forEach((key) => { + p[key] = !isEmpty(config.data_labels) && config.data_labels !== false && key === "top" ? v[key] : 0; + }); + } else { + p = v; + } + return p; + }, + /** + * Update size values + * @param {boolean} isInit If is called at initialization + * @private + */ + updateSizes(isInit) { + var _a, _b, _c, _d, _e; + const $$ = this; + const { config, state, $el: { legend } } = $$; + const isRotated = config.axis_rotated; + const isNonAxis = $$.hasArcType() || state.hasFunnel || state.hasTreemap; + const isFitPadding = ((_a = config.padding) == null ? void 0 : _a.mode) === "fit"; + !isInit && $$.setContainerSize(); + const currLegend = { + width: legend ? $$.getLegendWidth() : 0, + height: legend ? $$.getLegendHeight() : 0 + }; + if (!isNonAxis && config.axis_x_show && config.axis_x_tick_autorotate) { + $$.updateXAxisTickClip(); + } + const legendSize = { + right: config.legend_show && state.isLegendRight ? $$.getLegendWidth() + (isFitPadding ? 0 : 20) : 0, + bottom: !config.legend_show || state.isLegendRight || state.isLegendInset ? 0 : currLegend.height + }; + const xAxisHeight = isRotated || isNonAxis ? 0 : $$.getHorizontalAxisHeight("x"); + const subchartXAxisHeight = config.subchart_axis_x_show && config.subchart_axis_x_tick_text_show ? xAxisHeight : 30; + const subchartHeight = config.subchart_show && !isNonAxis ? config.subchart_size_height + subchartXAxisHeight : 0; + const gaugeHeight = $$.hasType("gauge") && config.arc_needle_show && !config.gauge_fullCircle && !config.gauge_label_show ? 10 : 0; + const padding = $$.getCurrentPadding(true); + state.margin = !isNonAxis && isRotated ? { + top: padding.top, + right: isNonAxis ? 0 : padding.right + legendSize.right, + bottom: legendSize.bottom + padding.bottom, + left: subchartHeight + (isNonAxis ? 0 : padding.left) + } : { + top: (isFitPadding ? 0 : 4) + padding.top, + // for top tick text + right: isNonAxis ? 0 : padding.right + legendSize.right, + bottom: gaugeHeight + subchartHeight + legendSize.bottom + padding.bottom, + left: isNonAxis ? 0 : padding.left + }; + state.margin = $$.getResettedPadding(state.margin); + state.margin2 = isRotated ? { + top: state.margin.top, + right: NaN, + bottom: 20 + legendSize.bottom, + left: $$.state.rotatedPadding.left + } : { + top: state.current.height - subchartHeight - legendSize.bottom, + right: NaN, + bottom: subchartXAxisHeight + legendSize.bottom, + left: state.margin.left + }; + state.margin3 = { + top: 0, + right: NaN, + bottom: 0, + left: 0 + }; + (_b = $$.updateSizeForLegend) == null ? void 0 : _b.call($$, currLegend); + state.width = state.current.width - state.margin.left - state.margin.right; + state.height = state.current.height - state.margin.top - state.margin.bottom; + if (state.width < 0) { + state.width = 0; + } + if (state.height < 0) { + state.height = 0; + } + state.width2 = isRotated ? state.margin.left - state.rotatedPadding.left - state.rotatedPadding.right : state.width; + state.height2 = isRotated ? state.height : state.current.height - state.margin2.top - state.margin2.bottom; + if (state.width2 < 0) { + state.width2 = 0; + } + if (state.height2 < 0) { + state.height2 = 0; + } + if ($$.hasArcType()) { + const hasGauge = $$.hasType("gauge"); + const isLegendRight = config.legend_show && state.isLegendRight; + const textWidth = (_c = state.hasRadar && $$.cache.get(KEY.radarTextWidth)) != null ? _c : 0; + state.arcWidth = state.width - (isLegendRight ? currLegend.width + 10 : 0) - textWidth; + state.arcHeight = state.height - (isLegendRight && !hasGauge ? 0 : 10); + if ((_d = config.arc_rangeText_values) == null ? void 0 : _d.length) { + if (hasGauge) { + state.arcWidth -= 25; + state.arcHeight -= 10; + state.margin.left += 10; + } else { + state.arcHeight -= 20; + state.margin.top += 10; + } + } + if (hasGauge && !config.gauge_fullCircle) { + state.arcHeight += state.height - $$.getPaddingBottomForGauge(); + } + (_e = $$.updateRadius) == null ? void 0 : _e.call($$); + } + if (state.isLegendRight && isNonAxis) { + state.margin3.left = state.arcWidth / 2 + state.radiusExpanded * 1.1; + } + } +}); + +;// ./src/ChartInternal/internals/style.ts + + +/* harmony default export */ var style = ({ + /** + * Add props color css rule to given selector + * @param {boolean} withShape Set shpes' prefix class + * @param {string} selector CSS selector + * @param {Array} props CSS props list + * @param {function} propsFn Function to retrieve value or determine for props + * @returns {function} + * @private + */ + setCssRule(withShape, selector, props, propsFn) { + const $$ = this; + const { config, state: { cssRule, style } } = $$; + return config.boost_useCssRule ? (selection) => { + selection.each((d) => { + const res = propsFn && (propsFn == null ? void 0 : propsFn.call($$, d)); + const shapeSelector = `${withShape ? `.${$SHAPE.shapes + $$.getTargetSelectorSuffix(d.id)}` : ""}${selector}`; + selector in cssRule && style.sheet.deleteRule(cssRule[shapeSelector]); + $$.state.cssRule[shapeSelector] = addCssRules( + style, + shapeSelector, + props.filter(Boolean).map((v) => isString(res) && v.indexOf(":") === -1 ? `${v}: ${res}` : v || "") + ); + }); + } : () => { + }; + }, + /** + * Get style prop value + * @param {function|string} v Value + * @returns {string|null} + * @private + */ + getStylePropValue(v) { + const { config: { boost_useCssRule: useCssRule } } = this; + return useCssRule ? null : isFunction(v) ? v.bind(this) : v; + } +}); + +;// ./src/ChartInternal/internals/text.util.ts + + + +function getRotateAnchor(angle) { + let anchor = "middle"; + if (angle > 0 && angle <= 170) { + anchor = "end"; + } else if (angle > 190 && angle <= 360) { + anchor = "start"; + } + return anchor; +} +function setRotatePos(d, pos, anchor, isRotated, isInverted) { + var _a; + const $$ = this; + const { value } = d; + const isCandlestickType = $$.isCandlestickType(d); + const isNegative = isNumber(value) && value < 0 || isCandlestickType && !((_a = $$.getCandlestickData(d)) == null ? void 0 : _a._isUp); + let { x, y } = pos; + const gap = 4; + const doubleGap = gap * 2; + if (isRotated) { + if (anchor === "start") { + x += isNegative ? 0 : doubleGap; + y += gap; + } else if (anchor === "middle") { + x += doubleGap; + y -= doubleGap; + } else if (anchor === "end") { + isNegative && (x -= doubleGap); + y += gap; + } + } else { + if (anchor === "start") { + x += gap; + isNegative && (y += doubleGap * 2); + } else if (anchor === "middle") { + y -= doubleGap; + } else if (anchor === "end") { + x -= gap; + isNegative && (y += doubleGap * 2); + } + if (isInverted) { + y += isNegative ? -17 : isCandlestickType ? 13 : 7; + } + } + return { x, y }; +} +function getTextPos(d, type) { + var _a; + const position = this.config.data_labels_position; + const { id, index, value } = d; + return (_a = isFunction(position) ? position.bind(this.api)(type, value, id, index, this.$el.text) : (id in position ? position[id] : position)[type]) != null ? _a : 0; +} +function updateTextBorder(text, pos, rectClass) { + var _a, _b; + const $$ = this; + const { config, $T } = $$; + const isRotated = config.axis_rotated; + const { + border: { + padding = "3 5", + radius = 10, + stroke = "#000", + strokeWidth = 1, + fill = "none" + } + } = config.data_labels; + const borderPadding = parseShorthand(padding); + const applyStyle = config.data_labels.border !== true; + const textRect = getBBox(text); + let borderRect = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(text.previousElementSibling); + if (borderRect.empty() || ((_a = borderRect.node()) == null ? void 0 : _a.tagName) !== "rect" || !((_b = borderRect.attr("class")) == null ? void 0 : _b.includes(rectClass))) { + borderRect = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(text.parentNode).insert("rect", () => text).attr("class", `${$TEXT.textBorderRect} ${rectClass}`).attr( + "width", + textRect.width + (applyStyle ? borderPadding.left + borderPadding.right : 0) + ).attr( + "height", + textRect.height + (applyStyle ? borderPadding.top + borderPadding.bottom : 0) + ); + if (applyStyle) { + borderRect.style("fill", fill).style("stroke", stroke).style("stroke-width", `${strokeWidth}px`).attr("rx", radius).attr("ry", radius); + } + } + $T(borderRect).attr( + "x", + pos.x - (applyStyle ? borderPadding.left : 0) - (isRotated ? 0 : textRect.width / 2) + ).attr("y", pos.y - (applyStyle ? borderPadding.top : 0) - textRect.height / 4 * 3.2); +} +function meetsLabelThreshold(ratio = 0, type) { + const $$ = this; + const { config } = $$; + const threshold = config[`${type}_label_threshold`] || 0; + return ratio >= threshold; +} +function updateTextImage() { + const $$ = this; + const { $el: { text }, config } = $$; + const isArc = $$.state.arcWidth; + if (isArc ? $$.getArcLabelConfig("image") : config.data_labels.image) { + text.filter(function() { + const prev = this.previousElementSibling; + if (prev) { + return prev.tagName !== "image" || !prev.classList.contains($TEXT.textLabelImage); + } + return true; + }).each(function(d) { + var _a, _b, _c, _d; + const { url, width, height, pos } = getDataLabelImgUrl.call($$, d); + if (url) { + const parentNode = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this.parentNode); + parentNode == null ? void 0 : parentNode.insert( + "image", + `${(_b = (_a = this.getAttribute("class")) == null ? void 0 : _a.replace(/(?:^(.)|\s)/g, ".$1")) != null ? _b : "text"}` + ).style("opacity", "0").attr("href", (d2) => tplProcess(url, { + ID: "id" in d2 ? d2.id : d2.data.id + })).attr("class", $TEXT.textLabelImage).style("pointer-events", "none").attr("width", width).attr("height", height).attr("transform", pos ? `translate(${(_c = pos.x) != null ? _c : 0} ${(_d = pos.y) != null ? _d : 0})` : null); + } + }); + } +} +function getDataLabelImgUrl(d) { + var _a; + const $$ = this; + const { config, state } = $$; + const image = state.arcWidth ? $$.getArcLabelConfig("image") : config.data_labels.image; + if (isFunction(image)) { + return (_a = image.call($$.api, d.value, d.id, d.index)) != null ? _a : { + url: "", + width: 0, + height: 0, + pos: { x: 0, y: 0 } + }; + } else if (image) { + const { url = "", width = 0, height = 0, pos } = image; + return { + url, + width, + height, + pos + }; + } + return null; +} +function updateTextImagePos(textNode, pos) { + var _a; + const $$ = this; + const { config, state: { arcWidth, hasTreemap } } = $$; + const isRotated = config.axis_rotated; + const image = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(textNode.previousElementSibling); + const isShown = (textNode2) => { + var _a2; + const isShown2 = textNode2.style.opacity !== "0" && textNode2.style.fillOpacity !== "0"; + return (arcWidth ? textNode2.textContent : isShown2) && ((_a2 = this.previousElementSibling) == null ? void 0 : _a2.tagName) !== "image"; + }; + if (!image.empty() && ((_a = image.node()) == null ? void 0 : _a.tagName) === "image") { + const textRect = getBoundingRect(textNode); + const w = +image.attr("width") / 2; + const h = +image.attr("height") / 2; + let x = pos.x - w; + let y = pos.y - h - textRect.height / 2; + if (isRotated) { + pos.x += w; + } else { + if (hasTreemap) { + x = -w; + y = -(h * 2 + textRect.height); + } + if (!($$.hasType("pie") || $$.hasType("polar"))) { + pos.y += h; + } + } + $$.$T(image).style("opacity", isShown(textNode) ? null : "0").attr("x", x).attr("y", y); + } +} +function batchGetBBox(elements) { + return toMap( + elements, + (element) => element, + (element) => getBBox(element) + ); +} + + +;// ./src/ChartInternal/internals/text.ts + + + + + +/* harmony default export */ var internals_text = ({ + opacityForText(d) { + const $$ = this; + return $$.isBarType(d) && !meetsLabelThreshold.call($$, Math.abs($$.getRatio("bar", d)), "bar") ? "0" : $$.hasDataLabel ? null : "0"; + }, + /** + * Initializes the text + * @private + */ + initText() { + const { $el } = this; + $el.main.select(`.${$COMMON.chart}`).append("g").attr("class", $TEXT.chartTexts).style("pointer-events", $el.funnel || $el.treemap ? "none" : null); + }, + /** + * Update chartText + * @param {object} targets $$.data.targets + * @private + */ + updateTargetsForText(targets) { + const $$ = this; + const classChartText = $$.getChartClass("Text"); + const classTexts = $$.getClass("texts", "id"); + const classFocus = $$.classFocus.bind($$); + const mainTextUpdate = $$.$el.main.select(`.${$TEXT.chartTexts}`).selectAll(`.${$TEXT.chartText}`).data($$.filterNullish(targets)).attr("class", (d) => `${classChartText(d)}${classFocus(d)}`.trim()); + const mainTextEnter = mainTextUpdate.enter().append("g").style("opacity", "0").attr("class", classChartText).call( + $$.setCssRule( + true, + ` .${$TEXT.text}`, + ["fill", "pointer-events:none"], + $$.updateTextColor + ) + ); + mainTextEnter.append("g").attr("class", classTexts); + }, + /** + * Update text + * @private + */ + updateText() { + const $$ = this; + const { $el, $T, config, axis } = $$; + const classText = $$.getClass("text", "index"); + const labelsCentered = config.data_labels.centered; + const text = $el.main.selectAll(`.${$TEXT.texts}`).selectAll(`.${$TEXT.text}`).data($$.labelishData.bind($$)); + $T(text.exit()).style("fill-opacity", "0").remove(); + $el.text = text.enter().append("text").merge(text).attr("class", classText).attr("text-anchor", (d) => { + const isInverted = config[`axis_${axis == null ? void 0 : axis.getId(d.id)}_inverted`]; + let isEndAnchor = isInverted ? d.value > 0 : d.value < 0; + if ($$.isCandlestickType(d)) { + const data = $$.getCandlestickData(d); + isEndAnchor = !(data == null ? void 0 : data._isUp); + } else if ($$.isTreemapType(d)) { + return labelsCentered ? "middle" : "start"; + } + return config.axis_rotated ? isEndAnchor ? "end" : "start" : "middle"; + }).style("fill", $$.getStylePropValue($$.updateTextColor)).style("fill-opacity", "0").each(function(d, i, texts) { + const node = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + let { value } = d; + if ($$.isBubbleZType(d)) { + value = $$.getBubbleZData(value, "z"); + } else if ($$.isCandlestickType(d)) { + const data = $$.getCandlestickData(d); + if (data) { + value = data.close; + } + } + value = $$.isTreemapType(d) ? $$.treemapDataLabelFormat(d)(node) : $$.dataLabelFormat(d.id)(value, d.id, d.index, texts); + if (isNumber(value)) { + this.textContent = value; + } else { + setTextValue(node, value, void 0, true); + } + }); + updateTextImage.call($$); + }, + updateTextColor(d) { + const $$ = this; + const { config } = $$; + const labelColors = config.data_labels_colors; + const defaultColor = $$.isArcType(d) && !$$.isRadarType(d) || $$.isFunnelType(d) || $$.isTreemapType(d) ? null : $$.color(d); + let color; + if (isString(labelColors)) { + color = labelColors; + } else if (isObject(labelColors)) { + const { id } = d.data || d; + color = labelColors[id]; + } else if (isFunction(labelColors)) { + color = labelColors.bind($$.api)(defaultColor, d); + } + if ($$.isCandlestickType(d) && !isFunction(labelColors)) { + const value = $$.getCandlestickData(d); + if (!(value == null ? void 0 : value._isUp)) { + const downColor = config.candlestick_color_down; + color = isObject(downColor) ? downColor[d.id] : downColor; + } + } + return color || defaultColor; + }, + /** + * Update data label text background color + * @param {object} d Data object + * @param {object|string|function} option option object + * @returns {string|null} + * @private + */ + updateTextBGColor(d, option) { + const $$ = this; + const { $el: { defs } } = $$; + let color = ""; + if (option) { + const id = isString(option) ? "" : $$.getTargetSelectorSuffix("id" in d ? d.id : d.data.id); + const filter = defs.select(["filter[id*='labels-bg", "']"].join(id)); + if (filter.size()) { + color = `url(#${filter.attr("id")})`; + } + if (isFunction(option)) { + $$.generateTextBGColorFilter(option); + const defaultColor = $$.color(d); + const bgColor = option.bind($$.api)(defaultColor, d); + if (bgColor) { + filter.select("feFlood").attr("flood-color", bgColor); + } else { + color = ""; + } + } + } + return color || null; + }, + /** + * Redraw chartText + * @param {function} getX Positioning function for x + * @param {function} getY Positioning function for y + * @param {boolean} forFlow Weather is flow + * @param {boolean} withTransition transition is enabled + * @returns {Array} + * @private + */ + redrawText(getX, getY, forFlow, withTransition) { + const $$ = this; + const { $T, axis, config, state: { hasTreemap } } = $$; + const t = getRandom(true); + const isRotated = config.axis_rotated; + const angle = config.data_labels.rotate; + const anchorString = getRotateAnchor(angle); + const rotateString = angle ? `rotate(${angle})` : ""; + let bboxCache = /* @__PURE__ */ new Map(); + if (config.data_labels.centered) { + const elementsToMeasure = []; + $$.$el.text.each(function(d) { + if ($$.isBarType(d) || $$.isTreemapType(d)) { + elementsToMeasure.push(this); + } + }); + if (elementsToMeasure.length > 0) { + bboxCache = batchGetBBox(elementsToMeasure); + } + } + $$.$el.text.style("fill", $$.getStylePropValue($$.updateTextColor)).attr( + "filter", + (d) => $$.updateTextBGColor.bind($$)(d, config.data_labels_backgroundColors) + ).style("fill-opacity", forFlow ? 0 : $$.opacityForText.bind($$)).each(function(d, i) { + const cachedBbox = bboxCache.get(this); + const node = $T( + hasTreemap && this.childElementCount ? this.parentNode : this, + !!(withTransition && (this.getAttribute("x") || this.getAttribute("transform"))), + t + ); + const isInverted = config[`axis_${axis == null ? void 0 : axis.getId(d.id)}_inverted`]; + let pos = { + x: getX.bind(this)(d, i, cachedBbox), + y: getY.bind(this)(d, i, cachedBbox) + }; + if (angle) { + pos = setRotatePos.bind($$)(d, pos, anchorString, isRotated, isInverted); + node.attr("text-anchor", anchorString); + } + updateTextImagePos.call($$, this, pos); + if (this.childElementCount || angle) { + node.attr("transform", `translate(${pos.x} ${pos.y}) ${rotateString}`); + } else { + node.attr("x", pos.x).attr("y", pos.y); + } + config.data_labels.border && updateTextBorder.call($$, node.node(), pos, `${$TEXT.textBorderRect}-${i}`); + }); + return true; + }, + /** + * Gets the getBoundingClientRect value of the element + * @param {HTMLElement|d3.selection|Array} source Target element + * @param {string} className Class name + * @returns {object} value of element.getBoundingClientRect() + * @private + */ + getTextRect(source, className) { + var _a, _b; + const $$ = this; + let cacheKey; + let base; + let text; + if (Array.isArray(source)) { + cacheKey = `${KEY.textRect}-${source.join("_")}`; + } else { + base = (_b = (_a = source.node) == null ? void 0 : _a.call(source)) != null ? _b : source; + if (!/text/i.test(base.tagName)) { + base = base.querySelector("text"); + } + text = base.textContent; + cacheKey = `${KEY.textRect}-${text.replace(/\W/g, "_")}`; + } + const rect = $$.cache.get(cacheKey) || []; + if (rect.length === 0) { + ($$.$el.svg || $$.$el.chart.select("svg")).selectAll(`.${$COMMON.dummy}`).data(text ? [text] : source).enter().append("text").style("visibility", "hidden").style("font", base ? (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(base).style("font") : null).classed(className || $COMMON.dummy, true).text((d) => d).each(function(v, i) { + rect[i] = getBoundingRect(this); + }).remove(); + $$.cache.add(cacheKey, rect); + } + return rect.length > 1 ? rect : rect[0]; + }, + /** + * Gets the x or y coordinate of the text + * @param {object} indices Indices values + * @param {boolean} forX whether or not to x + * @returns {number} coordinates + * @private + */ + generateXYForText(indices, forX) { + const $$ = this; + const { state: { hasRadar, hasFunnel, hasTreemap } } = $$; + const types = Object.keys(indices); + const points = {}; + const getter = forX ? $$.getXForText : $$.getYForText; + hasFunnel && types.push("funnel"); + hasRadar && types.push("radar"); + hasTreemap && types.push("treemap"); + types.forEach((v) => { + points[v] = $$[`generateGet${capitalize(v)}Points`](indices[v], false); + }); + return function(d, i) { + const type = $$.isAreaType(d) && "area" || $$.isBarType(d) && "bar" || $$.isCandlestickType(d) && "candlestick" || $$.isFunnelType(d) && "funnel" || $$.isRadarType(d) && "radar" || $$.isTreemapType(d) && "treemap" || "line"; + return getter.call($$, points[type](d, i), d, this); + }; + }, + /** + * Get centerized text position for bar type data.label.text + * @param {object} d Data object + * @param {Array} points Data points position + * @param {HTMLElement} textElement Data label text element + * @param {string} type 'x' or 'y' + * @param {DOMRect} cachedBbox Optional cached bounding box (from getBBox batching) + * @returns {number} Position value + * @private + */ + getCenteredTextPos(d, points, textElement, type, cachedBbox) { + const $$ = this; + const { config } = $$; + const isRotated = config.axis_rotated; + const isBarType = $$.isBarType(d); + const isTreemapType = $$.isTreemapType(d); + if (config.data_labels.centered && (isBarType || isTreemapType)) { + const rect = cachedBbox || getBBox(textElement); + if (isBarType) { + const isPositive = $$.getRangedData(d, null, "bar") >= 0; + if (isRotated) { + const w = (isPositive ? points[1][1] - points[0][1] : points[0][1] - points[1][1]) / 2 + rect.width / 2; + return isPositive ? -w - 3 : w + 2; + } else { + const h = (isPositive ? points[0][1] - points[1][1] : points[1][1] - points[0][1]) / 2 + rect.height / 2; + return isPositive ? h : -h - 2; + } + } else if (isTreemapType) { + return type === "x" ? (points[1][0] - points[0][0]) / 2 : ( + // X: Move to horizontal center of rect + (points[1][1] - points[0][1]) / 2 - rect.y - rect.height / 2 + ); + } + } + return 0; + }, + /** + * Gets the x coordinate of the text + * @param {object} points Data points position + * @param {object} d Data object + * @param {HTMLElement} textElement Data label text element + * @param {DOMRect} cachedBbox Optional cached bounding box (from getBBox batching) + * @returns {number} x coordinate + * @private + */ + getXForText(points, d, textElement, cachedBbox) { + var _a; + const $$ = this; + const { config } = $$; + const isRotated = config.axis_rotated; + const isFunnelType = $$.isFunnelType(d); + const isTreemapType = $$.isTreemapType(d); + let xPos = points ? points[0][0] : 0; + if ($$.isCandlestickType(d)) { + if (isRotated) { + xPos = ((_a = $$.getCandlestickData(d)) == null ? void 0 : _a._isUp) ? points[2][2] + 4 : points[2][1] - 4; + } else { + xPos += (points[1][0] - xPos) / 2; + } + } else if (isFunnelType) { + xPos += $$.state.current.width / 2; + } else if (isTreemapType) { + xPos += config.data_labels.centered ? 0 : 5; + } else { + if (isRotated) { + const isInverted = config[`axis_${$$.axis.getId(d.id)}_inverted`]; + const padding = $$.isBarType(d) ? 4 : 6; + const value = d.value; + xPos = points[2][1]; + if (isInverted) { + xPos -= padding * (value > 0 ? 1 : -1); + } else { + xPos += padding * (value < 0 ? -1 : 1); + } + } else { + xPos = $$.hasType("bar") ? (points[2][0] + points[0][0]) / 2 : xPos; + } + } + if (isRotated || isTreemapType) { + xPos += $$.getCenteredTextPos(d, points, textElement, "x", cachedBbox); + } + return xPos + getTextPos.call(this, d, "x"); + }, + /** + * Gets the y coordinate of the text + * @param {object} points Data points position + * @param {object} d Data object + * @param {HTMLElement} textElement Data label text element + * @param {DOMRect} cachedBbox Optional cached bounding box (from getBBox batching) + * @returns {number} y coordinate + * @private + */ + getYForText(points, d, textElement, cachedBbox) { + const $$ = this; + const { axis, config, state } = $$; + const isRotated = config.axis_rotated; + const isInverted = config[`axis_${axis == null ? void 0 : axis.getId(d.id)}_inverted`]; + const isBarType = $$.isBarType(d); + const isFunnelType = $$.isFunnelType(d); + const isTreemapType = $$.isTreemapType(d); + const r = config.point_r; + const rect = getBoundingRect(textElement); + let { value } = d; + let baseY = 3; + let yPos; + if ($$.isCandlestickType(d)) { + value = $$.getCandlestickData(d); + if (isRotated) { + yPos = points[0][0]; + yPos += (points[1][0] - yPos) / 2 + baseY; + } else { + yPos = value && value._isUp ? points[2][2] - baseY : points[2][1] + baseY * 4; + if (isInverted) { + yPos += 15 * (value._isUp ? 1 : -1); + } + } + } else if (isFunnelType) { + yPos = points ? points[0][1] + (points[1][1] - points[0][1]) / 2 + rect.height / 2 - 3 : 0; + } else if (isTreemapType) { + yPos = points[0][1] + (config.data_labels.centered ? 0 : rect.height + 5); + } else { + if (isRotated) { + yPos = (points[0][0] + points[2][0] + rect.height * 0.6) / 2; + } else { + yPos = points[2][1]; + if (isNumber(r) && r > 5 && ($$.isLineType(d) || $$.isScatterType(d))) { + baseY += config.point_r / 2.3; + } + if (value < 0 || value === 0 && !state.hasPositiveValue && state.hasNegativeValue) { + yPos += isInverted ? isBarType ? -3 : -5 : rect.height + (isBarType ? -baseY : baseY); + } else { + let diff = -baseY * 2; + if (isBarType) { + diff = -baseY; + } else if ($$.isBubbleType(d)) { + diff = baseY; + } + if (isInverted) { + diff = isBarType ? 10 : 15; + } + yPos += diff; + } + } + } + if (!isRotated || isTreemapType) { + yPos += $$.getCenteredTextPos(d, points, textElement, "y", cachedBbox); + } + return yPos + getTextPos.call(this, d, "y"); + }, + /** + * Calculate if two or more text nodes are overlapping + * Mark overlapping text nodes with "text-overlapping" class + * @param {string} id Axis id + * @param {ChartInternal} $$ ChartInternal context + * @param {string} selector Selector string + * @private + */ + markOverlapped(id, $$, selector) { + const textNodes = $$.$el.arcs.selectAll(selector); + const filteredTextNodes = textNodes.filter((node) => node.data.id !== id); + const textNode = textNodes.filter((node) => node.data.id === id); + const translate = getTranslation(textNode.node()); + const calcHypo = (x, y) => Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); + textNode.node() && filteredTextNodes.each(function() { + const coordinate = getTranslation(this); + const filteredTextNode = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const nodeForWidth = calcHypo(translate.e, translate.f) > calcHypo(coordinate.e, coordinate.f) ? textNode : filteredTextNode; + const overlapsX = Math.ceil(Math.abs(translate.e - coordinate.e)) < Math.ceil(nodeForWidth.node().getComputedTextLength()); + const overlapsY = Math.ceil(Math.abs(translate.f - coordinate.f)) < parseInt(textNode.style("font-size"), 10); + filteredTextNode.classed($TEXT.TextOverlapping, overlapsX && overlapsY); + }); + }, + /** + * Calculate if two or more text nodes are overlapping + * Remove "text-overlapping" class on selected text nodes + * @param {ChartInternal} $$ ChartInternal context + * @param {string} selector Selector string + * @private + */ + undoMarkOverlapped($$, selector) { + $$.$el.arcs.selectAll(selector).each(function() { + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.selectAll)([this, this.previousSibling]).classed($TEXT.TextOverlapping, false); + }); + } +}); + +;// ./src/ChartInternal/internals/title.ts + + +function _getTextXPos(pos = "left", width) { + const isNum = isNumber(width); + let position; + if (pos.indexOf("center") > -1) { + position = isNum ? width / 2 : "middle"; + } else if (pos.indexOf("right") > -1) { + position = isNum ? width : "end"; + } else { + position = isNum ? 0 : "start"; + } + return position; +} +/* harmony default export */ var internals_title = ({ + /** + * Initializes the title + * @private + */ + initTitle() { + const $$ = this; + const { config, $el } = $$; + if (config.title_text) { + $el.title = $el.svg.append("g"); + const text = $el.title.append("text").style("text-anchor", _getTextXPos(config.title_position)).attr("class", $TEXT.title); + setTextValue(text, config.title_text, [0.3, 1.5]); + } + }, + /** + * Redraw title + * @private + */ + redrawTitle() { + const $$ = this; + const { config, state: { current }, $el: { title } } = $$; + if (title) { + const x = _getTextXPos(config.title_position, current.width); + const y = (config.title_padding.top || 0) + $$.getTextRect($$.$el.title, $TEXT.title).height; + title.attr("transform", `translate(${x}, ${y})`); + } + }, + /** + * Get title padding + * @returns {number} padding value + * @private + */ + getTitlePadding() { + const $$ = this; + const { $el: { title }, config } = $$; + return (config.title_padding.top || 0) + (title ? $$.getTextRect(title, $TEXT.title).height : 0) + (config.title_padding.bottom || 0); + } +}); + +;// ./src/ChartInternal/internals/tooltip.ts + + + + +/* harmony default export */ var internals_tooltip = ({ + /** + * Initializes the tooltip + * @private + */ + initTooltip() { + const $$ = this; + const { config, $el } = $$; + $el.tooltip = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(config.tooltip_contents.bindto); + if ($el.tooltip.empty()) { + $el.tooltip = $el.chart.append("div").attr("class", $TOOLTIP.tooltipContainer).style("position", "absolute").style("pointer-events", "none").style("display", "none"); + } + $$.bindTooltipResizePos(); + }, + /** + * Show tooltip at initialization. + * Is called only when tooltip.init.show=true option is set + * @private + */ + initShowTooltip() { + var _a; + const $$ = this; + const { config, $el, state: { hasAxis, hasRadar } } = $$; + if (config.tooltip_init_show) { + const isArc = !(hasAxis || hasRadar); + if (((_a = $$.axis) == null ? void 0 : _a.isTimeSeries()) && isString(config.tooltip_init_x)) { + config.tooltip_init_x = parseDate.call($$, config.tooltip_init_x); + } + $$.api.tooltip.show({ + data: { + [isArc ? "index" : "x"]: config.tooltip_init_x + } + }); + const position = config.tooltip_init_position; + if (!config.tooltip_contents.bindto && !isEmpty(position)) { + const { top = 0, left = 50 } = position; + $el.tooltip.style("top", isString(top) ? top : `${top}px`).style("left", isString(left) ? left : `${left}px`).style("display", null); + } + } + }, + /** + * Get the tooltip HTML string + * @param {Array} args Arguments + * @returns {string} Formatted HTML string + * @private + */ + getTooltipHTML(...args) { + const $$ = this; + const { api, config } = $$; + return sanitize( + isFunction(config.tooltip_contents) ? config.tooltip_contents.bind(api)(...args) : $$.getTooltipContent(...args) + ); + }, + /** + * Returns the tooltip content(HTML string) + * @param {object} d data + * @param {function} defaultTitleFormat Default title format + * @param {function} defaultValueFormat Default format for each data value in the tooltip. + * @param {function} color Color function + * @returns {string} html + * @private + */ + getTooltipContent(d, defaultTitleFormat, defaultValueFormat, color) { + var _a; + const $$ = this; + const { api, config, state, $el } = $$; + const [titleFn, nameFn, valueFn] = ["title", "name", "value"].map((v) => { + const fn = config[`tooltip_format_${v}`]; + return isFunction(fn) ? fn.bind(api) : fn; + }); + const titleFormat = (...arg) => (titleFn || defaultTitleFormat)(...arg); + const nameFormat = (...arg) => (nameFn || ((name) => name))(...arg); + const valueFormat = (v, ratio, id, index) => { + let fn = valueFn; + if (!fn) { + if (state.hasTreemap || $$.isStackNormalized() && (!$$.isStackNormalizedPerGroup() || $$.isGrouped(id))) { + fn = (v2, ratio2) => `${(ratio2 * 100).toFixed(2)}%`; + } else { + fn = defaultValueFormat; + } + } + return fn(v, ratio, id, index); + }; + const order = config.tooltip_order; + const getRowValue = (row2) => $$.axis && $$.isBubbleZType(row2) ? $$.getBubbleZData(row2.value, "z") : $$.getBaseValue(row2); + const getBgColor = $$.levelColor ? (row2) => $$.levelColor(row2.value) : (row2) => color(row2); + const contents = config.tooltip_contents; + const tplStr = contents.template; + const targetIds = $$.mapToTargetIds(); + if (order === null && config.data_groups.length) { + const ids = $$.orderTargets($$.data.targets).map((i2) => i2.id).reverse(); + d.sort((a, b) => { + let v1 = a ? a.value : null; + let v2 = b ? b.value : null; + if (v1 > 0 && v2 > 0) { + v1 = a.id ? ids.indexOf(a.id) : null; + v2 = b.id ? ids.indexOf(b.id) : null; + } + return v1 - v2; + }); + } else if (/^(asc|desc)$/.test(order)) { + const isAscending = order === "asc"; + d.sort((a, b) => { + const v1 = a ? getRowValue(a) : null; + const v2 = b ? getRowValue(b) : null; + return isAscending ? v1 - v2 : v2 - v1; + }); + } else if (isFunction(order)) { + d.sort(order.bind(api)); + } + const tpl = $$.getTooltipContentTemplate(tplStr); + const len = d.length; + let text; + let row; + let param; + let value; + let i; + for (i = 0; i < len; i++) { + row = d[i]; + if (!row || !(getRowValue(row) || getRowValue(row) === 0)) { + continue; + } + if (isUndefined(text)) { + const title = (state.hasAxis || state.hasRadar) && titleFormat(row.x); + text = tplProcess(tpl[0], { + CLASS_TOOLTIP: $TOOLTIP.tooltip, + TITLE: isValue(title) ? tplStr ? title : `<tr><th colspan="2">${title}</th></tr>` : "" + }); + } + if (!row.ratio && $el.arcs) { + param = ["arc", $$.$el.arcs.select(`path.${$ARC.arc}-${row.id}`).data()[0]]; + row.ratio = $$.getRatio(...param); + } + param = [row.ratio, row.id, row.index]; + if ($$.isAreaRangeType(row)) { + const [high, low] = ["high", "low"].map( + (v) => valueFormat($$.getRangedData(row, v), ...param) + ); + const mid = valueFormat(getRowValue(row), ...param); + value = `<b>Mid:</b> ${mid} <b>High:</b> ${high} <b>Low:</b> ${low}`; + } else if ($$.isCandlestickType(row)) { + const [open, high, low, close, volume] = ["open", "high", "low", "close", "volume"].map((v) => { + const value2 = $$.getRangedData(row, v, "candlestick"); + return value2 ? valueFormat( + $$.getRangedData(row, v, "candlestick"), + ...param + ) : void 0; + }); + value = `<b>Open:</b> ${open} <b>High:</b> ${high} <b>Low:</b> ${low} <b>Close:</b> ${close}${volume ? ` <b>Volume:</b> ${volume}` : ""}`; + } else if ($$.isBarRangeType(row)) { + const { value: rangeValue, id, index } = row; + value = `${valueFormat(rangeValue, void 0, id, index)}`; + } else { + value = valueFormat(getRowValue(row), ...param); + } + if (value !== void 0) { + if (row.name === null) { + continue; + } + const name = nameFormat((_a = row.name) != null ? _a : row.id, ...param); + const color2 = getBgColor(row); + const contentValue = { + CLASS_TOOLTIP_NAME: $TOOLTIP.tooltipName + $$.getTargetSelectorSuffix(row.id), + COLOR: tplStr || !$$.patterns ? color2 : `<svg><rect style="fill:${color2}" width="10" height="10"></rect></svg>`, + NAME: name, + VALUE: value + }; + if (tplStr && isObject(contents.text)) { + const index = targetIds.indexOf(row.id); + Object.keys(contents.text).forEach((key) => { + contentValue[key] = contents.text[key][index]; + }); + } + text += tplProcess(tpl[1], contentValue); + } + } + return `${text}</table>`; + }, + /** + * Get the content template string + * @param {string} tplStr Tempalte string + * @returns {Array} Template string + * @private + */ + getTooltipContentTemplate(tplStr) { + return (tplStr || `<table class="{=CLASS_TOOLTIP}"><tbody> + {=TITLE} + {{<tr class="{=CLASS_TOOLTIP_NAME}"> + <td class="name">${this.patterns ? `{=COLOR}` : `<span style="background-color:{=COLOR}"></span>`}{=NAME}</td> + <td class="value">{=VALUE}</td> + </tr>}} + </tbody></table>`).replace(/(\r?\n|\t)/g, "").split(/{{(.*)}}/); + }, + /** + * Update tooltip position coordinate + * @param {object} dataToShow Data object + * @param {SVGElement} eventTarget Event element + * @private + */ + setTooltipPosition(dataToShow, eventTarget) { + var _a, _b; + const $$ = this; + const { config, scale, state, $el: { eventRect, tooltip, svg } } = $$; + const { bindto } = config.tooltip_contents; + const isRotated = config.axis_rotated; + const datum = tooltip == null ? void 0 : tooltip.datum(); + if (!bindto && datum) { + const data = dataToShow != null ? dataToShow : JSON.parse(datum.current); + const [x, y] = getPointer(state.event, eventTarget != null ? eventTarget : eventRect == null ? void 0 : eventRect.node()); + const currPos = { x, y }; + if (state.hasAxis && scale.x && datum && "x" in datum) { + const getYPos = (value = 0, id, axisId = "y") => { + var _a2; + const scaleFn = scale[id ? (_a2 = $$.axis) == null ? void 0 : _a2.getId(id) : axisId]; + return scaleFn ? scaleFn(value) + (isRotated ? state.margin.left : state.margin.top) : 0; + }; + currPos.xAxis = scale.x(datum.x) + // add margin only when user specified tooltip.position function + (config.tooltip_position ? isRotated ? state.margin.top : state.margin.left : 0); + if (data.length === 1) { + currPos.yAxis = getYPos(data[0].value, data[0].id); + } else { + currPos.yAxis = getYPos; + } + } + const { width = 0, height = 0 } = datum; + const pos = (_b = (_a = config.tooltip_position) == null ? void 0 : _a.bind($$.api)( + data, + width, + height, + eventRect == null ? void 0 : eventRect.node(), + currPos + )) != null ? _b : hasViewBox(svg) ? $$.getTooltipPositionViewBox.bind($$)(width, height, currPos) : $$.getTooltipPosition.bind($$)(width, height, currPos); + ["top", "left"].forEach((v) => { + const value = pos[v]; + tooltip.style(v, `${value}px`); + if (v === "left" && !datum.xPosInPercent) { + datum.xPosInPercent = value / state.current.width * 100; + } + }); + } + }, + /** + * Get tooltip position when svg has vieBox attribute + * @param {number} tWidth Tooltip width value + * @param {number} tHeight Tooltip height value + * @param {object} currPos Current event position value from SVG coordinate + * @returns {object} top, left value + */ + getTooltipPositionViewBox(tWidth, tHeight, currPos) { + var _a, _b; + const $$ = this; + const { $el: { eventRect, svg }, config, state } = $$; + const isRotated = config.axis_rotated; + const hasArcType = $$.hasArcType() || state.hasFunnel || state.hasTreemap; + const target = (_b = (_a = hasArcType ? svg : eventRect) == null ? void 0 : _a.node()) != null ? _b : state.event.target; + let { x, y } = currPos; + if (state.hasAxis) { + x = isRotated ? x : currPos.xAxis; + y = isRotated ? currPos.xAxis : y; + } + const ctm = getTransformCTM(target, x, y, false); + const rect = getBoundingRect(target); + const size = getTransformCTM(target, 20, 0, false).x; + let top = ctm.y; + let left = ctm.x + tWidth / 2 + size; + if (hasArcType) { + if (state.hasFunnel || state.hasTreemap || state.hasRadar) { + left -= tWidth / 2 + size; + top += tHeight; + } else { + top += rect.height / 2; + left += rect.width / 2 - (tWidth - size); + } + } + if (left + tWidth > rect.width) { + left = rect.width - tWidth - size; + } + if (top + tHeight > rect.height) { + top -= tHeight * 2; + } + return { + top, + left + }; + }, + /** + * Returns the position of the tooltip + * @param {string} tWidth Width value of tooltip element + * @param {string} tHeight Height value of tooltip element + * @param {object} currPos Current mouse position + * @returns {object} top, left value + * @private + */ + getTooltipPosition(tWidth, tHeight, currPos) { + var _a, _b, _c; + const $$ = this; + const { config, scale, state } = $$; + const { width, height, current, hasFunnel, hasRadar, hasTreemap, isLegendRight, inputType } = state; + const hasGauge = $$.hasType("gauge") && !config.gauge_fullCircle; + const isRotated = config.axis_rotated; + const hasArcType = $$.hasArcType(); + const svgLeft = $$.getSvgLeft(true); + let chartRight = svgLeft + current.width - $$.getCurrentPaddingByDirection("right"); + const size = 20; + let { x, y } = currPos; + if (hasRadar) { + x += x >= width / 2 ? 15 : -(tWidth + 15); + y += 15; + } else if (hasArcType) { + const notTouch = inputType !== "touch"; + if (notTouch) { + let titlePadding = (_b = (_a = $$.getTitlePadding) == null ? void 0 : _a.call($$)) != null ? _b : 0; + if (titlePadding && hasGauge && ((_c = config.arc_rangeText_values) == null ? void 0 : _c.length)) { + titlePadding += 10; + } + x += (width - (isLegendRight ? $$.getLegendWidth() : 0)) / 2; + y += (hasGauge ? height : height / 2 + tHeight) + titlePadding; + } + } else if (hasFunnel || hasTreemap) { + y += tHeight; + } else { + const padding = { + top: $$.getCurrentPaddingByDirection("top", true), + left: $$.getCurrentPaddingByDirection("left", true) + }; + if (isRotated) { + x += svgLeft + padding.left + size; + y = padding.top + currPos.xAxis + size; + chartRight -= svgLeft; + } else { + x = svgLeft + padding.left + size + (scale.zoom ? x : currPos.xAxis); + y += padding.top - 5; + } + } + if (x + tWidth + 15 > chartRight) { + x -= tWidth + (hasFunnel || hasTreemap || hasArcType ? 0 : isRotated ? size * 2 : 38); + } + if (y + tHeight > current.height) { + const gap = hasTreemap ? tHeight + 10 : 30; + y -= hasGauge ? tHeight * 1.5 : tHeight + gap; + } + const pos = { top: y, left: x }; + Object.keys(pos).forEach((v) => { + if (pos[v] < 0) { + pos[v] = 0; + } + }); + return pos; + }, + /** + * Show the tooltip + * @param {object} selectedData Data object + * @param {SVGElement} eventTarget Event element + * @private + */ + showTooltip(selectedData, eventTarget) { + const $$ = this; + const { config, $el: { tooltip } } = $$; + const dataToShow = selectedData.filter((d) => d && isValue($$.getBaseValue(d))); + if (!tooltip || dataToShow.length === 0 || !config.tooltip_show) { + return; + } + let datum = tooltip.datum(); + const dataStr = JSON.stringify(selectedData); + if (!datum || datum.current !== dataStr) { + const { index, x } = selectedData.concat().sort()[0]; + callFn(config.tooltip_onshow, $$.api, selectedData); + tooltip.html($$.getTooltipHTML( + selectedData, + // data + $$.axis ? $$.axis.getXAxisTickFormat() : $$.categoryName.bind($$), + // defaultTitleFormat + $$.getDefaultValueFormat(), + // defaultValueFormat + $$.color + // color + )).style("display", null).style("visibility", null).datum(datum = { + index, + x, + current: dataStr, + width: tooltip.property("offsetWidth"), + height: tooltip.property("offsetHeight") + }); + callFn(config.tooltip_onshown, $$.api, selectedData); + $$._handleLinkedCharts(true, index); + } + $$.setTooltipPosition(dataToShow, eventTarget); + }, + /** + * Adjust tooltip position on resize event + * @private + */ + bindTooltipResizePos() { + const $$ = this; + const { resizeFunction, state, $el: { tooltip } } = $$; + resizeFunction.add(() => { + if (tooltip.style("display") === "block") { + const { current } = state; + const { width, xPosInPercent } = tooltip.datum(); + let value = current.width / 100 * xPosInPercent; + const diff = current.width - (value + width); + if (diff < 0) { + value += diff; + } + tooltip.style("left", `${value}px`); + } + }); + }, + /** + * Hide the tooltip + * @param {boolean} force Force to hide + * @private + */ + hideTooltip(force) { + var _a; + const $$ = this; + const { api, config, $el: { tooltip } } = $$; + if (tooltip && tooltip.style("display") !== "none" && (!config.tooltip_doNotHide || force)) { + const selectedData = JSON.parse((_a = tooltip.datum().current) != null ? _a : {}); + callFn(config.tooltip_onhide, api, selectedData); + tooltip.style("display", "none").datum(null); + callFn(config.tooltip_onhidden, api, selectedData); + } + }, + /** + * Toggle display for linked chart instances + * @param {boolean} show true: show, false: hide + * @param {number} index x Axis index + * @private + */ + _handleLinkedCharts(show, index) { + const $$ = this; + const { charts, config, state: { event } } = $$; + if ((event == null ? void 0 : event.isTrusted) && config.tooltip_linked && charts.length > 1) { + const linkedName = config.tooltip_linked_name; + charts.filter((c) => c !== $$.api).forEach((c) => { + const { config: config2, $el } = c.internal; + const isLinked = config2.tooltip_linked; + const name = config2.tooltip_linked_name; + const isInDom = browser_doc.body.contains($el.chart.node()); + if (isLinked && linkedName === name && isInDom) { + const data = $el.tooltip.data()[0]; + const isNotSameIndex = index !== (data == null ? void 0 : data.index); + try { + c.tooltip[show && isNotSameIndex ? "show" : "hide"]({ index }); + } catch (e) { + } + } + }); + } + }, + /** + * Update tooltip content on redraw + * - In a situation where tooltip is displayed and data load happens, it should reflect loaded data to tooltip + * @param {d3Selection} context Event rect element + * @param {number} index Data index + * @private + */ + updateTooltipOnRedraw(context, index) { + var _a; + const $$ = this; + const { + config, + $el: { eventRect, svg, tooltip }, + state: { event, hasAxis, hasRadar, hasTreemap } + } = $$; + if ((tooltip == null ? void 0 : tooltip.style("display")) === "block" && event) { + const rect = context != null ? context : (_a = hasRadar ? svg : eventRect) == null ? void 0 : _a.node(); + if (hasAxis || hasRadar) { + if ($$.isMultipleX()) { + $$.selectRectForMultipleXs(rect, false); + } else { + const idx = index != null ? index : $$.getDataIndexFromEvent(event); + if (index === -1) { + $$.api.tooltip.hide(); + } else { + $$.selectRectForSingle(rect, idx); + $$.setExpand(idx, null, true); + } + } + } else { + const { clientX, clientY } = event; + setTimeout(() => { + let target = [clientX, clientY].every(Number.isFinite) && browser_doc.elementFromPoint(clientX, clientY); + const data = target && (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(target).datum(); + if (data) { + const d = $$.hasArcType() ? $$.convertToArcData($$.updateAngle(data)) : data == null ? void 0 : data.data; + hasTreemap && (target = svg.node()); + d && $$.showTooltip([d], target); + } else { + $$.api.tooltip.hide(); + } + }, config.transition_duration); + } + } + } +}); + +;// ./src/ChartInternal/internals/transform.ts + + +/* harmony default export */ var transform = ({ + getTranslate(target, index = 0) { + var _a; + const $$ = this; + const { config, state } = $$; + const isRotated = config.axis_rotated; + let padding = 0; + let x; + let y; + if (index && /^(x|y2?)$/.test(target)) { + padding = $$.getAxisSize(target) * index; + } + if (target === "main") { + x = asHalfPixel(state.margin.left); + y = asHalfPixel(state.margin.top); + } else if (target === "context") { + x = asHalfPixel(state.margin2.left); + y = asHalfPixel(state.margin2.top); + } else if (target === "legend") { + x = state.margin3.left; + y = state.margin3.top; + } else if (target === "x") { + x = isRotated ? -padding : 0; + y = isRotated ? 0 : state.height + padding; + } else if (target === "y") { + x = isRotated ? 0 : -padding; + y = isRotated ? state.height + padding : 0; + } else if (target === "y2") { + x = isRotated ? 0 : state.width + padding; + y = isRotated ? -padding - 1 : 0; + } else if (target === "subX") { + x = 0; + y = isRotated ? 0 : state.height2; + } else if (target === "arc") { + x = state.arcWidth / 2; + y = state.arcHeight / 2; + if ((_a = config.arc_rangeText_values) == null ? void 0 : _a.length) { + y += 5 + ($$.hasType("gauge") && config.title_text ? 10 : 0); + } + } else if (target === "polar") { + x = state.arcWidth / 2; + y = state.arcHeight / 2; + } else if (target === "radar") { + const [width, height] = $$.getRadarSize(); + x = state.width / 2 - width; + y = state.height / 2 - height; + } + return `translate(${x}, ${y})`; + }, + transformMain(withTransition, transitions) { + const $$ = this; + const { $el: { main }, $T } = $$; + const xAxis = (transitions == null ? void 0 : transitions.axisX) ? transitions.axisX : $T(main.select(`.${$AXIS.axisX}`), withTransition); + const yAxis = (transitions == null ? void 0 : transitions.axisY) ? transitions.axisY : $T(main.select(`.${$AXIS.axisY}`), withTransition); + const y2Axis = (transitions == null ? void 0 : transitions.axisY2) ? transitions.axisY2 : $T(main.select(`.${$AXIS.axisY2}`), withTransition); + $T(main, withTransition).attr("transform", $$.getTranslate("main")); + xAxis.attr("transform", $$.getTranslate("x")); + yAxis.attr("transform", $$.getTranslate("y")); + y2Axis.attr("transform", $$.getTranslate("y2")); + main.select(`.${$ARC.chartArcs}`).attr("transform", $$.getTranslate("arc")); + }, + transformAll(withTransition, transitions) { + const $$ = this; + const { config, state: { hasAxis, hasFunnel, hasTreemap }, $el } = $$; + !hasFunnel && !hasTreemap && $$.transformMain(withTransition, transitions); + hasAxis && config.subchart_show && $$.transformContext(withTransition, transitions); + $el.legend && $$.transformLegend(withTransition); + } +}); + +;// ./src/ChartInternal/internals/type.ts + + +/* harmony default export */ var type = ({ + /** + * Check if the given chart type is valid + * @param {string} type Chart type string + * @returns {boolean} + * @private + */ + isValidChartType(type) { + return !!(type && Object.values(TYPE).indexOf(type) > -1); + }, + setTargetType(targetIds, type) { + const $$ = this; + const { config, state: { withoutFadeIn } } = $$; + $$.mapToTargetIds(targetIds).forEach((id) => { + withoutFadeIn[id] = type === config.data_types[id]; + config.data_types[id] = type; + }); + if (!targetIds) { + config.data_type = type; + } + }, + /** + * Updte current used chart types + * @private + */ + updateTypesElements() { + const $$ = this; + const { state: { current } } = $$; + Object.keys(TYPE).forEach((v) => { + const t = TYPE[v]; + const has = $$.hasType(t, null, true); + const idx = current.types.indexOf(t); + if (idx === -1 && has) { + current.types.push(t); + } else if (idx > -1 && !has) { + current.types.splice(idx, 1); + } + }); + $$.setChartElements(); + }, + /** + * Check if given chart types exists + * @param {string} type Chart type + * @param {Array} targetsValue Data array + * @param {boolean} checkFromData Force to check type cotains from data targets + * @returns {boolean} + * @private + */ + hasType(type, targetsValue, checkFromData = false) { + var _a; + const $$ = this; + const { config, state: { current } } = $$; + const types = config.data_types; + const targets = targetsValue || $$.data.targets; + let has = false; + if (!checkFromData && ((_a = current.types) == null ? void 0 : _a.indexOf(type)) > -1) { + has = true; + } else if (targets == null ? void 0 : targets.length) { + targets.forEach((target) => { + const t = types[target.id]; + if (t === type || !t && type === "line") { + has = true; + } + }); + } else if (Object.keys(types).length) { + Object.keys(types).forEach((id) => { + if (types[id] === type) { + has = true; + } + }); + } else { + has = config.data_type === type; + } + return has; + }, + /** + * Check if contains given chart types + * @param {string} type Type key + * @param {object} targets Target data + * @param {Array} exclude Excluded types + * @returns {boolean} + * @private + */ + hasTypeOf(type, targets, exclude = []) { + if (type in TYPE_BY_CATEGORY) { + return !TYPE_BY_CATEGORY[type].filter((v) => exclude.indexOf(v) === -1).every((v) => !this.hasType(v, targets)); + } + return false; + }, + /** + * Check if given data is certain chart type + * @param {object} d Data object + * @param {string|Array} type chart type + * @returns {boolean} + * @private + */ + isTypeOf(d, type) { + var _a; + const id = isString(d) ? d : d.id; + const dataType = this.config && (((_a = this.config.data_types) == null ? void 0 : _a[id]) || this.config.data_type); + return isArray(type) ? type.indexOf(dataType) >= 0 : dataType === type; + }, + hasPointType() { + const $$ = this; + return $$.hasTypeOf("Line") || $$.hasType("bubble") || $$.hasType("scatter"); + }, + /** + * Check if contains arc types chart + * @param {object} targets Target data + * @param {Array} exclude Excluded types + * @returns {boolean} + * @private + */ + hasArcType(targets, exclude) { + return this.hasTypeOf("Arc", targets, exclude); + }, + hasMultiArcGauge() { + return this.hasType("gauge") && this.config.gauge_type === "multi"; + }, + isLineType(d) { + const id = isString(d) ? d : d.id; + return !this.config.data_types[id] || this.isTypeOf(id, TYPE_BY_CATEGORY.Line); + }, + isStepType(d) { + return this.isTypeOf(d, TYPE_BY_CATEGORY.Step); + }, + isSplineType(d) { + return this.isTypeOf(d, TYPE_BY_CATEGORY.Spline); + }, + isAreaType(d) { + return this.isTypeOf(d, TYPE_BY_CATEGORY.Area); + }, + isAreaRangeType(d) { + return this.isTypeOf(d, TYPE_BY_CATEGORY.AreaRange); + }, + isBarType(d) { + return this.isTypeOf(d, "bar"); + }, + isBubbleType(d) { + return this.isTypeOf(d, "bubble"); + }, + isCandlestickType(d) { + return this.isTypeOf(d, "candlestick"); + }, + isScatterType(d) { + return this.isTypeOf(d, "scatter"); + }, + isTreemapType(d) { + return this.isTypeOf(d, "treemap"); + }, + isPieType(d) { + return this.isTypeOf(d, "pie"); + }, + isFunnelType(d) { + return this.isTypeOf(d, "funnel"); + }, + isGaugeType(d) { + return this.isTypeOf(d, "gauge"); + }, + isDonutType(d) { + return this.isTypeOf(d, "donut"); + }, + isPolarType(d) { + return this.isTypeOf(d, "polar"); + }, + isRadarType(d) { + return this.isTypeOf(d, "radar"); + }, + isArcType(d) { + return this.isPieType(d) || this.isDonutType(d) || this.isGaugeType(d) || this.isPolarType(d) || this.isRadarType(d); + }, + // determine if is 'circle' data point + isCirclePoint(node) { + const { config } = this; + const pattern = config.point_pattern; + let isCircle = false; + if ((node == null ? void 0 : node.tagName) === "circle") { + isCircle = true; + } else { + isCircle = config.point_type === "circle" && (!pattern || isArray(pattern) && pattern.length === 0); + } + return isCircle; + }, + lineData(d) { + return this.isLineType(d) ? [d] : []; + }, + arcData(d) { + return this.isArcType(d.data) ? [d] : []; + }, + /** + * Get data adapt for data label showing + * @param {object} d Data object + * @returns {Array} + * @private + */ + labelishData(d) { + return this.isBarType(d) || this.isLineType(d) || this.isScatterType(d) || this.isBubbleType(d) || this.isCandlestickType(d) || this.isFunnelType(d) || this.isRadarType(d) || this.isTreemapType(d) ? d.values.filter((v) => isNumber(v.value) || Boolean(v.value)) : []; + }, + barLineBubbleData(d) { + return this.isBarType(d) || this.isLineType(d) || this.isBubbleType(d) ? d.values : []; + }, + // https://github.com/d3/d3-shape#curves + isInterpolationType(type) { + return [ + "basis", + "basis-closed", + "basis-open", + "bundle", + "cardinal", + "cardinal-closed", + "cardinal-open", + "catmull-rom", + "catmull-rom-closed", + "catmull-rom-open", + "linear", + "linear-closed", + "monotone-x", + "monotone-y", + "natural" + ].indexOf(type) >= 0; + } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-shape","commonjs2":"d3-shape","amd":"d3-shape","root":"d3"} +var external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_ = __webpack_require__(9); +;// ./src/ChartInternal/shape/shape.ts + + + + + +function _getGroupedDataPointsFn(d) { + const $$ = this; + let fn; + if ($$.isLineType(d)) { + fn = $$.generateGetLinePoints($$.getShapeIndices($$.isLineType)); + } else if ($$.isBarType(d)) { + fn = $$.generateGetBarPoints($$.getShapeIndices($$.isBarType)); + } + return fn; +} +/* harmony default export */ var shape = ({ + /** + * Get the shape draw function + * @returns {object} + * @private + */ + getDrawShape() { + const $$ = this; + const isRotated = $$.config.axis_rotated; + const { hasRadar, hasTreemap } = $$.state; + const shape = { type: {}, indices: {}, pos: {} }; + !hasTreemap && ["bar", "candlestick", "line", "area"].forEach((v) => { + const name = capitalize(/^(bubble|scatter)$/.test(v) ? "line" : v); + if ($$.hasType(v) || $$.hasTypeOf(name) || v === "line" && ($$.hasType("bubble") || $$.hasType("scatter"))) { + const indices = $$.getShapeIndices($$[`is${name}Type`]); + const drawFn = $$[`generateDraw${name}`]; + shape.indices[v] = indices; + shape.type[v] = drawFn ? drawFn.bind($$)(indices, false) : void 0; + } + }); + if (!$$.hasArcType() || hasRadar || hasTreemap) { + let cx; + let cy; + if (!hasTreemap) { + cx = hasRadar ? $$.radarCircleX : isRotated ? $$.circleY : $$.circleX; + cy = hasRadar ? $$.radarCircleY : isRotated ? $$.circleX : $$.circleY; + } + shape.pos = { + xForText: $$.generateXYForText(shape.indices, true), + yForText: $$.generateXYForText(shape.indices, false), + cx: (cx || function() { + }).bind($$), + cy: (cy || function() { + }).bind($$) + }; + } + return shape; + }, + /** + * Get shape's indices according it's position within each axis tick. + * + * From the below example, indices will be: + * ==> {data1: 0, data2: 0, data3: 1, data4: 1, __max__: 1} + * + * data1 data3 data1 data3 + * data2 data4 data2 data4 + * ------------------------- + * 0 1 + * @param {function} typeFilter Chart type filter function + * @returns {object} Indices object with its position + */ + getShapeIndices(typeFilter) { + const $$ = this; + const { config } = $$; + const xs = config.data_xs; + const hasXs = notEmpty(xs); + const indices = {}; + let i = hasXs ? {} : 0; + if (hasXs) { + getUnique(Object.keys(xs).map((v) => xs[v])).forEach((v) => { + i[v] = 0; + indices[v] = {}; + }); + } + $$.filterTargetsToShow($$.data.targets.filter(typeFilter, $$)).forEach((d) => { + var _a; + const xKey = d.id in xs ? xs[d.id] : ""; + const ind = xKey ? indices[xKey] : indices; + for (let j = 0, groups; groups = config.data_groups[j]; j++) { + if (groups.indexOf(d.id) < 0) { + continue; + } + for (let k = 0, key; key = groups[k]; k++) { + if (key in ind) { + ind[d.id] = ind[key]; + break; + } + if (d.id !== key && xKey) { + ind[key] = (_a = ind[d.id]) != null ? _a : i[xKey]; + } + } + } + if (isUndefined(ind[d.id])) { + ind[d.id] = xKey ? i[xKey]++ : i++; + ind.__max__ = (xKey ? i[xKey] : i) - 1; + } + }); + return indices; + }, + /** + * Get indices value based on data ID value + * @param {object} indices Indices object + * @param {object} d Data row + * @param {string} caller Caller function name (Used only for 'sparkline' plugin) + * @returns {object} Indices object + * @private + */ + getIndices(indices, d, caller) { + const $$ = this; + const { data_xs: xs, bar_indices_removeNull: removeNull } = $$.config; + const { id, index } = d; + if ($$.isBarType(id) && removeNull) { + const ind = {}; + $$.getAllValuesOnIndex(index, true).forEach((v, i) => { + ind[v.id] = i; + ind.__max__ = i; + }); + return ind; + } + return notEmpty(xs) ? indices[xs[id]] : indices; + }, + /** + * Get indices max number + * @param {object} indices Indices object + * @returns {number} Max number + * @private + */ + getIndicesMax(indices) { + return notEmpty(this.config.data_xs) ? ( + // if is multiple xs, return total sum of xs' __max__ value + Object.keys(indices).map((v) => indices[v].__max__ || 0).reduce((acc, curr) => acc + curr) + ) : indices.__max__; + }, + getShapeX(offset, indices, isSub) { + const $$ = this; + const { config, scale } = $$; + const currScale = isSub ? scale.subX : scale.zoom || scale.x; + const barOverlap = config.bar_overlap; + const barPadding = config.bar_padding; + const sum = (p, c) => p + c; + const halfWidth = isObjectType(offset) && (offset._$total.length ? offset._$total.reduce(sum) / 2 : 0); + return (d) => { + const ind = $$.getIndices(indices, d, "getShapeX"); + const index = d.id in ind ? ind[d.id] : 0; + const targetsNum = (ind.__max__ || 0) + 1; + let x = 0; + if (notEmpty(d.x)) { + const xPos = currScale(d.x, true); + if (halfWidth) { + const offsetWidth = offset[d.id] || offset._$width; + x = barOverlap ? xPos - offsetWidth / 2 : xPos - offsetWidth + offset._$total.slice(0, index + 1).reduce(sum) - halfWidth; + } else { + x = xPos - (isNumber(offset) ? offset : offset._$width) * (targetsNum / 2 - (barOverlap ? 1 : index)); + } + } + if (offset && x && targetsNum > 1 && barPadding) { + if (index) { + x += barPadding * index; + } + if (targetsNum > 2) { + x -= (targetsNum - 1) * barPadding / 2; + } else if (targetsNum === 2) { + x -= barPadding / 2; + } + } + return x; + }; + }, + getShapeY(isSub) { + const $$ = this; + const isStackNormalized = $$.isStackNormalized(); + return (d) => { + let { value } = d; + if (isNumber(d)) { + value = d; + } else if ($$.isAreaRangeType(d)) { + value = $$.getBaseValue(d, "mid"); + } else if (isStackNormalized) { + value = $$.getRatio("index", d, true); + } else if ($$.isBubbleZType(d)) { + value = $$.getBubbleZData(d.value, "y"); + } else if ($$.isBarRangeType(d)) { + value = value[1]; + } + return $$.getYScaleById(d.id, isSub)(value); + }; + }, + /** + * Get shape based y Axis min value + * @param {string} id Data id + * @returns {number} + * @private + */ + getShapeYMin(id) { + const $$ = this; + const axisId = $$.axis.getId(id); + const scale = $$.scale[axisId]; + const [yMin] = scale.domain(); + const inverted = $$.config[`axis_${axisId}_inverted`]; + return !$$.isGrouped(id) && !inverted && yMin > 0 ? yMin : 0; + }, + /** + * Get Shape's offset data + * @param {function} typeFilter Type filter function + * @returns {object} + * @private + */ + getShapeOffsetData(typeFilter) { + const $$ = this; + const targets = $$.orderTargets( + $$.filterTargetsToShow($$.data.targets.filter(typeFilter, $$)) + ); + const targetIds = targets.map((t) => t.id).join("_"); + const cacheKey = `${KEY.shapeOffset}_${targetIds}`; + const cachedData = $$.cache.get(cacheKey); + if (cachedData) { + return cachedData; + } + const isStackNormalized = $$.isStackNormalized(); + const shapeOffsetTargets = targets.map((target) => { + let rowValues = target.values; + const values = {}; + if ($$.isStepType(target)) { + rowValues = $$.convertValuesToStep(rowValues); + } + const rowValueMapByXValue = rowValues.reduce((out, d) => { + const key = Number(d.x); + out[key] = d; + values[key] = isStackNormalized ? $$.getRatio("index", d, true) : d.value; + return out; + }, {}); + return { + id: target.id, + rowValues, + rowValueMapByXValue, + values + }; + }); + const indexMapByTargetId = targets.reduce((out, { id }, index) => { + out[id] = index; + return out; + }, {}); + const result = { indexMapByTargetId, shapeOffsetTargets }; + $$.cache.add(cacheKey, result); + return result; + }, + getShapeOffset(typeFilter, indices, isSub) { + const $$ = this; + const { shapeOffsetTargets, indexMapByTargetId } = $$.getShapeOffsetData( + typeFilter + ); + const groupsZeroAs = $$.config.data_groupsZeroAs; + return (d, idx) => { + const { id, value, x } = d; + const ind = $$.getIndices(indices, d); + const scale = $$.getYScaleById(id, isSub); + if ($$.isBarRangeType(d)) { + return scale(value[0]); + } + const dataXAsNumber = Number(x); + const y0 = scale(groupsZeroAs === "zero" ? 0 : $$.getShapeYMin(id)); + let offset = y0; + shapeOffsetTargets.filter((t) => t.id !== id && ind[t.id] === ind[id]).forEach((t) => { + const { + id: tid, + rowValueMapByXValue, + rowValues, + values: tvalues + } = t; + if (indexMapByTargetId[tid] < indexMapByTargetId[id]) { + const rValue = tvalues[dataXAsNumber]; + let row = rowValues[idx]; + if (!row || Number(row.x) !== dataXAsNumber) { + row = rowValueMapByXValue[dataXAsNumber]; + } + if ((row == null ? void 0 : row.value) * value >= 0 && isNumber(rValue)) { + const addOffset = value === 0 ? groupsZeroAs === "positive" && rValue > 0 || groupsZeroAs === "negative" && rValue < 0 : true; + if (addOffset) { + offset += scale(rValue) - y0; + } + } + } + }); + return offset; + }; + }, + /** + * Get data's y coordinate + * @param {object} d Target data + * @param {number} i Index number + * @returns {number} y coordinate + * @private + */ + circleY(d, i) { + const $$ = this; + const id = d.id; + let points; + if ($$.isGrouped(id)) { + points = _getGroupedDataPointsFn.bind($$)(d); + } + return points ? points(d, i)[0][1] : $$.getYScaleById(id)($$.getBaseValue(d)); + }, + getBarW(type, axis, targetsNum) { + var _a, _b, _c, _d, _e; + const $$ = this; + const { config, org, scale, state } = $$; + const maxDataCount = $$.getMaxDataCount(); + const isGrouped = type === "bar" && ((_a = config.data_groups) == null ? void 0 : _a.length); + const configName = `${type}_width`; + const { k } = (_c = (_b = $$.getZoomTransform) == null ? void 0 : _b.call($$)) != null ? _c : { k: 1 }; + const xMinMax = [ + (_d = config.axis_x_min) != null ? _d : org.xDomain[0], + (_e = config.axis_x_max) != null ? _e : org.xDomain[1] + ].map($$.axis.isTimeSeries() ? parseDate.bind($$) : Number); + let tickInterval = axis.tickInterval(maxDataCount); + if (scale.zoom && !$$.axis.isCategorized() && k > 1) { + const isSameMinMax = xMinMax.every((v, i) => v === org.xDomain[i]); + tickInterval = org.xDomain.map((v, i) => { + const value = isSameMinMax ? v : v - Math.abs(xMinMax[i]); + return scale.zoom(value); + }).reduce((a, c) => Math.abs(a) + c) / maxDataCount; + } + const getWidth = (id) => { + const width = id ? config[configName][id] : config[configName]; + const ratio = id ? width.ratio : config[`${configName}_ratio`]; + const max = id ? width.max : config[`${configName}_max`]; + const w = isNumber(width) ? width : isFunction(width) ? width.call($$, state.width, targetsNum, maxDataCount) : targetsNum ? tickInterval * ratio / targetsNum : 0; + return max && w > max ? max : w; + }; + let result = getWidth(); + if (!isGrouped && isObjectType(config[configName])) { + result = { _$width: result, _$total: [] }; + $$.filterTargetsToShow($$.data.targets).forEach((v) => { + if (config[configName][v.id]) { + result[v.id] = getWidth(v.id); + result._$total.push(result[v.id] || result._$width); + } + }); + } + return result; + }, + /** + * Get shape element + * @param {string} shapeName Shape string + * @param {number} i Index number + * @param {string} id Data series id + * @returns {d3Selection} + * @private + */ + getShapeByIndex(shapeName, i, id) { + const $$ = this; + const { $el } = $$; + const suffix = isValue(i) ? `-${i}` : ``; + let shape = $el[shapeName]; + if (shape && !shape.empty()) { + shape = shape.filter((d) => id ? d.id === id : true).filter((d) => isValue(i) ? d.index === i : true); + } else { + shape = (id ? $el.main.selectAll( + `.${classes[`${shapeName}s`]}${$$.getTargetSelectorSuffix(id)}` + ) : $el.main).selectAll(`.${classes[shapeName]}${suffix}`); + } + return shape; + }, + isWithinShape(that, d) { + var _a; + const $$ = this; + const shape = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(that); + let isWithin; + if (!$$.isTargetToShow(d.id)) { + isWithin = false; + } else if ((_a = $$.hasValidPointType) == null ? void 0 : _a.call($$, that.nodeName)) { + isWithin = $$.isStepType(d) ? $$.isWithinStep(that, $$.getYScaleById(d.id)($$.getBaseValue(d))) : $$.isWithinCircle( + that, + $$.isBubbleType(d) ? $$.pointSelectR(d) * 1.5 : 0 + ); + } else if (that.nodeName === "path") { + isWithin = shape.classed(classes.bar) ? $$.isWithinBar(that) : true; + } + return isWithin; + }, + getInterpolate(d) { + const $$ = this; + const interpolation = $$.getInterpolateType(d); + return { + basis: external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveBasis, + "basis-closed": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveBasisClosed, + "basis-open": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveBasisOpen, + bundle: external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveBundle, + cardinal: external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveCardinal, + "cardinal-closed": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveCardinalClosed, + "cardinal-open": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveCardinalOpen, + "catmull-rom": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveCatmullRom, + "catmull-rom-closed": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveCatmullRomClosed, + "catmull-rom-open": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveCatmullRomOpen, + "monotone-x": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveMonotoneX, + "monotone-y": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveMonotoneY, + natural: external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveNatural, + "linear-closed": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveLinearClosed, + linear: external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveLinear, + step: external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveStep, + "step-after": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveStepAfter, + "step-before": external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.curveStepBefore + }[interpolation]; + }, + getInterpolateType(d) { + const $$ = this; + const { config } = $$; + const type = config.spline_interpolation_type; + const interpolation = $$.isInterpolationType(type) ? type : "cardinal"; + return $$.isSplineType(d) ? interpolation : $$.isStepType(d) ? config.line_step_type : "linear"; + }, + isWithinBar(that) { + const mouse = getPointer(this.state.event, that); + const list = getRectSegList(that); + const [seg0, seg1] = list; + const x = Math.min(seg0.x, seg1.x); + const y = Math.min(seg0.y, seg1.y); + const offset = this.config.bar_sensitivity; + const { width, height } = getBBox(that, true); + const sx = x - offset; + const ex = x + width + offset; + const sy = y + height + offset; + const ey = y - offset; + const isWithin = sx < mouse[0] && mouse[0] < ex && ey < mouse[1] && mouse[1] < sy; + return isWithin; + } +}); + +;// ./src/ChartInternal/ChartInternal.ts +var ChartInternal_defProp = Object.defineProperty; +var ChartInternal_defNormalProp = (obj, key, value) => key in obj ? ChartInternal_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var ChartInternal_publicField = (obj, key, value) => ChartInternal_defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class ChartInternal { + constructor(api) { + ChartInternal_publicField(this, "api"); + // API interface + ChartInternal_publicField(this, "config"); + // config object + ChartInternal_publicField(this, "cache"); + // cache instance + ChartInternal_publicField(this, "$el"); + // elements + ChartInternal_publicField(this, "state"); + // state variables + ChartInternal_publicField(this, "charts"); + // all Chart instances array within page (equivalent of 'bb.instances') + // data object + ChartInternal_publicField(this, "data", { + xs: {}, + targets: [] + }); + // Axis + ChartInternal_publicField(this, "axis"); + // Axis + // scales + ChartInternal_publicField(this, "scale", { + x: null, + y: null, + y2: null, + subX: null, + subY: null, + subY2: null, + zoom: null + }); + // original values + ChartInternal_publicField(this, "org", { + xScale: null, + xDomain: null + }); + // formatter function + ChartInternal_publicField(this, "color"); + ChartInternal_publicField(this, "patterns"); + ChartInternal_publicField(this, "levelColor"); + ChartInternal_publicField(this, "point"); + ChartInternal_publicField(this, "brush"); + // format function + ChartInternal_publicField(this, "format", { + extraLineClasses: null, + xAxisTick: null, + dataTime: null, + // dataTimeFormat + defaultAxisTime: null, + // defaultAxisTimeFormat + axisTime: null + // axisTimeFormat + }); + const $$ = this; + $$.api = api; + $$.config = new Options(); + $$.cache = new Cache(); + const store = new Store(); + $$.$el = store.getStore("element"); + $$.state = store.getStore("state"); + $$.$T = $$.$T.bind($$); + } + /** + * Get the selection based on transition config + * @param {SVGElement|d3Selection} selection Target selection + * @param {boolean} force Force transition + * @param {string} name Transition name + * @returns {d3Selection} + * @private + */ + $T(selection, force, name) { + const { config, state } = this; + const duration = config.transition_duration; + const subchart = config.subchart_show; + let t = selection; + if (t) { + if ("tagName" in t) { + t = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(t); + } + const transit = (force !== false && duration || force) && (!state.zooming || state.dragging) && !state.resizing && state.rendered && !subchart; + t = transit ? t.transition(name).duration(duration) : t; + } + return t; + } + beforeInit() { + const $$ = this; + $$.callPluginHook("$beforeInit"); + callFn($$.config.onbeforeinit, $$.api); + } + afterInit() { + const $$ = this; + $$.callPluginHook("$afterInit"); + callFn($$.config.onafterinit, $$.api); + } + init() { + const $$ = this; + const { config, state, $el } = $$; + const { boost_useCssRule, bindto } = config; + checkModuleImport($$); + const hasArcType = $$.hasArcType(); + state.hasRadar = !state.hasAxis && $$.hasType("radar"); + state.hasFunnel = !state.hasAxis && $$.hasType("funnel"); + state.hasTreemap = !state.hasAxis && $$.hasType("treemap"); + state.hasAxis = !hasArcType && !state.hasFunnel && !state.hasTreemap; + state.datetimeId = `bb-${+/* @__PURE__ */ new Date() * getRandom()}`; + if (boost_useCssRule) { + const styleEl = browser_doc.createElement("style"); + styleEl.type = "text/css"; + browser_doc.head.appendChild(styleEl); + state.style = { + rootSelctor: `.${state.datetimeId}`, + sheet: styleEl.sheet + }; + $el.style = styleEl; + } + const bindConfig = { + element: bindto, + classname: "bb" + }; + if (isObject(bindto)) { + bindConfig.element = bindto.element || "#chart"; + bindConfig.classname = bindto.classname || bindConfig.classname; + } + $el.chart = isFunction(bindConfig.element.node) ? bindto.element : (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(bindConfig.element || []); + if ($el.chart.empty()) { + $el.chart = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(browser_doc.body.appendChild(browser_doc.createElement("div"))); + } + $el.chart.html("").classed(bindConfig.classname, true).classed(state.datetimeId, boost_useCssRule).style("position", "relative"); + $$.initParams(); + $$.initToRender(); + } + /** + * Initialize the rendering process + * @param {boolean} forced Force to render process + * @private + */ + initToRender(forced) { + const $$ = this; + const { config, state, $el: { chart } } = $$; + const isHidden = () => hasStyle(chart, { display: "none", visibility: "hidden" }); + const isLazy = config.render.lazy === false ? false : config.render.lazy || isHidden(); + const MutationObserver = win.MutationObserver; + if (isLazy && MutationObserver && config.render.observe !== false && !forced) { + new MutationObserver((mutation, observer) => { + if (!isHidden()) { + observer.disconnect(); + !state.rendered && $$.initToRender(true); + } + }).observe(chart.node(), { + attributes: true, + attributeFilter: ["class", "style"] + }); + } + if (!isLazy || forced) { + $$.convertData(config, (res) => { + $$.initWithData(res); + $$.afterInit(); + }); + } + } + initParams() { + var _a; + const $$ = this; + const { config, format: format2, state } = $$; + $$.color = $$.generateColor(); + $$.levelColor = $$.generateLevelColor(); + if (config.padding === false) { + config.axis_x_show = false; + config.axis_y_show = false; + config.axis_y2_show = false; + config.subchart_show = false; + } + if ($$.hasPointType() || ((_a = $$.hasLegendDefsPoint) == null ? void 0 : _a.call($$))) { + $$.point = $$.generatePoint(); + } + if (state.hasAxis) { + $$.initClip(); + format2.extraLineClasses = $$.generateExtraLineClass(); + format2.dataTime = config.data_xLocaltime ? external_commonjs_d3_time_format_commonjs2_d3_time_format_amd_d3_time_format_root_d3_.timeParse : external_commonjs_d3_time_format_commonjs2_d3_time_format_amd_d3_time_format_root_d3_.utcParse; + format2.axisTime = config.axis_x_localtime ? external_commonjs_d3_time_format_commonjs2_d3_time_format_amd_d3_time_format_root_d3_.timeFormat : external_commonjs_d3_time_format_commonjs2_d3_time_format_amd_d3_time_format_root_d3_.utcFormat; + const isDragZoom = config.zoom_enabled && config.zoom_type === "drag"; + format2.defaultAxisTime = (d) => { + const { x, zoom } = $$.scale; + const isZoomed = isDragZoom ? zoom : zoom && x.orgDomain().toString() !== zoom.domain().toString(); + const specifier = d.getMilliseconds() && ".%L" || d.getSeconds() && ".:%S" || d.getMinutes() && "%I:%M" || d.getHours() && "%I %p" || d.getDate() !== 1 && "%b %d" || isZoomed && d.getDate() === 1 && "%b'%y" || d.getMonth() && "%-m/%-d" || "%Y"; + return format2.axisTime(specifier)(d); + }; + } + const { legend_position, legend_inset_anchor, axis_rotated } = config; + state.isLegendRight = legend_position === "right"; + state.isLegendInset = legend_position === "inset"; + state.isLegendTop = legend_inset_anchor === "top-left" || legend_inset_anchor === "top-right"; + state.isLegendLeft = legend_inset_anchor === "top-left" || legend_inset_anchor === "bottom-left"; + state.rotatedPadding.top = $$.getResettedPadding(state.rotatedPadding.top); + state.rotatedPadding.right = axis_rotated && !config.axis_x_show ? 0 : 30; + state.inputType = convertInputType( + config.interaction_inputType_mouse, + config.interaction_inputType_touch + ); + } + initWithData(data2) { + var _a, _b, _c; + const $$ = this; + const { config, scale: scale2, state, $el, org } = $$; + const { hasAxis, hasFunnel, hasTreemap } = state; + const hasInteraction = config.interaction_enabled; + const hasPolar = $$.hasType("polar"); + const labelsBGColor = config.data_labels_backgroundColors; + if (hasAxis) { + $$.axis = $$.getAxisInstance(); + config.zoom_enabled && $$.initZoom(); + } + $$.data.xs = {}; + $$.data.targets = $$.convertDataToTargets(data2); + if (config.data_filter) { + $$.data.targets = $$.data.targets.filter(config.data_filter.bind($$.api)); + } + if (config.data_hide) { + $$.addHiddenTargetIds( + config.data_hide === true ? $$.mapToIds($$.data.targets) : config.data_hide + ); + } + if (config.legend_hide) { + $$.addHiddenLegendIds( + config.legend_hide === true ? $$.mapToIds($$.data.targets) : config.legend_hide + ); + } + $$.updateSizes(); + $$.updateScales(true); + if (hasAxis) { + const { x, y, y2, subX, subY, subY2 } = scale2; + if (x) { + x.domain(sortValue($$.getXDomain($$.data.targets), !config.axis_x_inverted)); + subX.domain(x.domain()); + org.xDomain = x.domain(); + } + if (y) { + y.domain($$.getYDomain($$.data.targets, "y")); + subY.domain(y.domain()); + } + if (y2) { + y2.domain($$.getYDomain($$.data.targets, "y2")); + subY2 && subY2.domain(y2.domain()); + } + } + $el.svg = $el.chart.append("svg").style("overflow", "hidden").style("display", "block"); + if (hasInteraction && state.inputType) { + const isTouch = state.inputType === "touch"; + const { onclick, onover, onout } = config; + $el.svg.on("click", (onclick == null ? void 0 : onclick.bind($$.api)) || null).on( + isTouch ? "touchstart" : "mouseenter", + (onover == null ? void 0 : onover.bind($$.api)) || null, + isTouch ? { passive: true } : void 0 + ).on(isTouch ? "touchend" : "mouseleave", (onout == null ? void 0 : onout.bind($$.api)) || null); + } + config.svg_classname && $el.svg.attr("class", config.svg_classname); + const hasColorPatterns = isFunction(config.color_tiles) && $$.patterns; + if (hasAxis || hasColorPatterns || hasPolar || hasTreemap || labelsBGColor || ((_a = $$.hasLegendDefsPoint) == null ? void 0 : _a.call($$))) { + $el.defs = $el.svg.append("defs"); + if (hasAxis) { + ["id", "idXAxis", "idYAxis", "idGrid"].forEach((v) => { + $$.appendClip($el.defs, state.clip[v]); + }); + } + $$.generateTextBGColorFilter(labelsBGColor); + if (hasColorPatterns) { + $$.patterns.forEach((p) => $el.defs.append(() => p.node)); + } + } + $$.updateSvgSize(); + $$.bindResize(); + const main = $el.svg.append("g").classed($COMMON.main, true).attr("transform", hasFunnel || hasTreemap ? null : $$.getTranslate("main")); + $el.main = main; + config.subchart_show && $$.initSubchart(); + config.tooltip_show && $$.initTooltip(); + config.title_text && $$.initTitle(); + !hasTreemap && config.legend_show && $$.initLegend(); + if (config.data_empty_label_text) { + main.append("text").attr("class", `${$TEXT.text} ${$COMMON.empty}`).attr("text-anchor", "middle").attr("dominant-baseline", "middle"); + } + if (hasAxis) { + config.regions.length && $$.initRegion(); + !config.clipPath && $$.axis.init(); + } + main.append("g").classed($COMMON.chart, true).attr("clip-path", hasAxis ? state.clip.path : null); + $$.callPluginHook("$init"); + $$.initChartElements(); + if (hasAxis) { + hasInteraction && ((_b = $$.initEventRect) == null ? void 0 : _b.call($$)); + $$.initGrid(); + config.clipPath && ((_c = $$.axis) == null ? void 0 : _c.init()); + } + $$.updateTargets($$.data.targets); + $$.updateDimension(); + callFn(config.oninit, $$.api); + $$.setBackground(); + $$.redraw({ + withTransition: false, + withTransform: true, + withUpdateXDomain: true, + withUpdateOrgXDomain: true, + withTransitionForAxis: false, + initializing: true + }); + if (config.data_onmin || config.data_onmax) { + const minMax = $$.getMinMaxData(); + callFn(config.data_onmin, $$.api, minMax.min); + callFn(config.data_onmax, $$.api, minMax.max); + } + config.tooltip_show && $$.initShowTooltip(); + state.rendered = true; + } + /** + * Initialize chart elements + * @private + */ + initChartElements() { + const $$ = this; + const { hasAxis, hasRadar, hasTreemap } = $$.state; + const types = []; + if (hasAxis) { + const shapes = ["bar", "bubble", "candlestick", "line"]; + if ($$.config.bar_front) { + shapes.push(shapes.shift()); + } + for (const shape2 of shapes) { + const name = capitalize(shape2); + if (shape2 === "line" && $$.hasTypeOf(name) || $$.hasType(shape2)) { + types.push(name); + } + } + } else if (hasTreemap) { + types.push("Treemap"); + } else if ($$.hasType("funnel")) { + types.push("Funnel"); + } else { + const hasPolar = $$.hasType("polar"); + const hasGauge = $$.hasType("gauge"); + if (!hasRadar) { + types.push("Arc", "Pie"); + } + if (hasGauge) { + types.push("Gauge"); + } else if (hasRadar) { + types.push("Radar"); + } else if (hasPolar) { + types.push("Polar"); + } + } + for (const type of types) { + $$[`init${type}`](); + } + if (notEmpty($$.config.data_labels) && !$$.hasArcType(null, ["radar"])) { + $$.initText(); + } + } + /** + * Set chart elements + * @private + */ + setChartElements() { + const $$ = this; + const { + $el: { + chart, + svg, + defs, + main, + tooltip: tooltip2, + legend: legend2, + title: title2, + grid, + needle, + arcs: arc, + circle: circles, + bar: bars, + candlestick, + line: lines, + area: areas, + text: texts + } + } = $$; + $$.api.$ = { + chart, + svg, + defs, + main, + tooltip: tooltip2, + legend: legend2, + title: title2, + grid, + arc, + circles, + bar: { bars }, + candlestick, + line: { lines, areas }, + needle, + text: { texts } + }; + } + /** + * Set background element/image + * @private + */ + setBackground() { + const $$ = this; + const { config: { background: bg }, state, $el: { svg } } = $$; + if (notEmpty(bg)) { + const element = svg.select("g").insert(bg.imgUrl ? "image" : "rect", ":first-child"); + if (bg.imgUrl) { + element.attr("href", bg.imgUrl); + } else if (bg.color) { + element.style("fill", bg.color).attr("clip-path", state.clip.path); + } + element.attr("class", bg.class || null).attr("width", "100%").attr("height", "100%"); + } + } + /** + * Update targeted element with given data + * @param {object} targets Data object formatted as 'target' + * @private + */ + updateTargets(targets) { + var _a, _b; + const $$ = this; + const { hasAxis, hasFunnel, hasRadar, hasTreemap } = $$.state; + const helper = (type) => $$[`updateTargetsFor${type}`]( + targets.filter($$[`is${type}Type`].bind($$)) + ); + $$.updateTargetsForText(targets); + if (hasAxis) { + const shapes = ["bar", "candlestick", "line"]; + for (const shape2 of shapes) { + const name = capitalize(shape2); + if (shape2 === "line" && $$.hasTypeOf(name) || $$.hasType(shape2)) { + helper(name); + } + } + (_a = $$.updateTargetsForSubchart) == null ? void 0 : _a.call($$, targets); + } else if ($$.hasArcType(targets)) { + let type = "Arc"; + if (hasRadar) { + type = "Radar"; + } else if ($$.hasType("polar")) { + type = "Polar"; + } + helper(type); + } else if (hasFunnel) { + helper("Funnel"); + } else if (hasTreemap) { + helper("Treemap"); + } + const hasPointType = $$.hasType("bubble") || $$.hasType("scatter"); + if (hasPointType) { + (_b = $$.updateTargetForCircle) == null ? void 0 : _b.call($$); + } + $$.filterTargetsToShowAtInit(hasPointType); + } + /** + * Display targeted elements at initialization + * @param {boolean} hasPointType whether has point type(bubble, scatter) or not + * @private + */ + filterTargetsToShowAtInit(hasPointType = false) { + const $$ = this; + const { $el: { svg }, $T } = $$; + let selector = `.${$COMMON.target}`; + if (hasPointType) { + selector += `, .${$CIRCLE.chartCircles} > .${$CIRCLE.circles}`; + } + $T(svg.selectAll(selector).filter((d) => $$.isTargetToShow(d.id))).style("opacity", null); + } + getWithOption(options) { + const withOptions = { + Dimension: true, + EventRect: true, + Legend: false, + Subchart: true, + Transform: false, + Transition: true, + TrimXDomain: true, + UpdateXAxis: "UpdateXDomain", + UpdateXDomain: false, + UpdateOrgXDomain: false, + TransitionForExit: "Transition", + TransitionForAxis: "Transition", + Y: true + }; + for (const [key, defVal] of Object.entries(withOptions)) { + const value = isString(defVal) ? withOptions[defVal] : defVal; + withOptions[key] = getOption(options, `with${key}`, value); + } + return withOptions; + } + initialOpacity(d) { + const $$ = this; + const { withoutFadeIn } = $$.state; + return $$.getBaseValue(d) !== null && withoutFadeIn[d.id] ? null : "0"; + } + bindResize() { + const $$ = this; + const { $el, config, state } = $$; + const resizeFunction = generateResize(config.resize_timer); + const { resize_auto } = config; + const list = []; + list.push(() => callFn(config.onresize, $$.api)); + if (/^(true|parent)$/.test(resize_auto)) { + list.push(() => { + state.resizing = true; + if (config.legend_show) { + $$.updateSizes(); + $$.updateLegend(); + } + $$.api.flush(false); + }); + } + list.push(() => { + callFn(config.onresized, $$.api); + state.resizing = false; + }); + list.forEach((v) => resizeFunction.add(v)); + $$.resizeFunction = resizeFunction; + if (resize_auto === "parent") { + ($$.resizeFunction.resizeObserver = new ResizeObserver($$.resizeFunction.bind($$))).observe($el.chart.node().parentNode); + } else { + win.addEventListener("resize", $$.resizeFunction); + } + } + /** + * Call plugin hook + * @param {string} phase The lifecycle phase + * @param {Array} args Arguments + * @private + */ + callPluginHook(phase, ...args) { + this.config.plugins.forEach((v) => { + if (phase === "$beforeInit") { + v.$$ = this; + this.api.plugins.push(v); + } + v[phase](...args); + }); + } +} +extend(ChartInternal.prototype, [ + // common + convert, + data_data, + load, + category, + internals_class, + internals_color, + domain, + interactions_interaction, + format, + internals_legend, + redraw, + scale, + shape, + size, + style, + internals_text, + internals_title, + internals_tooltip, + transform, + type +]); + +;// ./src/config/config.ts + +function loadConfig(config) { + const thisConfig = this.config; + let target; + let keys; + let read; + const find = () => { + const key = keys.shift(); + if (key && target && isObjectType(target) && key in target) { + target = target[key]; + return find(); + } else if (!key) { + return target; + } + return void 0; + }; + Object.keys(thisConfig).forEach((key) => { + target = config; + keys = key.split("_"); + read = find(); + if (isDefined(read)) { + thisConfig[key] = read; + } + }); + if (this.api) { + this.state.orgConfig = config; + } +} + +;// ./src/Chart/api/chart.ts + + +/* harmony default export */ var chart = ({ + /** + * Resize the chart. + * @function resize + * @instance + * @memberof Chart + * @param {object} size This argument should include width and height in pixels. + * @param {number} [size.width] width value + * @param {number} [size.height] height value + * @example + * // Resize to 640x480 + * chart.resize({ + * width: 640, + * height: 480 + * }); + */ + resize(size) { + const $$ = this.internal; + const { config, state } = $$; + if (state.rendered) { + config.size_width = size ? size.width : null; + config.size_height = size ? size.height : null; + state.resizing = true; + this.flush(false); + $$.resizeFunction(); + } + }, + /** + * Force to redraw. + * - **NOTE:** When zoom/subchart is used, the zoomed state will be reset. + * @function flush + * @instance + * @memberof Chart + * @param {boolean} [soft] For soft redraw. + * @example + * chart.flush(); + * + * // for soft redraw + * chart.flush(true); + */ + flush(soft) { + var _a, _b; + const $$ = this.internal; + const { state, $el: { zoomResetBtn } } = $$; + if (state.rendered) { + if (state.resizing) { + (_a = $$.brush) == null ? void 0 : _a.updateResize(); + } else { + (_b = $$.axis) == null ? void 0 : _b.setOrient(); + } + zoomResetBtn == null ? void 0 : zoomResetBtn.style("display", "none"); + if ($$.scale.zoom) { + state.current.zoomDomain = $$.scale.zoom.domain(); + } + $$.scale.zoom = null; + soft ? $$.redraw({ + withTransform: true, + withUpdateXDomain: true, + withUpdateOrgXDomain: true, + withLegend: true + }) : $$.updateAndRedraw({ + withLegend: true, + withTransition: false, + withTransitionForTransform: false + }); + if (!state.resizing && $$.brush) { + $$.brush.getSelection().call($$.brush.move); + $$.unselectRect(); + } + if (state.current.zoomDomain) { + $$.api.zoom(state.current.zoomDomain); + state.current.zoomDomain = null; + } + } else { + $$.initToRender(true); + } + }, + /** + * Reset the chart object and remove element and events completely. + * @function destroy + * @instance + * @memberof Chart + * @returns {null} + * @example + * chart.destroy(); + */ + destroy() { + var _a; + const $$ = this.internal; + const { $el: { chart, style, svg } } = $$; + if (notEmpty($$)) { + $$.callPluginHook("$willDestroy"); + $$.charts.splice($$.charts.indexOf(this), 1); + $$.unbindAllEvents(); + svg.select("*").interrupt(); + $$.resizeFunction.clear(); + (_a = $$.resizeFunction.resizeObserver) == null ? void 0 : _a.disconnect(); + win.removeEventListener("resize", $$.resizeFunction); + chart.classed("bb", false).style("position", null).selectChildren().remove(); + style && style.parentNode.removeChild(style); + Object.keys(this).forEach((key) => { + key === "internal" && Object.keys($$).forEach((k) => { + $$[k] = null; + }); + this[key] = null; + delete this[key]; + }); + for (const key in this) { + this[key] = () => { + }; + } + } + return null; + }, + /** + * Get or set config option value. + * - **NOTE** + * - The option key name must be specified as the last level. + * - When no argument is given, it will return all specified generation options object only. (will exclude any other options not specified at the initialization) + * @function config + * @instance + * @memberof Chart + * @param {string} name The option key name. + * @param {string|number|boolean|object|Array} [value] The value accepted for indicated option. + * @param {boolean} [redraw] Set to redraw with the new option changes. + * - **NOTE:** Doesn't guarantee to work in all circumstances. It can be applied for limited options only. + * @returns {string|number|boolean|object|Array} The option value or all options object + * @example + * + * // Getter + * chart.config("gauge.max"); + * + * // Getter specified with top level key name will not work. + * // The option key name must be specified as the last level. + * // chart.config("gauge"); // will not work + * + * // without any arguments, it returns generation config object + * chart.config(); // {data: { ... }, axis: { ... }, ...} + * + * // Setter + * chart.config("gauge.max", 100); + * + * // Setter specified with top level key name will not work. + * // The option key name must be specified as the last level. + * // chart.config("gauge", {min: 10, max: 20}); // will not work + * + * // Setter & redraw with the new option + * chart.config("gauge.max", 100, true); + */ + config(name, value, redraw) { + const $$ = this.internal; + const { config, state } = $$; + const key = name == null ? void 0 : name.replace(/\./g, "_"); + let res; + if (name && key in config) { + if (isDefined(value)) { + config[key] = value; + res = value; + redraw && this.flush(); + } else { + res = config[key]; + } + } else if (arguments.length === 0 || isEmpty(name)) { + res = state.orgConfig; + } + return res; + } +}); + +;// ./src/Chart/api/color.ts +/* harmony default export */ var api_color = ({ + /** + * Get the color + * @function color + * @instance + * @memberof Chart + * @param {string} id id to get the color + * @returns {string} + * @example + * chart.color("data1"); + */ + color(id) { + return this.internal.color(id); + } +}); + +;// ./src/Chart/api/data.ts + +const api_data_data = function(targetIds) { + const { targets } = this.internal.data; + if (!isUndefined(targetIds)) { + const ids = isArray(targetIds) ? targetIds : [targetIds]; + return targets.filter((t) => ids.some((v) => v === t.id)); + } + return targets; +}; +extend(api_data_data, { + /** + * Get data shown in the chart. + * @function data․shown + * @instance + * @memberof Chart + * @param {string|Array} targetIds If this argument is given, this API filters the data with specified target ids. If this argument is not given, all shown data will be returned. + * @returns {Array} Data objects + * @example + * // Get shown data by filtering to include only data1 data + * chart.data.shown("data1"); + * // --> [{id: "data1", id_org: "data1", values: Array(6)}, ...] + * + * // Get shown data by filtering to include data1 and data2 data + * chart.data.shown(["data1", "data2"]); + * + * // Get all shown data + * chart.data.shown(); + */ + shown: function(targetIds) { + return this.internal.filterTargetsToShow(this.data(targetIds)); + }, + /** + * Get values of the data loaded in the chart. + * @function data․values + * @instance + * @memberof Chart + * @param {string|Array|null} targetIds This API returns the values of specified target. If this argument is not given, null will be returned + * @param {boolean} [flat=true] Get flatten values + * @returns {Array} Data values + * @example + * // Get data1 values + * chart.data.values("data1"); + * // --> [10, 20, 30, 40] + */ + values: function(targetIds, flat = true) { + let values = null; + if (targetIds) { + const targets = this.data(targetIds); + if (isArray(targets)) { + values = []; + targets.forEach((v) => { + const dataValue = v.values.map((d) => d.value); + flat ? values = values.concat(dataValue) : values.push(dataValue); + }); + } + } + return values; + }, + /** + * Get and set names of the data loaded in the chart. + * @function data․names + * @instance + * @memberof Chart + * @param {object} names If this argument is given, the names of data will be updated. If not given, the current names will be returned. The format of this argument is the same as [data.names](./Options.html#.data%25E2%2580%25A4names). + * @returns {object} Corresponding names according its key value, if specified names values. + * @example + * // Get current names + * chart.data.names(); + * // --> {data1: "test1", data2: "test2"} + * + * // Update names + * chart.data.names({ + * data1: "New Name 1", + * data2: "New Name 2" + * }); + */ + names: function(names) { + const $$ = this.internal; + return $$.updateDataAttributes("names", names); + }, + /** + * Get and set colors of the data loaded in the chart. + * - **NOTE:** If gradient option is set, the color update will affect only gradient stops have the same color. + * @function data․colors + * @instance + * @memberof Chart + * @param {object} colors If this argument is given, the colors of data will be updated. If not given, the current colors will be returned. The format of this argument is the same as [data.colors](./Options.html#.data%25E2%2580%25A4colors). + * @returns {object} Corresponding data color value according its key value. + * @example + * // Get current colors + * chart.data.colors(); + * // --> {data1: "#00c73c", data2: "#fa7171"} + * + * // Update colors + * chart.data.colors({ + * data1: "#FFFFFF", + * data2: "#000000" + * }); + */ + colors: function(colors) { + return this.internal.updateDataAttributes("colors", colors); + }, + /** + * Get and set axes of the data loaded in the chart. + * - **NOTE:** If all data is related to one of the axes, the domain of axis without related data will be replaced by the domain from the axis with related data + * @function data․axes + * @instance + * @memberof Chart + * @param {object} axes If this argument is given, the axes of data will be updated. If not given, the current axes will be returned. The format of this argument is the same as + * @returns {object} Corresponding axes value for data, if specified axes value. + * @example + * // Get current axes + * chart.data.axes(); + * // --> {data1: "y"} + * + * // Update axes + * chart.data.axes({ + * data1: "y", + * data2: "y2" + * }); + */ + axes: function(axes) { + return this.internal.updateDataAttributes("axes", axes); + }, + /** + * Get the minimum data value bound to the chart + * @function data․min + * @instance + * @memberof Chart + * @returns {Array} Data objects + * @example + * // Get current axes + * chart.data.min(); + * // --> [{x: 0, value: 30, id: "data1", index: 0}, ...] + */ + min: function() { + return this.internal.getMinMaxData().min; + }, + /** + * Get the maximum data value bound to the chart + * @function data․max + * @instance + * @memberof Chart + * @returns {Array} Data objects + * @example + * // Get current axes + * chart.data.max(); + * // --> [{x: 3, value: 400, id: "data1", index: 3}, ...] + */ + max: function() { + return this.internal.getMinMaxData().max; + } +}); +/* harmony default export */ var api_data = ({ data: api_data_data }); + +;// ./src/Chart/api/export.ts + + + +const b64EncodeUnicode = (str) => { + var _a, _b; + return (_b = (_a = win).btoa) == null ? void 0 : _b.call( + _a, + encodeURIComponent(str).replace( + /%([0-9A-F]{2})/g, + (match, p) => String.fromCharCode(Number(`0x${p}`)) + ) + ); +}; +function nodeToSvgDataUrl(node, option, orgSize) { + const { width, height } = option || orgSize; + const serializer = new XMLSerializer(); + const clone = node.cloneNode(true); + const cssText = getCssRules(toArray(browser_doc.styleSheets)).filter((r) => r.cssText).map((r) => r.cssText); + clone.setAttribute("xmlns", external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.namespaces.xhtml); + clone.style.margin = "0"; + clone.style.padding = "0"; + if (option.preserveFontStyle) { + clone.querySelectorAll("text").forEach((t) => { + t.innerHTML = ""; + }); + } + const nodeXml = serializer.serializeToString(clone); + const style = browser_doc.createElement("style"); + style.appendChild(browser_doc.createTextNode(cssText.join("\n"))); + const styleXml = serializer.serializeToString(style); + const dataStr = `<svg xmlns="${external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.namespaces.svg}" width="${width}" height="${height}" + viewBox="0 0 ${orgSize.width} ${orgSize.height}" + preserveAspectRatio="${(option == null ? void 0 : option.preserveAspectRatio) === false ? "none" : "xMinYMid meet"}"> + <foreignObject width="100%" height="100%"> + ${styleXml} + ${nodeXml.replace(/(url\()[^#]+/g, "$1")} + </foreignObject></svg>`; + return `data:image/svg+xml;base64,${b64EncodeUnicode(dataStr)}`; +} +function getCoords(elem, svgOffset) { + const { top, left } = svgOffset; + const { x, y } = getBBox(elem, true); + const { a, b, c, d, e, f } = elem.getScreenCTM(); + const { width, height } = getBoundingRect(elem, true); + return { + x: a * x + c * y + e - left, + y: b * x + d * y + f - top + (height - Math.round(height / 4)), + width, + height + }; +} +function getGlyph(svg) { + const { left, top } = getBoundingRect(svg); + const filterFn = (t) => t.textContent || t.childElementCount; + const glyph = []; + toArray(svg.querySelectorAll("text")).filter(filterFn).forEach((t) => { + const getStyleFn = (ts) => { + const { fill, fontFamily, fontSize, textAnchor, transform } = win.getComputedStyle( + ts + ); + const { x, y, width, height } = getCoords(ts, { left, top }); + return { + [ts.textContent]: { + x, + y, + width, + height, + fill, + fontFamily, + fontSize, + textAnchor, + transform + } + }; + }; + if (t.childElementCount > 1) { + const text = []; + toArray(t.querySelectorAll("tspan")).filter(filterFn).forEach((ts) => { + glyph.push(getStyleFn(ts)); + }); + return text; + } else { + glyph.push(getStyleFn(t)); + } + }); + return glyph; +} +function renderText(ctx, glyph) { + glyph.forEach((g) => { + Object.keys(g).forEach((key) => { + const { x, y, width, height, fill, fontFamily, fontSize, transform } = g[key]; + ctx.save(); + ctx.font = `${fontSize} ${fontFamily}`; + ctx.fillStyle = fill; + if (transform === "none") { + ctx.fillText(key, x, y); + } else { + const args = transform.replace(/(matrix|\(|\))/g, "").split(","); + if (args.splice(4).every((v) => +v === 0)) { + args.push(x + width - width / 4); + args.push(y - height + height / 3); + } else { + args.push(x); + args.push(y); + } + ctx.transform(...args); + ctx.fillText(key, 0, 0); + } + ctx.restore(); + }); + }); +} +/* harmony default export */ var api_export = ({ + /** + * Export chart as an image. + * - **NOTE:** + * - IE11 and below not work properly due to the lack of the feature(<a href="https://msdn.microsoft.com/en-us/library/hh834675(v=vs.85).aspx">foreignObject</a>) support + * - Every style applied to the chart & the basic CSS file(ex. billboard.css) should be at same domain as API call context to get correct styled export image. + * @function export + * @instance + * @memberof Chart + * @param {object} option Export option + * @param {string} [option.mimeType="image/png"] The desired output image format. (ex. 'image/png' for png, 'image/jpeg' for jpeg format) + * @param {number} [option.width={currentWidth}] width + * @param {number} [option.height={currentHeigth}] height + * @param {boolean} [option.preserveAspectRatio=true] Preserve aspect ratio on given size + * @param {boolean} [option.preserveFontStyle=false] Preserve font style(font-family).<br> + * **NOTE:** + * - This option is useful when outlink web font style's `font-family` are applied to chart's text element. + * - Text element's position(especially "transformed") can't be preserved correctly according the page's layout condition. + * - If need to preserve accurate text position, embed the web font data within to the page and set `preserveFontStyle=false`. + * - Checkout the embed example: <a href="https://stackblitz.com/edit/zfbya9-8nf9nn?file=index.html">https://stackblitz.com/edit/zfbya9-8nf9nn?file=index.html</a> + * @param {function(string): void} [callback] The callback to be invoked when export is ready. + * @returns {string} dataURI + * @example + * chart.export(); + * // --> "data:image/svg+xml;base64,PHN..." + * + * // Initialize the download automatically + * chart.export({mimeType: "image/png"}, dataUrl => { + * const link = document.createElement("a"); + * + * link.download = `${Date.now()}.png`; + * link.href = dataUrl; + * link.innerHTML = "Download chart as image"; + * + * document.body.appendChild(link); + * }); + * + * // Resize the exported image + * chart.export( + * { + * width: 800, + * height: 600, + * preserveAspectRatio: false, + * preserveFontStyle: false, + * mimeType: "image/png" + * }, + * dataUrl => { ... } + * ); + */ + export(option, callback) { + const $$ = this.internal; + const { state, $el: { chart, svg } } = $$; + const { width, height } = state.current; + const opt = mergeObj(/* @__PURE__ */ Object.create(null), { + width, + height, + preserveAspectRatio: true, + preserveFontStyle: false, + mimeType: "image/png" + }, option); + const svgDataUrl = nodeToSvgDataUrl(chart.node(), opt, { width, height }); + const glyph = opt.preserveFontStyle ? getGlyph(svg.node()) : []; + if (callback && isFunction(callback)) { + const img = new Image(); + img.crossOrigin = "Anonymous"; + img.onload = () => { + const canvas = browser_doc.createElement("canvas"); + const ctx = canvas.getContext("2d"); + canvas.width = opt.width || width; + canvas.height = opt.height || height; + ctx.drawImage(img, 0, 0); + if (glyph.length) { + renderText(ctx, glyph); + glyph.length = 0; + } + callback.bind(this)(canvas.toDataURL(opt.mimeType)); + }; + img.src = svgDataUrl; + } + return svgDataUrl; + } +}); + +;// ./src/Chart/api/focus.ts + + +/* harmony default export */ var api_focus = ({ + /** + * This API highlights specified targets and fade out the others.<br><br> + * You can specify multiple targets by giving an array that includes id as String. If no argument is given, all of targets will be highlighted. + * @function focus + * @instance + * @memberof Chart + * @param {string|Array} targetIdsValue Target ids to be highlighted. + * @example + * // data1 will be highlighted and the others will be faded out + * chart.focus("data1"); + * + * // data1 and data2 will be highlighted and the others will be faded out + * chart.focus(["data1", "data2"]); + * + * // all targets will be highlighted + * chart.focus(); + */ + focus(targetIdsValue) { + const $$ = this.internal; + const { state } = $$; + const targetIds = $$.mapToTargetIds(targetIdsValue); + const candidates = $$.$el.svg.selectAll( + $$.selectorTargets(targetIds.filter($$.isTargetToShow, $$)) + ); + this.revert(); + this.defocus(); + candidates.classed($FOCUS.focused, true).classed($FOCUS.defocused, false); + if ($$.hasArcType() && !state.hasRadar) { + $$.expandArc(targetIds); + $$.hasType("gauge") && $$.markOverlapped(targetIdsValue, $$, `.${$GAUGE.gaugeValue}`); + } + $$.toggleFocusLegend(targetIds, true); + state.focusedTargetIds = targetIds; + state.defocusedTargetIds = state.defocusedTargetIds.filter((id) => targetIds.indexOf(id) < 0); + }, + /** + * This API fades out specified targets and reverts the others.<br><br> + * You can specify multiple targets by giving an array that includes id as String. If no argument is given, all of targets will be faded out. + * @function defocus + * @instance + * @memberof Chart + * @param {string|Array} targetIdsValue Target ids to be faded out. + * @example + * // data1 will be faded out and the others will be reverted. + * chart.defocus("data1"); + * + * // data1 and data2 will be faded out and the others will be reverted. + * chart.defocus(["data1", "data2"]); + * + * // all targets will be faded out. + * chart.defocus(); + */ + defocus(targetIdsValue) { + const $$ = this.internal; + const { state } = $$; + const targetIds = $$.mapToTargetIds(targetIdsValue); + const candidates = $$.$el.svg.selectAll( + $$.selectorTargets(targetIds.filter($$.isTargetToShow, $$)) + ); + candidates.classed($FOCUS.focused, false).classed($FOCUS.defocused, true); + if ($$.hasArcType(null, ["polar"])) { + $$.unexpandArc(targetIds); + $$.hasType("gauge") && $$.undoMarkOverlapped($$, `.${$GAUGE.gaugeValue}`); + } + $$.toggleFocusLegend(targetIds, false); + state.focusedTargetIds = state.focusedTargetIds.filter((id) => targetIds.indexOf(id) < 0); + state.defocusedTargetIds = targetIds; + }, + /** + * Revert focused or defocused state to initial state.<br><br> + * You can specify multiple targets by giving an array that includes id as string. If no argument is given, all of targets will be reverted. + * @function revert + * @instance + * @memberof Chart + * @param {string|Array} targetIdsValue Target ids to be reverted + * @example + * // 'data1' will be reverted. + * chart.revert("data1"); + * + * // 'data1' and 'data2' will be reverted. + * chart.revert(["data1", "data2"]); + * + * // all targets will be reverted. + * chart.revert(); + */ + revert(targetIdsValue) { + const $$ = this.internal; + const { config, state, $el } = $$; + const targetIds = $$.mapToTargetIds(targetIdsValue); + const candidates = $el.svg.selectAll($$.selectorTargets(targetIds)); + candidates.classed($FOCUS.focused, false).classed($FOCUS.defocused, false); + $$.hasArcType(null, ["polar"]) && $$.unexpandArc(targetIds); + if (config.legend_show) { + $$.showLegend(targetIds.filter($$.isLegendToShow.bind($$))); + $el.legend.selectAll($$.selectorLegends(targetIds)).filter(function() { + return (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).classed($FOCUS.legendItemFocused); + }).classed($FOCUS.legendItemFocused, false); + } + state.focusedTargetIds = []; + state.defocusedTargetIds = []; + } +}); + +;// ./src/Chart/api/legend.ts +const legend_legend = { + /** + * Show legend for each target. + * - **NOTE:** Legend APIs aren't supported for `treemap` type. + * @function legend․show + * @instance + * @memberof Chart + * @param {string|Array} targetIds + * - If targetIds is given, specified target's legend will be shown. + * - If only one target is the candidate, String can be passed. + * - If no argument is given, all of target's legend will be shown. + * @example + * // Show legend for data1. + * chart.legend.show("data1"); + * + * // Show legend for data1 and data2. + * chart.legend.show(["data1", "data2"]); + * + * // Show all legend. + * chart.legend.show(); + */ + show: function(targetIds) { + const $$ = this.internal; + $$.showLegend($$.mapToTargetIds(targetIds)); + $$.updateAndRedraw({ withLegend: true }); + }, + /** + * Hide legend for each target. + * @function legend․hide + * @instance + * @memberof Chart + * @param {string|Array} targetIds + * - If targetIds is given, specified target's legend will be hidden. + * - If only one target is the candidate, String can be passed. + * - If no argument is given, all of target's legend will be hidden. + * @example + * // Hide legend for data1. + * chart.legend.hide("data1"); + * + * // Hide legend for data1 and data2. + * chart.legend.hide(["data1", "data2"]); + * + * // Hide all legend. + * chart.legend.hide(); + */ + hide: function(targetIds) { + const $$ = this.internal; + $$.hideLegend($$.mapToTargetIds(targetIds)); + $$.updateAndRedraw({ withLegend: true }); + } +}; +/* harmony default export */ var api_legend = ({ legend: legend_legend }); + +;// ./src/Chart/api/load.ts + + + +/* harmony default export */ var api_load = ({ + /** + * Load data to the chart.<br><br> + * You can specify multiple targets by giving an array that includes id as String. If no argument is given, all of targets will be toggles. + * - <b>Note:</b> + * - unload should be used if some data needs to be unloaded simultaneously. + * If you call unload API soon after/before load instead of unload param, chart will not be rendered properly because of cancel of animation.<br> + * - done will be called after data loaded, but it's not after rendering. + * It's because rendering will finish after some transition and there is some time lag between loading and rendering + * @function load + * @instance + * @memberof Chart + * @param {object} args The object can consist with following members:<br> + * + * | Key | Type | Description | + * | --- | --- | --- | + * | columns | Array | The `columns` data will be loaded. If data that has the same target id is given, the chart will be updated. Otherwise, new target will be added | + * | json | Array | The `json` data will be loaded. If data that has the same target id is given, the chart will be updated. Otherwise, new target will be added | + * | rows | Array | The `rows` data will be loaded. If data that has the same target id is given, the chart will be updated. Otherwise, new target will be added | + * | url | string | The data from `url` will be loaded. If data that has the same target id is given, the chart will be updated. Otherwise, new target will be added | + * |   | | | + * | append | boolean | Load data appending it to the current dataseries.<br>If the existing chart has`x` value, should provide with corresponding `x` value for newly loaded data. | + * | axes | Object | The axes specified by data.axes will be updated. axes must be Object that has target id as keys. | + * | categories | Array | The categories specified by axis.x.categories or data.x will be updated. categories must be Array. | + * | classes | Object | The classes specified by data.classes will be updated. classes must be Object that has target id as keys. | + * | colors | Object | The colors specified by data.colors will be updated. colors must be Object that has target id as keys. | + * | data | Object | Data objects to be loaded. Checkout the example. | + * | done | Function | The specified function will be called after data loaded.| + * | headers | string | Set request header if loading via `data.url`.<br>@see [data․headers](Options.html#.data%25E2%2580%25A4headers) | + * | keys | Object | Choose which JSON objects keys correspond to desired data.<br>**NOTE:** Only for JSON object given as array.<br>@see [data․keys](Options.html#.data%25E2%2580%25A4keys) | + * | mimeType | string | Set 'json' if loading JSON via url.<br>@see [data․mimeType](Options.html#.data%25E2%2580%25A4mimeType) | + * | names | Object | Same as data.names() | + * | resizeAfter | boolean | Resize after the load. Default value is `false`.<br>- This option won't call `onresize` neither `onresized`.<br>- When set to 'true', will call `.flush(true)` at the end of load. | + * | type | string | The type of targets will be updated. | + * | types | Object | The types of targets will be updated. | + * | unload | Array | Specify the data will be unloaded before loading new data. If true given, all of data will be unloaded. If target ids given as String or Array, specified targets will be unloaded. If absent or false given, unload will not occur. | + * | xs | string | Same as data.xs option | + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.DataFromURL) + * @example + * // Load data1 and unload data2 and data3 + * chart.load({ + * columns: [ + * ["data1", 100, 200, 150, ...], + * ... + * ], + * unload: ["data2", "data3"], + * url: "...", + * done: function() { ... } + * resizeAfter: true // will resize after load + * }); + * @example + * const chart = bb.generate({ + * data: { + * columns: [ + * ["data1", 20, 30, 40] + * ] + * } + * }); + * + * chart.load({ + * columns: [ + * // with 'append' option, the 'data1' will have `[20,30,40,50,60]`. + * ["data1", 50, 60] + * ], + * append: true + * }); + * @example + * const chart = bb.generate({ + * data: { + * x: "x", + * xFormat: "%Y-%m-%dT%H:%M:%S", + * columns: [ + * ["x", "2021-01-03T03:00:00", "2021-01-04T12:00:00", "2021-01-05T21:00:00"], + * ["data1", 36, 30, 24] + * ] + * }, + * axis: { + * x: { + * type: "timeseries" + * } + * } + * }; + * + * chart.load({ + * columns: [ + * // when existing chart has `x` value, should provide corresponding 'x' value. + * // with 'append' option, the 'data1' will have `[36,30,24,37]`. + * ["x", "2021-02-01T08:00:00"], + * ["data1", 37] + * ], + * append: true + * }); + * @example + * // myAPI.json + * // { + * // "data1": [220, 240, 270, 250, 280], + * // "data2": [180, 150, 300, 70, 120] + * // } + * + * chart.load({ + * url: './data/myAPI.json', + * mimeType: "json", + * + * // set request header if is needed + * headers: { + * "Content-Type": "text/json" + * } + * }); + * @example + * chart.load({ + * data: [ + * // equivalent as: columns: [["data1", 30, 200, 100]] + * {"data1": 30}, {"data1": 200}, {"data1": 100} + * + * // or + * // equivalent as: columns: [["data1", 10, 20], ["data2", 13, 30]] + * // {"data1": 10, "data2": 13}, {"data1": 20, "data2": 30}} + * ] + * }); + * @example + * chart.load({ + * json: [ + * {name: "www.site1.com", upload: 800, download: 500, total: 400}, + * ], + * keys: { + * x: "name", + * value: ["upload", "download"] + * } + * }); + * @example + * chart.load({ + * json: { + * data1:[30, 20, 50, 40, 60, 50], + * data2:[200, 130, 90, 240, 130, 220], + * } + * }); + */ + load(args) { + const $$ = this.internal; + const { config } = $$; + args.xs && $$.addXs(args.xs); + "names" in args && this.data.names(args.names); + "classes" in args && Object.keys(args.classes).forEach((id) => { + config.data_classes[id] = args.classes[id]; + }); + if ("categories" in args && $$.axis.isCategorized()) { + config.axis_x_categories = args.categories; + } + "axes" in args && Object.keys(args.axes).forEach((id) => { + config.data_axes[id] = args.axes[id]; + }); + "colors" in args && Object.keys(args.colors).forEach((id) => { + config.data_colors[id] = args.colors[id]; + }); + if ("unload" in args && args.unload !== false) { + $$.unload($$.mapToTargetIds(args.unload === true ? null : args.unload), () => { + requestIdleCallback(() => $$.loadFromArgs(args)); + }); + } else { + $$.loadFromArgs(args); + } + }, + /** + * Unload data to the chart.<br><br> + * You can specify multiple targets by giving an array that includes id as String. If no argument is given, all of targets will be toggles. + * - <b>Note:</b> + * If you call load API soon after/before unload, unload param of load should be used. Otherwise chart will not be rendered properly because of cancel of animation.<br> + * `done` will be called after data loaded, but it's not after rendering. It's because rendering will finish after some transition and there is some time lag between loading and rendering. + * @function unload + * @instance + * @memberof Chart + * @param {object} argsValue + * | key | Type | Description | + * | --- | --- | --- | + * | ids | String | Array | Target id data to be unloaded. If not given, all data will be unloaded. | + * | done | Function | Callback after data is unloaded. | + * | resizeAfter | boolean | Resize after the unload. Default value is `false`.<br>- This option won't call `onresize` neither `onresized`.<br>- When set to 'true', will call `.flush(true)` at the end of unload. | + * @example + * // Unload data2 and data3 + * chart.unload({ + * ids: ["data2", "data3"], + * done: function() { + * // called after the unloaded + * }, + * resizeAfter: true // will resize after unload + * }); + */ + unload(argsValue) { + const $$ = this.internal; + let args = argsValue || {}; + isEmpty(args) && this.tooltip.hide(); + if (isArray(args)) { + args = { ids: args }; + } else if (isString(args)) { + args = { ids: [args] }; + } + const ids = $$.mapToTargetIds(args.ids); + $$.unload(ids, () => { + $$.redraw({ + withUpdateOrgXDomain: true, + withUpdateXDomain: true, + withLegend: true + }); + $$.cache.remove(ids); + callDone.call($$, args.done, args.resizeAfter); + }); + } +}); + +;// ./src/Chart/api/show.ts + +function showHide(show, targetIdsValue, options) { + const $$ = this.internal; + const targetIds = $$.mapToTargetIds(targetIdsValue); + const hiddenIds = $$.state.hiddenTargetIds.map((v) => targetIds.indexOf(v) > -1 && v).filter(Boolean); + $$.state.toggling = true; + $$[`${show ? "remove" : "add"}HiddenTargetIds`](targetIds); + const targets = $$.$el.svg.selectAll($$.selectorTargets(targetIds)); + const opacity = show ? null : "0"; + if (show && hiddenIds.length) { + targets.style("display", null); + callFn($$.config.data_onshown, this, hiddenIds); + } + $$.$T(targets).style("opacity", opacity, "important").call(endall, () => { + var _a; + if (!show && hiddenIds.length === 0) { + targets.style("display", "none"); + callFn((_a = $$.config) == null ? void 0 : _a.data_onhidden, this, targetIds); + } + targets.style("opacity", opacity); + }); + options.withLegend && $$[`${show ? "show" : "hide"}Legend`](targetIds); + $$.redraw({ + withUpdateOrgXDomain: true, + withUpdateXDomain: true, + withLegend: true + }); + $$.state.toggling = false; +} +/* harmony default export */ var show = ({ + /** + * Show data series on chart + * @function show + * @instance + * @memberof Chart + * @param {string|Array} [targetIdsValue] The target id value. + * @param {object} [options] The object can consist with following members:<br> + * + * | Key | Type | default | Description | + * | --- | --- | --- | --- | + * | withLegend | boolean | false | whether or not display legend | + * + * @example + * // show 'data1' + * chart.show("data1"); + * + * // show 'data1' and 'data3' + * chart.show(["data1", "data3"]); + */ + show(targetIdsValue, options = {}) { + showHide.call(this, true, targetIdsValue, options); + }, + /** + * Hide data series from chart + * @function hide + * @instance + * @memberof Chart + * @param {string|Array} [targetIdsValue] The target id value. + * @param {object} [options] The object can consist with following members:<br> + * + * | Key | Type | default | Description | + * | --- | --- | --- | --- | + * | withLegend | boolean | false | whether or not display legend | + * + * @example + * // hide 'data1' + * chart.hide("data1"); + * + * // hide 'data1' and 'data3' + * chart.hide(["data1", "data3"]); + */ + hide(targetIdsValue, options = {}) { + showHide.call(this, false, targetIdsValue, options); + }, + /** + * Toggle data series on chart. When target data is hidden, it will show. If is shown, it will hide in vice versa. + * @function toggle + * @instance + * @memberof Chart + * @param {string|Array} [targetIds] The target id value. + * @param {object} [options] The object can consist with following members:<br> + * + * | Key | Type | default | Description | + * | --- | --- | --- | --- | + * | withLegend | boolean | false | whether or not display legend | + * + * @example + * // toggle 'data1' + * chart.toggle("data1"); + * + * // toggle 'data1' and 'data3' + * chart.toggle(["data1", "data3"]); + */ + toggle(targetIds, options = {}) { + const $$ = this.internal; + const targets = { show: [], hide: [] }; + $$.mapToTargetIds(targetIds).forEach((id) => targets[$$.isTargetToShow(id) ? "hide" : "show"].push(id)); + targets.show.length && this.show(targets.show, options); + targets.hide.length && setTimeout(() => this.hide(targets.hide, options), 0); + } +}); + +;// ./src/Chart/api/tooltip.ts + + +const tooltip_tooltip = { + /** + * Show tooltip + * @function tooltip․show + * @instance + * @memberof Chart + * @param {object} args The object can consist with following members:<br> + * + * | Key | Type | Description | + * | --- | --- | --- | + * | index | Number | Determine focus by index | + * | x | Number | Date | Determine focus by x Axis index | + * | mouse | Array | Determine x and y coordinate value relative the targeted '.bb-event-rect' x Axis.<br>It should be used along with `data`, `index` or `x` value. The default value is set as `[0,0]` | + * | data | Object | When [data.xs](Options.html#.data%25E2%2580%25A4xs) option is used or [tooltip.grouped](Options.html#.tooltip) set to 'false', `should be used giving this param`.<br><br>**Key:**<br>- x {number | Date}: x Axis value<br>- index {number}: x Axis index (useless for data.xs)<br>- id {string}: data id<br>- value {number}: The corresponding value for tooltip. | + * + * @example + * // show the 2nd x Axis coordinate tooltip + * // for Arc(gauge, donut & pie) and radar type, approach showing tooltip by using "index" number. + * chart.tooltip.show({ + * index: 1 + * }); + * + * // show tooltip for the 3rd x Axis in x:50 and y:100 coordinate of '.bb-event-rect' of the x Axis. + * chart.tooltip.show({ + * x: 2, + * mouse: [50, 100] + * }); + * + * // show tooltip for timeseries x axis + * chart.tooltip.show({ + * x: new Date("2018-01-02 00:00") + * }); + * + * // treemap type can be shown by using "id" only. + * chart.tooltip.show({ + * data: { + * id: "data1" // data id + * } + * }); + * + * // for Arc types, specify 'id' or 'index' + * chart.tooltip.show({ data: { id: "data2" }}); + * chart.tooltip.show({ data: { index: 2 }}); + * + * // when data.xs is used + * chart.tooltip.show({ + * data: { + * x: 3, // x Axis value + * id: "data1", // data id + * value: 500 // data value + * } + * }); + * + * // when data.xs isn't used, but tooltip.grouped=false is set + * chart.tooltip.show({ + * data: { + * index: 3, // or 'x' key value + * id: "data1", // data id + * value: 500 // data value + * } + * }); + */ + show: function(args) { + var _a, _b, _c; + const $$ = this.internal; + const { $el, config, state: { eventReceiver, hasFunnel, hasTreemap, inputType } } = $$; + let index; + let mouse; + if (args.mouse) { + mouse = args.mouse; + } + if (args.data) { + const { data } = args; + const y = (_a = $$.getYScaleById(data.id)) == null ? void 0 : _a(data.value); + if ((hasFunnel || hasTreemap) && data.id) { + const selector = $$.selectorTarget(data.id, void 0, `.${$SHAPE.shape}`); + eventReceiver.rect = $el.main.select(selector); + } else if ($$.isMultipleX()) { + mouse = [$$.xx(data), y]; + } else { + if (!config.tooltip_grouped) { + mouse = [0, y]; + } + index = (_c = data.index) != null ? _c : $$.hasArcType() && data.id ? (_b = $$.getArcElementByIdOrIndex(data.id)) == null ? void 0 : _b.datum().index : $$.getIndexByX(data.x); + } + } else if (isDefined(args.x)) { + index = $$.getIndexByX(args.x); + } else if (isDefined(args.index)) { + index = args.index; + } + (inputType === "mouse" ? ["mouseover", "mousemove"] : ["touchstart"]).forEach((eventName) => { + $$.dispatchEvent(eventName, index, mouse); + }); + }, + /** + * Hide tooltip + * @function tooltip․hide + * @instance + * @memberof Chart + */ + hide: function() { + var _a, _b, _c; + const $$ = this.internal; + const { state: { inputType }, $el: { tooltip: tooltip2 } } = $$; + const data = tooltip2 == null ? void 0 : tooltip2.datum(); + if (data) { + const { index } = JSON.parse(data.current)[0]; + (inputType === "mouse" ? ["mouseout"] : ["touchend"]).forEach((eventName) => { + $$.dispatchEvent(eventName, index); + }); + } + inputType === "touch" && $$.callOverOutForTouch(); + $$.hideTooltip(true); + (_a = $$.hideGridFocus) == null ? void 0 : _a.call($$); + (_b = $$.unexpandCircles) == null ? void 0 : _b.call($$); + (_c = $$.expandBarTypeShapes) == null ? void 0 : _c.call($$, false); + } +}; +/* harmony default export */ var api_tooltip = ({ tooltip: tooltip_tooltip }); + +;// ./src/Chart/Chart.ts +var Chart_defProp = Object.defineProperty; +var Chart_defNormalProp = (obj, key, value) => key in obj ? Chart_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var Chart_publicField = (obj, key, value) => Chart_defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + + + + + + + + + + + + +class Chart { + constructor(options) { + Chart_publicField(this, "plugins", []); + Chart_publicField(this, "internal"); + const $$ = new ChartInternal(this); + this.internal = $$; + (function bindThis(fn, target, argThis) { + Object.keys(fn).forEach((key) => { + const isFunc = isFunction(fn[key]); + const isChild = target !== argThis; + const isNotNil = notEmpty(fn[key]); + const hasChild = isNotNil && Object.keys(fn[key]).length > 0; + if (isFunc && (!isChild && hasChild || isChild)) { + target[key] = fn[key].bind(argThis); + } else if (isNotNil && !isFunc) { + target[key] = {}; + } else { + target[key] = fn[key]; + } + hasChild && bindThis(fn[key], target[key], argThis); + }); + })(Chart.prototype, this, this); + loadConfig.call($$, options); + $$.beforeInit(); + $$.init(); + } +} +extend(Chart.prototype, [ + chart, + api_color, + api_data, + api_export, + api_focus, + api_legend, + api_load, + show, + api_tooltip +]); + +;// ./src/Chart/api/selection.ts + + + +function setSelection(isSelection = false, ids, indices, resetOther) { + const $$ = this; + const { config, $el: { main } } = $$; + const selectionGrouped = config.data_selection_grouped; + const isSelectable = config.data_selection_isselectable.bind($$.api); + if (!config.data_selection_enabled) { + return; + } + main.selectAll(`.${$SHAPE.shapes}`).selectAll(`.${$SHAPE.shape}`).each(function(d) { + const shape = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const { id, index } = d.data ? d.data : d; + const toggle = $$.getToggle(this, d).bind($$); + const isTargetId = selectionGrouped || !ids || ids.indexOf(id) >= 0; + const isTargetIndex = !indices || indices.indexOf(index) >= 0; + const isSelected = shape.classed($SELECT.SELECTED); + if (shape.classed($LINE.line) || shape.classed($AREA.area)) { + return; + } + if (isSelection) { + if (isTargetId && isTargetIndex && isSelectable(d) && !isSelected) { + toggle(true, shape.classed($SELECT.SELECTED, true), d, index); + } else if (isDefined(resetOther) && resetOther && isSelected) { + toggle(false, shape.classed($SELECT.SELECTED, false), d, index); + } + } else { + if (isTargetId && isTargetIndex && isSelectable(d) && isSelected) { + toggle(false, shape.classed($SELECT.SELECTED, false), d, index); + } + } + }); +} +/* harmony default export */ var selection = ({ + /** + * Get selected data points.<br><br> + * By this API, you can get selected data points information. To use this API, data.selection.enabled needs to be set true. + * @function selected + * @instance + * @memberof Chart + * @param {string} [targetId] You can filter the result by giving target id that you want to get. If not given, all of data points will be returned. + * @returns {Array} dataPoint Array of the data points.<br>ex.) `[{x: 1, value: 200, id: "data1", index: 1, name: "data1"}, ...]` + * @example + * // all selected data points will be returned. + * chart.selected(); + * // --> ex.) [{x: 1, value: 200, id: "data1", index: 1, name: "data1"}, ... ] + * + * // all selected data points of data1 will be returned. + * chart.selected("data1"); + */ + selected(targetId) { + const $$ = this.internal; + const dataPoint = []; + $$.$el.main.selectAll(`.${$SHAPE.shapes + $$.getTargetSelectorSuffix(targetId)}`).selectAll(`.${$SHAPE.shape}`).filter(function() { + return (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).classed($SELECT.SELECTED); + }).each((d) => dataPoint.push(d)); + return dataPoint; + }, + /** + * Set data points to be selected. ([`data.selection.enabled`](Options.html#.data%25E2%2580%25A4selection%25E2%2580%25A4enabled) option should be set true to use this method) + * @function select + * @instance + * @memberof Chart + * @param {string|Array} [ids] id value to get selected. + * @param {Array} [indices] The index array of data points. If falsy value given, will select all data points. + * @param {boolean} [resetOther] Unselect already selected. + * @example + * // select all data points + * chart.select(); + * + * // select all from 'data2' + * chart.select("data2"); + * + * // select all from 'data1' and 'data2' + * chart.select(["data1", "data2"]); + * + * // select from 'data1', indices 2 and unselect others selected + * chart.select("data1", [2], true); + * + * // select from 'data1', indices 0, 3 and 5 + * chart.select("data1", [0, 3, 5]); + */ + select(ids, indices, resetOther) { + const $$ = this.internal; + setSelection.bind($$)(true, ids, indices, resetOther); + }, + /** + * Set data points to be un-selected. + * @function unselect + * @instance + * @memberof Chart + * @param {string|Array} [ids] id value to be unselected. + * @param {Array} [indices] The index array of data points. If falsy value given, will select all data points. + * @example + * // unselect all data points + * chart.unselect(); + * + * // unselect all from 'data1' + * chart.unselect("data1"); + * + * // unselect from 'data1', indices 2 + * chart.unselect("data1", [2]); + */ + unselect(ids, indices) { + const $$ = this.internal; + setSelection.bind($$)(false, ids, indices); + } +}); + +;// ./src/Chart/api/subchart.ts + + +const subchart = function(domainValue) { + var _a; + const $$ = this.internal; + const { axis, brush, config, scale: { x, subX }, state } = $$; + let domain; + if (config.subchart_show) { + domain = domainValue; + if (Array.isArray(domain)) { + if (axis.isTimeSeries()) { + domain = domain.map((x2) => parseDate.bind($$)(x2)); + } + const isWithinRange = $$.withinRange( + domain, + $$.getZoomDomain("subX", true), + $$.getZoomDomain("subX") + ); + if (isWithinRange) { + state.domain = domain; + brush.move( + brush.getSelection(), + domain.map(subX) + ); + } + } else { + domain = (_a = state.domain) != null ? _a : x.orgDomain(); + } + } + return domain; +}; +extend(subchart, { + /** + * Show subchart + * - **NOTE:** for ESM imports, needs to import 'subchart' exports and instantiate it by calling `subchart()`. + * @function subchart․show + * @instance + * @memberof Chart + * @example + * // for ESM imports, needs to import 'subchart' and must be instantiated first to enable subchart's API. + * import {subchart} from "billboard.js"; + * + * const chart = bb.generate({ + * ... + * subchart: { + * // need to be instantiated by calling 'subchart()' + * enabled: subchart() + * + * // in case don't want subchart to be shown at initialization, instantiate with '!subchart()' + * enabled: !subchart() + * } + * }); + * + * chart.subchart.show(); + */ + show() { + var _a, _b; + const $$ = this.internal; + const { $el: { subchart: subchart2 }, config } = $$; + const show = config.subchart_show; + if (!show) { + $$.unbindZoomEvent(); + config.subchart_show = !show; + !subchart2.main && $$.initSubchart(); + let $target = subchart2.main.selectAll(`.${$COMMON.target}`); + if ($$.data.targets.length !== $target.size()) { + $$.updateSizes(); + $$.updateTargetsForSubchart($$.data.targets); + $target = (_a = subchart2.main) == null ? void 0 : _a.selectAll(`.${$COMMON.target}`); + } + $target == null ? void 0 : $target.style("opacity", null); + (_b = subchart2.main) == null ? void 0 : _b.style("display", null); + this.resize(); + } + }, + /** + * Hide generated subchart + * - **NOTE:** for ESM imports, needs to import 'subchart' exports and instantiate it by calling `subchart()`. + * @function subchart․hide + * @instance + * @memberof Chart + * @example + * chart.subchart.hide(); + */ + hide() { + const $$ = this.internal; + const { $el: { subchart: { main } }, config } = $$; + if (config.subchart_show && (main == null ? void 0 : main.style("display")) !== "none") { + config.subchart_show = false; + main.style("display", "none"); + this.resize(); + } + }, + /** + * Toggle the visibility of subchart + * - **NOTE:** for ESM imports, needs to import 'subchart' exports and instantiate it by calling `subchart()`. + * @function subchart․toggle + * @instance + * @memberof Chart + * @example + * // When subchart is hidden, will be shown + * // When subchart is shown, will be hidden + * chart.subchart.toggle(); + */ + toggle() { + const $$ = this.internal; + const { config } = $$; + this.subchart[config.subchart_show ? "hide" : "show"](); + }, + /** + * Reset subchart selection + * @function subchart․reset + * @instance + * @memberof Chart + * @example + * // Reset subchart selection + * chart.subchart.reset(); + */ + reset() { + const $$ = this.internal; + const { brush } = $$; + brush.clear(brush.getSelection()); + } +}); +/* harmony default export */ var api_subchart = ({ + subchart +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-zoom","commonjs2":"d3-zoom","amd":"d3-zoom","root":"d3"} +var external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_ = __webpack_require__(10); +;// ./src/Chart/api/zoom.ts + + +const zoom = function(domainValue) { + var _a; + const $$ = this.internal; + const { axis, config, org, scale, state } = $$; + const isCategorized = axis.isCategorized(); + let domain; + if (config.zoom_enabled) { + domain = domainValue; + if (Array.isArray(domain)) { + if (axis.isTimeSeries()) { + domain = domain.map((x) => parseDate.bind($$)(x)); + } + const isWithinRange = $$.withinRange( + domain, + $$.getZoomDomain("zoom", true), + $$.getZoomDomain("zoom") + ); + if (isWithinRange) { + state.domain = domain; + domain = $$.getZoomDomainValue(domain); + $$.api.tooltip.hide(); + if (config.subchart_show) { + const x = scale.zoom || scale.x; + $$.brush.getSelection().call($$.brush.move, domain.map(x)); + } else { + const x = isCategorized ? scale.x.orgScale() : org.xScale || scale.x; + $$.updateCurrentZoomTransform(x, domain); + } + $$.setZoomResetButton(); + } + } else { + domain = $$.zoom.getDomain(); + } + } + return (_a = state.domain) != null ? _a : domain; +}; +extend(zoom, { + /** + * Enable and disable zooming. + * @function zoom․enable + * @instance + * @memberof Chart + * @param {string|boolean} enabled Possible string values are "wheel" or "drag". If enabled is true, "wheel" will be used. If false is given, zooming will be disabled.<br>When set to false, the current zooming status will be reset. + * @example + * // Enable zooming using the mouse wheel + * chart.zoom.enable(true); + * // Or + * chart.zoom.enable("wheel"); + * + * // Enable zooming by dragging + * chart.zoom.enable("drag"); + * + * // Disable zooming + * chart.zoom.enable(false); + */ + enable(enabled) { + const $$ = this.internal; + const { config } = $$; + if (/^(drag|wheel)$/.test(enabled)) { + config.zoom_type = enabled; + } + config.zoom_enabled = !!enabled; + if (!$$.zoom) { + $$.initZoom(); + $$.bindZoomEvent(); + } else if (enabled === false) { + $$.bindZoomEvent(false); + } + $$.updateAndRedraw(); + }, + /** + * Set or get x Axis maximum zoom range value + * @function zoom․max + * @instance + * @memberof Chart + * @param {number} [max] maximum value to set for zoom + * @returns {number} zoom max value + * @example + * // Set maximum range value + * chart.zoom.max(20); + */ + max(max) { + const $$ = this.internal; + const { config, org: { xDomain } } = $$; + if (max === 0 || max) { + config.zoom_x_max = getMinMax("max", [xDomain[1], max]); + } + return config.zoom_x_max; + }, + /** + * Set or get x Axis minimum zoom range value + * @function zoom․min + * @instance + * @memberof Chart + * @param {number} [min] minimum value to set for zoom + * @returns {number} zoom min value + * @example + * // Set minimum range value + * chart.zoom.min(-1); + */ + min(min) { + const $$ = this.internal; + const { config, org: { xDomain } } = $$; + if (min === 0 || min) { + config.zoom_x_min = getMinMax("min", [xDomain[0], min]); + } + return config.zoom_x_min; + }, + /** + * Set zoom range + * @function zoom․range + * @instance + * @memberof Chart + * @param {object} [range] zoom range + * @returns {object} zoom range value + * { + * min: 0, + * max: 100 + * } + * @example + * chart.zoom.range({ + * min: 10, + * max: 100 + * }); + */ + range(range) { + const zoom2 = this.zoom; + if (isObject(range)) { + const { min, max } = range; + isDefined(min) && zoom2.min(min); + isDefined(max) && zoom2.max(max); + } + return { + min: zoom2.min(), + max: zoom2.max() + }; + } +}); +/* harmony default export */ var api_zoom = ({ + zoom, + /** + * Unzoom zoomed area + * - **NOTE:** Calling .unzoom() will not trigger zoom events. + * @function unzoom + * @instance + * @memberof Chart + * @example + * chart.unzoom(); + */ + unzoom() { + const $$ = this.internal; + const { config, $el: { eventRect, zoomResetBtn }, scale: { zoom: zoom2 }, state } = $$; + if (zoom2) { + config.subchart_show ? $$.brush.getSelection().call($$.brush.move, null) : $$.zoom.updateTransformScale(external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomIdentity); + $$.updateZoom(true); + zoomResetBtn == null ? void 0 : zoomResetBtn.style("display", "none"); + if ((0,external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomTransform)(eventRect.node()) !== external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomIdentity) { + $$.zoom.transform(eventRect, external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomIdentity); + } + state.domain = void 0; + } + } +}); + +;// ./src/ChartInternal/interactions/subchart.ts + + + + +/* harmony default export */ var interactions_subchart = ({ + /** + * Initialize the brush. + * @private + */ + initBrush() { + const $$ = this; + const { config, scale, $el: { subchart }, state } = $$; + const isRotated = config.axis_rotated; + const height = config.subchart_size_height; + let lastDomain; + let lastSelection; + let timeout; + $$.brush = (isRotated ? (0,external_commonjs_d3_brush_commonjs2_d3_brush_amd_d3_brush_root_d3_.brushY)() : (0,external_commonjs_d3_brush_commonjs2_d3_brush_amd_d3_brush_root_d3_.brushX)()).handleSize(5); + $$.brush.on("start brush end", (event) => { + const { selection, sourceEvent, target, type } = event; + if (type === "start") { + $$.state.inputType === "touch" && $$.hideTooltip(); + lastSelection = sourceEvent ? selection : null; + } + if (/(start|brush)/.test(type)) { + type === "brush" && sourceEvent && state.domain && (lastSelection == null ? void 0 : lastSelection.forEach((v, i) => { + if (v !== selection[i]) { + state.domain[i] = scale.x.orgDomain()[i]; + } + })); + $$.redrawForBrush(type !== "start"); + } + if (type === "end") { + lastDomain = scale.x.orgDomain(); + } + if (target == null ? void 0 : target.handle) { + if (selection === null) { + $$.brush.handle.attr("display", "none"); + } else { + $$.brush.handle.attr("display", null).attr("transform", (d, i) => { + const pos = [selection[i], height / 2]; + return `translate(${isRotated ? pos.reverse() : pos})`; + }); + } + } + }); + $$.brush.updateResize = function() { + timeout && clearTimeout(timeout); + timeout = setTimeout(() => { + const selection = this.getSelection(); + lastDomain && (0,external_commonjs_d3_brush_commonjs2_d3_brush_amd_d3_brush_root_d3_.brushSelection)(selection.node()) && this.move(selection, lastDomain.map(scale.subX.orgScale())); + }, 0); + }; + $$.brush.update = function() { + var _a; + const extent = this.extent()(); + if (extent[1].filter((v) => isNaN(v)).length === 0) { + (_a = subchart.main) == null ? void 0 : _a.select(`.${classes.brush}`).call(this); + } + return this; + }; + $$.brush.scale = function(scale2) { + const h = config.subchart_size_height; + let extent = $$.axis.getExtent(); + if (!extent && scale2.range) { + extent = [[0, 0], [scale2.range()[1], h]]; + } else if (isArray(extent)) { + extent = extent.map((v, i) => [v, i > 0 ? h : i]); + } + isRotated && extent[1].reverse(); + this.extent(extent); + this.update(); + }; + $$.brush.getSelection = () => ( + // @ts-ignore + subchart.main ? subchart.main.select(`.${classes.brush}`) : (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)([]) + ); + }, + /** + * Initialize the subchart. + * @private + */ + initSubchart() { + const $$ = this; + const { config, state: { clip, hasAxis }, $el: { defs, svg, subchart, axis } } = $$; + if (!hasAxis) { + return; + } + const visibility = config.subchart_show ? null : "hidden"; + const clipId = `${clip.id}-subchart`; + const clipPath = $$.getClipPath(clipId); + clip.idSubchart = clipId; + $$.appendClip(defs, clipId); + $$.initBrush(); + subchart.main = svg.append("g").classed(classes.subchart, true).attr("transform", $$.getTranslate("context")); + const { main } = subchart; + main.style("visibility", visibility); + main.append("g").attr("clip-path", clipPath).attr("class", classes.chart); + ["bar", "line", "bubble", "candlestick", "scatter"].forEach((v) => { + const type = capitalize(/^(bubble|scatter)$/.test(v) ? "circle" : v); + if ($$.hasType(v) || $$.hasTypeOf(type)) { + const chart = main.select(`.${classes.chart}`); + const chartClassName = classes[`chart${type}s`]; + if (chart.select(`.${chartClassName}`).empty()) { + chart.append("g").attr("class", chartClassName); + } + } + }); + const brush = main.append("g").attr("clip-path", clipPath).attr("class", classes.brush).call($$.brush); + config.subchart_showHandle && $$.addBrushHandle(brush); + axis.subX = main.append("g").attr("class", classes.axisX).attr("transform", $$.getTranslate("subX")).attr("clip-path", config.axis_rotated ? "" : clip.pathXAxis).style("visibility", config.subchart_axis_x_show ? visibility : "hidden"); + }, + /** + * Add brush handle + * Enabled when: subchart.showHandle=true + * @param {d3Selection} brush Brush selection + * @private + */ + addBrushHandle(brush) { + const $$ = this; + const { config } = $$; + const isRotated = config.axis_rotated; + const initRange = config.subchart_init_range; + const customHandleClass = "handle--custom"; + const path = isRotated ? [ + "M8.5 0 a6 6 0 0 0 -6 -6.5 H-2.5 a 6 6 0 0 0 -6 6.5 z m-5 -2 H-3.5 m7 -2 H-3.5z", + "M8.5 0 a6 -6 0 0 1 -6 6.5 H-2.5 a 6 -6 0 0 1 -6 -6.5z m-5 2 H-3.5 m7 2 H-3.5z" + ] : [ + "M0 -8.5 A6 6 0 0 0 -6.5 -3.5 V2.5 A6 6 0 0 0 0 8.5 Z M-2 -3.5 V3.5 M-4 -3.5 V3.5z", + "M0 -8.5 A6 6 0 0 1 6.5 -3.5 V2.5 A6 6 0 0 1 0 8.5 Z M2 -3.5 V3.5 M4 -3.5 V3.5z" + ]; + $$.brush.handle = brush.selectAll(`.${customHandleClass}`).data(isRotated ? [{ type: "n" }, { type: "s" }] : [{ type: "w" }, { type: "e" }]).enter().append("path").attr("class", customHandleClass).attr("cursor", `${isRotated ? "ns" : "ew"}-resize`).attr("d", (d) => path[+/[se]/.test(d.type)]).attr("display", initRange ? null : "none"); + }, + /** + * Update sub chart + * @param {object} targets $$.data.targets + * @private + */ + updateTargetsForSubchart(targets) { + const $$ = this; + const { config, state, $el: { subchart: { main } } } = $$; + if (config.subchart_show) { + ["bar", "line", "bubble", "candlestick", "scatter"].filter((v) => $$.hasType(v) || $$.hasTypeOf(capitalize(v))).forEach((v) => { + const isPointType = /^(bubble|scatter)$/.test(v); + const name = capitalize(isPointType ? "circle" : v); + const chartClass = $$.getChartClass(name, true); + const shapeClass = $$.getClass(isPointType ? "circles" : `${v}s`, true); + const shapeChart = main.select(`.${classes[`chart${`${name}s`}`]}`); + if (isPointType) { + const circle = shapeChart.selectAll(`.${classes.circles}`).data(targets.filter($$[`is${capitalize(v)}Type`].bind($$))).attr("class", shapeClass); + circle.exit().remove(); + circle.enter().append("g").attr("class", shapeClass); + } else { + const shapeUpdate = shapeChart.selectAll(`.${classes[`chart${name}`]}`).attr("class", chartClass).data(targets.filter($$[`is${name}Type`].bind($$))); + const shapeEnter = shapeUpdate.enter().append("g").style("opacity", "0").attr("class", chartClass).append("g").attr("class", shapeClass); + shapeUpdate.exit().remove(); + v === "line" && $$.hasTypeOf("Area") && shapeEnter.append("g").attr("class", $$.getClass("areas", true)); + } + }); + main.selectAll(`.${classes.brush} rect`).attr( + config.axis_rotated ? "width" : "height", + config.axis_rotated ? state.width2 : state.height2 + ); + } + }, + /** + * Redraw subchart. + * @private + * @param {boolean} withSubchart whether or not to show subchart + * @param {number} duration duration + * @param {object} shape Shape's info + */ + redrawSubchart(withSubchart, duration, shape) { + var _a; + const $$ = this; + const { config, $el: { subchart: { main } }, state } = $$; + const withTransition = !!duration; + main.style("visibility", config.subchart_show ? null : "hidden"); + if (config.subchart_show) { + if (((_a = state.event) == null ? void 0 : _a.type) === "zoom") { + $$.brush.update(); + } + if (withSubchart) { + const initRange = config.subchart_init_range; + !brushEmpty($$) && $$.brush.update(); + Object.keys(shape.type).forEach((v) => { + const name = capitalize(v); + const drawFn = $$[`generateDraw${name}`](shape.indices[v], true); + $$[`update${name}`](withTransition, true); + $$[`redraw${name}`](drawFn, withTransition, true); + }); + if ($$.hasType("bubble") || $$.hasType("scatter")) { + const { cx } = shape.pos; + const cy = $$.updateCircleY(true); + $$.updateCircle(true); + $$.redrawCircle(cx, cy, withTransition, void 0, true); + } + if (!state.rendered && initRange) { + state.domain = initRange; + $$.brush.move( + $$.brush.getSelection(), + initRange.map($$.scale.x) + ); + } + } + } + }, + /** + * Redraw the brush. + * @param {boolean} [callCallbck=true] Call 'onbrush' callback or not. + * @private + */ + redrawForBrush(callCallbck = true) { + var _a; + const $$ = this; + const { + config: { + subchart_onbrush: onBrush, + zoom_rescale: withY + }, + scale, + state + } = $$; + $$.redraw({ + withTransition: false, + withY, + withSubchart: false, + withUpdateXDomain: true, + withDimension: false + }); + callCallbck && state.rendered && onBrush.bind($$.api)((_a = state.domain) != null ? _a : scale.x.orgDomain()); + }, + /** + * Transform context + * @param {boolean} withTransition indicates transition is enabled + * @param {object} transitions The return value of the generateTransitions method of Axis. + * @private + */ + transformContext(withTransition, transitions) { + const $$ = this; + const { $el: { subchart }, $T } = $$; + const subXAxis = (transitions == null ? void 0 : transitions.axisSubX) ? transitions.axisSubX : $T(subchart.main.select(`.${classes.axisX}`), withTransition); + subchart.main.attr("transform", $$.getTranslate("context")); + subXAxis.attr("transform", $$.getTranslate("subX")); + } +}); + +;// ./src/ChartInternal/interactions/zoom.ts + + + + + +/* harmony default export */ var interactions_zoom = ({ + /** + * Initialize zoom. + * @private + */ + initZoom() { + const $$ = this; + $$.scale.zoom = null; + $$.generateZoom(); + $$.config.zoom_type === "drag" && $$.initZoomBehaviour(); + }, + /** + * Bind zoom event + * @param {boolean} bind Weather bind or unbound + * @private + */ + bindZoomEvent(bind = true) { + const $$ = this; + const { config } = $$; + const zoomEnabled = config.zoom_enabled; + if (zoomEnabled && bind) { + !config.subchart_show && $$.bindZoomOnEventRect(); + } else if (bind === false) { + $$.api.unzoom(); + $$.unbindZoomEvent(); + } + }, + /** + * Generate zoom + * @private + */ + generateZoom() { + const $$ = this; + const { config, org, scale } = $$; + const zoom = (0,external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoom)().duration(0).on("start", $$.onZoomStart.bind($$)).on("zoom", $$.onZoom.bind($$)).on("end", $$.onZoomEnd.bind($$)); + zoom.orgScaleExtent = () => { + const extent = config.zoom_extent || [1, 10]; + return [extent[0], Math.max($$.getMaxDataCount() / extent[1], extent[1])]; + }; + zoom.updateScaleExtent = function() { + const ratio = diffDomain($$.scale.x.orgDomain()) / diffDomain($$.getZoomDomain()); + const extent = this.orgScaleExtent(); + this.scaleExtent([extent[0] * ratio, extent[1] * ratio]); + return this; + }; + zoom.updateTransformScale = (transform, correctTransform) => { + var _a; + const isRotated = config.axis_rotated; + (_a = org.xScale) == null ? void 0 : _a.range(scale.x.range()); + const newScale = transform[isRotated ? "rescaleY" : "rescaleX"](org.xScale || scale.x); + if (newScale.domain().some((v) => /(Invalid Date|NaN)/.test(v.toString()))) { + return; + } + const domain = $$.trimXDomain(newScale.domain()); + const rescale = config.zoom_rescale; + newScale.domain(domain, org.xDomain); + if (correctTransform) { + const t = newScale(scale.x.domain()[0]); + const tX = isRotated ? transform.x : t; + const tY = isRotated ? t : transform.y; + $$.$el.eventRect.property( + "__zoom", + external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomIdentity.translate(tX, tY).scale(transform.k) + ); + } + scale.zoom = $$.getCustomizedXScale(newScale); + $$.axis.x.scale(scale.zoom); + if (rescale) { + !org.xScale && (org.xScale = scale.x.copy()); + scale.x.domain(domain); + } else if (org.xScale) { + scale.x.domain(org.xScale.domain()); + org.xScale = null; + } + }; + zoom.getDomain = () => { + const domain = scale[scale.zoom ? "zoom" : "subX"].domain(); + const isCategorized = $$.axis.isCategorized(); + if (isCategorized) { + domain[1] -= 2; + } + return domain; + }; + $$.zoom = zoom; + }, + /** + * 'start' event listener + * @param {object} event Event object + * @private + */ + onZoomStart(event) { + const $$ = this; + const { sourceEvent } = event; + if (sourceEvent) { + $$.zoom.startEvent = sourceEvent; + $$.state.zooming = true; + callFn($$.config.zoom_onzoomstart, $$.api, event); + } + }, + /** + * 'zoom' event listener + * @param {object} event Event object + * @private + */ + onZoom(event) { + const $$ = this; + const { config, scale, state, org } = $$; + const { sourceEvent } = event; + const isUnZoom = (event == null ? void 0 : event.transform) === external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomIdentity; + if (!config.zoom_enabled || $$.filterTargetsToShow($$.data.targets).length === 0 || !scale.zoom && (sourceEvent == null ? void 0 : sourceEvent.type.indexOf("touch")) > -1 && (sourceEvent == null ? void 0 : sourceEvent.touches.length) === 1) { + return; + } + if (event.sourceEvent) { + state.zooming = true; + state.domain = void 0; + } + const isMousemove = (sourceEvent == null ? void 0 : sourceEvent.type) === "mousemove"; + const isZoomOut = (sourceEvent == null ? void 0 : sourceEvent.wheelDelta) < 0; + const { transform } = event; + if (!isMousemove && isZoomOut && scale.x.domain().every((v, i) => v !== org.xDomain[i])) { + scale.x.domain(org.xDomain); + } + $$.zoom.updateTransformScale(transform, config.zoom_type === "wheel" && sourceEvent); + const doTransition = config.transition_duration > 0 && !config.subchart_show && (state.dragging || isUnZoom || !event.sourceEvent); + const useRAF = sourceEvent && isMousemove && config.zoom_type !== "wheel"; + const executeRedraw = () => { + var _a; + $$.redraw({ + withTransition: doTransition, + withY: config.zoom_rescale, + withSubchart: false, + withEventRect: false, + withDimension: false + }); + $$.state.cancelClick = isMousemove; + !isUnZoom && callFn( + config.zoom_onzoom, + $$.api, + (_a = $$.state.domain) != null ? _a : $$.zoom.getDomain() + ); + }; + useRAF ? scheduleRAFUpdate($$.state, executeRedraw) : executeRedraw(); + }, + /** + * 'end' event listener + * @param {object} event Event object + * @private + */ + onZoomEnd(event) { + var _a, _b; + const $$ = this; + const { config, state } = $$; + let { startEvent } = $$.zoom; + let e = event == null ? void 0 : event.sourceEvent; + const isUnZoom = (event == null ? void 0 : event.transform) === external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomIdentity; + if ((startEvent == null ? void 0 : startEvent.type.indexOf("touch")) > -1) { + startEvent = startEvent.changedTouches[0]; + e = (_a = e == null ? void 0 : e.changedTouches) == null ? void 0 : _a[0]; + } + if (config.zoom_type === "drag" && (e && startEvent.clientX === e.clientX && startEvent.clientY === e.clientY)) { + return; + } + state.zooming = false; + $$.redrawEventRect(); + $$.updateZoom(); + !isUnZoom && (e || state.dragging) && callFn( + config.zoom_onzoomend, + $$.api, + (_b = $$.state.domain) != null ? _b : $$.zoom.getDomain() + ); + }, + /** + * Update zoom + * @param {boolean} force Force unzoom + * @private + */ + updateZoom(force) { + const $$ = this; + const { subX, x, zoom } = $$.scale; + if (zoom) { + const zoomDomain = zoom.domain(); + const xDomain = subX.domain(); + const delta = 0.015; + const isfullyShown = $$.config.axis_x_inverted ? (zoomDomain[0] >= xDomain[0] || zoomDomain[0] + delta >= xDomain[0]) && (xDomain[1] >= zoomDomain[1] || xDomain[1] >= zoomDomain[1] + delta) : (zoomDomain[0] <= xDomain[0] || zoomDomain[0] - delta <= xDomain[0]) && (xDomain[1] <= zoomDomain[1] || xDomain[1] <= zoomDomain[1] - delta); + if (force || isfullyShown) { + $$.axis.x.scale(subX); + x.domain(subX.orgDomain()); + $$.scale.zoom = null; + } + } + }, + /** + * Set zoom transform to event rect + * @param {function} x x Axis scale function + * @param {Array} domain Domain value to be set + * @private + */ + updateCurrentZoomTransform(x, domain) { + const $$ = this; + const { $el: { eventRect }, config } = $$; + const isRotated = config.axis_rotated; + const translate = [-x(domain[0]), 0]; + const transform = external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomIdentity.scale(x.range()[1] / (x(domain[1]) - x(domain[0]))).translate( + ...isRotated ? translate.reverse() : translate + ); + eventRect.call($$.zoom.transform, transform); + }, + /** + * Attach zoom event on <rect> + * @private + */ + bindZoomOnEventRect() { + var _a; + const $$ = this; + const { config, $el: { eventRect, svg } } = $$; + const behaviour = config.zoom_type === "drag" ? $$.zoomBehaviour : $$.zoom; + if (win.GestureEvent && /^((?!chrome|android|mobile).)*safari/i.test((_a = win.navigator) == null ? void 0 : _a.userAgent)) { + svg.on("wheel", () => { + }); + } + eventRect == null ? void 0 : eventRect.call(behaviour).on("dblclick.zoom", null); + }, + /** + * Initialize the drag behaviour used for zooming. + * @private + */ + initZoomBehaviour() { + const $$ = this; + const { config, state } = $$; + const isRotated = config.axis_rotated; + let start = 0; + let end = 0; + let zoomRect; + let extent; + const prop = { + axis: isRotated ? "y" : "x", + attr: isRotated ? "height" : "width", + index: isRotated ? 1 : 0 + }; + $$.zoomBehaviour = (0,external_commonjs_d3_drag_commonjs2_d3_drag_amd_d3_drag_root_d3_.drag)().clickDistance(4).on("start", function(event) { + extent = $$.scale.zoom ? null : $$.axis.getExtent(); + state.event = event; + $$.setDragStatus(true); + $$.unselectRect(); + if (!zoomRect) { + zoomRect = $$.$el.main.append("rect").attr("clip-path", state.clip.path).attr("class", $ZOOM.zoomBrush).attr("width", isRotated ? state.width : 0).attr("height", isRotated ? 0 : state.height); + } + start = getPointer(event, this)[prop.index]; + if (extent) { + if (start < extent[0]) { + start = extent[0]; + } else if (start > extent[1]) { + start = extent[1]; + } + } + end = start; + zoomRect.attr(prop.axis, start).attr(prop.attr, 0); + $$.onZoomStart(event); + }).on("drag", function(event) { + end = getPointer(event, this)[prop.index]; + if (extent) { + if (end > extent[1]) { + end = extent[1]; + } else if (end < extent[0]) { + end = extent[0]; + } + } + zoomRect.attr(prop.axis, Math.min(start, end)).attr(prop.attr, Math.abs(end - start)); + }).on("end", (event) => { + const scale = $$.scale.zoom || $$.scale.x; + state.event = event; + zoomRect.attr(prop.axis, 0).attr(prop.attr, 0); + if (start > end) { + [start, end] = [end, start]; + } + if (start < 0) { + end += Math.abs(start); + start = 0; + } + if (start !== end) { + $$.api.zoom([start, end].map((v) => scale.invert(v))); + } + $$.setDragStatus(false); + }); + }, + setZoomResetButton() { + const $$ = this; + const { config, $el } = $$; + const resetButton = config.zoom_resetButton; + if (resetButton && config.zoom_type === "drag") { + if (!$el.zoomResetBtn) { + $el.zoomResetBtn = $$.$el.chart.append("div").classed($COMMON.button, true).append("span").on("click", function() { + isFunction(resetButton.onclick) && resetButton.onclick.bind($$.api)(this); + $$.api.unzoom(); + }).classed($ZOOM.buttonZoomReset, true).text(resetButton.text || "Reset Zoom"); + } else { + $el.zoomResetBtn.style("display", null); + } + } + }, + getZoomTransform() { + const $$ = this; + const { $el: { eventRect } } = $$; + return (eventRect == null ? void 0 : eventRect.node()) ? (0,external_commonjs_d3_zoom_commonjs2_d3_zoom_amd_d3_zoom_root_d3_.zoomTransform)(eventRect.node()) : { k: 1 }; + } +}); + +;// ./src/ChartInternal/interactions/drag.ts + + + +/* harmony default export */ var drag = ({ + /** + * Called when dragging. + * Data points can be selected. + * @private + * @param {object} mouse Object + */ + drag(mouse) { + const $$ = this; + const { config, state, $el: { main } } = $$; + const isSelectionGrouped = config.data_selection_grouped; + const isSelectable = config.interaction_enabled && config.data_selection_isselectable; + if ($$.hasArcType() || !config.data_selection_enabled || // do nothing if not selectable + config.zoom_enabled && !$$.zoom.altDomain || // skip if zoomable because of conflict drag behavior + !config.data_selection_multiple) { + return; + } + const [sx, sy] = state.dragStart || [0, 0]; + const [mx, my] = mouse; + const minX = Math.min(sx, mx); + const maxX = Math.max(sx, mx); + const minY = isSelectionGrouped ? state.margin.top : Math.min(sy, my); + const maxY = isSelectionGrouped ? state.height : Math.max(sy, my); + const executeDrag = () => { + if (!$$ || !$$.$el || !$$.$el.main) { + return; + } + main.select(`.${$DRAG.dragarea}`).attr("x", minX).attr("y", minY).attr("width", maxX - minX).attr("height", maxY - minY); + main.selectAll(`.${$SHAPE.shapes}`).selectAll(`.${$SHAPE.shape}`).filter((d) => isSelectable == null ? void 0 : isSelectable.bind($$.api)(d)).each(function(d, i) { + const shape = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const isSelected = shape.classed($SELECT.SELECTED); + const isIncluded = shape.classed($DRAG.INCLUDED); + let isWithin = false; + let toggle; + if (shape.classed($CIRCLE.circle)) { + const x = +shape.attr("cx") * 1; + const y = +shape.attr("cy") * 1; + toggle = $$.togglePoint; + isWithin = minX < x && x < maxX && minY < y && y < maxY; + } else if (shape.classed($BAR.bar)) { + const { x, y, width, height } = getPathBox(this); + toggle = $$.togglePath; + isWithin = !(maxX < x || x + width < minX) && !(maxY < y || y + height < minY); + } else { + return; + } + if (isWithin ^ isIncluded) { + shape.classed($DRAG.INCLUDED, !isIncluded); + shape.classed($SELECT.SELECTED, !isSelected); + toggle.call($$, !isSelected, shape, d, i); + } + }); + }; + scheduleRAFUpdate($$.state, executeDrag); + }, + /** + * Called when the drag starts. + * Adds and Shows the drag area. + * @private + * @param {object} mouse Object + */ + dragstart(mouse) { + const $$ = this; + const { config, state, $el: { main } } = $$; + if ($$.hasArcType() || !config.data_selection_enabled) { + return; + } + state.dragStart = mouse; + main.select(`.${$COMMON.chart}`).append("rect").attr("class", $DRAG.dragarea).style("opacity", "0.1"); + $$.setDragStatus(true); + }, + /** + * Called when the drag finishes. + * Removes the drag area. + * @private + */ + dragend() { + const $$ = this; + const { config, $el: { main }, $T } = $$; + if ($$.hasArcType() || !config.data_selection_enabled) { + return; + } + $T(main.select(`.${$DRAG.dragarea}`)).style("opacity", "0").remove(); + main.selectAll(`.${$SHAPE.shape}`).classed($DRAG.INCLUDED, false); + $$.setDragStatus(false); + } +}); + +;// ./src/ChartInternal/internals/selection.ts +var selection_defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var selection_getOwnPropSymbols = Object.getOwnPropertySymbols; +var selection_hasOwnProp = Object.prototype.hasOwnProperty; +var selection_propIsEnum = Object.prototype.propertyIsEnumerable; +var selection_defNormalProp = (obj, key, value) => key in obj ? selection_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var selection_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (selection_hasOwnProp.call(b, prop)) + selection_defNormalProp(a, prop, b[prop]); + if (selection_getOwnPropSymbols) + for (var prop of selection_getOwnPropSymbols(b)) { + if (selection_propIsEnum.call(b, prop)) + selection_defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); + + + + +/* harmony default export */ var internals_selection = (__spreadProps(selection_spreadValues({}, drag), { + /** + * Select a point + * @param {object} target Target point + * @param {object} d Data object + * @param {number} i Index number + * @private + */ + selectPoint(target, d, i) { + const $$ = this; + const { config, $el: { main }, $T } = $$; + const isRotated = config.axis_rotated; + const cx = (isRotated ? $$.circleY : $$.circleX).bind($$); + const cy = (isRotated ? $$.circleX : $$.circleY).bind($$); + const r = $$.pointSelectR.bind($$); + callFn(config.data_onselected, $$.api, d, target.node()); + $T(main.select(`.${$SELECT.selectedCircles}${$$.getTargetSelectorSuffix(d.id)}`).selectAll(`.${$SELECT.selectedCircle}-${i}`).data([d]).enter().append("circle").attr("class", () => $$.generateClass($SELECT.selectedCircle, i)).attr("cx", cx).attr("cy", cy).attr("stroke", $$.color).attr("r", (d2) => $$.pointSelectR(d2) * 1.4)).attr("r", r); + }, + /** + * Unelect a point + * @param {object} target Target point + * @param {object} d Data object + * @param {number} i Index number + * @private + */ + unselectPoint(target, d, i) { + const $$ = this; + const { config, $el: { main }, $T } = $$; + callFn(config.data_onunselected, $$.api, d, target == null ? void 0 : target.node()); + $T(main.select(`.${$SELECT.selectedCircles}${$$.getTargetSelectorSuffix(d.id)}`).selectAll(`.${$SELECT.selectedCircle}-${i}`)).attr("r", 0).remove(); + }, + /** + * Toggles the selection of points + * @param {boolean} selected whether or not to select. + * @param {object} target Target object + * @param {object} d Data object + * @param {number} i Index number + * @private + */ + togglePoint(selected, target, d, i) { + const method = `${selected ? "" : "un"}selectPoint`; + this[method](target, d, i); + }, + /** + * Select a path + * @param {object} target Target path + * @param {object} d Data object + * @private + */ + selectPath(target, d) { + const $$ = this; + const { config } = $$; + callFn(config.data_onselected, $$.api, d, target.node()); + if (config.interaction_brighten) { + target.style("filter", "brightness(1.25)"); + } + }, + /** + * Unelect a path + * @private + * @param {object} target Target path + * @param {object} d Data object + */ + unselectPath(target, d) { + const $$ = this; + const { config } = $$; + callFn(config.data_onunselected, $$.api, d, target.node()); + if (config.interaction_brighten) { + target.style("filter", null); + } + }, + /** + * Toggles the selection of lines + * @param {boolean} selected whether or not to select. + * @param {object} target Target object + * @param {object} d Data object + * @param {number} i Index number + * @private + */ + togglePath(selected, target, d, i) { + this[`${selected ? "" : "un"}selectPath`](target, d, i); + }, + /** + * Returns the toggle method of the target + * @param {object} that shape + * @param {object} d Data object + * @returns {function} toggle method + * @private + */ + getToggle(that, d) { + const $$ = this; + return that.nodeName === "path" ? $$.togglePath : $$.isStepType(d) ? () => { + } : ( + // circle is hidden in step chart, so treat as within the click area + $$.togglePoint + ); + }, + /** + * Toggles the selection of shapes + * @param {object} that shape + * @param {object} d Data object + * @param {number} i Index number + * @private + */ + toggleShape(that, d, i) { + var _a; + const $$ = this; + const { config, $el: { main } } = $$; + if (config.data_selection_enabled && config.data_selection_isselectable.bind($$.api)(d)) { + const shape = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(that); + const isSelected = shape.classed($SELECT.SELECTED); + const toggle = $$.getToggle(that, d).bind($$); + let toggledShape; + if (!config.data_selection_multiple) { + const focusOnly = (_a = $$.isPointFocusOnly) == null ? void 0 : _a.call($$); + let selector = `.${focusOnly ? $SELECT.selectedCircles : $SHAPE.shapes}`; + if (config.data_selection_grouped) { + selector += $$.getTargetSelectorSuffix(d.id); + } + main.selectAll(selector).selectAll( + focusOnly ? `.${$SELECT.selectedCircle}` : `.${$SHAPE.shape}.${$SELECT.SELECTED}` + ).classed($SELECT.SELECTED, false).each(function(d2) { + const shape2 = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + toggledShape = shape2; + toggle(false, shape2, d2, d2.index); + }); + } + if (!toggledShape || toggledShape.node() !== shape.node()) { + shape.classed($SELECT.SELECTED, !isSelected); + toggle(!isSelected, shape, d, i); + } + } + } +})); + +;// ./src/config/Options/data/selection.ts +/* harmony default export */ var data_selection = ({ + /** + * Set data selection enabled<br><br> + * If this option is set true, we can select the data points and get/set its state of selection by API (e.g. select, unselect, selected). + * - **NOTE:** for ESM imports, needs to import 'selection' exports and instantiate it by calling `selection()`. + * - `enabled: selection()` + * @name data․selection․enabled + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.DataSelection) + * @example + * data: { + * selection: { + * enabled: true + * } + * } + * @example + * // importing ESM + * import bb, {selection} from "billboard.js"; + * + * data: { + * selection: { + * enabled: selection(), + * ... + * } + * } + */ + data_selection_enabled: false, + /** + * Set grouped selection enabled.<br><br> + * If this option set true, multiple data points that have same x value will be selected by one selection. + * @name data․selection․grouped + * @memberof Options + * @type {boolean} + * @default false + * @example + * data: { + * selection: { + * grouped: true + * } + * } + */ + data_selection_grouped: false, + /** + * Set a callback for each data point to determine if it's selectable or not.<br><br> + * The callback will receive d as an argument and it has some parameters like id, value, index. This callback should return boolean. + * @name data․selection․isselectable + * @memberof Options + * @type {function} + * @default function() { return true; } + * @example + * data: { + * selection: { + * isselectable: function(d) { ... } + * } + * } + */ + data_selection_isselectable: () => true, + /** + * Set multiple data points selection enabled.<br><br> + * If this option set true, multiple data points can have the selected state at the same time. If false set, only one data point can have the selected state and the others will be unselected when the new data point is selected. + * @name data․selection․multiple + * @memberof Options + * @type {boolean} + * @default true + * @example + * data: { + * selection: { + * multiple: false + * } + * } + */ + data_selection_multiple: true, + /** + * Enable to select data points by dragging. + * If this option set true, data points can be selected by dragging. + * - **NOTE:** If this option set true, scrolling on the chart will be disabled because dragging event will handle the event. + * @name data․selection․draggable + * @memberof Options + * @type {boolean} + * @default false + * @example + * data: { + * selection: { + * draggable: true + * } + * } + */ + data_selection_draggable: false, + /** + * Set a callback for on data selection. + * @name data․onselected + * @memberof Options + * @type {function} + * @default function() {} + * @example + * data: { + * onselected: function(d, element) { + * // d - ex) {x: 4, value: 150, id: "data1", index: 4, name: "data1"} + * // element - <circle> + * ... + * } + * } + */ + data_onselected: () => { + }, + /** + * Set a callback for on data un-selection. + * @name data․onunselected + * @memberof Options + * @type {function} + * @default function() {} + * @example + * data: { + * onunselected: function(d, element) { + * // d - ex) {x: 4, value: 150, id: "data1", index: 4, name: "data1"} + * // element - <circle> + * ... + * } + * } + */ + data_onunselected: () => { + } +}); + +;// ./src/config/Options/interaction/subchart.ts +/* harmony default export */ var interaction_subchart = ({ + /** + * Set subchart options. + * - **NOTE:** Not supported for `bubble`, `scatter` and non-Axis based(pie, donut, gauge, radar) types. + * @name subchart + * @memberof Options + * @type {object} + * @property {object} subchart Subchart object + * @property {boolean} [subchart.show=false] Show sub chart on the bottom of the chart. + * - **NOTE:** for ESM imports, needs to import 'subchart' exports and instantiate it by calling `subchart()`. + * - `show: subchart()` + * @property {boolean} [subchart.showHandle=false] Show sub chart's handle. + * @property {boolean} [subchart.axis.x.show=true] Show or hide x axis. + * @property {boolean} [subchart.axis.x.tick.show=true] Show or hide x axis tick line. + * @property {function|string} [subchart.axis.x.tick.format] Use custom format for x axis ticks - see [axis.x.tick.format](#.axis․x․tick․format) for details. + * @property {boolean} [subchart.axis.x.tick.text.show=true] Show or hide x axis tick text. + * @property {Array} [subchart.init.range] Set initial selection domain range. + * @property {number} [subchart.size.height] Change the height of the subchart. + * @property {function} [subchart.onbrush] Set callback for brush event.<br> + * Specified function receives the current zoomed x domain. + * @see [Demo](https://naver.github.io/billboard.js/demo/#Interaction.SubChart) + * @example + * subchart: { + * show: true, + * showHandle: true, + * size: { + * height: 20 + * }, + * init: { + * // specify initial range domain selection + * range: [1, 2] + * }, + * axis: { + * x: { + * show: true, + * tick: { + * show: true, + * format: (x) => d3Format(".1f")(x) + * text: { + * show: false + * } + * } + * } + * }, + * onbrush: function(domain) { ... } + * } + * @example + * // importing ESM + * import bb, {subchart} from "billboard.js"; + * + * subchart: { + * show: subchart(), + * ... + * } + */ + subchart_show: false, + subchart_showHandle: false, + subchart_size_height: 60, + subchart_axis_x_show: true, + subchart_axis_x_tick_show: true, + subchart_axis_x_tick_format: void 0, + subchart_axis_x_tick_text_show: true, + subchart_init_range: void 0, + subchart_onbrush: () => { + } +}); + +;// ./src/config/Options/interaction/zoom.ts +/* harmony default export */ var interaction_zoom = ({ + /** + * Set zoom options + * @name zoom + * @memberof Options + * @type {object} + * @property {object} zoom Zoom object + * @property {boolean} [zoom.enabled=false] Enable zooming. + * - **NOTE:** for ESM imports, needs to import 'zoom' exports and instantiate it by calling `zoom()`. + * - `enabled: zoom()` + * @property {string} [zoom.type='wheel'] Set zoom interaction type. + * - **Available types:** + * - wheel + * - drag + * @property {boolean} [zoom.rescale=false] Enable to rescale after zooming.<br> + * If true set, y domain will be updated according to the zoomed region. + * @property {Array} [zoom.extent=[1, 10]] Change zoom extent. + * @property {number|Date} [zoom.x.min] Set x Axis minimum zoom range + * @property {number|Date} [zoom.x.max] Set x Axis maximum zoom range + * @property {function} [zoom.onzoomstart=undefined] Set callback that is called when zooming starts.<br> + * Specified function receives the zoom event. + * @property {function} [zoom.onzoom=undefined] Set callback that is called when the chart is zooming.<br> + * Specified function receives the zoomed domain. + * @property {function} [zoom.onzoomend=undefined] Set callback that is called when zooming ends.<br> + * Specified function receives the zoomed domain. + * @property {boolean|object} [zoom.resetButton=true] Set to display zoom reset button for 'drag' type zoom + * @property {function} [zoom.resetButton.onclick] Set callback when clicks the reset button. The callback will receive reset button element reference as argument. + * @property {string} [zoom.resetButton.text='Reset Zoom'] Text value for zoom reset button. + * @see [Demo:zoom](https://naver.github.io/billboard.js/demo/#Interaction.Zoom) + * @see [Demo:drag zoom](https://naver.github.io/billboard.js/demo/#Interaction.DragZoom) + * @example + * zoom: { + * enabled: true, + * type: "drag", + * rescale: true, + * extent: [1, 100] // enable more zooming + * x: { + * min: -1, // set min range + * max: 10 // set max range + * }, + * onzoomstart: function(event) { ... }, + * onzoom: function(domain) { ... }, + * onzoomend: function(domain) { ... }, + * + * // show reset button when is zoomed-in + * resetButton: true, + * + * resetButton: { + * // onclick callback when reset button is clicked + * onclick: function(button) { + * button; // Reset button element reference + * ... + * }, + * + * // customized text value for reset zoom button + * text: "Unzoom" + * } + * } + * @example + * // importing ESM + * import bb, {zoom} from "billboard.js"; + * + * zoom: { + * enabled: zoom(), + * ... + * } + */ + zoom_enabled: false, + zoom_type: "wheel", + zoom_extent: void 0, + zoom_privileged: false, + zoom_rescale: false, + zoom_onzoom: void 0, + zoom_onzoomstart: void 0, + zoom_onzoomend: void 0, + zoom_resetButton: true, + zoom_x_min: void 0, + zoom_x_max: void 0 +}); + +;// ./src/config/resolver/interaction.ts + + + + + + + + + + + + + + +let selectionModule = () => { + extend(ChartInternal.prototype, internals_selection); + extend(Chart.prototype, selection); + Options.setOptions([data_selection]); + return (selectionModule = () => true)(); +}; +let subchartModule = () => { + extend(ChartInternal.prototype, interactions_subchart); + extend(Chart.prototype, api_subchart); + Options.setOptions([interaction_subchart]); + return (subchartModule = () => true)(); +}; +let zoomModule = () => { + extend(ChartInternal.prototype, interactions_zoom); + extend(Chart.prototype, api_zoom); + Options.setOptions([interaction_zoom]); + return (zoomModule = () => true)(); +}; + +;// ./src/Chart/api/axis.ts + +function setMinMax($$, type, value) { + const { config } = $$; + const helper = (key, value2) => { + const v = isNumber(value2) ? value2 : value2 === false ? void 0 : null; + if (v !== null) { + config[`axis_${key}_${type}`] = v; + } + }; + if (isDefined(value)) { + if (isObjectType(value)) { + Object.keys(value).forEach((key) => { + helper(key, value[key]); + }); + } else if (isNumber(value) || value === false) { + ["y", "y2"].forEach((key) => { + helper(key, value); + }); + } + $$.redraw({ + withUpdateOrgXDomain: true, + withUpdateXDomain: true + }); + } +} +function axis_getMinMax($$, type) { + const { config } = $$; + return { + x: config[`axis_x_${type}`], + y: config[`axis_y_${type}`], + y2: config[`axis_y2_${type}`] + }; +} +const axis = { + /** + * Get and set axis labels. + * - **NOTE:** Only applicable for chart types which has x and y axes. + * @function axis․labels + * @instance + * @memberof Chart + * @param {object} labels specified axis' label to be updated. + * @param {string} [labels.x] x Axis string + * @param {string} [labels.y] y Axis string + * @param {string} [labels.y2] y2 Axis string + * @returns {object|undefined} axis labels text object + * @example + * // Update axis' label + * chart.axis.labels({ + * x: "New X Axis Label", + * y: "New Y Axis Label", + * y2: "New Y2 Axis Label" + * }); + * + * chart.axis.labels(); + * // --> { + * // x: "New X Axis Label", + * // y: "New Y Axis Label", + * // y2: "New Y2 Axis Label" + * // } + */ + labels: function(labels) { + const $$ = this.internal; + let labelText; + if (labels) { + Object.keys(labels).forEach((axisId) => { + $$.axis.setLabelText(axisId, labels[axisId]); + }); + $$.axis.updateLabels(); + } + ["x", "y", "y2"].forEach((v) => { + const text = $$.axis.getLabelText(v); + if (text) { + !labelText && (labelText = {}); + labelText[v] = text; + } + }); + return labelText; + }, + /** + * Get and set axis min value. + * - **NOTE:** Only applicable for chart types which has x and y axes. + * @function axis․min + * @instance + * @memberof Chart + * @param {object} min If min is given, specified axis' min value will be updated.<br> + * If no argument is given, the min values set on generating option for each axis will be returned. + * If not set any min values on generation, it will return `undefined`.<br> + * To unset specific axis max, set `false` to each of them. + * @returns {object|undefined} + * @example + * // Update axis' min + * chart.axis.min({ + * x: -10, + * y: 1000, + * y2: 100 + * }); + * + * // To unset specific axis min, set false to each of them. + * chart.axis.min({ + * x: false, + * y: false, + * y2: false + * }); + * + * // shorthand (only affects y and y2 axis) + * chart.axis.min(-50); + * chart.axis.min(false); + */ + min: function(min) { + const $$ = this.internal; + return isValue(min) || min === false ? setMinMax($$, "min", min) : axis_getMinMax($$, "min"); + }, + /** + * Get and set axis max value. + * - **NOTE:** Only applicable for chart types which has x and y axes. + * @function axis․max + * @instance + * @memberof Chart + * @param {object} max If max is given, specified axis' max value will be updated.<br> + * If no argument is given, the max values set on generating option for each axis will be returned. + * If not set any max values on generation, it will return `undefined`.<br> + * To unset specific axis max, set `false` to each of them. + * @returns {object|undefined} + * @example + * // Update axis' label + * chart.axis.max({ + * x: 100, + * y: 1000, + * y2: 10000 + * }); + * + * // To unset specific axis max, set false to each of them. + * chart.axis.max({ + * x: false, + * y: false, + * y2: false + * }); + * + * // shorthand (only affects y and y2 axis) + * chart.axis.max(10); + * chart.axis.max(false); + */ + max: function(max) { + const $$ = this.internal; + return isValue(max) || max === false ? setMinMax($$, "max", max) : axis_getMinMax($$, "max"); + }, + /** + * Get and set axis min and max value. + * - **NOTE:** Only applicable for chart types which has x and y axes. + * @function axis․range + * @instance + * @memberof Chart + * @param {object} range If range is given, specified axis' min and max value will be updated. + * If no argument is given, the current min and max values for each axis will be returned.<br> + * To unset specific axis max, set `false` to each of them. + * @returns {object|undefined} + * @example + * // Update axis' label + * chart.axis.range({ + * min: { + * x: -10, + * y: -1000, + * y2: -10000 + * }, + * max: { + * x: 100, + * y: 1000, + * y2: 10000 + * }, + * }); + * + * // To unset specific axis max, set false to each of them. + * chart.axis.range({ + * min: { + * x: false, + * y: false, + * y2: false + * }, + * max: { + * x: false, + * y: false, + * y2: false + * }, + * }); + * + * // shorthand (only affects y and y2 axis) + * chart.axis.range({ min: -50, max: 1000 }); + * chart.axis.range({ min: false, max: false }); + */ + range: function(range) { + const { axis: axis2 } = this; + if (arguments.length) { + const { min, max } = range; + isDefined(max) && axis2.max(max); + isDefined(min) && axis2.min(min); + } else { + return { + max: axis2.max(), + min: axis2.min() + }; + } + return void 0; + } +}; +/* harmony default export */ var api_axis = ({ axis }); + +;// ./src/Chart/api/category.ts + +/* harmony default export */ var api_category = ({ + /** + * Set specified category name on category axis. + * @function category + * @instance + * @memberof Chart + * @param {number} i index of category to be changed + * @param {string} category category value to be changed + * @returns {string} + * @example + * chart.category(2, "Category 3"); + */ + category(i, category) { + const $$ = this.internal; + const { config } = $$; + if (arguments.length > 1) { + config.axis_x_categories[i] = category; + $$.redraw(); + } + return config.axis_x_categories[i]; + }, + /** + * Set or get category names on category axis. + * @function categories + * @instance + * @memberof Chart + * @param {Array} categories This must be an array that includes category names in string. If category names are included in the date by data.x option, this is not required. + * @returns {Array} + * @example + * chart.categories([ + * "Category 1", "Category 2", ... + * ]); + */ + categories(categories) { + const $$ = this.internal; + const { config } = $$; + if (!categories || !Array.isArray(categories)) { + const cat = config.axis_x_categories; + return isEmpty(cat) ? Object.values($$.data.xs)[0] : cat; + } + config.axis_x_categories = categories; + $$.redraw(); + return config.axis_x_categories; + } +}); + +;// ./src/Chart/api/flow.ts + +/* harmony default export */ var flow = ({ + /** + * Flow data to the chart.<br><br> + * By this API, you can append new data points to the chart. + * @function flow + * @instance + * @memberof Chart + * @param {object} args The object can consist with following members:<br> + * + * | Key | Type | Description | + * | --- | --- | --- | + * | json | Object | Data as JSON format (@see [data․json](Options.html#.data%25E2%2580%25A4json)) | + * | rows | Array | Data in array as row format (@see [data․rows](Options.html#.data%25E2%2580%25A4json)) | + * | columns | Array | Data in array as column format (@see [data․columns](Options.html#.data%25E2%2580%25A4columns)) | + * | to | String | The lower x edge will move to that point. If not given, the lower x edge will move by the number of given data points | + * | length | Number | The lower x edge will move by the number of this argument | + * | duration | Number | The duration of the transition will be specified value. If not given, transition.duration will be used as default | + * | done | Function | The specified function will be called when flow ends | + * + * - **NOTE:** + * - If json, rows and columns given, the data will be loaded. + * - If data that has the same target id is given, the chart will be appended. + * - Otherwise, new target will be added. One of these is required when calling. + * - If json specified, keys is required as well as data.json. + * - If tab isn't visible(by evaluating `document.hidden`), will not be executed to prevent unnecessary work. + * @example + * // 2 data points will be appended to the tail and popped from the head. + * // After that, 4 data points will be appended and no data points will be poppoed. + * chart.flow({ + * columns: [ + * ["x", "2018-01-11", "2018-01-21"], + * ["data1", 500, 200], + * ["data2", 100, 300], + * ["data3", 200, 120] + * ], + * to: "2013-01-11", + * done: function () { + * chart.flow({ + * columns: [ + * ["x", "2018-02-11", "2018-02-12", "2018-02-13", "2018-02-14"], + * ["data1", 200, 300, 100, 250], + * ["data2", 100, 90, 40, 120], + * ["data3", 100, 100, 300, 500] + * ], + * length: 2, + * duration: 1500 + * }); + * } + * }); + */ + flow(args) { + const $$ = this.internal; + let data; + if (args.json || args.rows || args.columns) { + $$.convertData(args, (res) => { + data = res; + _(); + }); + } + function _() { + let domain; + let length = 0; + let tail = 0; + let diff; + let to; + if ($$.state.redrawing || !data || !isTabVisible()) { + return; + } + const notfoundIds = []; + const orgDataCount = $$.getMaxDataCount(); + const targets = $$.convertDataToTargets(data, true); + const isTimeSeries = $$.axis.isTimeSeries(); + $$.data.targets.forEach((t) => { + let found = false; + for (let i = 0; i < targets.length; i++) { + if (t.id === targets[i].id) { + found = true; + if (t.values[t.values.length - 1]) { + tail = t.values[t.values.length - 1].index + 1; + } + length = targets[i].values.length; + for (let j = 0; j < length; j++) { + targets[i].values[j].index = tail + j; + if (!isTimeSeries) { + targets[i].values[j].x = tail + j; + } + } + t.values = t.values.concat(targets[i].values); + targets.splice(i, 1); + break; + } + } + !found && notfoundIds.push(t.id); + }); + $$.data.targets.forEach((t) => { + for (let i = 0; i < notfoundIds.length; i++) { + if (t.id === notfoundIds[i]) { + tail = t.values[t.values.length - 1].index + 1; + for (let j = 0; j < length; j++) { + t.values.push({ + id: t.id, + index: tail + j, + x: isTimeSeries ? $$.getOtherTargetX(tail + j) : tail + j, + value: null + }); + } + } + } + }); + if ($$.data.targets.length) { + targets.forEach((t) => { + const missing = []; + for (let i = $$.data.targets[0].values[0].index; i < tail; i++) { + missing.push({ + id: t.id, + index: i, + x: isTimeSeries ? $$.getOtherTargetX(i) : i, + value: null + }); + } + t.values.forEach((v) => { + v.index += tail; + if (!isTimeSeries) { + v.x += tail; + } + }); + t.values = missing.concat(t.values); + }); + } + $$.data.targets = $$.data.targets.concat(targets); + const baseTarget = $$.data.targets[0]; + const baseValue = baseTarget.values[0]; + if (isDefined(args.to)) { + length = 0; + to = isTimeSeries ? parseDate.call($$, args.to) : args.to; + baseTarget.values.forEach((v) => { + v.x < to && length++; + }); + } else if (isDefined(args.length)) { + length = args.length; + } + if (!orgDataCount) { + if (isTimeSeries) { + diff = baseTarget.values.length > 1 ? baseTarget.values[baseTarget.values.length - 1].x - baseValue.x : baseValue.x - $$.getXDomain($$.data.targets)[0]; + } else { + diff = 1; + } + domain = [baseValue.x - diff, baseValue.x]; + } else if (orgDataCount === 1 && isTimeSeries) { + diff = (baseTarget.values[baseTarget.values.length - 1].x - baseValue.x) / 2; + domain = [new Date(+baseValue.x - diff), new Date(+baseValue.x + diff)]; + } + domain && $$.updateXDomain(null, true, true, false, domain); + $$.updateTargets($$.data.targets); + $$.redraw({ + flow: { + index: baseValue.index, + length, + duration: isValue(args.duration) ? args.duration : $$.config.transition_duration, + done: args.done, + orgDataCount + }, + withLegend: true, + withTransition: orgDataCount > 1, + withTrimXDomain: false, + withUpdateXAxis: true + }); + } + } +}); + +;// ./src/Chart/api/grid.ts + +function grid(grids, axisId) { + const $$ = this.internal; + const { config } = $$; + const withTransition = config.transition_duration && isTabVisible(); + const gridPropLines = `grid_${axisId}_lines`; + if (!grids) { + return config[gridPropLines]; + } + config[gridPropLines] = grids; + $$.updateGrid(); + $$.redrawGrid(withTransition); + return config[gridPropLines]; +} +function add(grids, axisId) { + const gridPropLines = `grid_${axisId}_lines`; + return grid.bind(this)( + this.internal.config[gridPropLines].concat(grids || []), + axisId + ); +} +function remove(grids, isXAxis) { + this.internal.removeGridLines(grids, isXAxis); +} +const xgrids = function(grids) { + return grid.bind(this)(grids, "x"); +}; +extend(xgrids, { + /** + * Add x grid lines.<br> + * This API adds new x grid lines instead of replacing like xgrids. + * @function xgrids․add + * @instance + * @memberof Chart + * @param {Array|object} grids New x grid lines will be added. The format of this argument is the same as grid.x.lines and it's possible to give an Object if only one line will be added. + * @returns {Array} + * @example + * // Add a new x grid line + * chart.xgrids.add( + * {value: 4, text: "Label 4"} + * ); + * + * // Add new x grid lines + * chart.xgrids.add([ + * {value: 2, text: "Label 2"}, + * {value: 4, text: "Label 4"} + * ]); + */ + add(grids) { + return add.bind(this)(grids, "x"); + }, + /** + * Remove x grid lines.<br> + * This API removes x grid lines. + * @function xgrids․remove + * @instance + * @memberof Chart + * @param {object} grids This argument should include value or class. If value is given, the x grid lines that have specified x value will be removed. If class is given, the x grid lines that have specified class will be removed. If args is not given, all of x grid lines will be removed. + * @param {number} [grids.value] target value + * @param {string} [grids.class] target class + * @returns {void} + * @example + * // x grid line on x = 2 will be removed + * chart.xgrids.remove({value: 2}); + * + * // x grid lines that have 'grid-A' will be removed + * chart.xgrids.remove({ + * class: "grid-A" + * }); + * + * // all of x grid lines will be removed + * chart.xgrids.remove(); + */ + remove(grids) { + return remove.bind(this)(grids, true); + } +}); +const ygrids = function(grids) { + return grid.bind(this)(grids, "y"); +}; +extend(ygrids, { + /** + * Add y grid lines.<br> + * This API adds new y grid lines instead of replacing like ygrids. + * @function ygrids․add + * @instance + * @memberof Chart + * @param {Array|object} grids New y grid lines will be added. The format of this argument is the same as grid.y.lines and it's possible to give an Object if only one line will be added. + * @returns {object} + * @example + * // Add a new x grid line + * chart.ygrids.add( + * {value: 400, text: "Label 4"} + * ); + * + * // Add new x grid lines + * chart.ygrids.add([ + * {value: 200, text: "Label 2"}, + * {value: 400, text: "Label 4"} + * ]); + */ + add(grids) { + return add.bind(this)(grids, "y"); + }, + /** + * Remove y grid lines.<br> + * This API removes x grid lines. + * @function ygrids․remove + * @instance + * @memberof Chart + * @param {object} grids This argument should include value or class. If value is given, the y grid lines that have specified y value will be removed. If class is given, the y grid lines that have specified class will be removed. If args is not given, all of y grid lines will be removed. + * @param {number} [grids.value] target value + * @param {string} [grids.class] target class + * @returns {void} + * @example + * // y grid line on y = 200 will be removed + * chart.ygrids.remove({value: 200}); + * + * // y grid lines that have 'grid-A' will be removed + * chart.ygrids.remove({ + * class: "grid-A" + * }); + * + * // all of y grid lines will be removed + * chart.ygrids.remove(); + */ + remove(grids) { + return remove.bind(this)(grids, false); + } +}); +/* harmony default export */ var api_grid = ({ xgrids, ygrids }); + +;// ./src/Chart/api/group.ts + +/* harmony default export */ var group = ({ + /** + * Update groups for the targets. + * @function groups + * @instance + * @memberof Chart + * @param {Array} groups This argument needs to be an Array that includes one or more Array that includes target ids to be grouped. + * @returns {Array} Grouped data names array + * @example + * // data1 and data2 will be a new group. + * chart.groups([ + * ["data1", "data2"] + * ]); + */ + groups(groups) { + const $$ = this.internal; + const { config } = $$; + if (isUndefined(groups)) { + return config.data_groups; + } + config.data_groups = groups; + $$.redraw(); + return config.data_groups; + } +}); + +;// ./src/Chart/api/regions.ts + + +function regionsFn(regions2, isAdd = false) { + const $$ = this.internal; + const { config } = $$; + const withTransition = config.transition_duration && isTabVisible(); + if (!regions2) { + return config.regions; + } + config.regions = isAdd ? config.regions.concat(regions2) : regions2; + $$.updateRegion(); + $$.redrawRegion(withTransition); + return isAdd ? config.regions : regions2; +} +const regions = function(regions2) { + return regionsFn.bind(this)(regions2); +}; +extend(regions, { + /** + * Add new region.<br><br> + * This API adds new region instead of replacing like regions. + * @function regions․add + * @instance + * @memberof Chart + * @param {Array|object} regions New region will be added. The format of this argument is the same as [regions](./Options.html#.regions) and it's possible to give an Object if only one region will be added. + * @returns {Array} regions + * @example + * // Add a new region + * chart.regions.add( + * { + * axis: "x", start: 5, class: "regionX", + * label: { + * text: "Region Text", + * color: "red" // color string + * } + * } + * ); + * + * // Add new regions + * chart.regions.add([ + * {axis: "x", start: 5, class: "regionX"}, + * { + * axis: "y", end: 50, class: "regionY", + * label: { + * text: "Region Text", + * x: 5, // position relative of the initial x coordinate + * y: 5, // position relative of the initial y coordinate + * color: "red", // color string + * rotated: true // make text to show in vertical or horizontal + * } + * } + * ]); + */ + add: function(regions2) { + return regionsFn.bind(this)(regions2, true); + }, + /** + * Remove regions.<br><br> + * This API removes regions. + * @function regions․remove + * @instance + * @memberof Chart + * @param {object} optionsValue This argument should include classes. If classes is given, the regions that have one of the specified classes will be removed. If args is not given, all of regions will be removed. + * @returns {Array} regions Removed regions + * @example + * // regions that have 'region-A' or 'region-B' will be removed. + * chart.regions.remove({ + * classes: [ + * "region-A", "region-B" + * ] + * }); + * + * // all of regions will be removed. + * chart.regions.remove(); + */ + remove: function(optionsValue) { + const $$ = this.internal; + const { config, $T } = $$; + const options = optionsValue || {}; + const classes = getOption(options, "classes", [$REGION.region]); + let regions2 = $$.$el.main.select(`.${$REGION.regions}`).selectAll(classes.map((c) => `.${c}`)); + $T(regions2).style("opacity", "0").remove(); + regions2 = config.regions; + if (Object.keys(options).length) { + regions2 = regions2.filter((region) => { + let found = false; + if (!region.class) { + return true; + } + region.class.split(" ").forEach((c) => { + if (classes.indexOf(c) >= 0) { + found = true; + } + }); + return !found; + }); + config.regions = regions2; + } else { + config.regions = []; + } + return regions2; + } +}); +/* harmony default export */ var api_regions = ({ regions }); + +;// ./src/Chart/api/x.ts + +/* harmony default export */ var x = ({ + /** + * Get and set x values for the chart. + * @function x + * @instance + * @memberof Chart + * @param {Array} x If x is given, x values of every target will be updated. If no argument is given, current x values will be returned as an Object whose keys are the target ids. + * @returns {object} xs + * @example + * // Get current x values + * chart.x(); + * + * // Update x values for all targets + * chart.x([100, 200, 300, 400, ...]); + */ + x(x) { + const $$ = this.internal; + const { axis, data } = $$; + const isCategorized = axis.isCustomX() && axis.isCategorized(); + if (isArray(x)) { + if (isCategorized) { + this.categories(x); + } else { + $$.updateTargetX(data.targets, x); + $$.redraw({ + withUpdateOrgXDomain: true, + withUpdateXDomain: true + }); + } + } + return isCategorized ? this.categories() : data.xs; + }, + /** + * Get and set x values for the chart. + * @function xs + * @instance + * @memberof Chart + * @param {Array} xs If xs is given, specified target's x values will be updated. If no argument is given, current x values will be returned as an Object whose keys are the target ids. + * @returns {object} xs + * @example + * // Get current x values + * chart.xs(); + * + * // Update x values for all targets + * chart.xs({ + * data1: [10, 20, 30, 40, ...], + * data2: [100, 200, 300, 400, ...] + * }); + */ + xs(xs) { + const $$ = this.internal; + if (isObject(xs)) { + $$.updateTargetXs($$.data.targets, xs); + $$.redraw({ + withUpdateOrgXDomain: true, + withUpdateXDomain: true + }); + } + return $$.data.xs; + } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-axis","commonjs2":"d3-axis","amd":"d3-axis","root":"d3"} +var external_commonjs_d3_axis_commonjs2_d3_axis_amd_d3_axis_root_d3_ = __webpack_require__(11); +;// ./src/ChartInternal/Axis/AxisRendererHelper.ts +var AxisRendererHelper_defProp = Object.defineProperty; +var AxisRendererHelper_defNormalProp = (obj, key, value) => key in obj ? AxisRendererHelper_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var AxisRendererHelper_publicField = (obj, key, value) => AxisRendererHelper_defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + + +class AxisRendererHelper { + constructor(owner) { + AxisRendererHelper_publicField(this, "owner"); + AxisRendererHelper_publicField(this, "config"); + AxisRendererHelper_publicField(this, "scale"); + AxisRendererHelper_publicField(this, "charSize", {}); + const scale = getScale(); + const { config, params } = owner; + this.owner = owner; + this.config = config; + this.scale = scale; + if (config.noTransition || !params.config.transition_duration) { + config.withoutTransition = true; + } + config.range = this.scaleExtent((params.orgXScale || scale).range()); + } + /** + * Compute a character dimension + * @param {string} orient Axis orientation + * @param {d3.selection} text SVG text selection + * @param {boolean} memoize memoize the calculated size + * @returns {{w: number, h: number}} + * @private + */ + getSizeFor1Char(orient, text, memoize = true) { + const size = { + w: 5.5, + h: 11.5 + }; + if (this.charSize[orient] && memoize) { + return this.charSize[orient]; + } + !text.empty() && text.text("0").call((el) => { + try { + const { width, height } = getBBox(el.node(), true); + if (width && height) { + size.w = width; + size.h = height; + } + } finally { + el.text(""); + } + }); + this.charSize[orient] = size; + return size; + } + /** + * Get tick transform setter function + * @param {string} id Axis id + * @returns {(selection: d3Selection, scale) => void} transfrom setter function + * @private + */ + getTickTransformSetter(id) { + const { config } = this; + const fn = id === "x" ? (value) => `translate(${value + config.tickOffset},0)` : (value) => `translate(0,${value})`; + return (selection, scale) => { + selection.attr("transform", (d) => { + const x = scale(d); + return isValue(d) ? fn(x) : null; + }); + }; + } + scaleExtent(domain) { + const start = domain[0]; + const stop = domain[domain.length - 1]; + return start < stop ? [start, stop] : [stop, start]; + } + generateTicks(scale, isYAxes) { + const { tickStepSize } = this.owner.params; + const [start, end] = scale.domain(); + let ticks = []; + if (isYAxes && tickStepSize) { + let interval = Math.round(start); + while (interval <= end) { + ticks.push(interval); + interval += tickStepSize; + } + } else if (scale.ticks) { + const { tickArguments } = this.config; + if (scale.type === "log" && !tickArguments) { + const s = getScale("_log").domain([start > 0 ? start : 1, end]).range(scale.range()); + ticks = s.ticks(); + for (let cnt = end.toFixed().length; ticks.length > 15; cnt--) { + ticks = s.ticks(cnt); + } + ticks.splice(0, 1, start); + ticks.splice(ticks.length - 1, 1, end); + } else { + ticks = scale.ticks(...this.config.tickArguments || []); + } + ticks = ticks.map((v) => { + const r = isString(v) && isNumber(v) && !isNaN(v) && Math.round(v * 10) / 10 || v; + return r; + }); + } + return ticks; + } + copyScale() { + const newScale = this.scale.copy(); + if (!newScale.domain().length) { + newScale.domain(this.scale.domain()); + } + newScale.type = this.scale.type; + return newScale; + } + textFormatted(v) { + const tickFormat = this.config.tickFormat; + const value = /\d+\.\d+0{5,}\d$/.test(v) ? +String(v).replace(/0+\d$/, "") : v; + const formatted = tickFormat ? tickFormat(value) : value; + return isDefined(formatted) ? formatted : ""; + } + transitionise(selection) { + const { config } = this; + let transitionSelection = selection; + if (config.withoutTransition) { + transitionSelection = selection.interrupt(); + } else if (config.transition || !this.owner.params.noTransition) { + try { + transitionSelection = selection.transition(config.transition); + } catch (e) { + } + } + return transitionSelection; + } +} + +;// ./src/ChartInternal/Axis/AxisRenderer.ts +var AxisRenderer_defProp = Object.defineProperty; +var AxisRenderer_defNormalProp = (obj, key, value) => key in obj ? AxisRenderer_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var AxisRenderer_publicField = (obj, key, value) => AxisRenderer_defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + + + + +class AxisRenderer { + constructor(params = {}) { + AxisRenderer_publicField(this, "helper"); + AxisRenderer_publicField(this, "config"); + AxisRenderer_publicField(this, "params"); + AxisRenderer_publicField(this, "g"); + AxisRenderer_publicField(this, "generatedTicks"); + const config = { + innerTickSize: 6, + outerTickSize: params.outerTick ? 6 : 0, + orient: "bottom", + range: [], + tickArguments: null, + tickCentered: null, + tickCulling: true, + tickFormat: null, + tickLength: 9, + tickOffset: 0, + tickPadding: 3, + tickValues: null, + transition: null, + noTransition: params.noTransition + }; + config.tickLength = Math.max(config.innerTickSize, 0) + config.tickPadding; + this.config = config; + this.params = params; + this.helper = new AxisRendererHelper(this); + } + /** + * Create axis element + * @param {d3.selection} g Axis selection + * @private + */ + create(g) { + const ctx = this; + const { config, helper, params } = ctx; + const { scale } = helper; + const { orient } = config; + const splitTickText = this.splitTickText.bind(ctx); + const isLeftRight = /^(left|right)$/.test(orient); + const isTopBottom = /^(top|bottom)$/.test(orient); + const tickTransform = helper.getTickTransformSetter(isTopBottom ? "x" : "y"); + const axisPx = tickTransform === helper.axisX ? "y" : "x"; + const sign = /^(top|left)$/.test(orient) ? -1 : 1; + const rotate = params.tickTextRotate; + this.config.range = scale.rangeExtent ? scale.rangeExtent() : helper.scaleExtent((params.orgXScale || scale).range()); + const { innerTickSize, tickLength, range } = config; + const id = params.id; + const tickTextPos = id && /^(x|y|y2)$/.test(id) ? params.config[`axis_${id}_tick_text_position`] : { x: 0, y: 0 }; + const prefix = id === "subX" ? `subchart_axis_x` : `axis_${id}`; + const axisShow = params.config[`${prefix}_show`]; + const tickShow = { + tick: axisShow ? params.config[`${prefix}_tick_show`] : false, + text: axisShow ? params.config[`${prefix}_tick_text_show`] : false + }; + const evalTextSize = params.config.axis_evalTextSize; + let $g; + g.each(function() { + const g2 = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + let scale0 = this.__chart__ || scale; + let scale1 = helper.copyScale(); + $g = g2; + this.__chart__ = scale1; + config.tickOffset = params.isCategory ? (scale1(1) - scale1(0)) / 2 : 0; + const path = g2.selectAll(".domain").data([0]); + path.enter().append("path").attr("class", "domain").merge(path).attr("d", () => { + const outerTickSized = config.outerTickSize * sign; + return isTopBottom ? `M${range[0]},${outerTickSized}V0H${range[1]}V${outerTickSized}` : `M${outerTickSized},${range[0]}H0V${range[1]}H${outerTickSized}`; + }); + if (tickShow.tick || tickShow.text) { + const ticks = config.tickValues || helper.generateTicks(scale1, isLeftRight || params.config.axis_rotated); + ctx.generatedTicks = ticks; + let tick = g2.selectAll(".tick").data(ticks, scale1); + const tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick"); + const tickExit = tick.exit().remove(); + tick = tickEnter.merge(tick); + tickShow.tick && tickEnter.append("line"); + tickShow.text && tickEnter.append("text"); + const tickText = tick.select("text"); + const counts = []; + let sizeFor1Char = { w: 0, h: 0 }; + if (isFunction(evalTextSize)) { + sizeFor1Char = evalTextSize.bind(ctx.params.owner.api)(tickText.node(), id); + if (this.classList.contains($COMMON.dummy)) { + this.sizeFor1Char = sizeFor1Char; + } + } + if (!sizeFor1Char || sizeFor1Char.w === 0 || sizeFor1Char.h === 0) { + sizeFor1Char = ctx.helper.getSizeFor1Char(orient, tickText, !!evalTextSize); + } + let tspan = tickText.selectAll("tspan").data((d, index) => { + const split = params.tickMultiline ? splitTickText(d, scale1, ticks, isLeftRight, sizeFor1Char.w) : isArray(helper.textFormatted(d)) ? helper.textFormatted(d).concat() : [helper.textFormatted(d)]; + counts[index] = split.length; + return split.map((splitted) => ({ index, splitted })); + }); + tspan.exit().remove(); + tspan = tspan.enter().append("tspan").merge(tspan).text((d) => d.splitted); + tspan.attr("x", isTopBottom ? 0 : tickLength * sign).attr("dx", (() => { + let dx = 0; + if (/(top|bottom)/.test(orient) && rotate) { + dx = 8 * Math.sin(Math.PI * (rotate / 180)) * (orient === "top" ? -1 : 1); + } + return dx + (tickTextPos.x || 0); + })()).attr("dy", (d, i) => { + const defValue = ".71em"; + let dy = 0; + if (orient !== "top") { + dy = sizeFor1Char.h; + if (i === 0) { + dy = isLeftRight ? -((counts[d.index] - 1) * (sizeFor1Char.h / 2) - 3) : tickTextPos.y === 0 ? defValue : 0; + } + } + return isNumber(dy) && tickTextPos.y ? dy + tickTextPos.y : dy || defValue; + }); + const lineUpdate = tick.select("line"); + const textUpdate = tick.select("text"); + tickEnter.select("line").attr(`${axisPx}2`, innerTickSize * sign); + tickEnter.select("text").attr(axisPx, tickLength * sign); + ctx.setTickLineTextPosition(lineUpdate, textUpdate, sizeFor1Char); + if (params.tickTitle) { + const title = textUpdate.select("title"); + (title.empty() ? textUpdate.append("title") : title).text((index) => params.tickTitle[index]); + } + if (scale1.bandwidth) { + const x = scale1; + const dx = x.bandwidth() / 2; + scale0 = (d) => x(d) + dx; + scale1 = scale0; + } else if (scale0.bandwidth) { + scale0 = scale1; + } else { + tickTransform(tickExit, scale1); + } + tick = params.owner.state.flowing ? helper.transitionise(tick) : params.owner.$T(tick); + tickTransform(tickEnter, scale0); + tickTransform(tick.style("opacity", null), scale1); + } + }); + this.g = $g; + } + /** + * Get generated ticks + * @param {number} count Count of ticks + * @returns {Array} Generated ticks + * @private + */ + getGeneratedTicks(count) { + var _a; + const len = ((_a = this.generatedTicks) == null ? void 0 : _a.length) - 1; + let res = this.generatedTicks; + if (len > count) { + const interval = Math.round(len / count + 0.1); + res = this.generatedTicks.map((v, i) => i % interval === 0 ? v : null).filter((v) => v !== null).splice(0, count); + } + return res; + } + /** + * Get tick x/y coordinate + * @returns {{x: number, y: number}} + * @private + */ + getTickXY() { + const { config } = this; + const pos = { x: 0, y: 0 }; + if (this.params.isCategory) { + pos.x = config.tickCentered ? 0 : config.tickOffset; + pos.y = config.tickCentered ? config.tickOffset : 0; + } + return pos; + } + /** + * Get tick size + * @param {object} d data object + * @returns {number} + * @private + */ + getTickSize(d) { + const { scale } = this.helper; + const { config } = this; + const { innerTickSize, range } = config; + const tickPosition = scale(d) + (config.tickCentered ? 0 : config.tickOffset); + return range[0] < tickPosition && tickPosition < range[1] ? innerTickSize : 0; + } + /** + * Set tick's line & text position + * @param {d3.selection} lineUpdate Line selection + * @param {d3.selection} textUpdate Text selection + * @param {object} sizeFor1Char Size for 1 char + * @private + */ + setTickLineTextPosition(lineUpdate, textUpdate, sizeFor1Char) { + const tickPos = this.getTickXY(); + const { innerTickSize, orient, tickLength, tickOffset } = this.config; + const axisId = this.params.id; + const rotate = this.params.tickTextRotate; + const baseHeight = 6; + const charHeight = sizeFor1Char.h / 2 - baseHeight; + const textAnchorForText = (r) => { + const value = ["start", "end"]; + orient === "top" && value.reverse(); + return !r ? "middle" : value[r > 0 ? 0 : 1]; + }; + const textTransform = (r) => r ? `rotate(${r})` : null; + const yForText = (r) => { + const r2 = r / (orient === "bottom" ? 15 : 23); + const y = r ? 11.5 - 2.5 * r2 * (r > 0 ? 1 : -1) : tickLength; + return y; + }; + const { + config: { + axis_rotated: isRotated, + axis_x_tick_text_inner: inner + } + } = this.params.owner; + const tickLineInner = this.params.config[`axis_${axisId}_tick_inner`]; + switch (orient) { + case "bottom": + lineUpdate.attr("x1", tickPos.x).attr("x2", tickPos.x).attr("y2", (d) => this.getTickSize.bind(this)(d) * (tickLineInner ? -1 : 1)); + textUpdate.attr("x", 0).attr("y", yForText(rotate)).style("text-anchor", textAnchorForText(rotate)).style("text-anchor", (d, i, { length }) => { + if (!isRotated && i === 0 && (inner === true || inner.first)) { + return "start"; + } else if (!isRotated && i === length - 1 && (inner === true || inner.last)) { + return "end"; + } + return textAnchorForText(rotate); + }).attr("transform", textTransform(rotate)); + break; + case "top": + lineUpdate.attr("x2", 0).attr("y2", tickLineInner ? innerTickSize : -innerTickSize); + textUpdate.attr("x", 0).attr("y", -(yForText(rotate) + charHeight + baseHeight)).style("text-anchor", textAnchorForText(rotate)).attr("transform", textTransform(rotate)); + break; + case "left": + lineUpdate.attr("x2", tickLineInner ? innerTickSize : -innerTickSize).attr("y1", tickPos.y).attr("y2", tickPos.y); + textUpdate.attr("x", -tickLength).attr("y", tickOffset + (isRotated ? charHeight / 4 : charHeight)).style("text-anchor", "end"); + break; + case "right": + lineUpdate.attr("x2", tickLineInner ? -innerTickSize : innerTickSize).attr("y2", 0); + textUpdate.attr("x", tickLength).attr("y", charHeight).style("text-anchor", "start"); + } + } + // this should be called only when category axis + splitTickText(d, scale, ticks, isLeftRight, charWidth) { + const { params } = this; + const tickText = this.helper.textFormatted(d); + const splitted = isString(tickText) && tickText.indexOf("\n") > -1 ? tickText.split("\n") : []; + if (splitted.length) { + return splitted; + } + if (isArray(tickText)) { + return tickText; + } + let tickWidth = params.tickWidth; + if (!tickWidth || tickWidth <= 0) { + tickWidth = isLeftRight ? 95 : params.isCategory ? (params.isInverted ? scale(ticks[0]) - scale(ticks[1]) : scale(ticks[1]) - scale(ticks[0])) - 12 : 110; + } + function split(splitted2, text) { + let subtext; + let spaceIndex; + let textWidth; + for (let i = 1; i < text.length; i++) { + if (text.charAt(i) === " ") { + spaceIndex = i; + } + subtext = text.substr(0, i + 1); + textWidth = charWidth * subtext.length; + if (tickWidth < textWidth) { + return split( + splitted2.concat(text.substr(0, spaceIndex || i)), + text.slice(spaceIndex ? spaceIndex + 1 : i) + ); + } + } + return splitted2.concat(text); + } + return split(splitted, String(tickText)); + } + scale(x) { + if (!arguments.length) { + return this.helper.scale; + } + this.helper.scale = x; + return this; + } + orient(x) { + if (!arguments.length) { + return this.config.orient; + } + this.config.orient = x in { + top: 1, + right: 1, + bottom: 1, + left: 1 + } ? String(x) : "bottom"; + return this; + } + tickFormat(format) { + const { config } = this; + if (!arguments.length) { + return config.tickFormat; + } + config.tickFormat = format; + return this; + } + tickCentered(isCentered) { + const { config } = this; + if (!arguments.length) { + return config.tickCentered; + } + config.tickCentered = isCentered; + return this; + } + /** + * Return tick's offset value. + * The value will be set for 'category' axis type. + * @returns {number} + * @private + */ + tickOffset() { + return this.config.tickOffset; + } + /** + * Get tick interval count + * @private + * @param {number} size Total data size + * @returns {number} + */ + tickInterval(size) { + var _a; + const { outerTickSize, tickOffset, tickValues } = this.config; + let interval; + if (this.params.isCategory) { + interval = tickOffset * 2; + } else { + const scale = (_a = this.params.owner.scale.zoom) != null ? _a : this.helper.scale; + const length = this.g.select("path.domain").node().getTotalLength() - outerTickSize * 2; + interval = length / (size || this.g.selectAll("line").size()); + const intervalByValue = tickValues ? tickValues.map((v, i, arr) => { + const next = i + 1; + return next < arr.length ? scale(arr[next]) - scale(v) : null; + }).filter(Boolean) : []; + interval = Math.min(...intervalByValue, interval); + } + return interval === Infinity ? 0 : interval; + } + ticks(...args) { + const { config } = this; + if (!args.length) { + return config.tickArguments; + } + config.tickArguments = toArray(args); + return this; + } + tickCulling(culling) { + const { config } = this; + if (!arguments.length) { + return config.tickCulling; + } + config.tickCulling = culling; + return this; + } + tickValues(x) { + const { config } = this; + if (isFunction(x)) { + config.tickValues = () => x(this.helper.scale.domain()); + } else { + if (!arguments.length) { + return config.tickValues; + } + config.tickValues = x; + } + return this; + } + setTransition(t) { + this.config.transition = t; + return this; + } +} + +;// ./src/ChartInternal/Axis/Axis.ts +var Axis_defProp = Object.defineProperty; +var Axis_defNormalProp = (obj, key, value) => key in obj ? Axis_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var Axis_publicField = (obj, key, value) => Axis_defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + + + + + +/* harmony default export */ var Axis = ({ + getAxisInstance: function() { + return this.axis || new Axis_Axis(this); + } +}); +class Axis_Axis { + constructor(owner) { + Axis_publicField(this, "owner"); + Axis_publicField(this, "x"); + Axis_publicField(this, "subX"); + Axis_publicField(this, "y"); + Axis_publicField(this, "y2"); + Axis_publicField(this, "axesList", {}); + Axis_publicField(this, "tick", { + x: null, + y: null, + y2: null + }); + Axis_publicField(this, "xs", []); + Axis_publicField(this, "orient", { + x: "bottom", + y: "left", + y2: "right", + subX: "bottom" + }); + this.owner = owner; + this.setOrient(); + } + getAxisClassName(id) { + return `${$AXIS.axis} ${$AXIS[`axis${capitalize(id)}`]}`; + } + isHorizontal($$, forHorizontal) { + const isRotated = $$.config.axis_rotated; + return forHorizontal ? isRotated : !isRotated; + } + isCategorized() { + const { config, state } = this.owner; + return config.axis_x_type.indexOf("category") >= 0 || state.hasRadar; + } + isCustomX() { + const { config } = this.owner; + return !this.isTimeSeries() && (config.data_x || notEmpty(config.data_xs)); + } + isTimeSeries(id = "x") { + return this.owner.config[`axis_${id}_type`] === "timeseries"; + } + isLog(id = "x") { + return this.owner.config[`axis_${id}_type`] === "log"; + } + isTimeSeriesY() { + return this.isTimeSeries("y"); + } + getAxisType(id = "x") { + let type = "linear"; + if (this.isTimeSeries(id)) { + type = this.owner.config.axis_x_localtime ? "time" : "utc"; + } else if (this.isLog(id)) { + type = "log"; + } + return type; + } + /** + * Get extent value + * @returns {Array} default extent + * @private + */ + getExtent() { + const $$ = this.owner; + const { config, scale } = $$; + let extent = config.axis_x_extent; + if (extent) { + if (isFunction(extent)) { + extent = extent.bind($$.api)($$.getXDomain($$.data.targets), scale.subX); + } else if (this.isTimeSeries() && extent.every(isNaN)) { + const fn = parseDate.bind($$); + extent = extent.map((v) => scale.subX(fn(v))); + } + } + return extent; + } + init() { + const $$ = this.owner; + const { config, $el: { main, axis }, state: { clip } } = $$; + const target = ["x", "y"]; + config.axis_y2_show && target.push("y2"); + target.forEach((v) => { + const classAxis = this.getAxisClassName(v); + axis[v] = main.append("g").attr("class", classAxis).attr("clip-path", () => { + let res = null; + if (v === "x") { + res = clip.pathXAxis; + } else if (v === "y") { + res = clip.pathYAxis; + } + return res; + }).attr("transform", $$.getTranslate(v)).style("visibility", config[`axis_${v}_show`] ? null : "hidden"); + this.generateAxes(v); + }); + } + /** + * Set axis orient according option value + * @private + */ + setOrient() { + const $$ = this.owner; + const { + axis_rotated: isRotated, + axis_y_inner: yInner, + axis_y2_inner: y2Inner + } = $$.config; + this.orient = { + x: isRotated ? "left" : "bottom", + y: isRotated ? yInner ? "top" : "bottom" : yInner ? "right" : "left", + y2: isRotated ? y2Inner ? "bottom" : "top" : y2Inner ? "left" : "right", + subX: isRotated ? "left" : "bottom" + }; + } + /** + * Generate axes + * It's used when axis' axes option is set + * @param {string} id Axis id + * @private + */ + generateAxes(id) { + const $$ = this.owner; + const { config } = $$; + const axes = []; + const axesConfig = config[`axis_${id}_axes`]; + const isRotated = config.axis_rotated; + let d3Axis; + if (id === "x") { + d3Axis = isRotated ? external_commonjs_d3_axis_commonjs2_d3_axis_amd_d3_axis_root_d3_.axisLeft : external_commonjs_d3_axis_commonjs2_d3_axis_amd_d3_axis_root_d3_.axisBottom; + } else if (id === "y") { + d3Axis = isRotated ? external_commonjs_d3_axis_commonjs2_d3_axis_amd_d3_axis_root_d3_.axisBottom : external_commonjs_d3_axis_commonjs2_d3_axis_amd_d3_axis_root_d3_.axisLeft; + } else if (id === "y2") { + d3Axis = isRotated ? external_commonjs_d3_axis_commonjs2_d3_axis_amd_d3_axis_root_d3_.axisTop : external_commonjs_d3_axis_commonjs2_d3_axis_amd_d3_axis_root_d3_.axisRight; + } + if (axesConfig.length) { + axesConfig.forEach((v) => { + const tick = v.tick || {}; + const scale = $$.scale[id].copy(); + v.domain && scale.domain(v.domain); + axes.push( + d3Axis(scale).ticks(tick.count).tickFormat( + isFunction(tick.format) ? tick.format.bind($$.api) : ((x) => x) + ).tickValues(tick.values).tickSizeOuter(tick.outer === false ? 0 : 6) + ); + }); + } + this.axesList[id] = axes; + } + /** + * Update axes nodes + * @private + */ + updateAxes() { + const $$ = this.owner; + const { config, $el: { main }, $T } = $$; + Object.keys(this.axesList).forEach((id) => { + const axesConfig = config[`axis_${id}_axes`]; + const scale = $$.scale[id].copy(); + const range = scale.range(); + this.axesList[id].forEach((v, i) => { + const axisRange = v.scale().range(); + if (!range.every((v2, i2) => v2 === axisRange[i2])) { + v.scale().range(range); + } + const className = `${this.getAxisClassName(id)}-${i + 1}`; + let g = main.select(`.${className.replace(/\s/, ".")}`); + if (g.empty()) { + g = main.append("g").attr("class", className).style("visibility", config[`axis_${id}_show`] ? null : "hidden").call(v); + } else { + axesConfig[i].domain && scale.domain(axesConfig[i].domain); + $T(g).call(v.scale(scale)); + } + g.attr("transform", $$.getTranslate(id, i + 1)); + }); + }); + } + /** + * Set Axis & tick values + * called from: updateScales() + * @param {string} id Axis id string + * @param {d3Scale} scale Scale + * @param {boolean} outerTick If show outer tick + * @param {boolean} noTransition If with no transition + * @private + */ + setAxis(id, scale, outerTick, noTransition) { + const $$ = this.owner; + if (id !== "subX") { + this.tick[id] = this.getTickValues(id); + } + this[id] = this.getAxis( + id, + scale, + outerTick, + // do not transit x Axis on zoom and resizing + // https://github.com/naver/billboard.js/issues/1949 + id === "x" && ($$.scale.zoom || $$.config.subchart_show || $$.state.resizing) ? true : noTransition + ); + } + // called from : getMaxTickSize() + getAxis(id, scale, outerTick, noTransition, noTickTextRotate) { + const $$ = this.owner; + const { config } = $$; + const isX = /^(x|subX)$/.test(id); + const type = isX ? "x" : id; + const isCategory = isX && this.isCategorized(); + const orient = this.orient[id]; + const tickTextRotate = noTickTextRotate ? 0 : $$.getAxisTickRotate(type); + let tickFormat; + if (isX) { + tickFormat = id === "subX" ? $$.format.subXAxisTick : $$.format.xAxisTick; + } else { + const fn = config[`axis_${id}_tick_format`]; + if (isFunction(fn)) { + tickFormat = fn.bind($$.api); + } + } + let tickValues = this.tick[type]; + const axisParams = mergeObj({ + outerTick, + noTransition, + config, + id, + tickTextRotate, + owner: $$ + }, isX && { + isCategory, + isInverted: config.axis_x_inverted, + tickMultiline: config.axis_x_tick_multiline, + tickWidth: config.axis_x_tick_width, + tickTitle: isCategory && config.axis_x_tick_tooltip && $$.api.categories(), + orgXScale: $$.scale.x + }); + if (!isX) { + axisParams.tickStepSize = config[`axis_${type}_tick_stepSize`]; + } + const axis = new AxisRenderer(axisParams).scale(isX && $$.scale.zoom || scale).orient(orient); + if (isX && this.isTimeSeries() && tickValues && !isFunction(tickValues)) { + const fn = parseDate.bind($$); + tickValues = tickValues.map((v) => fn(v)); + } else if (!isX && this.isTimeSeriesY()) { + axis.ticks(config.axis_y_tick_time_value); + tickValues = null; + } + tickValues && axis.tickValues(tickValues); + axis.tickFormat( + tickFormat || !isX && ($$.isStackNormalized() && $$.hasAxisGroupedData(id) && ((x) => `${x}%`)) + ); + if (isCategory) { + axis.tickCentered(config.axis_x_tick_centered); + if (isEmpty(config.axis_x_tick_culling)) { + config.axis_x_tick_culling = false; + } + } + const tickCount = config[`axis_${type}_tick_count`]; + tickCount && axis.ticks(tickCount); + return axis; + } + updateXAxisTickValues(targets, axis) { + var _a; + const $$ = this.owner; + const { config } = $$; + const fit = config.axis_x_tick_fit; + let count = config.axis_x_tick_count; + let values; + if (fit || count && fit) { + values = $$.mapTargetsToUniqueXs(targets); + if (this.isCategorized() && count > values.length) { + count = values.length; + } + values = this.generateTickValues( + values, + count, + this.isTimeSeries() + ); + } + if (axis) { + axis.tickValues(values); + } else if (this.x) { + this.x.tickValues(values); + (_a = this.subX) == null ? void 0 : _a.tickValues(values); + } + return values; + } + getId(id) { + const { config, scale } = this.owner; + let axis = config.data_axes[id]; + if (!axis || !scale[axis]) { + axis = "y"; + } + return axis; + } + getXAxisTickFormat(forSubchart) { + const $$ = this.owner; + const { config, format } = $$; + const tickFormat = forSubchart ? config.subchart_axis_x_tick_format || config.axis_x_tick_format : config.axis_x_tick_format; + const isTimeSeries = this.isTimeSeries(); + const isCategorized = this.isCategorized(); + let currFormat; + if (tickFormat) { + if (isFunction(tickFormat)) { + currFormat = tickFormat.bind($$.api); + } else if (isTimeSeries) { + currFormat = (date) => date ? format.axisTime(tickFormat)(date) : ""; + } + } else { + currFormat = isTimeSeries ? format.defaultAxisTime : isCategorized ? $$.categoryName : (v) => v < 0 ? v.toFixed(0) : v; + } + return isFunction(currFormat) ? (v) => currFormat.apply($$, isCategorized ? [v, $$.categoryName(v)] : [v]) : currFormat; + } + getTickValues(id) { + const $$ = this.owner; + const tickValues = $$.config[`axis_${id}_tick_values`]; + const axis = $$[`${id}Axis`]; + return (isFunction(tickValues) ? tickValues.call($$.api) : tickValues) || (axis ? axis.tickValues() : void 0); + } + getLabelOptionByAxisId(id) { + return this.owner.config[`axis_${id}_label`]; + } + getLabelText(id) { + const option = this.getLabelOptionByAxisId(id); + return isString(option) ? option : option ? option.text : null; + } + setLabelText(id, text) { + const $$ = this.owner; + const { config } = $$; + const option = this.getLabelOptionByAxisId(id); + if (isString(option)) { + config[`axis_${id}_label`] = text; + } else if (option) { + option.text = text; + } + } + getLabelPosition(id, defaultPosition) { + const isRotated = this.owner.config.axis_rotated; + const option = this.getLabelOptionByAxisId(id); + const position = isObjectType(option) && option.position ? option.position : defaultPosition[+!isRotated]; + const has = (v) => !!~position.indexOf(v); + return { + isInner: has("inner"), + isOuter: has("outer"), + isLeft: has("left"), + isCenter: has("center"), + isRight: has("right"), + isTop: has("top"), + isMiddle: has("middle"), + isBottom: has("bottom") + }; + } + getAxisLabelPosition(id) { + return this.getLabelPosition( + id, + id === "x" ? ["inner-top", "inner-right"] : ["inner-right", "inner-top"] + ); + } + getLabelPositionById(id) { + return this.getAxisLabelPosition(id); + } + xForAxisLabel(id) { + const $$ = this.owner; + const { state: { width, height } } = $$; + const position = this.getAxisLabelPosition(id); + let x = position.isMiddle ? -height / 2 : 0; + if (this.isHorizontal($$, id !== "x")) { + x = position.isLeft ? 0 : position.isCenter ? width / 2 : width; + } else if (position.isBottom) { + x = -height; + } + return x; + } + textAnchorForAxisLabel(id) { + const $$ = this.owner; + const position = this.getAxisLabelPosition(id); + let anchor = position.isMiddle ? "middle" : "end"; + if (this.isHorizontal($$, id !== "x")) { + anchor = position.isLeft ? "start" : position.isCenter ? "middle" : "end"; + } else if (position.isBottom) { + anchor = "start"; + } + return anchor; + } + dxForAxisLabel(id) { + const $$ = this.owner; + const position = this.getAxisLabelPosition(id); + let dx = position.isBottom ? "0.5em" : "0"; + if (this.isHorizontal($$, id !== "x")) { + dx = position.isLeft ? "0.5em" : position.isRight ? "-0.5em" : "0"; + } else if (position.isTop) { + dx = "-0.5em"; + } + return dx; + } + dyForAxisLabel(id) { + const $$ = this.owner; + const { config } = $$; + const isRotated = config.axis_rotated; + const isInner = this.getAxisLabelPosition(id).isInner; + const tickRotate = config[`axis_${id}_tick_rotate`] ? $$.getHorizontalAxisHeight(id) : 0; + const { width: maxTickWidth } = this.getMaxTickSize(id); + let dy; + if (id === "x") { + const xHeight = config.axis_x_height; + if (isRotated) { + dy = isInner ? "1.2em" : -25 - maxTickWidth; + } else if (isInner) { + dy = "-0.5em"; + } else if (xHeight) { + dy = xHeight - 10; + } else if (tickRotate) { + dy = tickRotate - 10; + } else { + dy = "3em"; + } + } else { + dy = { + y: ["-0.5em", 10, "3em", "1.2em", 10], + y2: ["1.2em", -20, "-2.2em", "-0.5em", 15] + }[id]; + if (isRotated) { + if (isInner) { + dy = dy[0]; + } else if (tickRotate) { + dy = tickRotate * (id === "y2" ? -1 : 1) - dy[1]; + } else { + dy = dy[2]; + } + } else { + dy = isInner ? dy[3] : (dy[4] + (config[`axis_${id}_inner`] ? 0 : maxTickWidth + dy[4])) * (id === "y" ? -1 : 1); + } + } + return dy; + } + /** + * Get max tick size + * @param {string} id axis id string + * @param {boolean} withoutRecompute wheather or not to recompute + * @returns {object} {width, height} + * @private + */ + getMaxTickSize(id, withoutRecompute) { + const $$ = this.owner; + const { config, state: { current, resizing }, $el: { svg, chart } } = $$; + const currentTickMax = current.maxTickSize[id]; + const configPrefix = `axis_${id}`; + const max = { + width: 0, + height: 0 + }; + if (resizing || withoutRecompute || !config[`${configPrefix}_show`] || currentTickMax.width > 0 && $$.filterTargetsToShow().length === 0) { + return currentTickMax; + } + if (svg) { + const isYAxis = /^y2?$/.test(id); + const targetsToShow = $$.filterTargetsToShow($$.data.targets); + const scale = $$.scale[id].copy().domain( + $$[`get${isYAxis ? "Y" : "X"}Domain`](targetsToShow, id) + ); + const domain = scale.domain(); + const isDomainSame = domain[0] === domain[1] && domain.every((v) => v > 0); + const isCurrentMaxTickDomainSame = isArray(currentTickMax.domain) && currentTickMax.domain[0] === currentTickMax.domain[1] && currentTickMax.domain.every((v) => v > 0); + if (isDomainSame || isCurrentMaxTickDomainSame) { + return currentTickMax.size; + } else { + currentTickMax.domain = domain; + } + if (!isYAxis) { + currentTickMax.ticks.splice(0); + } + const axis = this.getAxis(id, scale, false, false, true); + const tickRotate = config[`${configPrefix}_tick_rotate`]; + const tickCount = config[`${configPrefix}_tick_count`]; + const tickValues = config[`${configPrefix}_tick_values`]; + if (!tickValues && tickCount) { + axis.tickValues( + this.generateTickValues( + domain, + tickCount, + isYAxis ? this.isTimeSeriesY() : this.isTimeSeries() + ) + ); + } + !isYAxis && this.updateXAxisTickValues(targetsToShow, axis); + const dummy = chart.append("svg").style("visibility", "hidden").style("position", "fixed").style("top", "0").style("left", "0"); + const g = dummy.append("g").attr("class", `${$AXIS[`axis${capitalize(id)}`]} ${$COMMON.dummy}`); + axis.create(g); + const { sizeFor1Char } = g.node(); + dummy.selectAll("text").attr("transform", isNumber(tickRotate) ? `rotate(${tickRotate})` : null).each(function(d, i) { + const { width, height } = sizeFor1Char ? { + width: this.textContent.length * sizeFor1Char.w, + height: sizeFor1Char.h + } : getBoundingRect(this, true); + max.width = Math.max(max.width, width); + max.height = Math.max(max.height, height); + if (!isYAxis) { + currentTickMax.ticks[i] = width; + } + }); + dummy.remove(); + } + Object.keys(max).forEach((key) => { + if (max[key] > 0) { + currentTickMax[key] = max[key]; + } + }); + return currentTickMax; + } + getXAxisTickTextY2Overflow(defaultPadding) { + const $$ = this.owner; + const { axis, config, state: { current, isLegendRight, legendItemWidth } } = $$; + const xAxisTickRotate = $$.getAxisTickRotate("x"); + const positiveRotation = xAxisTickRotate > 0 && xAxisTickRotate < 90; + if ((axis.isCategorized() || axis.isTimeSeries()) && config.axis_x_tick_fit && (!config.axis_x_tick_culling || isEmpty(config.axis_x_tick_culling)) && !config.axis_x_tick_multiline && positiveRotation) { + const y2AxisWidth = config.axis_y2_show && current.maxTickSize.y2.width || 0; + const legendWidth = isLegendRight && legendItemWidth || 0; + const widthWithoutCurrentPaddingLeft = current.width - $$.getCurrentPaddingByDirection("left"); + const maxOverflow = this.getXAxisTickMaxOverflow( + xAxisTickRotate, + widthWithoutCurrentPaddingLeft - defaultPadding + ) - y2AxisWidth - legendWidth; + const xAxisTickTextY2Overflow = Math.max(0, maxOverflow) + defaultPadding; + return Math.min(xAxisTickTextY2Overflow, widthWithoutCurrentPaddingLeft / 2); + } + return 0; + } + getXAxisTickMaxOverflow(xAxisTickRotate, widthWithoutCurrentPaddingLeft) { + const $$ = this.owner; + const { axis, config, state } = $$; + const isTimeSeries = axis.isTimeSeries(); + const tickTextWidths = state.current.maxTickSize.x.ticks; + const tickCount = tickTextWidths.length; + const { left, right } = state.axis.x.padding; + let maxOverflow = 0; + const remaining = tickCount - (isTimeSeries && config.axis_x_tick_fit ? 0.5 : 0); + for (let i = 0; i < tickCount; i++) { + const tickIndex = i + 1; + const rotatedTickTextWidth = Math.cos(Math.PI * xAxisTickRotate / 180) * tickTextWidths[i]; + const ticksBeforeTickText = tickIndex - (isTimeSeries ? 1 : 0.5) + left; + if (ticksBeforeTickText <= 0) { + continue; + } + const xAxisLengthWithoutTickTextWidth = widthWithoutCurrentPaddingLeft - rotatedTickTextWidth; + const tickLength = xAxisLengthWithoutTickTextWidth / ticksBeforeTickText; + const remainingTicks = remaining - tickIndex; + const paddingRightLength = right * tickLength; + const remainingTickWidth = remainingTicks * tickLength + paddingRightLength; + const overflow = rotatedTickTextWidth - tickLength / 2 - remainingTickWidth; + maxOverflow = Math.max(maxOverflow, overflow); + } + const filteredTargets = $$.filterTargetsToShow($$.data.targets); + let tickOffset = 0; + if (!isTimeSeries && config.axis_x_tick_count <= filteredTargets.length && filteredTargets[0].values.length) { + const scale = getScale( + $$.axis.getAxisType("x"), + 0, + widthWithoutCurrentPaddingLeft - maxOverflow + ).domain([ + left * -1, + $$.getXDomainMax($$.data.targets) + 1 + right + ]); + tickOffset = (scale(1) - scale(0)) / 2; + } + return maxOverflow + tickOffset; + } + /** + * Update axis label text + * @param {boolean} withTransition Weather update with transition + * @private + */ + updateLabels(withTransition) { + const $$ = this.owner; + const { config, $el: { main }, $T } = $$; + const isRotated = config.axis_rotated; + ["x", "y", "y2"].forEach((id) => { + const text = this.getLabelText(id); + const selector = `axis${capitalize(id)}`; + const classLabel = $AXIS[`${selector}Label`]; + if (text) { + let axisLabel = main.select(`text.${classLabel}`); + if (axisLabel.empty()) { + axisLabel = main.select(`g.${$AXIS[selector]}`).insert("text", ":first-child").attr("class", classLabel).attr("transform", ["rotate(-90)", null][id === "x" ? +!isRotated : +isRotated]).style("text-anchor", () => this.textAnchorForAxisLabel(id)); + } + $T(axisLabel, withTransition).attr("x", () => this.xForAxisLabel(id)).attr("dx", () => this.dxForAxisLabel(id)).attr("dy", () => this.dyForAxisLabel(id)).text(text); + } + }); + } + /** + * Get axis padding value + * @param {number|object} padding Padding object + * @param {string} key Key string of padding + * @param {Date|number} defaultValue Default value + * @param {number} domainLength Domain length + * @returns {number} Padding value in scale + * @private + */ + getPadding(padding, key, defaultValue, domainLength) { + const p = isNumber(padding) ? padding : padding[key]; + if (!isValue(p)) { + return defaultValue; + } + return this.owner.convertPixelToScale( + /(bottom|top)/.test(key) ? "y" : "x", + p, + domainLength + ); + } + generateTickValues(values, tickCount, forTimeSeries) { + let tickValues = values; + if (tickCount) { + const targetCount = isFunction(tickCount) ? tickCount() : tickCount; + if (targetCount === 1) { + tickValues = [values[0]]; + } else if (targetCount === 2) { + tickValues = [values[0], values[values.length - 1]]; + } else if (targetCount > 2) { + const isCategorized = this.isCategorized(); + const count = targetCount - 2; + const start = values[0]; + const end = values[values.length - 1]; + const interval = (end - start) / (count + 1); + let tickValue; + tickValues = [start]; + for (let i = 0; i < count; i++) { + tickValue = +start + interval * (i + 1); + tickValues.push( + forTimeSeries ? new Date(tickValue) : isCategorized ? Math.round(tickValue) : tickValue + ); + } + tickValues.push(end); + } + } + if (!forTimeSeries) { + tickValues = tickValues.sort((a, b) => a - b); + } + return tickValues; + } + generateTransitions(withTransition) { + const $$ = this.owner; + const { $el: { axis }, $T } = $$; + const [axisX, axisY, axisY2, axisSubX] = ["x", "y", "y2", "subX"].map((v) => $T(axis[v], withTransition)); + return { axisX, axisY, axisY2, axisSubX }; + } + redraw(transitions, isHidden, isInit) { + const $$ = this.owner; + const { config, state, $el } = $$; + const opacity = isHidden ? "0" : null; + ["x", "y", "y2", "subX"].forEach((id) => { + const axis = this[id]; + const $axis = $el.axis[id]; + if (axis && $axis) { + if (!isInit && !config.transition_duration) { + axis.config.withoutTransition = true; + } + $axis.style("opacity", opacity); + axis.create(transitions[`axis${capitalize(id)}`]); + } + }); + this.updateAxes(); + !state.rendered && config.axis_tooltip && this.setAxisTooltip(); + } + /** + * Redraw axis + * @param {Array} targetsToShow targets data to be shown + * @param {object} wth option object + * @param {d3.Transition} transitions Transition object + * @param {object} flow flow object + * @param {boolean} isInit called from initialization + * @private + */ + redrawAxis(targetsToShow, wth, transitions, flow, isInit) { + var _a, _b, _c; + const $$ = this.owner; + const { config, scale, $el } = $$; + const hasZoom = !!scale.zoom; + let xDomainForZoom; + if (!hasZoom && this.isCategorized() && targetsToShow.length === 0) { + scale.x.domain([0, $el.axis.x.selectAll(".tick").size()]); + } + if (scale.x && targetsToShow.length) { + !hasZoom && $$.updateXDomain( + targetsToShow, + wth.UpdateXDomain, + wth.UpdateOrgXDomain, + wth.TrimXDomain + ); + if (!config.axis_x_tick_values) { + this.updateXAxisTickValues(targetsToShow); + } + } else if (this.x) { + this.x.tickValues([]); + (_a = this.subX) == null ? void 0 : _a.tickValues([]); + } + if (config.zoom_rescale && !flow) { + xDomainForZoom = scale.x.orgDomain(); + } + ["y", "y2"].forEach((key) => { + const prefix = `axis_${key}_`; + const axisScale = scale[key]; + if (axisScale) { + const tickValues = config[`${prefix}tick_values`]; + const tickCount = config[`${prefix}tick_count`]; + axisScale.domain($$.getYDomain(targetsToShow, key, xDomainForZoom)); + if (!tickValues && tickCount) { + const axis = $$.axis[key]; + const domain = axisScale.domain(); + axis.tickValues( + this.generateTickValues( + domain, + domain.every((v) => v === 0) ? 1 : tickCount, + this.isTimeSeriesY() + ) + ); + } + } + }); + this.redraw(transitions, $$.hasArcType(), isInit); + this.updateLabels(wth.Transition); + if ((wth.UpdateXDomain || wth.UpdateXAxis || wth.Y) && targetsToShow.length) { + this.setCulling(); + } + if (wth.Y) { + (_b = scale.subY) == null ? void 0 : _b.domain($$.getYDomain(targetsToShow, "y")); + (_c = scale.subY2) == null ? void 0 : _c.domain($$.getYDomain(targetsToShow, "y2")); + } + } + /** + * Set manual culling + * @private + */ + setCulling() { + const $$ = this.owner; + const { config, state: { clip, current }, $el } = $$; + ["subX", "x", "y", "y2"].forEach((type) => { + const axis = $el.axis[type]; + const id = type === "subX" ? "x" : type; + const cullingOptionPrefix = `axis_${id}_tick_culling`; + const toCull = config[cullingOptionPrefix]; + if (axis && toCull) { + const tickNodes = axis.selectAll(".tick"); + const tickValues = sortValue( + tickNodes.data(), + !config[`${cullingOptionPrefix}_reverse`] + ); + const tickSize = tickValues.length; + const cullingMax = config[`${cullingOptionPrefix}_max`]; + const lines = config[`${cullingOptionPrefix}_lines`]; + let intervalForCulling; + if (tickSize) { + for (let i = 1; i < tickSize; i++) { + if (tickSize / i < cullingMax) { + intervalForCulling = i; + break; + } + } + tickNodes.each(function(d) { + const node = lines ? this.querySelector("text") : this; + if (node) { + node.style.display = tickValues.indexOf(d) % intervalForCulling ? "none" : null; + } + }); + } else { + tickNodes.style("display", null); + } + if (type === "x") { + const clipPath = current.maxTickSize.x.clipPath ? clip.pathXAxisTickTexts : null; + $el.svg.selectAll(`.${$AXIS.axisX} .tick text`).attr("clip-path", clipPath); + } + } + }); + } + /** + * Set axis tooltip + * @private + */ + setAxisTooltip() { + var _a; + const $$ = this.owner; + const { config: { axis_rotated: isRotated, axis_tooltip }, $el: { axis, axisTooltip } } = $$; + const bgColor = (_a = axis_tooltip.backgroundColor) != null ? _a : "black"; + $$.generateTextBGColorFilter( + bgColor, + { + x: -0.15, + y: -0.2, + width: 1.3, + height: 1.3 + } + ); + ["x", "y", "y2"].forEach((v) => { + var _a2, _b, _c; + if (isString(bgColor) || bgColor[v]) { + axisTooltip[v] = (_a2 = axis[v]) == null ? void 0 : _a2.append("text").classed($AXIS[`axis${v.toUpperCase()}Tooltip`], true).attr("filter", $$.updateTextBGColor({ id: v }, bgColor)); + if (isRotated) { + const pos = v === "x" ? "x" : "y"; + const val = v === "y" ? "1.15em" : v === "x" ? "-0.3em" : "-0.4em"; + (_b = axisTooltip[v]) == null ? void 0 : _b.attr(pos, val).attr(`d${v === "x" ? "y" : "x"}`, v === "x" ? "0.4em" : "-1.3em").style("text-anchor", v === "x" ? "end" : null); + } else { + const pos = v === "x" ? "y" : "x"; + const val = v === "x" ? "1.15em" : `${v === "y" ? "-" : ""}0.4em`; + (_c = axisTooltip[v]) == null ? void 0 : _c.attr(pos, val).attr(`d${v === "x" ? "x" : "y"}`, v === "x" ? "-1em" : "0.3em").style("text-anchor", v === "y" ? "end" : null); + } + } + }); + } +} + +;// ./src/ChartInternal/interactions/eventrect.ts + + +/* harmony default export */ var eventrect = ({ + /** + * Initialize the area that detects the event. + * Add a container for the zone that detects the event. + * @private + */ + initEventRect() { + const $$ = this; + $$.$el.main.select(`.${$COMMON.chart}`).append("g").attr("class", $EVENT.eventRects).style("fill-opacity", "0"); + }, + /** + * Redraws the area that detects the event. + * @private + */ + redrawEventRect() { + var _a; + const $$ = this; + const { config, state, $el } = $$; + const isMultipleX = $$.isMultipleX(); + const isInverted = config.axis_x_inverted; + if ($el.eventRect) { + $$.updateEventRect($el.eventRect, true); + } else if ($$.data.targets.length) { + const eventRects = $$.$el.main.select(`.${$EVENT.eventRects}`).style("cursor", config.zoom_enabled && config.zoom_type !== "drag" ? config.axis_rotated ? "ns-resize" : "ew-resize" : null).classed($EVENT.eventRectsMultiple, isMultipleX).classed($EVENT.eventRectsSingle, !isMultipleX); + const eventRectUpdate = eventRects.selectAll(`.${$EVENT.eventRect}`).data([0]).enter().append("rect"); + $$.updateEventRect(eventRectUpdate); + $$.updateEventType(eventRectUpdate); + eventRectUpdate.call($$.getDraggableSelection()); + $el.eventRect = eventRectUpdate; + if ($$.state.inputType === "touch" && !$el.svg.on("touchstart.eventRect") && !$$.hasArcType()) { + $$.bindTouchOnEventRect(); + } + state.rendered && $$.updateEventRect($el.eventRect, true); + } + if (!isMultipleX) { + const xAxisTickValues = $$.getMaxDataCountTarget(); + if (!config.data_xSort || isInverted) { + xAxisTickValues.sort((a, b) => isInverted ? b.x - a.x : a.x - b.x); + } + $$.updateDataIndexByX(xAxisTickValues); + $$.updateXs(xAxisTickValues); + (_a = $$.updatePointClass) == null ? void 0 : _a.call($$, true); + state.eventReceiver.data = xAxisTickValues; + } + $$.updateEventRectData(); + }, + bindTouchOnEventRect() { + const $$ = this; + const { config, state, $el: { eventRect, svg } } = $$; + const selectRect = (context) => { + if ($$.isMultipleX()) { + $$.selectRectForMultipleXs(context); + } else { + const index = $$.getDataIndexFromEvent(state.event); + $$.callOverOutForTouch(index); + index === -1 ? $$.unselectRect() : $$.selectRectForSingle(context, index); + } + }; + const unselectRect = () => { + $$.unselectRect(); + $$.callOverOutForTouch(); + }; + const preventDefault = config.interaction_inputType_touch.preventDefault; + const isPrevented = isBoolean(preventDefault) && preventDefault || false; + const preventThreshold = !isNaN(preventDefault) && preventDefault || null; + let startPx; + const passiveOption = !isPrevented && preventThreshold === null; + const preventEvent = (event) => { + const eventType = event.type; + const touch = event.changedTouches[0]; + const currentXY = touch[`client${config.axis_rotated ? "Y" : "X"}`]; + if (eventType === "touchstart") { + if (isPrevented) { + event.preventDefault(); + } else if (preventThreshold !== null) { + startPx = currentXY; + } + } else if (eventType === "touchmove") { + if (isPrevented || startPx === true || preventThreshold !== null && Math.abs(startPx - currentXY) >= preventThreshold) { + startPx = true; + event.preventDefault(); + } + } + }; + eventRect.on("touchstart", (event) => { + state.event = event; + $$.updateEventRect(); + }, { passive: passiveOption }).on("touchstart.eventRect touchmove.eventRect", (event) => { + state.event = event; + if (!eventRect.empty() && eventRect.classed($EVENT.eventRect)) { + if (state.dragging || state.flowing || $$.hasArcType() || event.touches.length > 1) { + return; + } + preventEvent(event); + selectRect(eventRect.node()); + } else { + unselectRect(); + } + }, { passive: passiveOption }).on("touchend.eventRect", (event) => { + state.event = event; + if (!eventRect.empty() && eventRect.classed($EVENT.eventRect)) { + if ($$.hasArcType() || !$$.toggleShape || state.cancelClick) { + state.cancelClick && (state.cancelClick = false); + } + } + }, { passive: passiveOption }); + svg.on("touchstart", (event) => { + state.event = event; + const { target } = event; + if (target && target !== eventRect.node()) { + unselectRect(); + } + }, { passive: passiveOption }); + }, + /** + * Update event rect size + * @param {d3Selection} eventRect Event <rect> element + * @param {boolean} force Force to update + * @private + */ + updateEventRect(eventRect, force = false) { + const $$ = this; + const { state, $el } = $$; + const { eventReceiver, width, height, rendered, resizing } = state; + const rectElement = eventRect || $el.eventRect; + const updateClientRect = () => { + if (eventReceiver) { + const scrollPos = getScrollPosition($el.chart.node()); + eventReceiver.rect = getBoundingRect(rectElement.node(), true).toJSON(); + eventReceiver.rect.top += scrollPos.y; + eventReceiver.rect.left += scrollPos.x; + } + }; + if (!rendered || resizing || force) { + rectElement.attr("x", 0).attr("y", 0).attr("width", width).attr("height", height); + if (!rendered || force) { + rectElement.classed($EVENT.eventRect, true); + } + } + updateClientRect(); + }, + /** + * Update event type (single or multiple x) + * @param {d3Selection | boolean} target Target element or boolean to rebind event + */ + updateEventType(target) { + const $$ = this; + const isRebindCall = isBoolean(target); + const eventRect = isRebindCall ? $$.$el.eventRect : target; + const unbindEvent = isRebindCall ? target !== (eventRect == null ? void 0 : eventRect.datum().multipleX) : false; + if (eventRect) { + unbindEvent && (eventRect == null ? void 0 : eventRect.on("mouseover mousemove mouseout click", null)); + $$.isMultipleX() ? $$.generateEventRectsForMultipleXs(eventRect) : $$.generateEventRectsForSingleX(eventRect); + } + }, + /** + * Updates the location and size of the eventRect. + * @private + */ + updateEventRectData() { + const $$ = this; + const { config, scale, state } = $$; + const xScale = scale.zoom || scale.x; + const isRotated = config.axis_rotated; + const isMultipleX = $$.isMultipleX(); + let x; + let y; + let w; + let h; + $$.updateEventType(isMultipleX); + if (isMultipleX) { + x = 0; + y = 0; + w = state.width; + h = state.height; + } else { + let rectW; + let rectX; + if ($$.axis.isCategorized()) { + rectW = $$.getEventRectWidth(); + rectX = (d) => xScale(d.x) - rectW / 2; + } else { + const getPrevNextX = ({ index }) => ({ + prev: $$.getPrevX(index), + next: $$.getNextX(index) + }); + rectW = (d) => { + const x2 = getPrevNextX(d); + const xDomain = xScale.domain(); + let val; + if (x2.prev === null && x2.next === null) { + val = isRotated ? state.height : state.width; + } else if (x2.prev === null) { + val = (xScale(x2.next) + xScale(d.x)) / 2; + } else if (x2.next === null) { + val = xScale(xDomain[1]) - (xScale(x2.prev) + xScale(d.x)) / 2; + } else { + Object.keys(x2).forEach((key, i) => { + var _a; + x2[key] = (_a = x2[key]) != null ? _a : xDomain[i]; + }); + val = Math.max(0, (xScale(x2.next) - xScale(x2.prev)) / 2); + } + return val; + }; + rectX = (d) => { + const x2 = getPrevNextX(d); + let val; + if (x2.prev === null && x2.next === null) { + val = 0; + } else if (x2.prev === null) { + val = xScale(xScale.domain()[0]); + } else { + val = (xScale(d.x) + xScale(x2.prev)) / 2; + } + return val; + }; + } + x = isRotated ? 0 : rectX; + y = isRotated ? rectX : 0; + w = isRotated ? state.width : rectW; + h = isRotated ? rectW : state.height; + } + const { eventReceiver } = state; + const call = (fn, v) => isFunction(fn) ? fn(v) : fn; + eventReceiver.coords.splice(eventReceiver.data.length); + eventReceiver.data.forEach((d, i) => { + eventReceiver.coords[i] = { + x: call(x, d), + y: call(y, d), + w: call(w, d), + h: call(h, d) + }; + }); + }, + /** + * Seletct rect for single x value + * @param {d3Selection} context Event rect element + * @param {number} index x Axis index + * @private + */ + selectRectForSingle(context, index) { + var _a, _b; + const $$ = this; + const { config, $el: { main, circle } } = $$; + const isSelectionEnabled = config.data_selection_enabled; + const isSelectionGrouped = config.data_selection_grouped; + const isSelectable = config.data_selection_isselectable; + const isTooltipGrouped = config.tooltip_grouped; + const selectedData = $$.getAllValuesOnIndex(index); + if (isTooltipGrouped) { + $$.showTooltip(selectedData, context); + (_a = $$.showGridFocus) == null ? void 0 : _a.call($$, selectedData); + if (!isSelectionEnabled || isSelectionGrouped) { + return; + } + } + !circle && main.selectAll(`.${$COMMON.EXPANDED}:not(.${$SHAPE.shape}-${index})`).classed( + $COMMON.EXPANDED, + false + ); + const shapeAtIndex = main.selectAll(`.${$SHAPE.shape}-${index}`).classed($COMMON.EXPANDED, true).style("cursor", isSelectable ? "pointer" : null).filter(function(d) { + return $$.isWithinShape(this, d); + }); + if (shapeAtIndex.empty() && !isTooltipGrouped && config.interaction_onout) { + (_b = $$.hideGridFocus) == null ? void 0 : _b.call($$); + $$.hideTooltip(); + !isSelectionGrouped && $$.setExpand(index); + } + shapeAtIndex.call((selected) => { + var _a2, _b2; + const d = selected.data(); + if (isSelectionEnabled && (isSelectionGrouped || (isSelectable == null ? void 0 : isSelectable.bind($$.api)(d)))) { + context.style.cursor = "pointer"; + } + if (!isTooltipGrouped) { + $$.showTooltip(d, context); + (_a2 = $$.showGridFocus) == null ? void 0 : _a2.call($$, d); + (_b2 = $$.unexpandCircles) == null ? void 0 : _b2.call($$); + selected.each((d2) => $$.setExpand(index, d2.id)); + } + }); + }, + /** + * Select rect for multiple x values + * @param {d3Selection} context Event rect element + * @param {boolean} [triggerEvent=true] Whether trigger event or not + * @private + */ + selectRectForMultipleXs(context, triggerEvent = true) { + const $$ = this; + const { config, state } = $$; + const targetsToShow = $$.filterTargetsToShow($$.data.targets); + if (state.dragging || $$.hasArcType(targetsToShow)) { + return; + } + const mouse = getPointer(state.event, context); + const closest = $$.findClosestFromTargets(targetsToShow, mouse); + if (triggerEvent && state.mouseover && (!closest || closest.id !== state.mouseover.id)) { + config.data_onout.call($$.api, state.mouseover); + state.mouseover = void 0; + } + if (!closest) { + $$.unselectRect(); + return; + } + const sameXData = $$.isBubbleType(closest) || $$.isScatterType(closest) || !config.tooltip_grouped ? [closest] : $$.filterByX(targetsToShow, closest.x); + const selectedData = sameXData.map((d) => $$.addName(d)); + $$.showTooltip(selectedData, context); + $$.setExpand(closest.index, closest.id, true); + $$.showGridFocus(selectedData); + const dist = $$.dist(closest, mouse); + if ($$.isBarType(closest.id) || dist < $$.getPointSensitivity(closest)) { + $$.$el.svg.select(`.${$EVENT.eventRect}`).style("cursor", "pointer"); + if (triggerEvent && (!state.mouseover || state.mouseover.x !== closest.x || state.mouseover.id !== closest.id)) { + config.data_onover.call($$.api, closest); + state.mouseover = closest; + } + } + }, + /** + * Unselect EventRect. + * @private + */ + unselectRect() { + const $$ = this; + const { $el: { circle, tooltip } } = $$; + $$.$el.svg.select(`.${$EVENT.eventRect}`).style("cursor", null); + $$.hideGridFocus(); + if (tooltip) { + $$.hideTooltip(); + $$._handleLinkedCharts(false); + } + circle && !$$.isPointFocusOnly() && $$.unexpandCircles(); + $$.expandBarTypeShapes(false); + }, + /** + * Create eventRect for each data on the x-axis. + * Register touch and drag events. + * @param {object} eventRectEnter d3.select($EVENT.eventRects) object. + * @returns {object} d3.select($EVENT.eventRects) object. + * @private + */ + generateEventRectsForSingleX(eventRectEnter) { + const $$ = this; + const { config, state } = $$; + const { eventReceiver } = state; + const rect = eventRectEnter.style( + "cursor", + config.data_selection_enabled && config.data_selection_grouped ? "pointer" : null + ).on("click", function(event) { + state.event = event; + const { currentIdx, data } = eventReceiver; + const d = data[currentIdx === -1 ? $$.getDataIndexFromEvent(event) : currentIdx]; + $$.clickHandlerForSingleX.bind(this)(d, $$); + }).datum({ multipleX: false }); + if (state.inputType === "mouse") { + const getData = (event) => { + const index = event ? $$.getDataIndexFromEvent(event) : eventReceiver.currentIdx; + return index > -1 ? eventReceiver.data[index] : null; + }; + rect.on("mouseover", (event) => { + state.event = event; + $$.updateEventRect(); + Object.values($$.$el.axisTooltip).forEach((v) => v == null ? void 0 : v.style("display", null)); + }).on("mousemove", function(event) { + const d = getData(event); + state.event = event; + if (!d) { + return; + } + let { index } = d; + const stepType = config.line_step_type; + if (config.line_step_tooltipMatch && $$.hasType("step") && /^step\-(before|after)$/.test(stepType)) { + const scale = $$.scale.zoom || $$.scale.x; + const xs = $$.axis.xs[index]; + const inverted = scale.invert(getPointer(event, this)[0]); + if (stepType === "step-after" && inverted < xs) { + index -= 1; + } else if (stepType === "step-before" && inverted > xs) { + index += 1; + } + } + $$.showAxisGridFocus(); + const eventOnSameIdx = config.tooltip_grouped && index === eventReceiver.currentIdx; + if (state.dragging || state.flowing || $$.hasArcType() || eventOnSameIdx) { + config.tooltip_show && eventOnSameIdx && $$.setTooltipPosition(); + return; + } + if (index !== eventReceiver.currentIdx) { + $$.setOverOut(false, eventReceiver.currentIdx); + eventReceiver.currentIdx = index; + } + index === -1 ? $$.unselectRect() : $$.selectRectForSingle(this, index); + $$.setOverOut(index !== -1, index); + }).on("mouseout", (event) => { + state.event = event; + if (!config || $$.hasArcType() || eventReceiver.currentIdx === -1 || !config.interaction_onout) { + return; + } + $$.hideAxisGridFocus(); + $$.unselectRect(); + $$.setOverOut(false, eventReceiver.currentIdx); + eventReceiver.currentIdx = -1; + }); + } + return rect; + }, + clickHandlerForSingleX(d, ctx) { + const $$ = ctx; + const { config, state, $el: { main } } = $$; + if (!d || $$.hasArcType() || state.cancelClick) { + state.cancelClick && (state.cancelClick = false); + return; + } + const { index } = d; + main.selectAll(`.${$SHAPE.shape}-${index}`).each(function(d2) { + var _a; + if (config.data_selection_grouped || $$.isWithinShape(this, d2)) { + (_a = $$.toggleShape) == null ? void 0 : _a.call($$, this, d2, index); + config.data_onclick.bind($$.api)(d2, this); + } + }); + }, + /** + * Create an eventRect, + * Register touch and drag events. + * @param {object} eventRectEnter d3.select($EVENT.eventRects) object. + * @private + */ + generateEventRectsForMultipleXs(eventRectEnter) { + const $$ = this; + const { config, state } = $$; + eventRectEnter.on("click", function(event) { + state.event = event; + $$.clickHandlerForMultipleXS.bind(this)($$); + }).datum({ multipleX: true }); + if (state.inputType === "mouse") { + eventRectEnter.on("mouseover mousemove", function(event) { + state.event = event; + $$.selectRectForMultipleXs(this); + }).on("mouseout", (event) => { + state.event = event; + if (!$$.config || $$.hasArcType() || !config.interaction_onout) { + return; + } + $$.unselectRect(); + }); + } + }, + clickHandlerForMultipleXS(ctx) { + const $$ = ctx; + const { config, state } = $$; + const targetsToShow = $$.filterTargetsToShow($$.data.targets); + if ($$.hasArcType(targetsToShow)) { + return; + } + const mouse = getPointer(state.event, this); + const closest = $$.findClosestFromTargets(targetsToShow, mouse); + const sensitivity = $$.getPointSensitivity(closest); + if (!closest) { + return; + } + if ($$.isBarType(closest.id) || $$.dist(closest, mouse) < sensitivity) { + $$.$el.main.selectAll(`.${$SHAPE.shapes}${$$.getTargetSelectorSuffix(closest.id)}`).selectAll(`.${$SHAPE.shape}-${closest.index}`).each(function() { + var _a; + if (config.data_selection_grouped || $$.isWithinShape(this, closest)) { + (_a = $$.toggleShape) == null ? void 0 : _a.call($$, this, closest, closest.index); + config.data_onclick.bind($$.api)(closest, this); + } + }); + } + } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-ease","commonjs2":"d3-ease","amd":"d3-ease","root":"d3"} +var external_commonjs_d3_ease_commonjs2_d3_ease_amd_d3_ease_root_d3_ = __webpack_require__(12); +;// ./src/ChartInternal/interactions/flow.ts + + + + +/* harmony default export */ var interactions_flow = ({ + /** + * Generate flow + * @param {object} args option object + * @returns {function} + * @private + */ + generateFlow(args) { + const $$ = this; + const { data, state, $el } = $$; + return function() { + const flowLength = args.flow.length; + state.flowing = true; + data.targets.forEach((d) => { + d.values.splice(0, flowLength); + }); + if ($$.updateXGrid) { + $$.updateXGrid(true); + } + const elements = {}; + [ + "axis.x", + "grid.x", + "gridLines.x", + "region.list", + "text", + "bar", + "line", + "area", + "circle" + ].forEach((v) => { + const name = v.split("."); + let node = $el[name[0]]; + if (node && name.length > 1) { + node = node[name[1]]; + } + if (node == null ? void 0 : node.size()) { + elements[v] = node; + } + }); + $$.hideGridFocus(); + $$.setFlowList(elements, args); + }; + }, + /** + * Set flow list + * @param {object} elements Target elements + * @param {object} args option object + * @private + */ + setFlowList(elements, args) { + const $$ = this; + const { flow, targets } = args; + const { + duration = args.duration, + index: flowIndex, + length: flowLength, + orgDataCount + } = flow; + const transform = $$.getFlowTransform(targets, orgDataCount, flowIndex, flowLength); + const wait = generateWait(); + let n; + wait.add(Object.keys(elements).map((v) => { + n = elements[v].transition().ease(external_commonjs_d3_ease_commonjs2_d3_ease_amd_d3_ease_root_d3_.easeLinear).duration(duration); + if (v === "axis.x") { + n = n.call((g) => { + $$.axis.x.setTransition(g).create(g); + }); + } else if (v === "region.list") { + n = n.filter($$.isRegionOnX).attr("transform", transform); + } else { + n = n.attr("transform", transform); + } + return n; + })); + n.call(wait, () => { + $$.cleanUpFlow(elements, args); + }); + }, + /** + * Clean up flow + * @param {object} elements Target elements + * @param {object} args option object + * @private + */ + cleanUpFlow(elements, args) { + const $$ = this; + const { config, state, $el: { svg } } = $$; + const isRotated = config.axis_rotated; + const { flow, shape, xv } = args; + const { cx, cy, xForText, yForText } = shape.pos; + const { + done = () => { + }, + length: flowLength + } = flow; + if (flowLength) { + ["circle", "text", "shape", "eventRect"].forEach((v) => { + const target = []; + for (let i = 0; i < flowLength; i++) { + target.push(`.${classes[v]}-${i}`); + } + svg.selectAll(`.${classes[`${v}s`]}`).selectAll(target).remove(); + }); + svg.select(`.${classes.xgrid}`).remove(); + } + Object.keys(elements).forEach((v) => { + const n = elements[v]; + if (v !== "axis.x") { + n.attr("transform", null); + } + if (v === "grid.x") { + n.attr(state.xgridAttr); + } else if (v === "gridLines.x") { + n.attr("x1", isRotated ? 0 : xv).attr("x2", isRotated ? state.width : xv); + n.select("text").attr("x", isRotated ? state.width : 0).attr("y", xv); + } else if (/^(area|bar|line)$/.test(v)) { + n.attr("d", shape.type[v]); + } else if (v === "text") { + n.attr("x", xForText).attr("y", yForText).style("fill-opacity", $$.opacityForText.bind($$)); + } else if (v === "circle") { + if ($$.isCirclePoint()) { + n.attr("cx", cx).attr("cy", cy); + } else { + const xFunc = (d) => cx(d) - config.point_r; + const yFunc = (d) => cy(d) - config.point_r; + n.attr("x", xFunc).attr("y", yFunc); + } + } else if (v === "region.list") { + n.select("rect").filter($$.isRegionOnX).attr("x", $$.regionX.bind($$)).attr("width", $$.regionWidth.bind($$)); + } + }); + config.interaction_enabled && $$.redrawEventRect(); + done.call($$.api); + state.flowing = false; + }, + /** + * Get flow transform value + * @param {object} targets target + * @param {number} orgDataCount original data count + * @param {number} flowIndex flow index + * @param {number} flowLength flow length + * @returns {string} + * @private + */ + getFlowTransform(targets, orgDataCount, flowIndex, flowLength) { + const $$ = this; + const { data, scale: { x } } = $$; + const dataValues = data.targets[0].values; + let flowStart = $$.getValueOnIndex(dataValues, flowIndex); + let flowEnd = $$.getValueOnIndex(dataValues, flowIndex + flowLength); + let translateX; + const orgDomain = x.domain(); + const domain = $$.updateXDomain(targets, true, true); + if (!orgDataCount) { + if (dataValues.length !== 1) { + translateX = x(orgDomain[0]) - x(domain[0]); + } else { + if ($$.axis.isTimeSeries()) { + flowStart = $$.getValueOnIndex(dataValues, 0); + flowEnd = $$.getValueOnIndex(dataValues, dataValues.length - 1); + translateX = x(flowStart.x) - x(flowEnd.x); + } else { + translateX = diffDomain(domain) / 2; + } + } + } else if (orgDataCount === 1 || (flowStart == null ? void 0 : flowStart.x) === (flowEnd == null ? void 0 : flowEnd.x)) { + translateX = x(orgDomain[0]) - x(domain[0]); + } else { + translateX = $$.axis.isTimeSeries() ? x(orgDomain[0]) - x(domain[0]) : x((flowStart == null ? void 0 : flowStart.x) || 0) - x(flowEnd.x); + } + const scaleX = diffDomain(orgDomain) / diffDomain(domain); + return `translate(${translateX},0) scale(${scaleX},1)`; + } +}); + +;// ./src/ChartInternal/internals/clip.ts +/* harmony default export */ var clip = ({ + initClip() { + const $$ = this; + const { clip, datetimeId } = $$.state; + clip.id = `${datetimeId}-clip`; + clip.idXAxis = `${clip.id}-xaxis`; + clip.idYAxis = `${clip.id}-yaxis`; + clip.idGrid = `${clip.id}-grid`; + clip.path = $$.getClipPath(clip.id); + clip.pathXAxis = $$.getClipPath(clip.idXAxis); + clip.pathYAxis = $$.getClipPath(clip.idYAxis); + clip.pathGrid = $$.getClipPath(clip.idGrid); + }, + getClipPath(id) { + const $$ = this; + const { config } = $$; + if (!config.clipPath && /-clip$/.test(id) || !config.axis_x_clipPath && /-clip-xaxis$/.test(id) || !config.axis_y_clipPath && /-clip-yaxis$/.test(id)) { + return null; + } + return `url(#${id})`; + }, + appendClip(parent, id) { + id && parent.append("clipPath").attr("id", id).append("rect"); + }, + /** + * Set x Axis clipPath dimension + * @param {d3Selecton} node clipPath <rect> selection + * @private + */ + setXAxisClipPath(node) { + const $$ = this; + const { config, state: { margin, width, height } } = $$; + const isRotated = config.axis_rotated; + const left = Math.max(30, margin.left) - (isRotated ? 0 : 20); + const h = (isRotated ? margin.top + height + 10 : margin.bottom) + 20; + const x = isRotated ? -(1 + left) : -(left - 1); + const y = -15; + const w = isRotated ? margin.left + 20 : width + 10 + left; + node.attr("x", x).attr("y", y).attr("width", w).attr("height", h); + }, + /** + * Set y Axis clipPath dimension + * @param {d3Selection} node clipPath <rect> selection + * @private + */ + setYAxisClipPath(node) { + const $$ = this; + const { config, state: { margin, width, height } } = $$; + const isRotated = config.axis_rotated; + const left = Math.max(30, margin.left) - (isRotated ? 20 : 0); + const isInner = config.axis_y_inner; + const x = isInner && !isRotated ? config.axis_y_label.text ? -20 : -1 : isRotated ? -(1 + left) : -(left - 1); + const y = -(isRotated ? 20 : margin.top); + const w = (isRotated ? width + 15 + left : margin.left + 20) + (isInner ? 20 : 0); + const h = (isRotated ? margin.bottom + 10 : margin.top + height) + 10; + node.attr("x", x).attr("y", y).attr("width", w).attr("height", h); + }, + updateXAxisTickClip() { + const $$ = this; + const { config, state: { clip, xAxisHeight }, $el: { defs } } = $$; + const newXAxisHeight = $$.getHorizontalAxisHeight("x"); + if (defs && !clip.idXAxisTickTexts) { + const clipId = `${clip.id}-xaxisticktexts`; + $$.appendClip(defs, clipId); + clip.pathXAxisTickTexts = $$.getClipPath(clip.idXAxisTickTexts); + clip.idXAxisTickTexts = clipId; + } + if (!config.axis_x_tick_multiline && $$.getAxisTickRotate("x") && newXAxisHeight !== xAxisHeight) { + $$.setXAxisTickClipWidth(); + $$.setXAxisTickTextClipPathWidth(); + } + $$.state.xAxisHeight = newXAxisHeight; + }, + setXAxisTickClipWidth() { + const $$ = this; + const { config, state: { current: { maxTickSize } } } = $$; + const xAxisTickRotate = $$.getAxisTickRotate("x"); + if (!config.axis_x_tick_multiline && xAxisTickRotate) { + const sinRotation = Math.sin(Math.PI / 180 * Math.abs(xAxisTickRotate)); + maxTickSize.x.clipPath = ($$.getHorizontalAxisHeight("x") - 20) / sinRotation; + } else { + maxTickSize.x.clipPath = null; + } + }, + setXAxisTickTextClipPathWidth() { + const $$ = this; + const { state: { clip, current }, $el: { svg } } = $$; + if (svg) { + svg.select(`#${clip.idXAxisTickTexts} rect`).attr("width", current.maxTickSize.x.clipPath).attr("height", 30); + } + } +}); + +;// ./src/ChartInternal/internals/grid.ts + + + +const _getGridTextAnchor = (d) => isValue(d.position) || "end"; +const _getGridTextDx = (d) => d.position === "start" ? 4 : d.position === "middle" ? 0 : -4; +function _getGridTextX(isX, width, height) { + return (d) => { + let x = isX ? 0 : width; + if (d.position === "start") { + x = isX ? -height : 0; + } else if (d.position === "middle") { + x = (isX ? -height : width) / 2; + } + return x; + }; +} +function _smoothLines(el, type) { + if (type === "grid") { + el.each(function() { + const g = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + ["x1", "x2", "y1", "y2"].forEach((v) => g.attr(v, +g.attr(v))); + }); + } +} +/* harmony default export */ var internals_grid = ({ + hasGrid() { + const { config } = this; + return ["x", "y"].some((v) => config[`grid_${v}_show`] || config[`grid_${v}_lines`].length); + }, + initGrid() { + const $$ = this; + $$.hasGrid() && $$.initGridLines(); + $$.initFocusGrid(); + }, + initGridLines() { + const $$ = this; + const { config, state: { clip }, $el } = $$; + if (config.grid_x_lines.length || config.grid_y_lines.length) { + $el.gridLines.main = $el.main.insert( + "g", + `.${$COMMON.chart}${config.grid_lines_front ? " + *" : ""}` + ).attr("clip-path", clip.pathGrid).attr("class", `${$GRID.grid} ${$GRID.gridLines}`); + $el.gridLines.main.append("g").attr("class", $GRID.xgridLines); + $el.gridLines.main.append("g").attr("class", $GRID.ygridLines); + $el.gridLines.x = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.selectAll)([]); + } + }, + updateXGrid(withoutUpdate) { + const $$ = this; + const { config, scale, state, $el: { main, grid } } = $$; + const isRotated = config.axis_rotated; + const xgridData = $$.generateGridData(config.grid_x_type, scale.x); + const tickOffset = $$.axis.isCategorized() ? $$.axis.x.tickOffset() : 0; + const pos = (d) => (scale.zoom || scale.x)(d) + tickOffset * (isRotated ? -1 : 1); + state.xgridAttr = isRotated ? { + x1: 0, + x2: state.width, + y1: pos, + y2: pos + } : { + x1: pos, + x2: pos, + y1: 0, + y2: state.height + }; + grid.x = main.select(`.${$GRID.xgrids}`).selectAll(`.${$GRID.xgrid}`).data(xgridData); + grid.x.exit().remove(); + grid.x = grid.x.enter().append("line").attr("class", $GRID.xgrid).merge(grid.x); + if (!withoutUpdate) { + grid.x.each(function() { + const grid2 = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + Object.keys(state.xgridAttr).forEach((id) => { + grid2.attr(id, state.xgridAttr[id]).style("opacity", () => grid2.attr(isRotated ? "y1" : "x1") === (isRotated ? state.height : 0) ? "0" : null); + }); + }); + } + }, + updateYGrid() { + const $$ = this; + const { axis, config, scale, state, $el: { grid, main } } = $$; + const isRotated = config.axis_rotated; + const pos = (d) => scale.y(d); + const gridValues = axis.y.getGeneratedTicks(config.grid_y_ticks) || $$.scale.y.ticks(config.grid_y_ticks); + grid.y = main.select(`.${$GRID.ygrids}`).selectAll(`.${$GRID.ygrid}`).data(gridValues); + grid.y.exit().remove(); + grid.y = grid.y.enter().append("line").attr("class", $GRID.ygrid).merge(grid.y); + grid.y.attr("x1", isRotated ? pos : 0).attr("x2", isRotated ? pos : state.width).attr("y1", isRotated ? 0 : pos).attr("y2", isRotated ? state.height : pos); + _smoothLines(grid.y, "grid"); + }, + updateGrid() { + const $$ = this; + const { $el: { grid, gridLines } } = $$; + !gridLines.main && $$.initGridLines(); + grid.main.style("visibility", $$.hasArcType() ? "hidden" : null); + $$.hideGridFocus(); + $$.updateGridLines("x"); + $$.updateGridLines("y"); + }, + /** + * Update Grid lines + * @param {string} type x | y + * @private + */ + updateGridLines(type) { + const $$ = this; + const { config, $el: { gridLines, main }, $T } = $$; + const isRotated = config.axis_rotated; + const isX = type === "x"; + config[`grid_${type}_show`] && $$[`update${type.toUpperCase()}Grid`](); + let lines = main.select(`.${$GRID[`${type}gridLines`]}`).selectAll(`.${$GRID[`${type}gridLine`]}`).data(config[`grid_${type}_lines`]); + $T(lines.exit()).style("opacity", "0").remove(); + const gridLine = lines.enter().append("g"); + gridLine.append("line").style("opacity", "0"); + lines = gridLine.merge(lines); + lines.each(function(d) { + const g = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + if (g.select("text").empty() && d.text) { + g.append("text").style("opacity", "0"); + } + }); + $T(lines.attr("class", (d) => `${$GRID[`${type}gridLine`]} ${d.class || ""}`.trim()).select("text").attr("text-anchor", _getGridTextAnchor).attr( + "transform", + () => isX ? isRotated ? null : "rotate(-90)" : isRotated ? "rotate(-90)" : null + ).attr("dx", _getGridTextDx).attr("dy", -5)).text(function(d) { + var _a; + return (_a = d.text) != null ? _a : this.remove(); + }); + gridLines[type] = lines; + }, + redrawGrid(withTransition) { + const $$ = this; + const { + config: { axis_rotated: isRotated }, + state: { width, height }, + $el: { gridLines }, + $T + } = $$; + const xv = $$.xv.bind($$); + const yv = $$.yv.bind($$); + let xLines = gridLines.x.select("line"); + let xTexts = gridLines.x.select("text"); + let yLines = gridLines.y.select("line"); + let yTexts = gridLines.y.select("text"); + xLines = $T(xLines, withTransition).attr("x1", isRotated ? 0 : xv).attr("x2", isRotated ? width : xv).attr("y1", isRotated ? xv : 0).attr("y2", isRotated ? xv : height); + xTexts = $T(xTexts, withTransition).attr("x", _getGridTextX(!isRotated, width, height)).attr("y", xv); + yLines = $T(yLines, withTransition).attr("x1", isRotated ? yv : 0).attr("x2", isRotated ? yv : width).attr("y1", isRotated ? 0 : yv).attr("y2", isRotated ? height : yv); + yTexts = $T(yTexts, withTransition).attr("x", _getGridTextX(isRotated, width, height)).attr("y", yv); + return [ + xLines.style("opacity", null), + xTexts.style("opacity", null), + yLines.style("opacity", null), + yTexts.style("opacity", null) + ]; + }, + initFocusGrid() { + const $$ = this; + const { config, state: { clip }, $el } = $$; + const isFront = config.grid_front; + const className = `.${isFront && $el.gridLines.main ? $GRID.gridLines : $COMMON.chart}${isFront ? " + *" : ""}`; + const grid = $el.main.insert("g", className).attr("clip-path", clip.pathGrid).attr("class", $GRID.grid); + $el.grid.main = grid; + config.grid_x_show && grid.append("g").attr("class", $GRID.xgrids); + config.grid_y_show && grid.append("g").attr("class", $GRID.ygrids); + if (config.axis_tooltip) { + const axis = grid.append("g").attr("class", "bb-axis-tooltip"); + axis.append("line").attr("class", "bb-axis-tooltip-x"); + axis.append("line").attr("class", "bb-axis-tooltip-y"); + } + if (config.interaction_enabled && config.grid_focus_show && !config.axis_tooltip) { + grid.append("g").attr("class", $FOCUS.xgridFocus).append("line").attr("class", $FOCUS.xgridFocus); + if (config.grid_focus_y && !config.tooltip_grouped) { + grid.append("g").attr("class", $FOCUS.ygridFocus).append("line").attr("class", $FOCUS.ygridFocus); + } + } + }, + showAxisGridFocus() { + var _a, _b; + const $$ = this; + const { config, format, state: { event, width, height } } = $$; + const isRotated = config.axis_rotated; + const [x, y] = getPointer(event, (_a = $$.$el.eventRect) == null ? void 0 : _a.node()); + const pos = { x, y }; + for (const [axis, node] of Object.entries($$.$el.axisTooltip)) { + const attr = axis === "x" && !isRotated || axis !== "x" && isRotated ? "x" : "y"; + const value = pos[attr]; + let scaleText = (_b = $$.scale[axis]) == null ? void 0 : _b.invert(value); + if (scaleText) { + scaleText = axis === "x" && $$.axis.isTimeSeries() ? format.xAxisTick(scaleText) : scaleText == null ? void 0 : scaleText.toFixed(2); + node == null ? void 0 : node.attr(attr, value).text(scaleText); + } + } + $$.$el.main.selectAll( + `line.bb-axis-tooltip-x, line.bb-axis-tooltip-y` + ).style("visibility", null).each(function(d, i) { + const line = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + if (i === 0) { + line.attr("x1", x).attr("x2", x).attr("y1", i ? 0 : height).attr("y2", i ? height : 0); + } else { + line.attr("x1", i ? 0 : width).attr("x2", i ? width : 0).attr("y1", y).attr("y2", y); + } + }); + }, + hideAxisGridFocus() { + const $$ = this; + $$.$el.main.selectAll( + `line.${$AXIS.axisTooltipX}, line.${$AXIS.axisTooltipY}` + ).style("visibility", "hidden"); + Object.values($$.$el.axisTooltip).forEach((v) => v == null ? void 0 : v.style("display", "none")); + }, + /** + * Show grid focus line + * @param {Array} data Selected data + * @private + */ + showGridFocus(data) { + var _a; + const $$ = this; + const { config, state: { width, height } } = $$; + const isRotated = config.axis_rotated; + const focusEl = $$.$el.main.selectAll( + `line.${$FOCUS.xgridFocus}, line.${$FOCUS.ygridFocus}` + ); + const dataToShow = (data || [focusEl.datum()]).filter( + (d) => d && isValue($$.getBaseValue(d)) + ); + if (!config.tooltip_show || dataToShow.length === 0 || !config.axis_x_forceAsSingle && $$.hasType("bubble") || $$.hasArcType()) { + return; + } + const isEdge = config.grid_focus_edge && !config.tooltip_grouped; + const xx = $$.xx.bind($$); + focusEl.style("visibility", null).data(dataToShow.concat(dataToShow)).each(function(d) { + const el = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const pos = { + x: xx(d), + y: $$.getYScaleById(d.id)(d.value) + }; + let xy; + if (el.classed($FOCUS.xgridFocus)) { + xy = isRotated ? [ + null, + // x1 + pos.x, + // y1 + isEdge ? pos.y : width, + // x2 + pos.x + // y2 + ] : [ + pos.x, + isEdge ? pos.y : null, + pos.x, + height + ]; + } else { + const isY2 = $$.axis.getId(d.id) === "y2"; + xy = isRotated ? [ + pos.y, + // x1 + isEdge && !isY2 ? pos.x : null, + // y1 + pos.y, + // x2 + isEdge && isY2 ? pos.x : height + // y2 + ] : [ + isEdge && isY2 ? pos.x : null, + pos.y, + isEdge && !isY2 ? pos.x : width, + pos.y + ]; + } + ["x1", "y1", "x2", "y2"].forEach((v, i) => el.attr(v, xy[i])); + }); + _smoothLines(focusEl, "grid"); + (_a = $$.showCircleFocus) == null ? void 0 : _a.call($$, data); + }, + hideGridFocus() { + var _a; + const $$ = this; + const { state: { inputType, resizing }, $el: { main } } = $$; + if (inputType === "mouse" || !resizing) { + main.selectAll(`line.${$FOCUS.xgridFocus}, line.${$FOCUS.ygridFocus}`).style("visibility", "hidden"); + (_a = $$.hideCircleFocus) == null ? void 0 : _a.call($$); + } + }, + updateGridFocus() { + var _a; + const $$ = this; + const { state: { inputType, width, height, resizing }, $el: { grid } } = $$; + const xgridFocus = grid.main.select(`line.${$FOCUS.xgridFocus}`); + if (inputType === "touch") { + if (xgridFocus.empty()) { + resizing && ((_a = $$.showCircleFocus) == null ? void 0 : _a.call($$)); + } else { + $$.showGridFocus(); + } + } else { + const isRotated = $$.config.axis_rotated; + xgridFocus.attr("x1", isRotated ? 0 : -10).attr("x2", isRotated ? width : -10).attr("y1", isRotated ? -10 : 0).attr("y2", isRotated ? -10 : height); + } + return true; + }, + generateGridData(type, scale) { + const $$ = this; + const tickNum = $$.$el.main.select(`.${$AXIS.axisX}`).selectAll(".tick").size(); + let gridData = []; + if (type === "year") { + const xDomain = $$.getXDomain(); + const [firstYear, lastYear] = xDomain.map((v) => v.getFullYear()); + for (let i = firstYear; i <= lastYear; i++) { + gridData.push(/* @__PURE__ */ new Date(`${i}-01-01 00:00:00`)); + } + } else { + gridData = scale.ticks(10); + if (gridData.length > tickNum) { + gridData = gridData.filter((d) => String(d).indexOf(".") < 0); + } + } + return gridData; + }, + getGridFilterToRemove(params) { + return params ? (line) => { + let found = false; + (isArray(params) ? params.concat() : [params]).forEach((param) => { + if ("value" in param && line.value === param.value || "class" in param && line.class === param.class) { + found = true; + } + }); + return found; + } : () => true; + }, + removeGridLines(params, forX) { + const $$ = this; + const { config, $T } = $$; + const toRemove = $$.getGridFilterToRemove(params); + const toShow = (line) => !toRemove(line); + const classLines = forX ? $GRID.xgridLines : $GRID.ygridLines; + const classLine = forX ? $GRID.xgridLine : $GRID.ygridLine; + $T($$.$el.main.select(`.${classLines}`).selectAll(`.${classLine}`).filter(toRemove)).style("opacity", "0").remove(); + const gridLines = `grid_${forX ? "x" : "y"}_lines`; + config[gridLines] = config[gridLines].filter(toShow); + } +}); + +;// ./src/ChartInternal/internals/region.ts + + + +/* harmony default export */ var region = ({ + initRegion() { + const $$ = this; + const { $el } = $$; + $el.region.main = $el.main.insert("g", ":first-child").attr("clip-path", $$.state.clip.path).attr("class", $REGION.regions); + }, + updateRegion() { + const $$ = this; + const { config, $el: { region }, $T } = $$; + if (!region.main) { + $$.initRegion(); + } + region.main.style("visibility", $$.hasArcType() ? "hidden" : null); + const regions = region.main.selectAll(`.${$REGION.region}`).data(config.regions); + $T(regions.exit()).style("opacity", "0").remove(); + const regionsEnter = regions.enter().append("g"); + regionsEnter.append("rect").style("fill-opacity", "0"); + region.list = regionsEnter.merge(regions).attr("class", $$.classRegion.bind($$)); + region.list.each(function(d) { + var _a; + const g = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + if (g.select("text").empty() && ((_a = d.label) == null ? void 0 : _a.text)) { + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).append("text").style("opacity", "0"); + } + }); + }, + redrawRegion(withTransition) { + const $$ = this; + const { $el: { region }, $T } = $$; + const regionX = $$.regionX.bind($$); + const regionY = $$.regionY.bind($$); + const attr = ["width", "height"]; + let regions = region.list.select("rect"); + let label = region.list.selectAll("text"); + regions = $T(regions, withTransition).attr("x", regionX).attr("y", regionY).attr("width", $$.regionWidth.bind($$)).attr("height", $$.regionHeight.bind($$)); + label = $T(label, withTransition).text((d) => { + var _a; + return (_a = d.label) == null ? void 0 : _a.text; + }).attr("transform", ({ label: label2 }) => label2.rotated ? ` rotate(-90)` : null).attr("transform", function(d) { + var _a; + const { x = 0, y = 0, center = false, rotated = false } = (_a = d.label) != null ? _a : {}; + const rect = this.previousElementSibling; + const pos = { x: 0, y: 0 }; + if (isString(center)) { + ["x", "y"].forEach((v, i) => { + if (center.indexOf(v) > -1) { + pos[v] = (+rect.getAttribute(attr[i]) - getBoundingRect(this)[attr[i]]) / 2; + } + }); + } + return `translate(${regionX(d) + pos.x + x}, ${regionY(d) + pos.y + y})${rotated ? ` rotate(-90)` : ``}`; + }).attr("text-anchor", ({ label: label2 }) => (label2 == null ? void 0 : label2.rotated) ? "end" : null).attr("dy", "1em").style("fill", ({ label: label2 }) => { + var _a; + return (_a = label2 == null ? void 0 : label2.color) != null ? _a : null; + }); + return [ + regions.style("fill-opacity", (d) => isValue(d.opacity) ? d.opacity : null).on("end", function() { + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this.parentNode).selectAll("rect:not([x])").remove(); + }), + label.style("opacity", null) + ]; + }, + regionX(d) { + return this.getRegionSize("x", d); + }, + regionY(d) { + return this.getRegionSize("y", d); + }, + regionWidth(d) { + return this.getRegionSize("width", d); + }, + regionHeight(d) { + return this.getRegionSize("height", d); + }, + /** + * Get Region size according start/end position + * @param {string} type Type string + * @param {ojbect} d Data object + * @returns {number} + * @private + */ + getRegionSize(type, d) { + const $$ = this; + const { config, scale, state } = $$; + const isRotated = config.axis_rotated; + const isAxisType = /(x|y|y2)/.test(type); + const isType = isAxisType ? type === "x" : type === "width"; + const start = !isAxisType && $$[isType ? "regionX" : "regionY"](d); + let key = isAxisType ? "start" : "end"; + let pos = isAxisType ? 0 : state[type]; + let currScale; + if (d.axis === "y" || d.axis === "y2") { + if (!isAxisType && !isType) { + key = "start"; + } else if (isAxisType && !isType) { + key = "end"; + } + if ((isType ? isRotated : !isRotated) && key in d) { + currScale = scale[d.axis]; + } + } else if ((isType ? !isRotated : isRotated) && key in d) { + currScale = scale.zoom || scale.x; + } + if (currScale) { + let offset = 0; + pos = d[key]; + if ($$.axis.isTimeSeries(d.axis)) { + pos = parseDate.call($$, pos); + } else if (/(x|width)/.test(type) && $$.axis.isCategorized() && isNaN(pos)) { + pos = config.axis_x_categories.indexOf(pos); + offset = $$.axis.x.tickOffset() * (key === "start" ? -1 : 1); + } + pos = currScale(pos) + offset; + } + return isAxisType ? pos : pos < start ? 0 : pos - start; + }, + isRegionOnX(d) { + return !d.axis || d.axis === "x"; + } +}); + +;// ./src/ChartInternal/internals/size.axis.ts + +/* harmony default export */ var size_axis = ({ + /** + * Get Axis size according its position + * @param {string} id Axis id value - x, y or y2 + * @returns {number} size Axis size value + * @private + */ + getAxisSize(id) { + const $$ = this; + const isRotated = $$.config.axis_rotated; + return isRotated && id === "x" || !isRotated && /y2?/.test(id) ? $$.getAxisWidthByAxisId(id, true) : $$.getHorizontalAxisHeight(id); + }, + getAxisWidthByAxisId(id, withoutRecompute) { + var _a, _b; + const $$ = this; + if ($$.axis) { + const position = (_a = $$.axis) == null ? void 0 : _a.getLabelPositionById(id); + const { width } = $$.axis.getMaxTickSize(id, withoutRecompute); + const gap = width === 0 ? 0.5 : 0; + return width + (((_b = $$.config.padding) == null ? void 0 : _b.mode) === "fit" ? position.isInner ? 10 + gap : 10 : position.isInner ? 20 + gap : 40); + } else { + return 40; + } + }, + getHorizontalAxisHeight(id) { + var _a, _b; + const $$ = this; + const { config, state } = $$; + const { rotatedPadding, isLegendRight, isLegendInset } = state; + const isRotated = config.axis_rotated; + const isFitPadding = ((_a = config.padding) == null ? void 0 : _a.mode) === "fit"; + const isInner = config[`axis_${id}_inner`]; + const hasLabelText = config[`axis_${id}_label`].text; + const defaultHeight = 13; + let h = ((_b = config.padding) == null ? void 0 : _b.mode) === "fit" ? isInner && !hasLabelText ? id === "y" ? 1 : 0 : 20 : 30; + if (id === "x" && !config.axis_x_show) { + return 8; + } + if (id === "x" && isNumber(config.axis_x_height)) { + return config.axis_x_height; + } + if (id === "y" && !config.axis_y_show) { + return config.legend_show && !isLegendRight && !isLegendInset ? 10 : 1; + } + if (id === "y2" && !config.axis_y2_show) { + return isFitPadding ? 0 : rotatedPadding.top; + } + const maxtickSize = $$.axis.getMaxTickSize(id); + const isXAxisTickRotated = Math.abs(config.axis_x_tick_rotate) > 0 && (!config.axis_x_tick_autorotate || $$.needToRotateXAxisTickTexts()); + if ((config.axis_x_tick_multiline || isXAxisTickRotated) && maxtickSize.height > defaultHeight) { + h += maxtickSize.height - defaultHeight; + } + return h + ($$.axis.getLabelPositionById(id).isInner ? 0 : 10) + (id === "y2" && !isRotated ? -10 : 0); + }, + getEventRectWidth() { + const $$ = this; + const { config, axis } = $$; + const isInverted = config.axis_x_inverted; + const tickInterval = axis.x.tickInterval(); + return Math.max(0, isInverted ? Math.abs(tickInterval) : tickInterval); + }, + /** + * Get axis tick test rotate value + * @param {string} id Axis id + * @returns {number} rotate value + * @private + */ + getAxisTickRotate(id) { + const $$ = this; + const { axis, config, state, $el } = $$; + let rotate = config[`axis_${id}_tick_rotate`]; + if (id === "x") { + const allowedXAxisTypes = axis.isCategorized() || axis.isTimeSeries(); + if (config.axis_x_tick_fit && allowedXAxisTypes) { + const xTickCount = config.axis_x_tick_count; + const currentXTicksLength = state.current.maxTickSize.x.ticks.length; + let tickCount = 0; + if (xTickCount) { + tickCount = xTickCount > currentXTicksLength ? currentXTicksLength : xTickCount; + } else if (currentXTicksLength) { + tickCount = currentXTicksLength; + } + if (tickCount !== state.axis.x.tickCount) { + const { targets } = $$.data; + state.axis.x.padding = $$.getXDomainPadding([ + $$.getXDomainMinMax(targets, "min"), + $$.getXDomainMinMax(targets, "max") + ], tickCount); + } + state.axis.x.tickCount = tickCount; + } + if ($el.svg && config.axis_x_tick_autorotate && config.axis_x_tick_fit && !config.axis_x_tick_multiline && !config.axis_x_tick_culling && allowedXAxisTypes) { + rotate = $$.needToRotateXAxisTickTexts() ? config.axis_x_tick_rotate : 0; + } + } + return rotate; + }, + /** + * Check weather axis tick text needs to be rotated + * @returns {boolean} + * @private + */ + needToRotateXAxisTickTexts() { + const $$ = this; + const { state: { axis, current, isLegendRight, legendItemWidth } } = $$; + const legendWidth = isLegendRight && legendItemWidth; + const xAxisLength = current.width - legendWidth - $$.getCurrentPaddingByDirection("left") - $$.getCurrentPaddingByDirection("right"); + const tickCountWithPadding = axis.x.tickCount + axis.x.padding.left + axis.x.padding.right; + const { width } = $$.axis.getMaxTickSize("x"); + const tickLength = tickCountWithPadding ? xAxisLength / tickCountWithPadding : 0; + return width > tickLength; + } +}); + +;// ./src/config/Options/axis/x.ts +/* harmony default export */ var axis_x = ({ + /** + * Set clip-path attribute for x axis element + * @name axis․x․clipPath + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo]() + * @example + * // don't set 'clip-path' attribute + * clipPath: false + */ + axis_x_clipPath: true, + /** + * Show or hide x axis. + * @name axis․x․show + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * x: { + * show: false + * } + * } + */ + axis_x_show: true, + /** + * Force the x axis to interact as single rather than multiple x axes. + * - **NOTE:** The tooltip event will be triggered nearing each data points(for multiple xs) rather than x axis based(as single x does) in below condition: + * - for `bubble` & `scatter` type + * - when `data.xs` is set + * - when `tooltip.grouped=false` is set + * - `tooltip.grouped` options will take precedence over `axis.forceSingleX` option. + * @name axis․x․forceAsSingle + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.ForceAsSingle) + * @example + * axis: { + * x: { + * // will work as single x axis + * forceAsSingle: true + * } + * } + */ + axis_x_forceAsSingle: false, + /** + * Set type of x axis.<br><br> + * **Available Values:** + * - category + * - indexed + * - log + * - timeseries + * + * **NOTE:**<br> + * - **log** type: + * - the x values specified by [`data.x`](#.data%25E2%2580%25A4x)(or by any equivalent option), must be exclusively-positive. + * - x axis min value should be >= 0. + * - for 'category' type, `data.xs` option isn't supported. + * @name axis․x․type + * @memberof Options + * @type {string} + * @default indexed + * @see [Demo: indexed](https://naver.github.io/billboard.js/demo/#Chart.AreaChart) + * @see [Demo: timeseries](https://naver.github.io/billboard.js/demo/#Chart.TimeseriesChart) + * @see [Demo: category](https://naver.github.io/billboard.js/demo/#Data.CategoryData) + * @see [Demo: log](https://naver.github.io/billboard.js/demo/#Axis.LogScales) + * @example + * axis: { + * x: { + * type: "timeseries" + * } + * } + */ + axis_x_type: "indexed", + /** + * Set how to treat the timezone of x values.<br> + * If true, treat x value as localtime. If false, convert to UTC internally. + * @name axis․x․localtime + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * x: { + * localtime: false + * } + * } + */ + axis_x_localtime: true, + /** + * Set category names on category axis. + * This must be an array that includes category names in string. If category names are included in the date by data.x option, this is not required. + * @name axis․x․categories + * @memberof Options + * @type {Array} + * @default [] + * @example + * axis: { + * x: { + * categories: ["Category 1", "Category 2", ...] + * } + * } + */ + axis_x_categories: [], + /** + * centerize ticks on category axis. + * @name axis․x․tick․centered + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * x: { + * tick: { + * centered: true + * } + * } + * } + */ + axis_x_tick_centered: false, + /** + * A function to format tick value. Format string is also available for timeseries data. + * @name axis․x․tick․format + * @memberof Options + * @type {function|string} + * @default undefined + * @see [D3's time specifier](https://d3js.org/d3-time-format#locale_format) + * @example + * axis: { + * x: { + * tick: { + * // for timeseries, a 'datetime' object is given as parameter + * format: function(x) { + * return x.getFullYear(); + * } + * + * // for category, index(Number) and categoryName(String) are given as parameter + * format: function(index, categoryName) { + * return categoryName.substr(0, 10); + * }, + * + * // for timeseries format specifier + * format: "%Y-%m-%d %H:%M:%S" + * } + * } + * } + */ + axis_x_tick_format: void 0, + /** + * Setting for culling ticks. + * - `true`: the ticks will be culled, then only limited tick text will be shown.<br> + * This option does not hide the tick lines by default, if want to hide tick lines, set `axis.x.tick.culling.lines=false`. + * - `false`: all of ticks will be shown.<br><br> + * The number of ticks to be shown can be changed by `axis.x.tick.culling.max`. + * @name axis․x․tick․culling + * @memberof Options + * @type {boolean} + * @default + * `true` for indexed axis and timeseries axis, `false` for category axis + * @example + * axis: { + * x: { + * tick: { + * culling: false, + * } + * } + * } + */ + axis_x_tick_culling: {}, + /** + * The number of tick texts will be adjusted to less than this value. + * @name axis․x․tick․culling․max + * @memberof Options + * @type {number} + * @default 10 + * @example + * axis: { + * x: { + * tick: { + * culling: { + * max: 5 + * } + * } + * } + * } + */ + axis_x_tick_culling_max: 10, + /** + * Control visibility of tick lines within culling option, along with tick text. + * @name axis․x․tick․culling․lines + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * x: { + * tick: { + * culling: { + * lines: false, + * } + * } + * } + * } + */ + axis_x_tick_culling_lines: true, + /** + * Control culling start point to be reversed. If set to true, the culling will be started from the end to start. + * - **NOTE:** This option is only available when `axis.x.tick.culling` is set to truthy value. + * @name axis․x․tick․culling․reverse + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.XAxisTickCulling) + * @example + * axis: { + * x: { + * tick: { + * culling: { + * reverse: true, + * } + * } + * } + * } + */ + axis_x_tick_culling_reverse: false, + /** + * The number of x axis ticks to show.<br><br> + * This option hides tick lines together with tick text. If this option is used on timeseries axis, the ticks position will be determined precisely and not nicely positioned (e.g. it will have rough second value). + * @name axis․x․tick․count + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * x: { + * tick: { + * count: 5 + * } + * } + * } + */ + axis_x_tick_count: void 0, + /** + * Set the axis tick line to be positioned inside of the chart. + * @name axis․x․tick․inner + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.TickInner) + * @example + * axis: { + * x: { + * tick: { + * inner: true + * } + * } + * } + */ + axis_x_tick_inner: false, + /** + * Show or hide x axis tick line. + * @name axis․x․tick․show + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.HideTickLineText) + * @example + * axis: { + * x: { + * tick: { + * show: false + * } + * } + * } + */ + axis_x_tick_show: true, + /** + * Show or hide x axis tick text. + * @name axis․x․tick․text․show + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.HideTickLineText) + * @example + * axis: { + * x: { + * tick: { + * text: { + * show: false + * } + * } + * } + * } + */ + axis_x_tick_text_show: true, + /** + * Set the first/last axis tick text to be positioned inside of the chart on non-rotated axis. + * @name axis․x․tick․text․inner + * @memberof Options + * @type {boolean|object} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.XAxisTickInner) + * @example + * axis: { + * x: { + * tick: { + * text: { + * inner: true, + * + * // or specify each position of the first and last tick text + * inner: { + * first: true, + * last: true + * } + * } + * } + * } + * } + */ + axis_x_tick_text_inner: false, + /** + * Set the x Axis tick text's position relatively its original position + * @name axis․x․tick․text․position + * @memberof Options + * @type {object} + * @default {x: 0, y:0} + * @example + * axis: { + * x: { + * tick: { + * text: { + * position: { + * x: 10, + * y: 10 + * } + * } + * } + * } + * } + */ + axis_x_tick_text_position: { x: 0, y: 0 }, + /** + * Fit x axis ticks. + * - **true**: ticks will be shown according to x value of the data points. + * - **false**: ticks will be shown as to have same intervals. + * @name axis․x․tick․fit + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.XAxisTickFitting) + * @see [Demo: for timeseries zoom](https://naver.github.io/billboard.js/demo/#Axis.XAxisTickTimeseries) + * @example + * axis: { + * x: { + * tick: { + * fit: false + * } + * } + * } + */ + axis_x_tick_fit: true, + /** + * Set the x values of ticks manually.<br><br> + * If this option is provided, the position of the ticks will be determined based on those values.<br> + * This option works with `timeseries` data and the x values will be parsed according to the type of the value and data.xFormat option. + * @name axis․x․tick․values + * @memberof Options + * @type {Array|function} + * @default null + * @example + * axis: { + * x: { + * tick: { + * values: [1, 2, 4, 8, 16, 32, ...], + * + * // an Array value should be returned + * values: function() { + * return [ ... ]; + * } + * } + * } + * } + */ + axis_x_tick_values: null, + /** + * Rotate x axis tick text if there is not enough space for 'category' and 'timeseries' type axis. + * - **NOTE:** The conditions where `autorotate` is enabled are: + * - axis.x.type='category' or 'timeseries + * - axis.x.tick.multiline=false + * - axis.x.tick.culling=false + * - axis.x.tick.fit=true + * - **NOTE:** axis.x.tick.clippath=false is necessary for calculating the overflow padding between the end of x axis and the width of the SVG + * @name axis․x․tick․autorotate + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.XAxisTickAutorotate) + * @example + * axis: { + * x: { + * tick: { + * rotate: 15, + * autorotate: true, + * multiline: false, + * culling: false, + * fit: true + * }, + * clipPath: false + * } + * } + */ + axis_x_tick_autorotate: false, + /** + * Rotate x axis tick text. + * - If you set negative value, it will rotate to opposite direction. + * - Applied when [`axis.rotated`](#.axis%25E2%2580%25A4rotated) option is `false`. + * - As long as `axis_x_tick_fit` is set to `true` it will calculate an overflow for the y2 axis and add this value to the right padding. + * @name axis․x․tick․rotate + * @memberof Options + * @type {number} + * @default 0 + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.RotateXAxisTickText) + * @example + * axis: { + * x: { + * tick: { + * rotate: 60 + * } + * } + * } + */ + axis_x_tick_rotate: 0, + /** + * Show x axis outer tick. + * @name axis․x․tick․outer + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * x: { + * tick: { + * outer: false + * } + * } + * } + */ + axis_x_tick_outer: true, + /** + * Set tick text to be multiline + * - **NOTE:** + * > When x tick text contains `\n`, it's used as line break and 'axis.x.tick.width' option is ignored. + * @name axis․x․tick․multiline + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.XAxisTickMultiline) + * @example + * axis: { + * x: { + * tick: { + * multiline: false + * } + * } + * } + * @example + * // example of line break with '\n' + * // In this case, 'axis.x.tick.width' is ignored + * data: { + * x: "x", + * columns: [ + * ["x", "long\ntext", "Another\nLong\nText"], + * ... + * ], + * } + */ + axis_x_tick_multiline: true, + /** + * Set tick width + * - **NOTE:** + * > When x tick text contains `\n`, this option is ignored. + * @name axis․x․tick․width + * @memberof Options + * @type {number} + * @default null + * @example + * axis: { + * x: { + * tick: { + * width: 50 + * } + * } + * } + */ + axis_x_tick_width: null, + /** + * Set to display system tooltip(via `<title>` element) for tick text + * - **NOTE:** Only available for category axis type (`axis.x.type='category'`) + * @name axis․x․tick․tooltip + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * x: { + * tick: { + * tooltip: true + * } + * } + * } + */ + axis_x_tick_tooltip: false, + /** + * Set max value of x axis range. + * @name axis․x․max + * @memberof Options + * @property {number} max Set the max value + * @property {boolean} [max.fit=false] When specified `max.value` is greater than the bound data value, setting `true` will make x axis max to be fitted to the bound data max value. + * - **NOTE:** If the bound data max value is greater than the `max.value`, the x axis max will be limited as the given `max.value`. + * @property {number} [max.value] Set the max value + * @example + * axis: { + * x: { + * max: 100, + * + * max: { + * // 'fit=true' will make x axis max to be limited as the bound data value max when 'max.value' is greater. + * // - when bound data max is '10' and max.value: '100' ==> x axis max will be '10' + * // - when bound data max is '1000' and max.value: '100' ==> x axis max will be '100' + * fit: true, + * value: 100 + * } + * } + * } + */ + axis_x_max: void 0, + /** + * Set min value of x axis range. + * @name axis․x․min + * @memberof Options + * @property {number} min Set the min value + * @property {boolean} [min.fit=false] When specified `min.value` is lower than the bound data value, setting `true` will make x axis min to be fitted to the bound data min value. + * - **NOTE:** If the bound data min value is lower than the `min.value`, the x axis min will be limited as the given `min.value`. + * @property {number} [min.value] Set the min value + * @example + * axis: { + * x: { + * min: -100, + * + * min: { + * // 'fit=true' will make x axis min to be limited as the bound data value min when 'min.value' is lower. + * // - when bound data min is '-10' and min.value: '-100' ==> x axis min will be '-10' + * // - when bound data min is '-1000' and min.value: '-100' ==> x axis min will be '-100' + * fit: true, + * value: -100 + * } + * } + * } + */ + axis_x_min: void 0, + /** + * Change the direction of x axis.<br><br> + * If true set, the direction will be `right -> left`. + * @name axis․x․inverted + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.InvertedAxis) + * @example + * axis: { + * x: { + * inverted: true + * } + * } + */ + axis_x_inverted: false, + /** + * Set padding for x axis.<br><br> + * If this option is set, the range of x axis will increase/decrease according to the values. + * If no padding is needed in the rage of x axis, 0 should be set. + * By default, left/right padding are set depending on x axis type or chart types. + * - **NOTE:** + * - The meaning of padding values, differs according axis types:<br> + * - **category/indexed:** The unit of tick value + * ex. the given value `1`, is same as the width of 1 tick width + * - **timeseries:** Numeric time value + * ex. the given value `1000*60*60*24`, which is numeric time equivalent of a day, is same as the width of 1 tick width + * - If want values to be treated as pixels, specify `unit:"px"`. + * - The pixel value will be converted based on the scale values. Hence can not reflect accurate padding result. + * @name axis․x․padding + * @memberof Options + * @type {object|number} + * @default {} + * @example + * axis: { + * x: { + * padding: { + * // when axis type is 'category' + * left: 1, // set left padding width of equivalent value of a tick's width + * right: 0.5 // set right padding width as half of equivalent value of tick's width + * + * // when axis type is 'timeseries' + * left: 1000*60*60*24, // set left padding width of equivalent value of a day tick's width + * right: 1000*60*60*12 // set right padding width as half of equivalent value of a day tick's width + * }, + * + * // or set both values at once. + * padding: 10, + * + * // or set padding values as pixel unit. + * padding: { + * left: 100, + * right: 50, + * unit: "px" + * }, + * } + * } + */ + axis_x_padding: {}, + /** + * Set height of x axis.<br><br> + * The height of x axis can be set manually by this option. If you need more space for x axis, please use this option for that. The unit is pixel. + * @name axis․x․height + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * x: { + * height: 20 + * } + * } + */ + axis_x_height: void 0, + /** + * Set extent for subchart and zoom(drag only). This can be an array or function that returns an array. + * - **NOTE:** Specifying value, will limit the zoom scope selection within. + * @name axis․x․extent + * @memberof Options + * @type {Array|function} + * @default undefined + * @example + * axis: { + * x: { + * // extent range as a pixel value + * extent: [0, 200], + * + * // when axis is 'timeseries', parsable datetime string + * extent: ["2019-03-01", "2019-03-05"], + * + * // return extent value + * extent: function(domain, scale) { + * var extent = domain.map(function(v) { + * return scale(v); + * }); + * + * // it should return a format of array + * // ex) [0, 584] + * return extent; + * } + * } + * } + */ + axis_x_extent: void 0, + /** + * Set label on x axis.<br><br> + * You can set x axis label and change its position by this option. + * `string` and `object` can be passed and we can change the poisiton by passing object that has position key.<br> + * Available position differs according to the axis direction (vertical or horizontal). + * If string set, the position will be the default. + * + * - **If it's horizontal axis:** + * - inner-right [default] + * - inner-center + * - inner-left + * - outer-right + * - outer-center + * - outer-left + * - **If it's vertical axis:** + * - inner-top [default] + * - inner-middle + * - inner-bottom + * - outer-top + * - outer-middle + * - outer-bottom + * @name axis․x․label + * @memberof Options + * @type {string|object} + * @default undefined + * @example + * axis: { + * x: { + * label: "Your X Axis" + * } + * } + * + * axis: { + * x: { + * label: { + * text: "Your X Axis", + * position: "outer-center" + * } + * } + * } + */ + axis_x_label: {}, + /** + * Set additional axes for x Axis. + * - **NOTE:** Axis' scale is based on x Axis value if domain option isn't set. + * + * Each axis object should consist with following options: + * + * | Name | Type | Default | Description | + * | --- | --- | --- | --- | + * | domain | Array | - | Set the domain value | + * | tick.outer | boolean | true | Show outer tick | + * | tick.format | Function | - | Set formatter for tick text | + * | tick.count | Number | - | Set the number of y axis ticks | + * | tick.values | Array | - | Set tick values manually | + * @name axis․x․axes + * @memberof Options + * @type {Array} + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.MultiAxes) + * @see [Demo: Domain](https://naver.github.io/billboard.js/demo/#Axis.MultiAxesDomain) + * @example + * x: { + * axes: [ + * { + * // if set, will not be correlated with the main x Axis domain value + * domain: [0, 1000], + * tick: { + * outer: false, + * format: function(x) { + * return x + "%"; + * }, + * count: 2, + * values: [10, 20, 30] + * } + * }, + * ... + * ] + * } + */ + axis_x_axes: [] +}); + +;// ./src/config/Options/axis/y.ts +/* harmony default export */ var y = ({ + /** + * Set clip-path attribute for y axis element + * - **NOTE**: `clip-path` attribute for y Axis is set only when `axis.y.inner` option is true. + * @name axis․y․clipPath + * @memberof Options + * @type {boolean} + * @default true + * @example + * // don't set 'clip-path' attribute + * clipPath: false + */ + axis_y_clipPath: true, + /** + * Show or hide y axis. + * @name axis․y․show + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * y: { + * show: false + * } + * } + */ + axis_y_show: true, + /** + * Set type of y axis.<br><br> + * **Available Values:** + * - indexed + * - log + * - timeseries + * + * **NOTE:**<br> + * - **log** type: + * - the bound data values must be exclusively-positive. + * - y axis min value should be >= 0. + * - [`data.groups`](#.data%25E2%2580%25A4groups)(stacked data) option aren't supported. + * + * @name axis․y․type + * @memberof Options + * @type {string} + * @default "indexed" + * @see [Demo: log](https://naver.github.io/billboard.js/demo/#Axis.LogScales) + * @example + * axis: { + * y: { + * type: "log" + * } + * } + */ + axis_y_type: "indexed", + /** + * Set max value of y axis. + * - **NOTE:** Padding will be added based on this value, so if you don't need the padding, please set axis.y.padding to disable it (e.g. axis.y.padding = 0). + * @name axis․y․max + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y: { + * max: 1000 + * } + * } + */ + axis_y_max: void 0, + /** + * Set min value of y axis. + * - **NOTE:** + * Padding will be added based on this value, so if you don't need the padding, please set axis.y.padding to disable it (e.g. axis.y.padding = 0). + * @name axis․y․min + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y: { + * min: 1000 + * } + * } + */ + axis_y_min: void 0, + /** + * Change the direction of y axis.<br><br> + * If true set, the direction will be `top -> bottom`. + * @name axis․y․inverted + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.InvertedAxis) + * @example + * axis: { + * y: { + * inverted: true + * } + * } + */ + axis_y_inverted: false, + /** + * Set center value of y axis. + * @name axis․y․center + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y: { + * center: 0 + * } + * } + */ + axis_y_center: void 0, + /** + * Show y axis inside of the chart. + * @name axis․y․inner + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * y: { + * inner: true + * } + * } + */ + axis_y_inner: false, + /** + * Set label on y axis.<br><br> + * You can set y axis label and change its position by this option. This option works in the same way as [axis.x.label](#.axis%25E2%2580%25A4x%25E2%2580%25A4label). + * @name axis․y․label + * @memberof Options + * @type {string|object} + * @default {} + * @see [axis.x.label](#.axis%25E2%2580%25A4x%25E2%2580%25A4label) for position string value. + * @example + * axis: { + * y: { + * label: "Your Y Axis" + * } + * } + * + * axis: { + * y: { + * label: { + * text: "Your Y Axis", + * position: "outer-middle" + * } + * } + * } + */ + axis_y_label: {}, + /** + * Set formatter for y axis tick text.<br><br> + * This option accepts d3.format object as well as a function you define. + * @name axis․y․tick․format + * @memberof Options + * @type {function} + * @default undefined + * @example + * axis: { + * y: { + * tick: { + * format: function(x) { + * return x.getFullYear(); + * } + * } + * } + * } + */ + axis_y_tick_format: void 0, + /** + * Setting for culling ticks. + * - `true`: the ticks will be culled, then only limited tick text will be shown.<br> + * This option does not hide the tick lines by default, if want to hide tick lines, set `axis.y.tick.culling.lines=false`. + * - `false`: all of ticks will be shown.<br><br> + * The number of ticks to be shown can be changed by `axis.y.tick.culling.max`. + * @name axis․y․tick․culling + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * y: { + * tick: { + * culling: false + * } + * } + * } + */ + axis_y_tick_culling: false, + /** + * The number of tick texts will be adjusted to less than this value. + * @name axis․y․tick․culling․max + * @memberof Options + * @type {number} + * @default 5 + * @example + * axis: { + * y: { + * tick: { + * culling: { + * max: 5 + * } + * } + * } + * } + */ + axis_y_tick_culling_max: 5, + /** + * Control visibility of tick lines within culling option, along with tick text. + * @name axis․y․tick․culling․lines + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * y: { + * tick: { + * culling: { + * lines: false, + * } + * } + * } + * } + */ + axis_y_tick_culling_lines: true, + /** + * Control culling start point to be reversed. If set to true, the culling will be started from the end to start. + * - **NOTE:** This option is only available when `axis.y.tick.culling` is set to truthy value. + * @name axis․y․tick․culling․reverse + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * y: { + * tick: { + * culling: { + * reverse: true, + * } + * } + * } + * } + */ + axis_y_tick_culling_reverse: false, + /** + * Set the axis tick line to be positioned inside of the chart. + * @name axis․y․tick․inner + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.TickInner) + * axis: { + * y: { + * tick: { + * inner: true + * } + * } + * } + */ + axis_y_tick_inner: false, + /** + * Show y axis outer tick. + * @name axis․y․tick․outer + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * y: { + * tick: { + * outer: false + * } + * } + * } + */ + axis_y_tick_outer: true, + /** + * Set y axis tick values manually. + * @name axis․y․tick․values + * @memberof Options + * @type {Array|function} + * @default null + * @example + * axis: { + * y: { + * tick: { + * values: [100, 1000, 10000], + * + * // an Array value should be returned + * values: function() { + * return [ ... ]; + * } + * } + * } + * } + */ + axis_y_tick_values: null, + /** + * Rotate y axis tick text. + * - If you set negative value, it will rotate to opposite direction. + * - Applied when [`axis.rotated`](#.axis%25E2%2580%25A4rotated) option is `true`. + * @name axis․y․tick․rotate + * @memberof Options + * @type {number} + * @default 0 + * @example + * axis: { + * y: { + * tick: { + * rotate: 60 + * } + * } + * } + */ + axis_y_tick_rotate: 0, + /** + * Set the number of y axis ticks.<br><br> + * - **NOTE:** The position of the ticks will be calculated precisely, so the values on the ticks will not be rounded nicely. In the case, axis.y.tick.format or axis.y.tick.values will be helpful. + * @name axis․y․tick․count + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y: { + * tick: { + * count: 5 + * } + * } + * } + */ + axis_y_tick_count: void 0, + /** + * Show or hide y axis tick line. + * @name axis․y․tick․show + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.HideTickLineText) + * @example + * axis: { + * y: { + * tick: { + * show: false + * } + * } + * } + */ + axis_y_tick_show: true, + /** + * Set axis tick step(interval) size. + * - **NOTE:** Will be ignored if `axis.y.tick.count` or `axis.y.tick.values` options are set. + * @name axis․y․tick․stepSize + * @memberof Options + * @type {number} + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.StepSizeForYAxis) + * @example + * axis: { + * y: { + * tick: { + * // tick value will step as indicated interval value. + * // ex) 'stepSize=15' ==> [0, 15, 30, 45, 60] + * stepSize: 15 + * } + * } + * } + */ + axis_y_tick_stepSize: null, + /** + * Show or hide y axis tick text. + * @name axis․y․tick․text․show + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.HideTickLineText) + * @example + * axis: { + * y: { + * tick: { + * text: { + * show: false + * } + * } + * } + * } + */ + axis_y_tick_text_show: true, + /** + * Set the y Axis tick text's position relatively its original position + * @name axis․y․tick․text․position + * @memberof Options + * @type {object} + * @default {x: 0, y:0} + * @example + * axis: { + * y: { + * tick: { + * text: { + * position: { + * x: 10, + * y: 10 + * } + * } + * } + * } + * } + */ + axis_y_tick_text_position: { x: 0, y: 0 }, + /** + * Set the number of y axis ticks.<br><br> + * - **NOTE:** The position of the ticks will be calculated precisely, so the values on the ticks will not be rounded nicely. In the case, axis.y.tick.format or axis.y.tick.values will be helpful. + * @name axis․y․tick․time + * @memberof Options + * @private + * @type {object} + * @property {object} time time object + * @property {function} [time.value] D3's time interval function (https://github.com/d3/d3-time#intervals) + * @example + * axis: { + * y: { + * tick: { + * time: { + * // ticks at 15-minute intervals + * // https://github.com/d3/d3-scale/blob/master/README.md#time_ticks + * value: d3.timeMinute.every(15) + * } + * } + * } + * } + */ + // @TODO: not fully implemented yet + axis_y_tick_time_value: void 0, + /** + * Set padding for y axis.<br><br> + * You can set padding for y axis to create more space on the edge of the axis. + * This option accepts object and it can include top and bottom. top, bottom will be treated as pixels. + * + * - **NOTE:** + * - Given values are translated relative to the y Axis domain value for padding + * - For area and bar type charts, [area.zerobased](#.area) or [bar.zerobased](#.bar) options should be set to 'false` to get padded bottom. + * @name axis․y․padding + * @memberof Options + * @type {object|number} + * @default {} + * @example + * axis: { + * y: { + * padding: { + * top: 0, + * bottom: 0 + * }, + * + * // or set both values at once. + * padding: 10 + * } + * } + */ + axis_y_padding: {}, + /** + * Set default range of y axis.<br><br> + * This option set the default value for y axis when there is no data on init. + * @name axis․y․default + * @memberof Options + * @type {Array} + * @default undefined + * @example + * axis: { + * y: { + * default: [0, 1000] + * } + * } + */ + axis_y_default: void 0, + /** + * Set additional axes for y Axis. + * - **NOTE:** Axis' scale is based on y Axis value if domain option isn't set. + * + * Each axis object should consist with following options: + * + * | Name | Type | Default | Description | + * | --- | --- | --- | --- | + * | domain | Array | - | Set the domain value | + * | tick.outer | boolean | true | Show outer tick | + * | tick.format | Function | - | Set formatter for tick text | + * | tick.count | Number | - | Set the number of y axis ticks | + * | tick.values | Array | - | Set tick values manually | + * @name axis․y․axes + * @memberof Options + * @type {Array} + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.MultiAxes) + * @see [Demo: Domain](https://naver.github.io/billboard.js/demo/#Axis.MultiAxesDomain) + * @example + * y: { + * axes: [ + * { + * // if set, will not be correlated with the main y Axis domain value + * domain: [0, 1000], + * tick: { + * outer: false, + * format: function(x) { + * return x + "%"; + * }, + * count: 2, + * values: [10, 20, 30] + * } + * }, + * ... + * ] + * } + */ + axis_y_axes: [] +}); + +;// ./src/config/Options/axis/y2.ts +/* harmony default export */ var y2 = ({ + /** + * Show or hide y2 axis. + * - **NOTE**: + * - When set to `false` will not generate y2 axis node. In this case, all 'y2' axis related functionality won't work properly. + * - If need to use 'y2' related options while y2 isn't visible, set the value `true` and control visibility by css display property. + * @name axis․y2․show + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * y2: { + * show: true + * } + * } + */ + axis_y2_show: false, + /** + * Set type of y2 axis.<br><br> + * **Available Values:** + * - indexed + * - log + * - timeseries + * + * **NOTE:**<br> + * - **log** type: + * - the bound data values must be exclusively-positive. + * - y2 axis min value should be >= 0. + * - [`data.groups`](#.data%25E2%2580%25A4groups)(stacked data) option aren't supported. + * + * @name axis․y2․type + * @memberof Options + * @type {string} + * @default "indexed" + * @see [Demo: log](https://naver.github.io/billboard.js/demo/#Axis.LogScales) + * @example + * axis: { + * y2: { + * type: "indexed" + * } + * } + */ + axis_y2_type: "indexed", + /** + * Set max value of y2 axis. + * @name axis․y2․max + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y2: { + * max: 1000 + * } + * } + */ + axis_y2_max: void 0, + /** + * Set min value of y2 axis. + * @name axis․y2․min + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y2: { + * min: -1000 + * } + * } + */ + axis_y2_min: void 0, + /** + * Change the direction of y2 axis.<br><br> + * If true set, the direction will be `top -> bottom`. + * @name axis․y2․inverted + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.InvertedAxis) + * @example + * axis: { + * y2: { + * inverted: true + * } + * } + */ + axis_y2_inverted: false, + /** + * Set center value of y2 axis. + * @name axis․y2․center + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y2: { + * center: 0 + * } + * } + */ + axis_y2_center: void 0, + /** + * Show y2 axis inside of the chart. + * @name axis․y2․inner + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * y2: { + * inner: true + * } + * } + */ + axis_y2_inner: false, + /** + * Set label on y2 axis.<br><br> + * You can set y2 axis label and change its position by this option. This option works in the same way as [axis.x.label](#.axis%25E2%2580%25A4x%25E2%2580%25A4label). + * @name axis․y2․label + * @memberof Options + * @type {string|object} + * @default {} + * @see [axis.x.label](#.axis%25E2%2580%25A4x%25E2%2580%25A4label) for position string value. + * @example + * axis: { + * y2: { + * label: "Your Y2 Axis" + * } + * } + * + * axis: { + * y2: { + * label: { + * text: "Your Y2 Axis", + * position: "outer-middle" + * } + * } + * } + */ + axis_y2_label: {}, + /** + * Set formatter for y2 axis tick text.<br><br> + * This option works in the same way as axis.y.format. + * @name axis․y2․tick․format + * @memberof Options + * @type {function} + * @default undefined + * @example + * axis: { + * y2: { + * tick: { + * format: d3.format("$,") + * //or format: function(d) { return "$" + d; } + * } + * } + * } + */ + axis_y2_tick_format: void 0, + /** + * Setting for culling ticks. + * - `true`: the ticks will be culled, then only limited tick text will be shown.<br> + * This option does not hide the tick lines by default, if want to hide tick lines, set `axis.y2.tick.culling.lines=false`. + * - `false`: all of ticks will be shown.<br><br> + * The number of ticks to be shown can be changed by `axis.y2.tick.culling.max`. + * @name axis․y2․tick․culling + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * y2: { + * tick: { + * culling: false + * } + * } + * } + */ + axis_y2_tick_culling: false, + /** + * The number of tick texts will be adjusted to less than this value. + * @name axis․y2․tick․culling․max + * @memberof Options + * @type {number} + * @default 5 + * @example + * axis: { + * y2: { + * tick: { + * culling: { + * max: 5 + * } + * } + * } + * } + */ + axis_y2_tick_culling_max: 5, + /** + * Control visibility of tick lines within culling option, along with tick text. + * @name axis․y2․tick․culling․lines + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * y2: { + * tick: { + * culling: { + * lines: false, + * } + * } + * } + * } + */ + axis_y2_tick_culling_lines: true, + /** + * Control culling start point to be reversed. If set to true, the culling will be started from the end to start. + * - **NOTE:** This option is only available when `axis.y2.tick.culling` is set to truthy value. + * @name axis․y2․tick․culling․reverse + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * y2: { + * tick: { + * culling: { + * reverse: true, + * } + * } + * } + * } + */ + axis_y2_tick_culling_reverse: false, + /** + * Set the axis tick line to be positioned inside of the chart. + * @name axis․y2․tick․inner + * @memberof Options + * @type {boolean} + * @default false + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.TickInner) + * @example + * axis: { + * y2: { + * tick: { + * inner: true + * } + * } + * } + */ + axis_y2_tick_inner: false, + /** + * Show or hide y2 axis outer tick. + * @name axis․y2․tick․outer + * @memberof Options + * @type {boolean} + * @default true + * @example + * axis: { + * y2: { + * tick: { + * outer: false + * } + * } + * } + */ + axis_y2_tick_outer: true, + /** + * Set y2 axis tick values manually. + * @name axis․y2․tick․values + * @memberof Options + * @type {Array|function} + * @default null + * @example + * axis: { + * y2: { + * tick: { + * values: [100, 1000, 10000], + * + * // an Array value should be returned + * values: function() { + * return [ ... ]; + * } + * } + * } + * } + */ + axis_y2_tick_values: null, + /** + * Rotate y2 axis tick text. + * - If you set negative value, it will rotate to opposite direction. + * - Applied when [`axis.rotated`](#.axis%25E2%2580%25A4rotated) option is `true`. + * @name axis․y2․tick․rotate + * @memberof Options + * @type {number} + * @default 0 + * @example + * axis: { + * y2: { + * tick: { + * rotate: 60 + * } + * } + * } + */ + axis_y2_tick_rotate: 0, + /** + * Set the number of y2 axis ticks. + * - **NOTE:** This works in the same way as axis.y.tick.count. + * @name axis․y2․tick․count + * @memberof Options + * @type {number} + * @default undefined + * @example + * axis: { + * y2: { + * tick: { + * count: 5 + * } + * } + * } + */ + axis_y2_tick_count: void 0, + /** + * Show or hide y2 axis tick line. + * @name axis․y2․tick․show + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.HideTickLineText) + * @example + * axis: { + * y2: { + * tick: { + * show: false + * } + * } + * } + */ + axis_y2_tick_show: true, + /** + * Set axis tick step(interval) size. + * - **NOTE:** Will be ignored if `axis.y2.tick.count` or `axis.y2.tick.values` options are set. + * @name axis․y2․tick․stepSize + * @memberof Options + * @type {number} + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.StepSizeForYAxis) + * @example + * axis: { + * y2: { + * tick: { + * // tick value will step as indicated interval value. + * // ex) 'stepSize=15' ==> [0, 15, 30, 45, 60] + * stepSize: 15 + * } + * } + * } + */ + axis_y2_tick_stepSize: null, + /** + * Show or hide y2 axis tick text. + * @name axis․y2․tick․text․show + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.HideTickLineText) + * @example + * axis: { + * y2: { + * tick: { + * text: { + * show: false + * } + * } + * } + * } + */ + axis_y2_tick_text_show: true, + /** + * Set the y2 Axis tick text's position relatively its original position + * @name axis․y2․tick․text․position + * @memberof Options + * @type {object} + * @default {x: 0, y:0} + * @example + * axis: { + * y2: { + * tick: { + * text: { + * position: { + * x: 10, + * y: 10 + * } + * } + * } + * } + * } + */ + axis_y2_tick_text_position: { x: 0, y: 0 }, + /** + * Set padding for y2 axis.<br><br> + * You can set padding for y2 axis to create more space on the edge of the axis. + * This option accepts object and it can include top and bottom. top, bottom will be treated as pixels. + * + * - **NOTE:** + * - Given values are translated relative to the y2 Axis domain value for padding + * - For area and bar type charts, [area.zerobased](#.area) or [bar.zerobased](#.bar) options should be set to 'false` to get padded bottom. + * @name axis․y2․padding + * @memberof Options + * @type {object|number} + * @default {} + * @example + * axis: { + * y2: { + * padding: { + * top: 100, + * bottom: 100 + * } + * + * // or set both values at once. + * padding: 10 + * } + */ + axis_y2_padding: {}, + /** + * Set default range of y2 axis.<br><br> + * This option set the default value for y2 axis when there is no data on init. + * @name axis․y2․default + * @memberof Options + * @type {Array} + * @default undefined + * @example + * axis: { + * y2: { + * default: [0, 1000] + * } + * } + */ + axis_y2_default: void 0, + /** + * Set additional axes for y2 Axis. + * - **NOTE:** Axis' scale is based on y2 Axis value if domain option isn't set. + * + * Each axis object should consist with following options: + * + * | Name | Type | Default | Description | + * | --- | --- | --- | --- | + * | domain | Array | - | Set the domain value | + * | tick.outer | boolean | true | Show outer tick | + * | tick.format | Function | - | Set formatter for tick text | + * | tick.count | Number | - | Set the number of y axis ticks | + * | tick.values | Array | - | Set tick values manually | + * @name axis․y2․axes + * @memberof Options + * @type {Array} + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.MultiAxes) + * @see [Demo: Domain](https://naver.github.io/billboard.js/demo/#Axis.MultiAxesDomain) + * @example + * y2: { + * axes: [ + * { + * // if set, will not be correlated with the main y2 Axis domain value + * domain: [0, 1000], + * tick: { + * outer: false, + * format: function(x) { + * return x + "%"; + * }, + * count: 2, + * values: [10, 20, 30] + * } + * }, + * ... + * ] + * } + */ + axis_y2_axes: [] +}); + +;// ./src/config/Options/axis/axis.ts +var axis_defProp = Object.defineProperty; +var axis_getOwnPropSymbols = Object.getOwnPropertySymbols; +var axis_hasOwnProp = Object.prototype.hasOwnProperty; +var axis_propIsEnum = Object.prototype.propertyIsEnumerable; +var axis_defNormalProp = (obj, key, value) => key in obj ? axis_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var axis_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (axis_hasOwnProp.call(b, prop)) + axis_defNormalProp(a, prop, b[prop]); + if (axis_getOwnPropSymbols) + for (var prop of axis_getOwnPropSymbols(b)) { + if (axis_propIsEnum.call(b, prop)) + axis_defNormalProp(a, prop, b[prop]); + } + return a; +}; + + + +/* harmony default export */ var axis_axis = (axis_spreadValues(axis_spreadValues(axis_spreadValues({ + /** + * Setup the way to evaluate tick text size. + * - **NOTE:** + * - When setting `false` or a custom evaluator, it is highly recommended to memoize evaluated text dimension value to not degrade performance. + * @name axis․evalTextSize + * @memberof Options + * @type {boolean|function} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.AxisEvalTextSize) + * @example + * axis: { + * // will evaluate getting text size every time. + * evalTextSize: false, + * + * // set a custom evaluator + * evalTextSize: function(textElement, axisId) { + * // set some character to be evaluated + * // NOTE: The dummy textElement is a descendant of given axisId('x', 'y' or 'y2'). + * textElement.textContent = "0"; + * + * // get the size + * const box = textElement.getBBox(); + * + * // clear text + * textElement.textContent = ""; + * + * return { w: 7, h: 12}; + * }, + * + * // set a custom evaluator by returning fixed value + * evalTextSize: function(textElement, axisId) { + * return { + * x: {w: 7, h: 12}, + * y: {w: 15.75, h: 30}, + * y2: {w: 9.5, h: 18} + * }[axisId]; + * } + * } + */ + axis_evalTextSize: true, + /** + * Switch x and y axis position. + * @name axis․rotated + * @memberof Options + * @type {boolean} + * @default false + * @example + * axis: { + * rotated: true + * } + */ + axis_rotated: false, + /** + * Set axis tooltip. + * - **NOTE:** + * - When enabled, will disable default focus grid line. + * - For `timeseries` x Axis, tooltip will be formatted using x Axis' tick format. + * - For `category` x Axis, tooltip will be displaying scales' value text. + * @name axis․tooltip + * @memberof Options + * @type {boolean} + * @default false + * @property {object} axis Axis object + * @property {boolean} [axis.tooltip=false] Show tooltip or not. + * @property {string|object} [axis.tooltip.backgroundColor] Set axis tooltip text background colors. + * @see [Demo](https://naver.github.io/billboard.js/demo/#Axis.AxisTooltip) + * @example + * axis: { + * tooltip: true, // default background color is + * + * // set background color for axis tooltip texts + * tooltip: { + * backgroundColor: "red", + * + * // set different background colors per axes + * // NOTE: In this case, only specified axes tooltip will appear. + * backgroundColor: { + * x: "green", + * y: "yellow", + * y2: "red" + * } + * } + * } + */ + axis_tooltip: false +}, axis_x), y), y2)); + +;// ./src/config/Options/common/grid.ts +/* harmony default export */ var common_grid = ({ + /** + * Set related options + * @name grid + * @memberof Options + * @type {object} + * @property {boolean} [front=false] Set 'grid & focus lines' to be positioned over grid lines and chart elements. + * @property {object} x Grid x object + * @property {boolean} [x.show=false] Show grids along x axis. + * @property {Array} [x.lines=[]] Show additional grid lines along x axis.<br> + * This option accepts array including object that has value, text, position and class. text, position and class are optional. For position, start, middle and end (default) are available. + * If x axis is category axis, value can be category name. If x axis is timeseries axis, value can be date string, Date object and unixtime integer. + * @property {object} y Grid y object + * @property {boolean} [y.show=false] Show grids along x axis. + * @property {Array} [y.lines=[]] Show additional grid lines along y axis.<br> + * This option accepts array including object that has value, text, position and class. + * @property {number} [y.ticks=undefined] Number of y grids to be shown. + * @property {object} focus Grid focus object + * @property {boolean} [focus.edge=false] Show edged focus grid line.<br>**NOTE:** Available when [`tooltip.grouped=false`](#.tooltip) option is set. + * @property {boolean} [focus.show=true] Show grid line when focus. + * @property {boolean} [focus.y=false] Show y coordinate focus grid line.<br>**NOTE:** Available when [`tooltip.grouped=false`](#.tooltip) option is set. + * @property {object} lines Grid lines object + * @property {boolean} [lines.front=true] Set grid lines to be positioned over chart elements. + * @default undefined + * @see [Demo](https://naver.github.io/billboard.js/demo/#Grid.GridLines) + * @see [Demo: X Grid Lines](https://naver.github.io/billboard.js/demo/#Grid.OptionalXGridLines) + * @see [Demo: Y Grid Lines](https://naver.github.io/billboard.js/demo/#Grid.OptionalYGridLines) + * @example + * grid: { + * x: { + * show: true, + * lines: [ + * {value: 2, text: "Label on 2"}, + * {value: 5, text: "Label on 5", class: "label-5"}, + * {value: 6, text: "Label on 6", position: "start"} + * ] + * }, + * y: { + * show: true, + * lines: [ + * {value: 100, text: "Label on 100"}, + * {value: 200, text: "Label on 200", class: "label-200"}, + * {value: 300, text: "Label on 300", position: 'middle'} + * ], + * ticks: 5 + * }, + * front: true, + * focus: { + * show: false, + * + * // Below options are available when 'tooltip.grouped=false' option is set + * edge: true, + * y: true + * }, + * lines: { + * front: false + * } + * } + */ + grid_x_show: false, + grid_x_type: "tick", + grid_x_lines: [], + grid_y_show: false, + grid_y_lines: [], + grid_y_ticks: void 0, + grid_focus_edge: false, + grid_focus_show: true, + grid_focus_y: false, + grid_front: false, + grid_lines_front: true +}); + +;// ./src/config/Options/data/axis.ts +/* harmony default export */ var data_axis = ({ + /** + * Specify the keys of the x values for each data.<br><br> + * This option can be used if we want to show the data that has different x values. + * @name data․xs + * @memberof Options + * @type {object} + * @default {} + * @example + * data: { + * xs: { + * data1: "x1", + * data2: "x2" + * } + * } + */ + data_xs: {}, + /** + * Set a format specifier to parse string specified as x. + * @name data․xFormat + * @memberof Options + * @type {string} + * @default %Y-%m-%d + * @example + * data: { + * x: "x", + * columns: [ + * ["x", "01012019", "02012019", "03012019"], + * ["data1", 30, 200, 100] + * ], + * // Format specifier to parse as datetime for given 'x' string value + * xFormat: "%m%d%Y" + * }, + * axis: { + * x: { + * type: "timeseries" + * } + * } + * @see [D3's time specifier](https://d3js.org/d3-time-format#locale_format) + */ + data_xFormat: "%Y-%m-%d", + /** + * Set localtime format to parse x axis. + * @name data․xLocaltime + * @memberof Options + * @type {boolean} + * @default true + * @example + * data: { + * xLocaltime: false + * } + */ + data_xLocaltime: true, + /** + * Sort on x axis. + * - **NOTE:** This option works for lineish(area/line/spline/step) types only. + * @name data․xSort + * @memberof Options + * @type {boolean} + * @default true + * @see [Demo](https://naver.github.io/billboard.js/demo/#Data.DataXSort) + * @example + * data: { + * xSort: false, + * x: "x", + * columns: [ + * // The line graph will start to be drawn following the x axis sequence + * // Below data, will start drawing x=1: 200, x=2: 300, x=3: 100 + * ["x", 3, 1, 2], + * ["data1", 100, 200, 300] + * ] + * } + */ + data_xSort: true, + /** + * Set y axis the data related to. y and y2 can be used. + * - **NOTE:** If all data is related to one of the axes, the domain of axis without related data will be replaced by the domain from the axis with related data + * @name data․axes + * @memberof Options + * @type {object} + * @default {} + * @example + * data: { + * axes: { + * data1: "y", + * data2: "y2" + * } + * } + */ + data_axes: {}, + /** + * Define regions for each data.<br> + * The values must be an array for each data and it should include an object that has `start`, `end` and `style`. + * - The object type should be as: + * - start {number}: Start data point number. If not set, the start will be the first data point. + * - [end] {number}: End data point number. If not set, the end will be the last data point. + * - [style.dasharray="2 2"] {string}: The first number specifies a distance for the filled area, and the second a distance for the unfilled area. + * - **NOTE:** + * - Supports only line type. + * - `start` and `end` values should be in the exact x value range. + * - Dashes will be applied using `stroke-dasharray` css property when data doesn't contain nullish value(or nullish value with `line.connectNull=true` set). + * - Dashes will be applied via path command when data contains nullish value. + * @name data․regions + * @memberof Options + * @type {object} + * @default {} + * @example + * data: { + * regions: { + * data1: [{ + * start: 1, + * end: 2, + * style: { + * dasharray: "5 2" + * } + * }, { + * start: 3 + * }], + * ... + * } + * } + */ + data_regions: {}, + /** + * Set the stacking to be normalized + * - **NOTE:** + * - For stacking, '[data.groups](#.data%25E2%2580%25A4groups)' option should be set + * - y Axis will be set in percentage value (0 ~ 100%) + * - Must have positive values + * - Data not in any group will not be normalized when using perGroup option + * @name data․stack․normalize + * @memberof Options + * @type {boolean|object} + * @default false + * @see [Demo: Data Stack Normalized](https://naver.github.io/billboard.js/demo/#Data.DataStackNormalized) + * @see [Demo: Data Stack Normalized per Group](https://naver.github.io/billboard.js/demo/#Data.DataStackNormalizedGroup) + * @example + * data: { + * stack: { + * // Normalize all grouped data together (all groups combined to 0-100%) + * normalize: true + * + * // Normalize per group (each group independently becomes 0-100%) + * // Data not in any group will display with their original values. + * // If non-grouped data shares the same axis (e.g., y), it will be + * // displayed on the 0-100 absolute scale. To display original values, + * // assign them to a separate axis (e.g., y2). + * normalize: { + * perGroup: true + * } + * }, + * groups: [ + * ["data1", "data2"] // This group will be normalized to 0-100% + * ], + * // data3 is not in any group, so it displays original values + * // Assign it to y2 axis to use a separate scale + * axes: { + * data3: "y2" + * } + * }, + * axis: { + * y2: { + * show: true + * } + * } + */ + data_stack_normalize: false +}); + +;// ./src/config/resolver/axis.ts + + + + + + + + + + + + + + + + + +const api = [ + api_axis, + api_category, + flow, + api_grid, + group, + api_regions, + x +]; +const internal = { + axis: Axis, + clip: clip, + eventrect: eventrect, + flow: interactions_flow, + grid: internals_grid, + region: region, + sizeAxis: size_axis +}; +const options = { + optDataAxis: data_axis, + optAxis: axis_axis, + optGrid: common_grid +}; + +// EXTERNAL MODULE: external {"commonjs":"d3-interpolate","commonjs2":"d3-interpolate","amd":"d3-interpolate","root":"d3"} +var external_commonjs_d3_interpolate_commonjs2_d3_interpolate_amd_d3_interpolate_root_d3_ = __webpack_require__(13); +;// ./src/ChartInternal/internals/text.arc.ts + + + + +const BREAK_POINT_OFFSET = 15; +const DEFAULT_LINE_DISTANCE = 20; +const TEXT_VERTICAL_OFFSET = 0.35; +function getArcType(excludeMultiGauge = false) { + const $$ = this; + return ["donut", "pie", "polar", "gauge"].find( + (type) => $$.hasType(type) && !(type === "gauge" && excludeMultiGauge && $$.hasMultiArcGauge()) + ); +} +function getConfig() { + const $$ = this; + const { config } = $$; + const chartType = getArcType.call($$, true); + const lineConfig = chartType && config[`${chartType}_label_line`]; + const isValidConfig = isObjectType(lineConfig); + const defaultFormatter = (value, ratio, id) => id; + const line = { + show: lineConfig === true || isValidConfig && (lineConfig == null ? void 0 : lineConfig.show) !== false, + distance: isValidConfig && (lineConfig == null ? void 0 : lineConfig.distance) || DEFAULT_LINE_DISTANCE + }; + if (lineConfig === true) { + return { + chartType, + line, + text: { formatter: defaultFormatter } + }; + } + if (!isValidConfig) { + return { + chartType, + line: { show: false, distance: DEFAULT_LINE_DISTANCE }, + text: { formatter: null } + }; + } + let formatter = defaultFormatter; + if (isFunction(lineConfig.text)) { + formatter = lineConfig.text; + } else if (lineConfig.text === false) { + formatter = null; + } + return { + chartType, + line, + text: { formatter } + }; +} +function getLinePosition(d, lineDistance) { + const $$ = this; + const { state } = $$; + const updated = $$.updateAngle(d); + if (!updated) { + return null; + } + let { outerRadius } = $$.getRadius(d); + let arcOuterRadius = outerRadius; + if ($$.hasType("polar")) { + arcOuterRadius = $$.getPolarOuterRadius(d, outerRadius); + outerRadius = state.radius; + } + let midAngle = (updated.startAngle + updated.endAngle) / 2; + const isFullCircleArc = Math.abs(updated.endAngle - updated.startAngle - 2 * Math.PI) < 0.01; + if (isFullCircleArc) { + midAngle = Math.PI / 2; + } + const sinAngle = Math.sin(midAngle); + const cosAngle = -Math.cos(midAngle); + const startPoint = { + x: sinAngle * arcOuterRadius, + y: cosAngle * arcOuterRadius + }; + const breakRadius = outerRadius + BREAK_POINT_OFFSET; + const breakPoint = { + x: sinAngle * breakRadius, + y: cosAngle * breakRadius + }; + const isRight = sinAngle >= 0; + const endPoint = { + x: breakPoint.x + lineDistance * (isRight ? 1 : -1), + y: breakPoint.y + }; + return { startPoint, breakPoint, endPoint, isRight, midAngle }; +} +function isLabelWithLine() { + return getConfig.call(this).line.show; +} +function redrawArcLabelLines(duration) { + const $$ = this; + const { $el: { arcs }, $T } = $$; + const { line: lineConfig, text: textConfig } = getConfig.call($$); + const lineDistance = lineConfig.distance; + let cachedFontSize = null; + arcs.selectAll(`.${$ARC.chartArc}`).each(function(d) { + var _a, _b, _c; + const g = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const linePos = getLinePosition.call($$, d, lineDistance); + const { ratio, meetsThreshold, updated } = (_a = d._cache) != null ? _a : {}; + if (!updated || !linePos) { + return; + } + const isVisible = $$.isTargetToShow(d.data.id) && meetsThreshold; + const { startPoint, breakPoint, endPoint, isRight } = linePos; + const points = `${startPoint.x},${startPoint.y} ${breakPoint.x},${breakPoint.y} ${endPoint.x},${endPoint.y}`; + if (lineConfig.show) { + let line = g.select(`.${$ARC.arcLabelLine}`); + if (line.empty()) { + line = g.append("polyline").attr("class", $ARC.arcLabelLine); + } + $T(line, duration).attr("points", points).style("stroke", $$.color(d.data)).style("opacity", isVisible ? null : "0"); + } + let labelLineText = g.select(`.${$ARC.arcLabelLineText}`); + if (labelLineText.empty()) { + labelLineText = g.append("text").attr("class", $ARC.arcLabelLineText).style("pointer-events", "none"); + } + if (isVisible) { + const { value } = updated; + const { id } = d.data; + const text = ((_c = (_b = textConfig.formatter) != null ? _b : $$.getArcLabelConfig("format")) != null ? _c : $$.defaultArcValueFormat)(value, ratio, id).toString(); + setTextValue(labelLineText, text, [-1, 1], false); + const pos = { + x: endPoint.x + 5 * (isRight ? 1 : -1), + // 5: label offset from endpoint + y: endPoint.y + }; + labelLineText.style("text-anchor", isRight ? "start" : "end"); + const textNode = labelLineText.node(); + const tspanNodes = textNode == null ? void 0 : textNode.querySelectorAll("tspan"); + if (cachedFontSize === null) { + cachedFontSize = parseFloat(win.getComputedStyle(textNode).fontSize) || 12; + } + if (tspanNodes && tspanNodes.length > 1) { + const lineCount = tspanNodes.length; + const centerOffset = (lineCount - 3) / 2; + pos.y += (-centerOffset + TEXT_VERTICAL_OFFSET) * cachedFontSize; + } else { + pos.y += TEXT_VERTICAL_OFFSET * cachedFontSize; + } + $T(labelLineText, duration).attr("transform", `translate(${pos.x},${pos.y})`).style("opacity", null).style("fill", $$.updateTextColor.bind($$)(d)); + } else { + $T(labelLineText, duration).style("opacity", "0"); + } + }); +} + + +;// ./src/ChartInternal/shape/arc.ts +var arc_defProp = Object.defineProperty; +var arc_defProps = Object.defineProperties; +var arc_getOwnPropDescs = Object.getOwnPropertyDescriptors; +var arc_getOwnPropSymbols = Object.getOwnPropertySymbols; +var arc_hasOwnProp = Object.prototype.hasOwnProperty; +var arc_propIsEnum = Object.prototype.propertyIsEnumerable; +var arc_defNormalProp = (obj, key, value) => key in obj ? arc_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var arc_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (arc_hasOwnProp.call(b, prop)) + arc_defNormalProp(a, prop, b[prop]); + if (arc_getOwnPropSymbols) + for (var prop of arc_getOwnPropSymbols(b)) { + if (arc_propIsEnum.call(b, prop)) + arc_defNormalProp(a, prop, b[prop]); + } + return a; +}; +var arc_spreadProps = (a, b) => arc_defProps(a, arc_getOwnPropDescs(b)); + + + + + + + + +function _getArcType($$) { + return ["donut", "pie", "polar", "gauge"].find((type) => $$.hasType(type)); +} +function _calculateRangeOrGaugePosition($$, d, updated, forRange) { + var _a, _b; + const { config, state: { radiusExpanded } } = $$; + const angle = updated.endAngle - Math.PI / 2; + const sinAngle = Math.sin(angle); + const pos = { + x: Math.cos(angle) * (radiusExpanded + (forRange ? 5 : 25)), + // 5: range offset, 25: gauge offset + y: sinAngle * (radiusExpanded + 15 - Math.abs(sinAngle * 10)) + 3 + // 10: y factor, 3: y offset + }; + if (forRange) { + const rangeTextPosition = config.arc_rangeText_position; + if (rangeTextPosition) { + const rangeValues = config.arc_rangeText_values; + const position = isFunction(rangeTextPosition) ? rangeTextPosition(rangeValues[d.index]) : rangeTextPosition; + pos.x += (_a = position == null ? void 0 : position.x) != null ? _a : 0; + pos.y += (_b = position == null ? void 0 : position.y) != null ? _b : 0; + } + } + return pos; +} +function _calculateLabelRatio($$, d, outerRadius, distance) { + const { config } = $$; + const chartType = _getArcType($$); + let ratio = chartType ? config[`${chartType}_label_ratio`] : void 0; + if (ratio) { + ratio = isFunction(ratio) ? ratio.bind($$.api)(d, outerRadius, distance) : ratio; + } else { + const LABEL_MIN_SIZE = 36; + const LABEL_RATIO_THRESHOLD = 0.375; + const LABEL_RATIO_BASE = 1.175; + const LABEL_RATIO_LARGE = 0.8; + const labelSpaceRatio = LABEL_MIN_SIZE / outerRadius; + const isSmallChart = labelSpaceRatio > LABEL_RATIO_THRESHOLD; + ratio = outerRadius && distance ? (isSmallChart ? LABEL_RATIO_BASE - labelSpaceRatio : LABEL_RATIO_LARGE) * outerRadius / distance : 0; + } + return ratio; +} +function _calculateStandardArcPosition($$, d, updated) { + let { outerRadius } = $$.getRadius(d); + if ($$.hasType("polar")) { + outerRadius = $$.getPolarOuterRadius(d, outerRadius); + } + const [x, y] = $$.svgArc.centroid(updated).map((v) => isNaN(v) ? 0 : v); + const distance = Math.sqrt(x * x + y * y); + const ratio = _calculateLabelRatio($$, d, outerRadius, distance); + return { + pos: { x, y }, + ratio + }; +} +function _getRadiusFn(expandRate = 0) { + const $$ = this; + const { config, state } = $$; + const hasMultiArcGauge = $$.hasMultiArcGauge(); + const singleArcWidth = state.gaugeArcWidth / $$.filterTargetsToShow($$.data.targets).length; + const expandWidth = expandRate ? Math.min( + state.radiusExpanded * expandRate - state.radius, + singleArcWidth * 0.8 - (1 - expandRate) * 100 + ) : 0; + return { + /** + * Getter of arc innerRadius value + * @param {IArcData} d Data object + * @returns {number} innerRadius value + * @private + */ + inner(d) { + const { innerRadius } = $$.getRadius(d); + return hasMultiArcGauge ? state.radius - singleArcWidth * (d.index + 1) : isNumber(innerRadius) ? innerRadius : 0; + }, + /** + * Getter of arc outerRadius value + * @param {IArcData} d Data object + * @returns {number} outerRadius value + * @private + */ + outer(d) { + const { outerRadius } = $$.getRadius(d); + let radius; + if (hasMultiArcGauge) { + radius = state.radius - singleArcWidth * d.index + expandWidth; + } else if ($$.hasType("polar") && !expandRate) { + radius = $$.getPolarOuterRadius(d, outerRadius); + } else { + radius = outerRadius; + if (expandRate) { + let { radiusExpanded } = state; + if (state.radius !== outerRadius) { + radiusExpanded -= Math.abs(state.radius - outerRadius); + } + radius = radiusExpanded * expandRate; + } + } + return radius; + }, + /** + * Getter of arc cornerRadius value + * @param {IArcData} d Data object + * @param {number} outerRadius outer radius value + * @returns {number} cornerRadius value + * @private + */ + corner(d, outerRadius) { + const { + arc_cornerRadius_ratio: ratio = 0, + arc_cornerRadius: cornerRadius = 0 + } = config; + const { data: { id }, value } = d; + let corner = 0; + if (ratio) { + corner = ratio * outerRadius; + } else { + corner = isNumber(cornerRadius) ? cornerRadius : cornerRadius.call($$.api, id, value, outerRadius); + } + return corner; + } + }; +} +function _getAttrTweenFn(fn) { + return function(d) { + const getAngleKeyValue = ({ startAngle = 0, endAngle = 0, padAngle = 0 }) => ({ + startAngle, + endAngle, + padAngle + }); + const interpolate = (0,external_commonjs_d3_interpolate_commonjs2_d3_interpolate_amd_d3_interpolate_root_d3_.interpolate)( + getAngleKeyValue(this._current), + getAngleKeyValue(d) + ); + this._current = d; + return function(t) { + const interpolated = interpolate(t); + const { data, index, value } = d; + return fn(arc_spreadProps(arc_spreadValues({}, interpolated), { data, index, value })); + }; + }; +} +/* harmony default export */ var arc = ({ + initPie() { + const $$ = this; + const { config } = $$; + const dataType = config.data_type; + const padding = config[`${dataType}_padding`]; + const startingAngle = config[`${dataType}_startingAngle`] || 0; + const padAngle = (padding ? padding * 0.01 : config[`${dataType}_padAngle`]) || 0; + $$.pie = (0,external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.pie)().startAngle(startingAngle).endAngle(startingAngle + 2 * Math.PI).padAngle(padAngle).value((d) => { + var _a, _b; + return (_b = (_a = d.values) == null ? void 0 : _a.reduce((a, b) => a + b.value, 0)) != null ? _b : d; + }).sort($$.getSortCompareFn.bind($$)(true)); + }, + updateRadius() { + const $$ = this; + const { config, state } = $$; + const dataType = config.data_type; + const padding = config[`${dataType}_padding`]; + const w = config.gauge_width || config.donut_width; + const gaugeArcWidth = $$.filterTargetsToShow($$.data.targets).length * config.gauge_arcs_minWidth; + const LABEL_RADIUS_RATIO = 0.85; + const labelWithLineRatio = isLabelWithLine.call($$) ? LABEL_RADIUS_RATIO : 1; + state.radiusExpanded = Math.min(state.arcWidth, state.arcHeight) / 2 * ($$.hasMultiArcGauge() && config.gauge_label_show ? LABEL_RADIUS_RATIO : labelWithLineRatio); + state.radius = state.radiusExpanded * 0.95; + state.innerRadiusRatio = w ? (state.radius - w) / state.radius : 0.6; + state.gaugeArcWidth = w || (gaugeArcWidth <= state.radius - state.innerRadius ? state.radius - state.innerRadius : gaugeArcWidth <= state.radius ? gaugeArcWidth : state.radius); + const innerRadius = config.pie_innerRadius || (padding ? padding * (state.innerRadiusRatio + 0.1) : 0); + state.outerRadius = config.pie_outerRadius; + state.innerRadius = $$.hasType("donut") || $$.hasType("gauge") ? state.radius * state.innerRadiusRatio : innerRadius; + }, + /** + * Get pie's inner & outer radius value + * @param {object|undefined} d Data object + * @returns {object} + * @private + */ + getRadius(d) { + const $$ = this; + const data = d == null ? void 0 : d.data; + let { innerRadius, outerRadius } = $$.state; + if (!isNumber(innerRadius) && data) { + innerRadius = innerRadius[data.id] || 0; + } + if (isObject(outerRadius) && data && data.id in outerRadius) { + outerRadius = outerRadius[data.id]; + } else if (!isNumber(outerRadius)) { + outerRadius = $$.state.radius; + } + return { innerRadius, outerRadius }; + }, + updateArc() { + const $$ = this; + $$.updateRadius(); + $$.svgArc = $$.getSvgArc(); + $$.svgArcExpanded = $$.getSvgArcExpanded(); + }, + getArcLength() { + const $$ = this; + const { config } = $$; + const arcLengthInPercent = config.gauge_arcLength * 3.6; + let len = 2 * (arcLengthInPercent / 360); + if (arcLengthInPercent < -360) { + len = -2; + } else if (arcLengthInPercent > 360) { + len = 2; + } + return len * Math.PI; + }, + getStartingAngle() { + const $$ = this; + const { config } = $$; + const dataType = config.data_type; + const isFullCircle = $$.hasType("gauge") ? config.gauge_fullCircle : false; + const defaultStartAngle = -1 * Math.PI / 2; + const defaultEndAngle = Math.PI / 2; + let startAngle = config[`${dataType}_startingAngle`] || 0; + if (!isFullCircle && startAngle <= defaultStartAngle) { + startAngle = defaultStartAngle; + } else if (!isFullCircle && startAngle >= defaultEndAngle) { + startAngle = defaultEndAngle; + } else if (startAngle > Math.PI || startAngle < -1 * Math.PI) { + startAngle = Math.PI; + } + return startAngle; + }, + /** + * Update angle data + * @param {object} dValue Data object + * @param {boolean} forRange Weather is for ranged text option(arc.rangeText.values) + * @returns {object|null} Updated angle data + * @private + */ + updateAngle(dValue, forRange = false) { + var _a; + const $$ = this; + const { config, state } = $$; + const hasGauge = forRange && $$.hasType("gauge"); + let { pie } = $$; + let d = dValue; + let found = false; + if (!config) { + return null; + } + const gStart = $$.getStartingAngle(); + const radius = config.gauge_fullCircle || forRange && !hasGauge ? $$.getArcLength() : gStart * -2; + if (d.data && $$.isGaugeType(d.data) && !$$.hasMultiArcGauge()) { + const { gauge_min: gMin, gauge_max: gMax } = config; + const totalSum = $$.getTotalDataSum(state.rendered); + const gEnd = radius * ((totalSum - gMin) / (gMax - gMin)); + pie = pie.startAngle(gStart).endAngle(gEnd + gStart); + } + if (forRange === false) { + pie($$.filterTargetsToShow()).forEach((t, i) => { + var _a2; + if (!found && t.data.id === ((_a2 = d.data) == null ? void 0 : _a2.id)) { + found = true; + d = t; + d.index = i; + } + }); + } + if (isNaN(d.startAngle)) { + d.startAngle = 0; + } + if (isNaN(d.endAngle)) { + d.endAngle = d.startAngle; + } + if (forRange || d.data && (config.gauge_enforceMinMax || $$.hasMultiArcGauge())) { + const { gauge_min: gMin, gauge_max: gMax } = config; + const max = forRange && !hasGauge ? $$.getTotalDataSum(state.rendered) : gMax; + const gTic = radius / (max - gMin); + const value = (_a = d.value) != null ? _a : 0; + const gValue = value < gMin ? 0 : value < max ? value - gMin : max - gMin; + d.startAngle = gStart; + d.endAngle = gStart + gTic * gValue; + } + return found || forRange ? d : null; + }, + getSvgArc() { + const $$ = this; + const { inner, outer, corner } = _getRadiusFn.call($$); + const arc = (0,external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.arc)().innerRadius(inner).outerRadius(outer); + const newArc = function(d, withoutUpdate) { + var _a; + let path = "M 0 0"; + if (d.value || d.data) { + const data = withoutUpdate ? d : (_a = $$.updateAngle(d)) != null ? _a : null; + if (data) { + path = arc.cornerRadius( + corner(data, outer(data)) + )(data); + } + } + return path; + }; + newArc.centroid = arc.centroid; + return newArc; + }, + /** + * Get expanded arc path function + * @param {number} rate Expand rate + * @returns {function} Expanded arc path getter function + * @private + */ + getSvgArcExpanded(rate = 1) { + const $$ = this; + const { inner, outer, corner } = _getRadiusFn.call($$, rate); + const arc = (0,external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.arc)().innerRadius(inner).outerRadius(outer); + return (d) => { + const updated = $$.updateAngle(d); + const outerR = outer(updated); + let cornerR = 0; + if (updated) { + cornerR = corner(updated, outerR); + } + return updated ? arc.cornerRadius(cornerR)(updated) : "M 0 0"; + }; + }, + getArc(d, withoutUpdate, force) { + return force || this.isArcType(d.data) ? this.svgArc(d, withoutUpdate) : "M 0 0"; + }, + /** + * Render range value text + * @private + */ + redrawArcRangeText() { + const $$ = this; + const { config, $el: { arcs }, state, $T } = $$; + const format = config.arc_rangeText_format; + const fixed = $$.hasType("gauge") && config.arc_rangeText_fixed; + let values = config.arc_rangeText_values; + if (values == null ? void 0 : values.length) { + const isPercent = config.arc_rangeText_unit === "%"; + const totalSum = $$.getTotalDataSum(state.rendered); + if (isPercent) { + values = values.map((v) => totalSum / 100 * v); + } + const pieData = $$.pie(values).map((d, i) => (d.index = i, d)); + let rangeText = arcs.selectAll(`.${$ARC.arcRange}`).data(values); + rangeText.exit(); + rangeText = $T(rangeText.enter().append("text").attr("class", $ARC.arcRange).style("text-anchor", "middle").style("pointer-events", "none").style("opacity", "0").text((v) => { + const range = isPercent ? v / totalSum * 100 : v; + return isFunction(format) ? format(range) : `${range}${isPercent ? "%" : ""}`; + }).merge(rangeText)); + if ((!state.rendered || state.rendered && !fixed) && totalSum > 0) { + rangeText.attr("transform", function(d, i) { + return $$.transformForArcLabel(this, pieData[i], true); + }); + } + rangeText.style( + "opacity", + (d) => !fixed && (d > totalSum || totalSum === 0) ? "0" : null + ); + } + }, + /** + * Set transform attributes to arc label text + * @param {SVGTextElement} textNode Text node element + * @param {object} d Data object + * @param {boolean} forRange Weather is for ranged text option(arc.rangeText.values) + * @returns {string} Translate attribute string + * @private + */ + transformForArcLabel(textNode, d, forRange = false) { + const $$ = this; + const updated = $$.updateAngle(d, forRange); + if (!updated) { + return ""; + } + let pos; + let ratio = 1; + if (forRange || $$.hasMultiArcGauge()) { + pos = _calculateRangeOrGaugePosition($$, d, updated, forRange); + } else if (!$$.hasType("gauge") || $$.data.targets.length > 1) { + const result = _calculateStandardArcPosition($$, d, updated); + pos = result.pos; + ratio = result.ratio; + } else { + return ""; + } + updateTextImagePos.call($$, textNode, pos); + return `translate(${pos.x * ratio},${pos.y * ratio})`; + }, + convertToArcData(d) { + return this.addName({ + id: "data" in d ? d.data.id : d.id, + value: d.value, + ratio: this.getRatio("arc", d), + index: d.index + }); + }, + textForArcLabel(selection) { + var _a; + const $$ = this; + const hasGauge = $$.hasType("gauge"); + const chartType = (_a = ["donut", "gauge", "pie", "polar"].filter($$.hasType.bind($$))) == null ? void 0 : _a[0]; + if ($$.shouldShowArcLabel()) { + selection.style("fill", $$.updateTextColor.bind($$)).attr("filter", (d) => $$.updateTextBGColor.bind($$)(d, $$.config.data_labels_backgroundColors)).each(function(d) { + const node = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const updated = $$.updateAngle(d); + const ratio = $$.getRatio("arc", updated); + const meetsThreshold = meetsLabelThreshold.call($$, ratio, chartType); + d._cache = { updated, ratio, meetsThreshold }; + if (meetsThreshold) { + const { value } = updated || d; + const text = ($$.getArcLabelConfig("format") || $$.defaultArcValueFormat)(value, ratio, d.data.id).toString(); + setTextValue(node, text, [-1, 1], hasGauge); + } else { + node.text(""); + } + }); + } + }, + expandArc(targetIds) { + const $$ = this; + const { state: { transiting }, $el } = $$; + if (transiting) { + const interval = setInterval(() => { + if (!transiting) { + clearInterval(interval); + $el.legend.selectAll(`.${$FOCUS.legendItemFocused}`).size() > 0 && $$.expandArc(targetIds); + } + }, 10); + return; + } + const newTargetIds = $$.mapToTargetIds(targetIds); + $el.svg.selectAll($$.selectorTargets(newTargetIds, `.${$ARC.chartArc}`)).each(function(d) { + if (!$$.shouldExpand(d.data.id)) { + return; + } + const expandDuration = $$.getExpandConfig(d.data.id, "duration"); + const svgArcExpandedSub = $$.getSvgArcExpanded( + $$.getExpandConfig(d.data.id, "rate") + ); + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).selectAll("path").transition().duration(expandDuration).attrTween("d", _getAttrTweenFn($$.svgArcExpanded.bind($$))).transition().duration(expandDuration * 2).attrTween("d", _getAttrTweenFn(svgArcExpandedSub.bind($$))); + }); + }, + unexpandArc(targetIds) { + const $$ = this; + const { state: { transiting }, $el: { svg } } = $$; + if (transiting) { + return; + } + const newTargetIds = $$.mapToTargetIds(targetIds); + svg.selectAll($$.selectorTargets(newTargetIds, `.${$ARC.chartArc}`)).selectAll("path").transition().duration((d) => $$.getExpandConfig(d.data.id, "duration")).attrTween("d", _getAttrTweenFn($$.svgArc.bind($$))); + svg.selectAll(`${$ARC.arc}`).style("opacity", null); + }, + /** + * Get expand config value + * @param {string} id data ID + * @param {string} key config key: 'duration | rate' + * @returns {number} + * @private + */ + getExpandConfig(id, key) { + const $$ = this; + const { config } = $$; + const def = { + duration: 50, + rate: 0.98 + }; + let type; + if ($$.isDonutType(id)) { + type = "donut"; + } else if ($$.isGaugeType(id)) { + type = "gauge"; + } else if ($$.isPieType(id)) { + type = "pie"; + } + return type ? config[`${type}_expand_${key}`] : def[key]; + }, + shouldExpand(id) { + const $$ = this; + const { config } = $$; + return $$.isDonutType(id) && config.donut_expand || $$.isGaugeType(id) && config.gauge_expand || $$.isPieType(id) && config.pie_expand; + }, + shouldShowArcLabel() { + const $$ = this; + const { config } = $$; + return ["donut", "gauge", "pie", "polar"].some((v) => $$.hasType(v) && config[`${v}_label_show`]); + }, + getArcLabelConfig(name = "format") { + const $$ = this; + const { config } = $$; + let fn = (v) => v; + ["donut", "gauge", "pie", "polar"].filter($$.hasType.bind($$)).forEach((v) => { + fn = config[`${v}_label_${name}`]; + }); + if (name === "format") { + return isFunction(fn) ? fn.bind($$.api) : fn; + } else { + return fn; + } + }, + updateTargetsForArc(targets) { + const $$ = this; + const { $el } = $$; + const hasGauge = $$.hasType("gauge"); + const classChartArc = $$.getChartClass("Arc"); + const classArcs = $$.getClass("arcs", true); + const classFocus = $$.classFocus.bind($$); + const chartArcs = $el.main.select(`.${$ARC.chartArcs}`); + const mainPieUpdate = chartArcs.selectAll(`.${$ARC.chartArc}`).data($$.pie(targets)).attr("class", (d) => classChartArc(d) + classFocus(d.data)); + const mainPieEnter = mainPieUpdate.enter().append("g").attr("class", classChartArc).call( + this.setCssRule(false, `.${$ARC.chartArcs} text`, [ + "pointer-events:none", + "text-anchor:middle" + ]) + ); + mainPieEnter.append("g").attr("class", classArcs).merge(mainPieUpdate); + mainPieEnter.append("text").attr("dy", hasGauge && !$$.hasMultiTargets() ? "-.1em" : null).style("opacity", "0").style("text-anchor", $$.getStylePropValue("middle")).style("pointer-events", $$.getStylePropValue("none")); + $el.text = chartArcs.selectAll(`.${$COMMON.target} text`); + }, + initArc() { + const $$ = this; + const { $el } = $$; + $el.arcs = $el.main.select(`.${$COMMON.chart}`).append("g").attr("class", $ARC.chartArcs).attr("transform", $$.getTranslate("arc")); + $$.setArcTitle(); + }, + /** + * Set arc title text + * @param {string} str Title text + * @private + */ + setArcTitle(str) { + const $$ = this; + const title = str || $$.getArcTitle(); + const hasGauge = $$.hasType("gauge"); + if (title) { + const className = hasGauge ? $GAUGE.chartArcsGaugeTitle : $ARC.chartArcsTitle; + let text = $$.$el.arcs.select(`.${className}`); + if (text.empty()) { + text = $$.$el.arcs.append("text").attr("class", className).style("text-anchor", "middle"); + } + hasGauge && text.attr("dy", "-0.3em"); + setTextValue(text, title, hasGauge ? void 0 : [-0.6, 1.35], true); + } + }, + /** + * Return arc title text + * @returns {string} Arc title text + * @private + */ + getArcTitle() { + const $$ = this; + const type = $$.hasType("donut") && "donut" || $$.hasType("gauge") && "gauge"; + return type ? $$.config[`${type}_title`] : ""; + }, + /** + * Get arc title text with needle value + * @returns {string|boolean} When title contains needle template string will return processed string, otherwise false + * @private + */ + getArcTitleWithNeedleValue() { + const $$ = this; + const { config, state } = $$; + const title = $$.getArcTitle(); + if (title && $$.config.arc_needle_show && /{=[A-Z_]+}/.test(title)) { + let value = state.current.needle; + if (!isNumber(value)) { + value = config.arc_needle_value; + } + return tplProcess(title, { + NEEDLE_VALUE: ~~value + }); + } + return false; + }, + redrawArc(duration, durationForExit, withTransform) { + const $$ = this; + const { config, state, $el: { main } } = $$; + const hasInteraction = config.interaction_enabled; + const isSelectable = hasInteraction && config.data_selection_isselectable; + let mainArc = main.selectAll(`.${$ARC.arcs}`).selectAll(`.${$ARC.arc}`).data($$.arcData.bind($$)); + mainArc.exit().transition().duration(durationForExit).style("opacity", "0").remove(); + mainArc = mainArc.enter().append("path").attr("class", $$.getClass("arc", true)).style("fill", (d) => $$.color(d.data)).style("cursor", (d) => { + var _a; + return ((_a = isSelectable == null ? void 0 : isSelectable.bind) == null ? void 0 : _a.call(isSelectable, $$.api)(d)) ? "pointer" : null; + }).style("opacity", "0").each(function(d) { + if ($$.isGaugeType(d.data)) { + d.startAngle = config.gauge_startingAngle; + d.endAngle = config.gauge_startingAngle; + } + this._current = d; + }).merge(mainArc); + if ($$.hasType("gauge")) { + $$.updateGaugeMax(); + $$.hasMultiArcGauge() && $$.redrawArcGaugeLine(); + } + mainArc.attr("transform", (d) => !$$.isGaugeType(d.data) && withTransform ? "scale(0)" : "").style("opacity", function(d) { + return d === this._current ? "0" : null; + }).each(() => { + state.transiting = true; + }).transition().duration(duration).attrTween("d", function(d) { + const updated = $$.updateAngle(d); + if (!updated) { + return () => "M 0 0"; + } + if (isNaN(this._current.startAngle)) { + this._current.startAngle = 0; + } + if (isNaN(this._current.endAngle)) { + this._current.endAngle = this._current.startAngle; + } + const interpolate = (0,external_commonjs_d3_interpolate_commonjs2_d3_interpolate_amd_d3_interpolate_root_d3_.interpolate)(this._current, updated); + this._current = interpolate(0); + return function(t) { + const interpolated = interpolate(t); + interpolated.data = d.data; + return $$.getArc(interpolated, true); + }; + }).attr("transform", withTransform ? "scale(1)" : "").style("fill", (d) => { + let color; + if ($$.levelColor) { + color = $$.levelColor(d.data.values[0].value); + config.data_colors[d.data.id] = color; + } else { + color = $$.color(d.data); + } + return color; + }).style("opacity", null).call(endall, function() { + if ($$.levelColor) { + const path = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + const d = path.datum(this._current); + $$.updateLegendItemColor(d.data.id, path.style("fill")); + } + state.transiting = false; + callFn(config.onrendered, $$.api); + }); + hasInteraction && $$.bindArcEvent(mainArc); + $$.hasType("polar") && $$.redrawPolar(); + $$.hasType("gauge") && $$.redrawBackgroundArcs(); + config.arc_needle_show && $$.redrawNeedle(); + $$.redrawArcText(duration); + $$.redrawArcRangeText(); + }, + /** + * Update needle element + * @private + */ + redrawNeedle() { + const $$ = this; + const { $el, config, state: { hiddenTargetIds, radius } } = $$; + const length = (radius - 1) / 100 * config.arc_needle_length; + const hasDataToShow = hiddenTargetIds.length !== $$.data.targets.length; + let needle = $$.$el.arcs.select(`.${$ARC.needle}`); + const pathFn = config.arc_needle_path; + const baseWidth = config.arc_needle_bottom_width / 2; + const topWidth = config.arc_needle_top_width / 2; + const topRx = config.arc_needle_top_rx; + const topRy = config.arc_needle_top_ry; + const bottomLen = config.arc_needle_bottom_len; + const bottomRx = config.arc_needle_bottom_rx; + const bottomRy = config.arc_needle_bottom_ry; + const needleAngle = $$.getNeedleAngle(); + const updateNeedleValue = () => { + const title = $$.getArcTitleWithNeedleValue(); + title && $$.setArcTitle(title); + }; + updateNeedleValue(); + if (needle.empty()) { + needle = $el.arcs.append("path").classed($ARC.needle, true); + $el.needle = needle; + $el.needle.updateHelper = (v, updateConfig = false) => { + if ($el.needle.style("display") !== "none") { + $$.$T($el.needle).style("transform", `rotate(${$$.getNeedleAngle(v)}deg)`).call(endall, () => { + updateConfig && (config.arc_needle_value = v); + updateNeedleValue(); + }); + } + }; + } + if (hasDataToShow) { + const path = isFunction(pathFn) ? pathFn.call($$, length) : `M-${baseWidth} ${bottomLen} A${bottomRx} ${bottomRy} 0 0 0 ${baseWidth} ${bottomLen} L${topWidth} -${length} A${topRx} ${topRy} 0 0 0 -${topWidth} -${length} L-${baseWidth} ${bottomLen} Z`; + $$.$T(needle).attr("d", path).style("fill", config.arc_needle_color).style("display", null).style("transform", `rotate(${needleAngle}deg)`); + } else { + needle.style("display", "none"); + } + }, + /** + * Get needle angle value relative given value + * @param {number} v Value to be calculated angle + * @returns {number} angle value + * @private + */ + getNeedleAngle(v) { + const $$ = this; + const { config, state } = $$; + const arcLength = $$.getArcLength(); + const hasGauge = $$.hasType("gauge"); + const total = $$.getTotalDataSum(true); + let value = isDefined(v) ? v : config.arc_needle_value; + let startingAngle = config[`${config.data_type}_startingAngle`] || 0; + let radian = 0; + if (!isNumber(value)) { + value = hasGauge && $$.data.targets.length === 1 ? total : 0; + } + state.current.needle = value; + if (hasGauge) { + startingAngle = $$.getStartingAngle(); + const radius = config.gauge_fullCircle ? arcLength : startingAngle * -2; + const { gauge_min: min, gauge_max: max } = config; + radian = radius * ((value - min) / (max - min)); + } else { + radian = arcLength * (value / total); + } + return (startingAngle + radian) * (180 / Math.PI); + }, + redrawBackgroundArcs() { + const $$ = this; + const { config, state } = $$; + const hasMultiArcGauge = $$.hasMultiArcGauge(); + const isFullCircle = config.gauge_fullCircle; + const showEmptyTextLabel = $$.filterTargetsToShow($$.data.targets).length === 0 && !!config.data_empty_label_text; + const startAngle = $$.getStartingAngle(); + const endAngle = isFullCircle ? startAngle + $$.getArcLength() : startAngle * -1; + let backgroundArc = $$.$el.arcs.select( + `${hasMultiArcGauge ? "g" : ""}.${$ARC.chartArcsBackground}` + ); + if (hasMultiArcGauge) { + let index = 0; + backgroundArc = backgroundArc.selectAll(`path.${$ARC.chartArcsBackground}`).data($$.data.targets); + backgroundArc.enter().append("path").attr("class", (d, i) => `${$ARC.chartArcsBackground} ${$ARC.chartArcsBackground}-${i}`).merge(backgroundArc).style("fill", config.gauge_background || null).attr("d", ({ id }) => { + if (showEmptyTextLabel || state.hiddenTargetIds.indexOf(id) >= 0) { + return "M 0 0"; + } + const d = { + data: [{ value: config.gauge_max }], + startAngle, + endAngle, + index: index++ + }; + return $$.getArc(d, true, true); + }); + backgroundArc.exit().remove(); + } else { + backgroundArc.attr("d", showEmptyTextLabel ? "M 0 0" : () => { + const d = { + data: [{ value: config.gauge_max }], + startAngle, + endAngle + }; + return $$.getArc(d, true, true); + }); + } + }, + bindArcEvent(arc) { + const $$ = this; + const { config, state } = $$; + const isTouch = state.inputType === "touch"; + const isMouse = state.inputType === "mouse"; + function selectArc(_this, arcData, id) { + $$.expandArc(id); + $$.api.focus(id); + $$.toggleFocusLegend(id, true); + $$.showTooltip([arcData], _this); + } + function unselectArc(arcData) { + const id = (arcData == null ? void 0 : arcData.id) || void 0; + $$.unexpandArc(id); + $$.api.revert(); + $$.revertLegend(); + $$.hideTooltip(); + } + arc.on("click", function(event, d, i) { + var _a; + const updated = $$.updateAngle(d); + let arcData; + if (updated) { + arcData = $$.convertToArcData(updated); + (_a = $$.toggleShape) == null ? void 0 : _a.call($$, this, arcData, i); + config.data_onclick.bind($$.api)(arcData, this); + } + }); + if (isMouse) { + arc.on("mouseover", function(event, d) { + if (state.transiting) { + return; + } + state.event = event; + const updated = $$.updateAngle(d); + const arcData = updated ? $$.convertToArcData(updated) : null; + const id = (arcData == null ? void 0 : arcData.id) || void 0; + selectArc(this, arcData, id); + $$.setOverOut(true, arcData); + }).on("mouseout", (event, d) => { + if (state.transiting || !config.interaction_onout) { + return; + } + state.event = event; + const updated = $$.updateAngle(d); + const arcData = updated ? $$.convertToArcData(updated) : null; + unselectArc(); + $$.setOverOut(false, arcData); + }).on("mousemove", function(event, d) { + const updated = $$.updateAngle(d); + const arcData = updated ? $$.convertToArcData(updated) : null; + state.event = event; + $$.showTooltip([arcData], this); + }); + } + if (isTouch && $$.hasArcType() && !$$.radars) { + const getEventArc = (event) => { + var _a, _b; + const { clientX, clientY } = (_b = (_a = event.changedTouches) == null ? void 0 : _a[0]) != null ? _b : { clientX: 0, clientY: 0 }; + const eventArc = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(browser_doc.elementFromPoint(clientX, clientY)); + return eventArc; + }; + $$.$el.svg.on("touchstart touchmove", function(event) { + if (state.transiting) { + return; + } + state.event = event; + const eventArc = getEventArc(event); + const datum = eventArc.datum(); + const updated = (datum == null ? void 0 : datum.data) && datum.data.id ? $$.updateAngle(datum) : null; + const arcData = updated ? $$.convertToArcData(updated) : null; + const id = (arcData == null ? void 0 : arcData.id) || void 0; + $$.callOverOutForTouch(arcData); + isUndefined(id) ? unselectArc() : selectArc(this, arcData, id); + }, { passive: true }); + } + }, + redrawArcText(duration) { + const $$ = this; + const { config, state, $el: { main, arcs } } = $$; + const hasGauge = $$.hasType("gauge"); + const hasMultiArcGauge = $$.hasMultiArcGauge(); + let text; + if (!(hasGauge && $$.data.targets.length === 1 && config.gauge_title)) { + text = main.selectAll(`.${$ARC.chartArc}`).select("text").style("opacity", "0").attr("class", (d) => $$.isGaugeType(d.data) ? $GAUGE.gaugeValue : null).call($$.textForArcLabel.bind($$)).style("font-size", (d) => $$.isGaugeType(d.data) && $$.data.targets.length === 1 && !hasMultiArcGauge ? `${Math.round(state.radius / 5)}px` : null); + updateTextImage.call($$); + text.attr("transform", function(d) { + return $$.transformForArcLabel.bind($$)(this, d); + }).transition().duration(duration).style( + "opacity", + (d) => $$.isTargetToShow(d.data.id) && $$.isArcType(d.data) ? null : "0" + ); + hasMultiArcGauge && text.attr("dy", "-.1em"); + } + main.select(`.${$ARC.chartArcsTitle}`).style("opacity", $$.hasType("donut") || hasGauge ? null : "0"); + if (hasGauge) { + const isFullCircle = config.gauge_fullCircle; + isFullCircle && (text == null ? void 0 : text.attr("dy", `${hasMultiArcGauge ? 0 : Math.round(state.radius / 14)}`)); + if (config.gauge_label_show) { + arcs.select(`.${$GAUGE.chartArcsGaugeUnit}`).attr("dy", `${isFullCircle ? 1.5 : 0.75}em`).text(config.gauge_units); + arcs.select(`.${$GAUGE.chartArcsGaugeMin}`).attr("dx", `${-1 * (state.innerRadius + (state.radius - state.innerRadius) / (isFullCircle ? 1 : 2))}px`).attr("dy", "1.2em").text($$.textForGaugeMinMax(config.gauge_min, false)); + !isFullCircle && arcs.select(`.${$GAUGE.chartArcsGaugeMax}`).attr("dx", `${state.innerRadius + (state.radius - state.innerRadius) / 2}px`).attr("dy", "1.2em").text($$.textForGaugeMinMax(config.gauge_max, true)); + } + } + isLabelWithLine.call($$) && redrawArcLabelLines.call($$, duration); + }, + /** + * Get Arc element by id or index + * @param {string|number} value id or index of Arc + * @returns {d3Selection} Arc path element + * @private + */ + getArcElementByIdOrIndex(value) { + const $$ = this; + const { $el: { arcs } } = $$; + const filterFn = isNumber(value) ? (d) => d.index === value : (d) => d.data.id === value; + return arcs == null ? void 0 : arcs.selectAll(`.${$COMMON.target} path`).filter(filterFn); + } +}); + +;// ./src/ChartInternal/shape/area.ts + + + + +/* harmony default export */ var shape_area = ({ + initArea(mainLine) { + const $$ = this; + const { config } = $$; + mainLine.insert("g", `.${config.area_front ? $CIRCLE.circles : $LINE.lines}`).attr("class", $$.getClass("areas", true)); + }, + /** + * Update area color + * @param {object} d Data object + * @returns {string} Color string + * @private + */ + updateAreaColor(d) { + const $$ = this; + return $$.config.area_linearGradient ? $$.getGradienColortUrl(d.id) : $$.color(d); + }, + /** + * Generate/Update elements + * @param {boolean} withTransition Transition for exit elements + * @param {boolean} isSub Subchart draw + * @private + */ + updateArea(withTransition, isSub = false) { + const $$ = this; + const { config, state, $el, $T } = $$; + const $root = isSub ? $el.subchart : $el; + config.area_linearGradient && $$.updateLinearGradient(); + const area = $root.main.selectAll(`.${$AREA.areas}`).selectAll(`.${$AREA.area}`).data($$.lineData.bind($$)); + $T(area.exit(), withTransition).style("opacity", "0").remove(); + $root.area = area.enter().append("path").attr("class", $$.getClass("area", true)).style("fill", $$.updateAreaColor.bind($$)).style("opacity", function() { + state.orgAreaOpacity = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).style("opacity"); + return "0"; + }).merge(area); + area.style("opacity", state.orgAreaOpacity); + $$.setRatioForGroupedData($root.area.data()); + }, + /** + * Redraw function + * @param {function} drawFn Retuned functino from .generateDrawCandlestick() + * @param {boolean} withTransition With or without transition + * @param {boolean} isSub Subchart draw + * @returns {Array} + */ + redrawArea(drawFn, withTransition, isSub = false) { + const $$ = this; + const { area } = isSub ? this.$el.subchart : this.$el; + const { orgAreaOpacity } = $$.state; + return [ + $$.$T(area, withTransition, getRandom()).attr("d", drawFn).style("fill", $$.updateAreaColor.bind($$)).style( + "opacity", + (d) => String($$.isAreaRangeType(d) ? orgAreaOpacity / 1.75 : orgAreaOpacity) + ) + ]; + }, + /** + * Generate area path data + * @param {object} areaIndices Indices + * @param {boolean} isSub Weather is sub axis + * @returns {function} + * @private + */ + generateDrawArea(areaIndices, isSub) { + const $$ = this; + const { config } = $$; + const lineConnectNull = config.line_connectNull; + const isRotated = config.axis_rotated; + const getPoints = $$.generateGetAreaPoints(areaIndices, isSub); + const yScale = $$.getYScaleById.bind($$); + const xValue = (d) => (isSub ? $$.subxx : $$.xx).call($$, d); + const value0 = (d, i) => $$.isGrouped(d.id) ? getPoints(d, i)[0][1] : yScale(d.id, isSub)( + $$.isAreaRangeType(d) ? $$.getRangedData(d, "high") : $$.getShapeYMin(d.id) + ); + const value1 = (d, i) => $$.isGrouped(d.id) ? getPoints(d, i)[1][1] : yScale(d.id, isSub)( + $$.isAreaRangeType(d) ? $$.getRangedData(d, "low") : d.value + ); + return (d) => { + let values = lineConnectNull ? $$.filterRemoveNull(d.values) : d.values; + let x0 = 0; + let y0 = 0; + let path; + if ($$.isAreaType(d)) { + let area = (0,external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.area)(); + area = isRotated ? area.y(xValue).x0(value0).x1(value1) : area.x(xValue).y0(config.area_above ? 0 : config.area_below ? $$.state.height : value0).y1(value1); + if (!lineConnectNull) { + area = area.defined((d2) => $$.getBaseValue(d2) !== null); + } + if ($$.isStepType(d)) { + values = $$.convertValuesToStep(values); + } + path = area.curve($$.getCurve(d))(values); + } else { + if (values[0]) { + x0 = $$.scale.x(values[0].x); + y0 = $$.getYScaleById(d.id)(values[0].value); + } + path = isRotated ? `M ${y0} ${x0}` : `M ${x0} ${y0}`; + } + return path || "M 0 0"; + }; + }, + generateGetAreaPoints(areaIndices, isSub) { + const $$ = this; + const { config } = $$; + const x = $$.getShapeX(0, areaIndices, isSub); + const y = $$.getShapeY(!!isSub); + const areaOffset = $$.getShapeOffset($$.isAreaType, areaIndices, isSub); + const yScale = $$.getYScaleById.bind($$); + return function(d, i) { + const y0 = yScale.call($$, d.id, isSub)($$.getShapeYMin(d.id)); + const offset = areaOffset(d, i) || y0; + const posX = x(d); + const value = d.value; + let posY = y(d); + if (config.axis_rotated && (value > 0 && posY < y0 || value < 0 && y0 < posY)) { + posY = y0; + } + return [ + [posX, offset], + [posX, posY - (y0 - offset)], + [posX, posY - (y0 - offset)], + // needed for compatibility + [posX, offset] + // needed for compatibility + ]; + }; + } +}); + +;// ./src/ChartInternal/shape/bar.ts + + + +function _getConnectLineType(id) { + const connectLine = this.config.bar_connectLine; + const type = (connectLine == null ? void 0 : connectLine[id]) || connectLine; + return /^(start|end)\-(start|end)$/.test(type) ? type : null; +} +/* harmony default export */ var bar = ({ + initBar() { + const { $el, config, state: { clip } } = this; + $el.bar = $el.main.select(`.${$COMMON.chart}`); + $el.bar = config.bar_front ? $el.bar.append("g") : $el.bar.insert("g", ":first-child"); + $el.bar.attr("class", $BAR.chartBars).call(this.setCssRule(false, `.${$BAR.chartBars}`, ["pointer-events:none"])); + if (config.clipPath === false && (config.bar_radius || config.bar_radius_ratio)) { + $el.bar.attr("clip-path", clip.pathXAxis.replace(/#[^)]*/, `#${clip.id}`)); + } + }, + updateTargetsForBar(targets) { + const $$ = this; + const { config, $el } = $$; + const classChartBar = $$.getChartClass("Bar"); + const classBars = $$.getClass("bars", true); + const classFocus = $$.classFocus.bind($$); + const isSelectable = config.interaction_enabled && config.data_selection_isselectable; + if (!$el.bar) { + $$.initBar(); + } + const mainBarUpdate = $el.main.select(`.${$BAR.chartBars}`).selectAll(`.${$BAR.chartBar}`).data($$.filterNullish(targets)).attr("class", (d) => classChartBar(d) + classFocus(d)); + const mainBarEnter = mainBarUpdate.enter().append("g").attr("class", classChartBar).style("opacity", "0").style("pointer-events", $$.getStylePropValue("none")); + mainBarEnter.append("g").attr("class", classBars).style("cursor", (d) => { + var _a; + return ((_a = isSelectable == null ? void 0 : isSelectable.bind) == null ? void 0 : _a.call(isSelectable, $$.api)(d)) ? "pointer" : null; + }).call((selection) => { + $$.setCssRule(true, ` .${$BAR.bar}`, ["fill"], $$.color)(selection); + selection.each(function(d) { + if (_getConnectLineType.call($$, d.id)) { + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).append("path").attr("class", $BAR.barConnectLine); + } + }); + }); + }, + /** + * Generate/Update elements + * @param {boolean} withTransition Transition for exit elements + * @param {boolean} isSub Subchart draw + * @private + */ + updateBar(withTransition, isSub = false) { + const $$ = this; + const { config, $el, $T } = $$; + const $root = isSub ? $el.subchart : $el; + const classBar = $$.getClass("bar", true); + const initialOpacity = $$.initialOpacity.bind($$); + config.bar_linearGradient && $$.updateLinearGradient(); + const bar = $root.main.selectAll(`.${$BAR.bars}`).selectAll(`.${$BAR.bar}`).data($$.labelishData.bind($$)); + $T(bar.exit(), withTransition).style("opacity", "0").remove(); + $root.bar = bar.enter().append("path").attr("class", classBar).style("fill", $$.updateBarColor.bind($$)).merge(bar).style("opacity", initialOpacity); + $$.setRatioForGroupedData($root.bar.data()); + }, + /** + * Update bar color + * @param {object} d Data object + * @returns {string} Color string + * @private + */ + updateBarColor(d) { + const $$ = this; + const fn = $$.getStylePropValue($$.color); + return $$.config.bar_linearGradient ? $$.getGradienColortUrl(d.id) : fn ? fn(d) : null; + }, + /** + * Redraw function + * @param {function} drawFn Retuned function from .getDrawShape() => .generateDrawBar() + * @param {boolean} withTransition With or without transition + * @param {boolean} isSub Subchart draw + * @returns {Array} + * @private + */ + redrawBar(drawFn, withTransition, isSub = false) { + const $$ = this; + const { bar } = isSub ? $$.$el.subchart : $$.$el; + const barPath = []; + return [ + $$.$T(bar, withTransition, getRandom()).attr("d", function(d, i, arr) { + const path = (isNumber(d.value) || $$.isBarRangeType(d)) && drawFn(d, i); + const connectLineType = _getConnectLineType.call($$, d.id); + if (path.length > 1) { + barPath.push(path[1]); + if (i === arr.length - 1) { + const barConnectLineNode = $$.$T( + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this.parentNode.querySelector(`.${$BAR.barConnectLine}`)), + withTransition, + getRandom() + ); + $$.updateConnectLine(barConnectLineNode, connectLineType, barPath); + barPath.splice(0); + } + } + return path[0]; + }).style("fill", $$.updateBarColor.bind($$)).style("clip-path", (d) => d.clipPath).style("opacity", null) + ]; + }, + /** + * Generate draw function + * @param {object} barIndices data order within x axis. + * barIndices ==> {data1: 0, data2: 0, data3: 1, data4: 1, __max__: 1} + * + * When gropus given as: + * groups: [ + * ["data1", "data2"], + * ["data3", "data4"] + * ], + * + * Will be rendered as: + * data1 data3 data1 data3 + * data2 data4 data2 data4 + * ------------------------- + * 0 1 + * @param {boolean} isSub If is for subchart + * @returns {function} + * @private + */ + generateDrawBar(barIndices, isSub) { + const $$ = this; + const { config } = $$; + const getPoints = $$.generateGetBarPoints(barIndices, isSub); + const isRotated = config.axis_rotated; + const barRadius = config.bar_radius; + const barRadiusRatio = config.bar_radius_ratio; + const getRadius = isNumber(barRadius) && barRadius > 0 ? () => barRadius : isNumber(barRadiusRatio) ? (w) => w * barRadiusRatio : null; + return (d, i) => { + const points = getPoints(d, i); + const indexX = +isRotated; + const indexY = +!indexX; + const isUnderZero = d.value < 0; + const isInverted = config[`axis_${$$.axis.getId(d.id)}_inverted`]; + const isNegative = !isInverted && isUnderZero || isInverted && !isUnderZero; + const pathRadius = ["", ""]; + const isGrouped = $$.isGrouped(d.id); + const isRadiusData = getRadius && isGrouped ? $$.isStackingRadiusData(d) : false; + const init = [ + points[0][indexX], + points[0][indexY] + ]; + let radius = 0; + d.clipPath = null; + if (getRadius) { + const index = isRotated ? indexY : indexX; + const barW = points[2][index] - points[0][index]; + radius = !isGrouped || isRadiusData ? getRadius(barW) : 0; + const arc = `a${radius} ${radius} ${isNegative ? `1 0 0` : `0 0 1`} `; + pathRadius[+!isRotated] = `${arc}${radius},${radius}`; + pathRadius[+isRotated] = `${arc}${[-radius, radius][isRotated ? "sort" : "reverse"]()}`; + isNegative && pathRadius.reverse(); + } + const pos = isRotated ? points[1][indexX] + (isNegative ? radius : -radius) : points[1][indexY] + (isNegative ? -radius : radius); + if (radius) { + let clipPath = ""; + if (isRotated) { + if (isNegative && init[0] < pos) { + clipPath = `0 ${pos - init[0]}px 0 0`; + } else if (!isNegative && init[0] > pos) { + clipPath = `0 0 0 ${init[0] - pos}px`; + } + } else { + if (isNegative && init[1] > pos) { + clipPath = `${init[1] - pos}px 0 0 0`; + } else if (!isNegative && init[1] < pos) { + clipPath = `0 0 ${pos - init[1]}px 0`; + } + } + if (clipPath) { + d.clipPath = `inset(${clipPath})`; + } + } + const path = isRotated ? `H${pos} ${pathRadius[0]}V${points[2][indexY] - radius} ${pathRadius[1]}H${points[3][indexX]}` : `V${pos} ${pathRadius[0]}H${points[2][indexX] - radius} ${pathRadius[1]}V${points[3][indexY]}`; + const coords = [`M${points[0][indexX]},${points[0][indexY]}${path}z`]; + if (_getConnectLineType.call($$, d.id)) { + coords.push(isRotated ? { + x: points[0][indexX], + y: points[0][indexY], + width: points[0][indexX] - pos, + height: points[2][indexY] - points[0][indexY] + } : { + x: points[0][indexX], + y: pos, + width: points[2][indexX] - points[0][indexX], + height: points[3][indexY] - pos + }); + } + return coords; + }; + }, + /** + * Determine if given stacking bar data is radius type + * @param {object} d Data row + * @returns {boolean} + */ + isStackingRadiusData(d) { + const $$ = this; + const { $el, config, data, state } = $$; + const { id, index, value } = d; + if (state.hiddenTargetIds.indexOf(id) > -1) { + const target = $el.bar.filter((d2) => d2.id === id && d2.value === value); + return !target.empty() && /a\d+/i.test(target.attr("d")); + } + const keys = config.data_groups.find((v) => v.indexOf(id) > -1); + const sortedList = $$.orderTargets( + $$.filterTargetsToShow(data.targets.filter($$.isBarType, $$)) + ).filter((v) => keys.indexOf(v.id) > -1); + const sortedIds = sortedList.map( + (v) => v.values.filter( + (v2) => v2.index === index && (isNumber(value) && value > 0 ? v2.value > 0 : v2.value < 0) + )[0] + ).filter(Boolean).map((v) => v.id); + return value !== 0 && sortedIds.indexOf(id) === sortedIds.length - 1; + }, + /** + * Generate bar coordinate points data + * @param {object} barIndices Data order within x axis. + * @param {boolean} isSub If is for subchart + * @returns {Array} Array of coordinate points + * @private + */ + generateGetBarPoints(barIndices, isSub) { + const $$ = this; + const { config } = $$; + const axis = isSub ? $$.axis.subX : $$.axis.x; + const barTargetsNum = $$.getIndicesMax(barIndices) + 1; + const barW = $$.getBarW("bar", axis, barTargetsNum); + const barX = $$.getShapeX(barW, barIndices, !!isSub); + const barY = $$.getShapeY(!!isSub); + const barOffset = $$.getShapeOffset($$.isBarType, barIndices, !!isSub); + const yScale = $$.getYScaleById.bind($$); + return (d, i) => { + const { id } = d; + const y0 = yScale.call($$, id, isSub)($$.getShapeYMin(id)); + const offset = barOffset(d, i) || y0; + const width = isNumber(barW) ? barW : barW[d.id] || barW._$width; + const isInverted = config[`axis_${$$.axis.getId(id)}_inverted`]; + const value = d.value; + const posX = barX(d); + let posY = barY(d); + if (config.axis_rotated && !isInverted && (value > 0 && posY < y0 || value < 0 && y0 < posY)) { + posY = y0; + } + if (!$$.isBarRangeType(d)) { + posY -= y0 - offset; + } + const startPosX = posX + width; + return [ + [posX, offset], + [posX, posY], + [startPosX, posY], + [startPosX, offset] + ]; + }; + }, + /** + * Update the bar connect line path + * @param {d3Selection} node d3 selection of bar connect line + * @param {string} type Type of connect line, one of "start-start", "start-end", "end-start", "end-end" + * @param {Array} barPath d3 path data for the bar + */ + updateConnectLine(node, type, barPath) { + const path = barPath.map((v, i, arr) => { + const isRotated = this.config.axis_rotated; + const isStart = /^start-(start|end)$/.test(type); + const isEnd = /^end-(start|end)$/.test(type); + const path2 = []; + const x = isRotated ? isEnd ? v.x - v.width : v.x : v.x + v.width; + const y = isRotated ? v.y + v.height : isStart ? v.y + v.height : v.y; + if (i === 0) { + path2.push(`${x},${y}`); + } else { + path2.push( + isRotated ? `L${v.x - (/\w+-end$/.test(type) ? v.width : 0)},${v.y}` : `L${v.x},${v.y + (/\w+-start$/.test(type) ? v.height : 0)}` + ); + if (i < arr.length - 1) { + path2.push(`M${x},${y}`); + } + } + return path2.join(" "); + }); + node.attr("d", `M${path.join("")}z`); + } +}); + +;// ./src/ChartInternal/shape/bubble.ts + + +/* harmony default export */ var bubble = ({ + /** + * Initializer + * @private + */ + initBubble() { + const $$ = this; + const { config } = $$; + if ($$.hasType("bubble")) { + config.point_show = true; + config.point_type = "circle"; + } + }, + /** + * Get user agent's computed value + * @returns {number} + * @private + */ + getBaseLength() { + const $$ = this; + const { width, height } = $$.state; + const cacheKey = KEY.bubbleBaseLength; + let baseLength = $$.cache.get(cacheKey); + if (!baseLength) { + $$.cache.add(cacheKey, baseLength = getMinMax("min", [width, height])); + } + return baseLength; + }, + /** + * Get the radius value for bubble circle + * @param {object} d Data object + * @returns {number} + * @private + */ + getBubbleR(d) { + const $$ = this; + let maxR = $$.config.bubble_maxR; + if (isFunction(maxR)) { + maxR = maxR.bind($$.api)(d); + } else if (!isNumber(maxR)) { + maxR = $$.getBaseLength() / ($$.getMaxDataCount() * 2) + 12; + } + const max = getMinMax("max", $$.getMinMaxData().max.map((d2) => $$.isBubbleZType(d2) ? $$.getBubbleZData(d2.value, "y") : isObject(d2.value) ? d2.value.mid : d2.value)); + const maxArea = maxR * maxR * Math.PI; + const area = ($$.isBubbleZType(d) ? $$.getBubbleZData(d.value, "z") : d.value) * (maxArea / max); + return Math.sqrt(area / Math.PI); + }, + /** + * Get bubble dimension data + * @param {object|Array} d data value + * @param {string} type - y or z + * @returns {number} + * @private + */ + getBubbleZData(d, type) { + return isObject(d) ? d[type] : d[type === "y" ? 0 : 1]; + } +}); + +;// ./src/ChartInternal/shape/candlestick.ts +var candlestick_defProp = Object.defineProperty; +var candlestick_getOwnPropSymbols = Object.getOwnPropertySymbols; +var candlestick_hasOwnProp = Object.prototype.hasOwnProperty; +var candlestick_propIsEnum = Object.prototype.propertyIsEnumerable; +var candlestick_defNormalProp = (obj, key, value) => key in obj ? candlestick_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var candlestick_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (candlestick_hasOwnProp.call(b, prop)) + candlestick_defNormalProp(a, prop, b[prop]); + if (candlestick_getOwnPropSymbols) + for (var prop of candlestick_getOwnPropSymbols(b)) { + if (candlestick_propIsEnum.call(b, prop)) + candlestick_defNormalProp(a, prop, b[prop]); + } + return a; +}; + + + +/* harmony default export */ var candlestick = ({ + initCandlestick() { + const { $el } = this; + $el.candlestick = $el.main.select(`.${$COMMON.chart}`).append("g").attr("class", $CANDLESTICK.chartCandlesticks); + }, + /** + * Update targets by its data + * called from: ChartInternal.updateTargets() + * @param {Array} targets Filtered target by type + * @private + */ + updateTargetsForCandlestick(targets) { + const $$ = this; + const { $el } = $$; + const classChart = $$.getChartClass("Candlestick"); + if (!$el.candlestick) { + $$.initCandlestick(); + } + const mainUpdate = $$.$el.main.select(`.${$CANDLESTICK.chartCandlesticks}`).selectAll(`.${$CANDLESTICK.chartCandlestick}`).data($$.filterNullish(targets)); + mainUpdate.enter().append("g").attr("class", classChart).style("pointer-events", "none"); + }, + /** + * Generate/Update elements + * @param {boolean} withTransition Transition for exit elements + * @param {boolean} isSub Subchart draw + * @private + */ + updateCandlestick(withTransition, isSub = false) { + const $$ = this; + const { $el, $T } = $$; + const $root = isSub ? $el.subchart : $el; + const classSetter = $$.getClass("candlestick", true); + const initialOpacity = $$.initialOpacity.bind($$); + const candlestick = $root.main.selectAll(`.${$CANDLESTICK.chartCandlestick}`).selectAll(`.${$CANDLESTICK.candlestick}`).data($$.labelishData.bind($$)); + $T(candlestick.exit(), withTransition).style("opacity", "0").remove(); + const candlestickEnter = candlestick.enter().filter((d) => d.value).append("g").attr("class", classSetter); + candlestickEnter.append("line"); + candlestickEnter.append("path"); + $root.candlestick = candlestick.merge(candlestickEnter).style("opacity", initialOpacity); + }, + /** + * Get draw function + * @param {object} indices Indice data + * @param {boolean} isSub Subchart draw + * @returns {function} + * @private + */ + generateDrawCandlestick(indices, isSub) { + const $$ = this; + const { config } = $$; + const getPoints = $$.generateGetCandlestickPoints(indices, isSub); + const isRotated = config.axis_rotated; + const downColor = config.candlestick_color_down; + return (d, i, g) => { + const points = getPoints(d, i); + const value = $$.getCandlestickData(d); + const isUp = value == null ? void 0 : value._isUp; + const indexX = +isRotated; + const indexY = +!indexX; + if (g.classed) { + g.classed($CANDLESTICK[isUp ? "valueUp" : "valueDown"], true); + } + const path = isRotated ? `H${points[1][1]} V${points[1][0]} H${points[0][1]}` : `V${points[1][1]} H${points[1][0]} V${points[0][1]}`; + g.select("path").attr("d", `M${points[0][indexX]},${points[0][indexY]}${path}z`).style("fill", (d2) => { + const color = isUp ? $$.color(d2) : isObject(downColor) ? downColor[d2.id] : downColor; + return color || $$.color(d2); + }); + const line = g.select("line"); + const pos = isRotated ? { + x1: points[2][1], + x2: points[2][2], + y1: points[2][0], + y2: points[2][0] + } : { + x1: points[2][0], + x2: points[2][0], + y1: points[2][1], + y2: points[2][2] + }; + for (const x in pos) { + line.attr(x, pos[x]); + } + }; + }, + /** + * Generate shape drawing points + * @param {object} indices Indice data + * @param {boolean} isSub Subchart draw + * @returns {function} + */ + generateGetCandlestickPoints(indices, isSub = false) { + const $$ = this; + const axis = isSub ? $$.axis.subX : $$.axis.x; + const targetsNum = $$.getIndicesMax(indices) + 1; + const barW = $$.getBarW("candlestick", axis, targetsNum); + const x = $$.getShapeX(barW, indices, !!isSub); + const y = $$.getShapeY(!!isSub); + const shapeOffset = $$.getShapeOffset($$.isBarType, indices, !!isSub); + const yScale = $$.getYScaleById.bind($$); + return (d, i) => { + const y0 = yScale.call($$, d.id, isSub)($$.getShapeYMin(d.id)); + const offset = shapeOffset(d, i) || y0; + const width = isNumber(barW) ? barW : barW[d.id] || barW._$width; + const value = $$.getCandlestickData(d); + let points; + if (value && isNumber(value.open) && isNumber(value.close)) { + const posX = { + start: x(d), + end: 0 + }; + posX.end = posX.start + width; + const posY = { + start: y(value.open), + end: y(value.close) + }; + const posLine = { + x: posX.start + width / 2, + high: y(value.high), + low: y(value.low) + }; + posY.start -= y0 - offset; + points = [ + [posX.start, posY.start], + [posX.end, posY.end], + [posLine.x, posLine.low, posLine.high] + ]; + } else { + points = [[0, 0], [0, 0], [0, 0, 0]]; + } + return points; + }; + }, + /** + * Redraw function + * @param {function} drawFn Retuned functino from .generateDrawCandlestick() + * @param {boolean} withTransition With or without transition + * @param {boolean} isSub Subchart draw + * @returns {Array} + */ + redrawCandlestick(drawFn, withTransition, isSub = false) { + const $$ = this; + const { $el, $T } = $$; + const { candlestick } = isSub ? $el.subchart : $el; + const rand = getRandom(true); + return [ + candlestick.each(function(d, i) { + const g = $T((0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this), withTransition, rand); + drawFn(d, i, g); + }).style("opacity", null) + ]; + }, + /** + * Get candlestick data as object + * @param {object} param Data object + * @param {Array|object} param.value Data value + * @returns {object|null} Converted data object + * @private + */ + getCandlestickData({ value }) { + let d; + if (isArray(value)) { + const [open, high, low, close, volume = false] = value; + d = { open, high, low, close }; + if (volume !== false) { + d.volume = volume; + } + } else if (isObject(value)) { + d = candlestick_spreadValues({}, value); + } + if (d) { + d._isUp = d.close >= d.open; + } + return d || null; + } +}); + +;// ./src/ChartInternal/shape/funnel.ts +var funnel_defProp = Object.defineProperty; +var funnel_getOwnPropSymbols = Object.getOwnPropertySymbols; +var funnel_hasOwnProp = Object.prototype.hasOwnProperty; +var funnel_propIsEnum = Object.prototype.propertyIsEnumerable; +var funnel_defNormalProp = (obj, key, value) => key in obj ? funnel_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var funnel_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (funnel_hasOwnProp.call(b, prop)) + funnel_defNormalProp(a, prop, b[prop]); + if (funnel_getOwnPropSymbols) + for (var prop of funnel_getOwnPropSymbols(b)) { + if (funnel_propIsEnum.call(b, prop)) + funnel_defNormalProp(a, prop, b[prop]); + } + return a; +}; + + + +function _getSize(checkNeck = false) { + const $$ = this; + const { config, state: { current: { width, height } } } = $$; + const padding = $$.getCurrentPadding(); + const size = funnel_spreadValues({ + width: width - (padding.left + padding.right), + height: height - (config.legend_show ? $$.getLegendHeight() + 10 : 0) - (padding.top + padding.bottom) + }, padding); + if (checkNeck) { + const { width: neckWidth, height: neckHeight } = _getNeckSize.call($$, { + width: size.width, + height: size.height + }); + if (size.width < neckWidth) { + size.width = neckWidth; + } + if (size.height < neckHeight) { + size.height = neckHeight; + } + } + return size; +} +function _getNeckSize(current) { + const $$ = this; + const { config } = $$; + let width = config.funnel_neck_width; + let height = config.funnel_neck_height; + [width, height] = [width, height].map((v, i) => { + let size = v; + if (isObject(v)) { + size = current[i ? "height" : "width"] * v.ratio; + } + return size; + }); + return { + width, + height + }; +} +function _getCoord(d) { + const $$ = this; + const { top, left, width } = _getSize.call($$, true); + const coords = []; + d.forEach((d2, i) => { + const { ratio } = d2; + const y = i > 0 ? coords[i - 1][2][1] : top; + coords.push(d2.coords = [ + [left, y], + // M + [left + width, y], + // 1 + [left + width, i > 0 ? ratio + y : ratio + top], + // 2 + [left, i > 0 ? ratio + y : ratio + top], + // 3 + [left, y] + // 4 + ]); + }); + return coords; +} +function _getClipPath(forBackground = false) { + const $$ = this; + const { width, height, top, left } = _getSize.call($$, true); + const neck = _getNeckSize.call($$, { width, height }); + const leftX = (width - neck.width) / 2; + const rightX = (width + neck.width) / 2; + const bodyHeigth = height - neck.height; + const coords = [ + [0, 0], + // M + [width, 0], + // 1 + [rightX, bodyHeigth], + // 2 + [rightX, height], + // 3 + [leftX, height], + // 4 + [leftX, bodyHeigth], + // 5 + [0, 0] + // 6 + ]; + if (forBackground) { + coords.forEach((d) => { + d[0] += left; + d[1] += top; + }); + } + return `M${coords.join("L")}z`; +} +function _getFunnelData(d) { + const $$ = this; + const { config } = $$; + const data = d.map((d2) => ({ + id: d2.id, + value: d2.values.reduce((a, b) => a + b.value, 0) + })); + if (config.data_order) { + data.sort($$.getSortCompareFn.bind($$)(true)); + } + return _updateRatio.call($$, data); +} +function _updateRatio(data) { + const $$ = this; + const { height } = _getSize.call($$); + const total = $$.getTotalDataSum(true); + data.forEach((d) => { + d.ratio = d.value / total * height; + }); + return data; +} +/* harmony default export */ var funnel = ({ + /** + * Initialize polar + * @private + */ + initFunnel() { + const $$ = this; + const { $el } = $$; + $el.funnel = $el.main.select(`.${$COMMON.chart}`).append("g").classed($FUNNEL.chartFunnels, true); + $el.funnel.background = $el.funnel.append("path").classed($FUNNEL.funnelBackground, true); + $$.bindFunnelEvent(); + }, + /** + * Bind events + * @private + */ + bindFunnelEvent() { + const $$ = this; + const { $el: { funnel }, config, state } = $$; + const getTarget = (event) => { + var _a; + const target = event.isTrusted ? event.target : (_a = state.eventReceiver.rect) == null ? void 0 : _a.node(); + let data; + if (/^path$/i.test(target.tagName)) { + state.event = event; + data = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(target).datum(); + } + return data; + }; + if (config.interaction_enabled) { + const isTouch = state.inputType === "touch"; + funnel.on(isTouch ? "touchstart" : "mouseover mousemove", (event) => { + const data = getTarget(event); + if (data) { + $$.showTooltip([data], event.target); + /^(touchstart|mouseover)$/.test(event.type) && $$.setOverOut(true, data); + } + }, isTouch ? { passive: true } : void 0).on(isTouch ? "touchend" : "mouseout", (event) => { + const data = getTarget(event); + if (config.interaction_onout) { + $$.hideTooltip(); + $$.setOverOut(false, data); + } + }); + } + }, + /** + * Update polar based on given data array + * @param {object} t Data object + * @private + */ + updateTargetsForFunnel(t) { + const $$ = this; + const { $el: { funnel } } = $$; + const classChartFunnel = $$.getChartClass("Funnel"); + const classFunnel = $$.getClass("funnel", true); + if (!funnel) { + $$.initFunnel(); + } + const targets = _getFunnelData.call($$, t.filter($$.isFunnelType.bind($$))); + const mainFunnelUpdate = funnel.selectAll(`.${$FUNNEL.chartFunnel}`).data($$.filterNullish(targets)); + mainFunnelUpdate.exit().remove(); + const mainFunnelEnter = mainFunnelUpdate.enter().insert("g", `.${$FUNNEL.funnelBackground}`); + mainFunnelEnter.append("path"); + funnel.path = mainFunnelEnter.merge(mainFunnelUpdate).attr("class", (d) => classChartFunnel(d)).select("path").attr("class", classFunnel).style("opacity", "0").style("fill", $$.color); + }, + /** + * Update funnel path selection + * @param {object} targets Updated target data + * @private + */ + updateFunnel(targets) { + const $$ = this; + const { $el: { funnel } } = $$; + const targetIds = targets.map(({ id }) => id); + funnel.path = funnel.path.filter((d) => targetIds.indexOf(d.id) >= 0); + }, + /** + * Generate treemap coordinate points data + * @returns {Array} Array of coordinate points + * @private + */ + generateGetFunnelPoints() { + const $$ = this; + const { $el: { funnel } } = $$; + const targets = $$.filterTargetsToShow(funnel.path); + const { top, left, right } = _getSize.call($$); + const center = (left - right) / 2; + const points = {}; + let accumulatedHeight = top != null ? top : 0; + targets.each((d, i) => { + var _a; + points[d.id] = [ + [center, accumulatedHeight], + [center, accumulatedHeight += ((_a = targets == null ? void 0 : targets[i]) != null ? _a : d).ratio] + ]; + }); + return (d) => points[d.id]; + }, + /** + * Called whenever redraw happens + * @private + */ + redrawFunnel() { + const $$ = this; + const { $T, $el: { funnel } } = $$; + const targets = $$.filterTargetsToShow(funnel.path); + const coords = _getCoord.call($$, _updateRatio.call($$, targets.data())); + funnel.attr("clip-path", `path('${_getClipPath.bind($$)()}')`); + funnel.background.attr("d", _getClipPath.call($$, true)); + $T(targets).attr("d", (d, i) => `M${coords[i].join("L")}z`).style("opacity", "1"); + funnel.selectAll("g").style("opacity", null); + } +}); + +;// ./src/ChartInternal/shape/gauge.ts + + + +/* harmony default export */ var gauge = ({ + initGauge() { + const $$ = this; + const { config, $el: { arcs } } = $$; + const appendText = (className = null, value = "") => { + arcs.append("text").attr("class", className).style("text-anchor", "middle").style("pointer-events", "none").text(value); + }; + if ($$.hasType("gauge")) { + const hasMulti = $$.hasMultiArcGauge(); + arcs.append(hasMulti ? "g" : "path").attr("class", $ARC.chartArcsBackground).style("fill", !hasMulti && config.gauge_background || null); + config.gauge_units && appendText($GAUGE.chartArcsGaugeUnit); + if (config.gauge_label_show) { + appendText($GAUGE.chartArcsGaugeMin); + !config.gauge_fullCircle && appendText($GAUGE.chartArcsGaugeMax); + } + } + }, + updateGaugeMax() { + const $$ = this; + const { config, state } = $$; + const hasMultiGauge = $$.hasMultiArcGauge(); + const max = hasMultiGauge ? $$.getMinMaxData().max[0].value : $$.getTotalDataSum(state.rendered); + if (!config.gauge_enforceMinMax && max + config.gauge_min * (config.gauge_min > 0 ? -1 : 1) > config.gauge_max) { + config.gauge_max = max - config.gauge_min; + } + }, + redrawArcGaugeLine() { + const $$ = this; + const { config, state, $el } = $$; + const { hiddenTargetIds } = $$.state; + const arcLabelLines = $el.main.selectAll(`.${$ARC.arcs}`).selectAll(`.${$ARC.arcLabelLine}`).data($$.arcData.bind($$)); + const mainArcLabelLine = arcLabelLines.enter().append("rect").attr( + "class", + (d) => `${$ARC.arcLabelLine} ${$COMMON.target} ${$COMMON.target}-${d.data.id}` + ).merge(arcLabelLines); + mainArcLabelLine.style( + "fill", + (d) => $$.levelColor ? $$.levelColor(d.data.values[0].value) : $$.color(d.data) + ).style("display", config.gauge_label_show ? null : "none").each(function(d) { + let lineLength = 0; + const lineThickness = 2; + let x = 0; + let y = 0; + let transform = ""; + if (hiddenTargetIds.indexOf(d.data.id) < 0) { + const updated = $$.updateAngle(d); + const innerLineLength = state.gaugeArcWidth / $$.filterTargetsToShow($$.data.targets).length * (updated.index + 1); + const lineAngle = updated.endAngle - Math.PI / 2; + const arcInnerRadius = state.radius - innerLineLength; + const linePositioningAngle = lineAngle - (arcInnerRadius === 0 ? 0 : 1 / arcInnerRadius); + lineLength = state.radiusExpanded - state.radius + innerLineLength; + x = Math.cos(linePositioningAngle) * arcInnerRadius; + y = Math.sin(linePositioningAngle) * arcInnerRadius; + transform = `rotate(${lineAngle * 180 / Math.PI}, ${x}, ${y})`; + } + (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).attr("x", x).attr("y", y).attr("width", lineLength).attr("height", lineThickness).attr("transform", transform).style("stroke-dasharray", `0, ${lineLength + lineThickness}, 0`); + }); + }, + textForGaugeMinMax(value, isMax) { + const $$ = this; + const { config } = $$; + const format = config.gauge_label_extents; + return isFunction(format) ? format.bind($$.api)(value, isMax) : value; + }, + getGaugeLabelHeight() { + const { config } = this; + return this.config.gauge_label_show && !config.gauge_fullCircle ? 20 : 0; + }, + getPaddingBottomForGauge() { + const $$ = this; + return $$.getGaugeLabelHeight() * ($$.config.gauge_label_show ? 2 : 2.5); + } +}); + +;// ./src/ChartInternal/shape/line.ts +var line_defProp = Object.defineProperty; +var line_defProps = Object.defineProperties; +var line_getOwnPropDescs = Object.getOwnPropertyDescriptors; +var line_getOwnPropSymbols = Object.getOwnPropertySymbols; +var line_hasOwnProp = Object.prototype.hasOwnProperty; +var line_propIsEnum = Object.prototype.propertyIsEnumerable; +var line_defNormalProp = (obj, key, value) => key in obj ? line_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var line_spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (line_hasOwnProp.call(b, prop)) + line_defNormalProp(a, prop, b[prop]); + if (line_getOwnPropSymbols) + for (var prop of line_getOwnPropSymbols(b)) { + if (line_propIsEnum.call(b, prop)) + line_defNormalProp(a, prop, b[prop]); + } + return a; +}; +var line_spreadProps = (a, b) => line_defProps(a, line_getOwnPropDescs(b)); + + + + +function _getStrokeDashArray(start, end, pattern, isLastX = false) { + const dash = start ? [start, 0] : pattern; + for (let i = start ? start : pattern.reduce((a, c) => a + c); i <= end; ) { + pattern.forEach((v) => { + if (i + v <= end) { + dash.push(v); + } + i += v; + }); + } + dash.length % 2 !== 0 && dash.push(isLastX ? pattern[1] : 0); + return { + dash: dash.join(" "), + length: dash.reduce((a, b) => a + b, 0) + }; +} +function _getRegions(d, _regions, isTimeSeries) { + const $$ = this; + const regions = []; + const dasharray = "2 2"; + if (isDefined(_regions)) { + const getValue = (v, def) => isUndefined(v) ? def : isTimeSeries ? parseDate.call($$, v) : v; + for (let i = 0, reg; reg = _regions[i]; i++) { + const start = getValue(reg.start, d[0].x); + const end = getValue(reg.end, d[d.length - 1].x); + const style = reg.style || { dasharray }; + regions[i] = { start, end, style }; + } + } + return regions; +} +/* harmony default export */ var line = ({ + initLine() { + const { $el } = this; + $el.line = $el.main.select(`.${$COMMON.chart}`).append("g").attr("class", $LINE.chartLines).call(this.setCssRule(false, `.${$LINE.chartLines}`, ["pointer-events:none"])); + }, + updateTargetsForLine(t) { + const $$ = this; + const { $el: { area, line, main } } = $$; + const classChartLine = $$.getChartClass("Line"); + const classLines = $$.getClass("lines", true); + const classFocus = $$.classFocus.bind($$); + if (!line) { + $$.initLine(); + } + const targets = t.filter((d) => !($$.isScatterType(d) || $$.isBubbleType(d))); + const mainLineUpdate = main.select(`.${$LINE.chartLines}`).selectAll(`.${$LINE.chartLine}`).data($$.filterNullish(targets)).attr("class", (d) => classChartLine(d) + classFocus(d)); + const mainLineEnter = mainLineUpdate.enter().append("g").attr("class", classChartLine).style("opacity", "0").style("pointer-events", $$.getStylePropValue("none")); + mainLineEnter.append("g").attr("class", classLines); + if ($$.hasTypeOf("Area")) { + const mainLine = (!area && mainLineEnter.empty() ? mainLineUpdate : mainLineEnter).filter($$.isAreaType.bind($$)); + $$.initArea(mainLine); + } + $$.updateTargetForCircle(targets, mainLineEnter); + }, + /** + * Generate/Update elements + * @param {boolean} withTransition Transition for exit elements + * @param {boolean} isSub Subchart draw + * @private + */ + updateLine(withTransition, isSub = false) { + const $$ = this; + const { format: { extraLineClasses }, $el, $T } = $$; + const $root = isSub ? $el.subchart : $el; + const line = $root.main.selectAll(`.${$LINE.lines}`).selectAll(`.${$LINE.line}`).data($$.lineData.bind($$)); + $T(line.exit(), withTransition).style("opacity", "0").remove(); + $root.line = line.enter().append("path").attr("class", (d) => `${$$.getClass("line", true)(d)} ${extraLineClasses(d) || ""}`).style("stroke", $$.color).merge(line).style("opacity", $$.initialOpacity.bind($$)).attr("transform", null); + }, + /** + * Redraw function + * @param {function} drawFn Retuned functino from .generateDrawCandlestick() + * @param {boolean} withTransition With or without transition + * @param {boolean} isSub Subchart draw + * @returns {Array} + * @private + */ + redrawLine(drawFn, withTransition, isSub = false) { + const $$ = this; + const { $el, $T } = $$; + const { line } = isSub ? $el.subchart : $el; + return [ + $T(line, withTransition, getRandom()).attr("d", drawFn).style("stroke", this.color).style("opacity", null) + ]; + }, + /** + * Get the curve interpolate + * @param {Array} d Data object + * @returns {function} + * @private + */ + getCurve(d) { + const $$ = this; + const isRotatedStepType = $$.config.axis_rotated && $$.isStepType(d); + return isRotatedStepType ? (context) => { + const step = $$.getInterpolate(d)(context); + step.orgPoint = step.point; + step.pointRotated = function(x, y) { + this._point === 1 && (this._point = 2); + const y1 = this._y * (1 - this._t) + y * this._t; + this._context.lineTo(this._x, y1); + this._context.lineTo(x, y1); + this._x = x; + this._y = y; + }; + step.point = function(x, y) { + this._point === 0 ? this.orgPoint(x, y) : this.pointRotated(x, y); + }; + return step; + } : $$.getInterpolate(d); + }, + generateDrawLine(lineIndices, isSub) { + const $$ = this; + const { config, scale } = $$; + const lineConnectNull = config.line_connectNull; + const isRotated = config.axis_rotated; + const getPoints = $$.generateGetLinePoints(lineIndices, isSub); + const yScale = $$.getYScaleById.bind($$); + const xValue = (d) => (isSub ? $$.subxx : $$.xx).call($$, d); + const yValue = (d, i) => $$.isGrouped(d.id) ? getPoints(d, i)[0][1] : yScale(d.id, isSub)($$.getBaseValue(d)); + let line = (0,external_commonjs_d3_shape_commonjs2_d3_shape_amd_d3_shape_root_d3_.line)(); + line = isRotated ? line.x(yValue).y(xValue) : line.x(xValue).y(yValue); + if (!lineConnectNull) { + line = line.defined((d) => $$.getBaseValue(d) !== null); + } + const x = isSub ? scale.subX : scale.x; + return (d) => { + const y = yScale(d.id, isSub); + let values = lineConnectNull ? $$.filterRemoveNull(d.values) : d.values; + let x0 = 0; + let y0 = 0; + let path; + if ($$.isLineType(d)) { + const regions = config.data_regions[d.id]; + if (regions) { + if ($$.isAreaRangeType(d)) { + values = values.map((dv) => line_spreadProps(line_spreadValues({}, dv), { value: $$.getRangedData(dv, "mid") })); + } + path = $$.lineWithRegions(values, scale.zoom || x, y, regions); + } else { + if ($$.isStepType(d)) { + values = $$.convertValuesToStep(values); + } + path = line.curve($$.getCurve(d))(values); + } + } else { + if (values[0]) { + x0 = x(values[0].x); + y0 = y(values[0].value); + } + path = isRotated ? `M ${y0} ${x0}` : `M ${x0} ${y0}`; + } + return path || "M 0 0"; + }; + }, + /** + * Set regions dasharray and get path + * @param {Array} d Data object + * @param {function} x x scale function + * @param {function} y y scale function + * @param {object} _regions regions to be set + * @returns {stirng} Path string + * @private + */ + lineWithRegions(d, x, y, _regions) { + const $$ = this; + const { config } = $$; + const isRotated = config.axis_rotated; + const isTimeSeries = $$.axis.isTimeSeries(); + const dasharray = "2 2"; + const regions = _getRegions.bind($$)(d, _regions, isTimeSeries); + const hasNullDataValue = $$.hasNullDataValue(d); + let xp; + let yp; + let diff; + let diffx2; + const xValue = isRotated ? (dt) => y(dt.value) : (dt) => x(dt.x); + const yValue = isRotated ? (dt) => x(dt.x) : (dt) => y(dt.value); + const generateM = (points) => `M${points[0][0]},${points[0][1]}L${points[1][0]},${points[1][1]}`; + const sWithRegion = isTimeSeries ? (d0, d1, k, timeseriesDiff) => { + const x0 = d0.x.getTime(); + const xDiff = d1.x - d0.x; + const xv0 = new Date(x0 + xDiff * k); + const xv1 = new Date(x0 + xDiff * (k + timeseriesDiff)); + const points = isRotated ? [[y(yp(k)), x(xv0)], [y(yp(k + diff)), x(xv1)]] : [[x(xv0), y(yp(k))], [x(xv1), y(yp(k + diff))]]; + return generateM(points); + } : (d0, d1, k, otherDiff) => { + const x0 = x(d1.x, !isRotated); + const y0 = y(d1.value, isRotated); + const gap = k + otherDiff; + const xValue2 = x(xp(k), !isRotated); + const yValue2 = y(yp(k), isRotated); + let xDiff = x(xp(gap), !isRotated); + let yDiff = y(yp(gap), isRotated); + if (xDiff > x0) { + xDiff = x0; + } + if (d0.value > d1.value && (isRotated ? yDiff < y0 : yDiff > y0)) { + yDiff = y0; + } + const points = [ + [xValue2, yValue2], + [xDiff, yDiff] + ]; + isRotated && points.forEach((v) => v.reverse()); + return generateM(points); + }; + const axisType = { x: $$.axis.getAxisType("x"), y: $$.axis.getAxisType("y") }; + let path = ""; + const target = $$.$el.line.filter(({ id }) => id === d[0].id); + const tempNode = target.clone().style("display", "none"); + const getLength = (node, path2) => node.attr("d", path2).node().getTotalLength(); + const dashArray = { + dash: [], + lastLength: 0 + }; + let isLastX = false; + for (let i = 0, data; data = d[i]; i++) { + const prevData = d[i - 1]; + const hasPrevData = prevData && isValue(prevData.value); + let style = $$.isWithinRegions(data.x, regions); + if (!isValue(data.value)) { + continue; + } + if (isUndefined(regions) || !style || !hasPrevData) { + path += `${i && hasPrevData ? "L" : "M"}${xValue(data)},${yValue(data)}`; + } else if (hasPrevData) { + style = ((style == null ? void 0 : style.dasharray) || dasharray).split(" ").map(Number); + xp = getScale(axisType.x, prevData.x, data.x); + yp = getScale(axisType.y, prevData.value, data.value); + if (hasNullDataValue) { + const dx = x(data.x) - x(prevData.x); + const dy = y(data.value) - y(prevData.value); + const dd = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2)); + diff = style[0] / dd; + diffx2 = diff * style[1]; + for (let j = diff; j <= 1; j += diffx2) { + path += sWithRegion(prevData, data, j, diff); + if (j + diffx2 >= 1) { + path += sWithRegion(prevData, data, 1, 0); + } + } + } else { + let points = []; + isLastX = data.x === d[d.length - 1].x; + if (isTimeSeries) { + const x0 = +prevData.x; + const xv0 = new Date(x0); + const xv1 = new Date(x0 + (+data.x - x0)); + points = [ + [x(xv0), y(yp(0))], + // M + [x(xv1), y(yp(1))] + // L + ]; + } else { + points = [ + [x(xp(0)), y(yp(0))], + // M + [x(xp(1)), y(yp(1))] + // L + ]; + } + isRotated && points.forEach((v) => v.reverse()); + const startLength = getLength(tempNode, path); + const endLength = getLength(tempNode, path += `L${points[1].join(",")}`); + const strokeDashArray = _getStrokeDashArray( + startLength - dashArray.lastLength, + endLength - dashArray.lastLength, + style, + isLastX + ); + dashArray.lastLength += strokeDashArray.length; + dashArray.dash.push(strokeDashArray.dash); + } + } + } + if (dashArray.dash.length) { + !isLastX && dashArray.dash.push(getLength(tempNode, path)); + tempNode.remove(); + target.attr("stroke-dasharray", dashArray.dash.join(" ")); + } + return path; + }, + isWithinRegions(withinX, withinRegions) { + for (let i = 0, reg; reg = withinRegions[i]; i++) { + if (reg.start < withinX && withinX <= reg.end) { + return reg.style; + } + } + return false; + }, + isWithinStep(that, y) { + return Math.abs(y - getPointer(this.state.event, that)[1]) < 30; + }, + shouldDrawPointsForLine(d) { + const linePoint = this.config.line_point; + return linePoint === true || isArray(linePoint) && linePoint.indexOf(d.id) !== -1; + } +}); + +;// ./src/ChartInternal/shape/point.ts + + + +const getTransitionName = () => getRandom(); +/* harmony default export */ var point = ({ + initialOpacityForCircle(d) { + const { config, state: { withoutFadeIn } } = this; + let opacity = config.point_opacity; + if (isUndefined(opacity)) { + opacity = this.getBaseValue(d) !== null && withoutFadeIn[d.id] ? this.opacityForCircle(d) : "0"; + } + return opacity; + }, + opacityForCircle(d) { + var _a; + const { config } = this; + let opacity = config.point_opacity; + if (isUndefined(opacity)) { + opacity = config.point_show && !((_a = this.isPointFocusOnly) == null ? void 0 : _a.call(this)) ? null : "0"; + opacity = isValue(this.getBaseValue(d)) ? this.isBubbleType(d) || this.isScatterType(d) ? "0.5" : opacity : "0"; + } + return opacity; + }, + initCircle() { + const $$ = this; + const { $el: { main } } = $$; + !$$.point && ($$.point = $$.generatePoint()); + if (($$.hasType("bubble") || $$.hasType("scatter")) && main.select(`.${$COMMON.chart} > .${$CIRCLE.chartCircles}`).empty()) { + main.select(`.${$COMMON.chart}`).append("g").attr("class", $CIRCLE.chartCircles); + } + }, + updateTargetForCircle(targetsValue, enterNodeValue) { + const $$ = this; + const { config, data, $el } = $$; + const selectionEnabled = config.interaction_enabled && config.data_selection_enabled; + const isSelectable = selectionEnabled && config.data_selection_isselectable; + const classCircles = $$.getClass("circles", true); + if (!config.point_show) { + return; + } + $$.initCircle(); + let targets = targetsValue; + let enterNode = enterNodeValue; + if (!targets) { + targets = $$.filterNullish(data.targets).filter((d) => this.isScatterType(d) || this.isBubbleType(d)); + const mainCircle = $el.main.select(`.${$CIRCLE.chartCircles}`).style("pointer-events", "none").selectAll(`.${$CIRCLE.circles}`).data(targets); + mainCircle.exit().remove(); + enterNode = mainCircle.enter(); + } + selectionEnabled && enterNode.append("g").attr("class", (d) => $$.generateClass($SELECT.selectedCircles, d.id)); + enterNode.append("g").attr("class", classCircles).call((selection) => { + $$.setCssRule(true, `.${$CIRCLE.circles}`, ["cursor:pointer"], isSelectable)( + selection + ); + $$.setCssRule(true, ` .${$CIRCLE.circle}`, ["fill", "stroke"], $$.color)(selection); + }).style("opacity", function() { + const parent = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this.parentNode); + return parent.attr("class").indexOf($CIRCLE.chartCircles) > -1 ? "0" : null; + }); + selectionEnabled && targets.forEach((t) => { + $el.main.selectAll(`.${$SELECT.selectedCircles}${$$.getTargetSelectorSuffix(t.id)}`).selectAll(`${$SELECT.selectedCircle}`).each((d) => { + d.value = t.values[d.index].value; + }); + }); + }, + updateCircle(isSub = false) { + const $$ = this; + const { config, state, $el } = $$; + const focusOnly = $$.isPointFocusOnly(); + const $root = isSub ? $el.subchart : $el; + if (config.point_show && !state.toggling) { + config.point_radialGradient && $$.updateLinearGradient(); + const circles = $root.main.selectAll(`.${$CIRCLE.circles}`).selectAll(`.${$CIRCLE.circle}`).data((d) => { + const data = $$.isLineType(d) && $$.shouldDrawPointsForLine(d) || $$.isBubbleType(d) || $$.isRadarType(d) || $$.isScatterType(d) ? focusOnly ? [d.values[0]] : d.values : []; + return $$.filterNullish(data); + }); + circles.exit().remove(); + circles.enter().filter(Boolean).append( + $$.point("create", this, $$.pointR.bind($$), $$.updateCircleColor.bind($$)) + ); + $root.circle = $root.main.selectAll(`.${$CIRCLE.circles} .${$CIRCLE.circle}`).style("stroke", $$.getStylePropValue($$.color)).style("opacity", $$.initialOpacityForCircle.bind($$)); + } + }, + /** + * Update circle color + * @param {object} d Data object + * @returns {string} Color string + * @private + */ + updateCircleColor(d) { + const $$ = this; + const fn = $$.getStylePropValue($$.color); + return $$.config.point_radialGradient ? $$.getGradienColortUrl(d.id) : fn ? fn(d) : null; + }, + redrawCircle(cx, cy, withTransition, flow, isSub = false) { + const $$ = this; + const { state: { rendered }, $el, $T } = $$; + const $root = isSub ? $el.subchart : $el; + const selectedCircles = $root.main.selectAll(`.${$SELECT.selectedCircle}`); + if (!$$.config.point_show) { + return []; + } + const fn = $$.point( + "update", + $$, + cx, + cy, + $$.updateCircleColor.bind($$), + withTransition, + flow, + selectedCircles + ); + const posAttr = $$.isCirclePoint() ? "c" : ""; + const t = getRandom(); + const opacityStyleFn = $$.opacityForCircle.bind($$); + const mainCircles = []; + $root.circle.each(function(d) { + let result = fn.bind(this)(d); + result = $T(result, withTransition || !rendered, t).style("opacity", opacityStyleFn); + mainCircles.push(result); + }); + return [ + mainCircles, + $T(selectedCircles, withTransition).attr(`${posAttr}x`, cx).attr(`${posAttr}y`, cy) + ]; + }, + /** + * Show focused data point circle + * @param {object} d Selected data + * @private + */ + showCircleFocus(d) { + const $$ = this; + const { state: { hasRadar, resizing, toggling, transiting }, $el } = $$; + let { circle } = $el; + if (transiting === false && circle && $$.isPointFocusOnly()) { + const cx = (hasRadar ? $$.radarCircleX : $$.circleX).bind($$); + const cy = (hasRadar ? $$.radarCircleY : $$.circleY).bind($$); + const withTransition = toggling || isUndefined(d); + const fn = $$.point( + "update", + $$, + cx, + cy, + $$.getStylePropValue($$.color), + resizing ? false : withTransition + ); + if (d) { + circle = circle.filter(function(t) { + var _a; + const data = (_a = d.filter) == null ? void 0 : _a.call(d, (v) => v.id === t.id); + return data.length ? (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).datum(data[0]) : false; + }); + } + circle.attr("class", this.updatePointClass.bind(this)).style("opacity", null).each(function(d2) { + const { id, index, value } = d2; + let visibility = "hidden"; + if (isValue(value)) { + fn.bind(this)(d2); + $$.expandCircles(index, id); + visibility = ""; + } + this.style.visibility = visibility; + }); + } + }, + /** + * Hide focused data point circle + * @private + */ + hideCircleFocus() { + const $$ = this; + const { $el: { circle } } = $$; + if ($$.isPointFocusOnly() && circle) { + $$.unexpandCircles(); + circle.style("visibility", "hidden"); + } + }, + circleX(d) { + return this.xx(d); + }, + updateCircleY(isSub = false) { + const $$ = this; + const getPoints = $$.generateGetLinePoints($$.getShapeIndices($$.isLineType), isSub); + return (d, i) => { + const id = d.id; + return $$.isGrouped(id) ? getPoints(d, i)[0][1] : $$.getYScaleById(id, isSub)($$.getBaseValue(d)); + }; + }, + expandCircles(i, id, reset) { + const $$ = this; + const r = $$.pointExpandedR.bind($$); + reset && $$.unexpandCircles(); + const circles = $$.getShapeByIndex("circle", i, id).classed($COMMON.EXPANDED, true); + const scale = r(circles) / $$.config.point_r; + const ratio = 1 - scale; + if ($$.isCirclePoint()) { + circles.attr("r", r); + } else { + circles.each(function() { + const point = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + if (this.tagName === "circle") { + point.attr("r", r); + } else { + const { width, height } = getBBox(this); + const x = ratio * (+point.attr("x") + width / 2); + const y = ratio * (+point.attr("y") + height / 2); + point.attr("transform", `translate(${x} ${y}) scale(${scale})`); + } + }); + } + }, + unexpandCircles(i) { + const $$ = this; + const r = $$.pointR.bind($$); + const circles = $$.getShapeByIndex("circle", i).filter(function() { + return (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this).classed($COMMON.EXPANDED); + }).classed($COMMON.EXPANDED, false); + circles.attr("r", r); + if (!$$.isCirclePoint()) { + const scale = r(circles) / $$.config.point_r; + circles.attr("transform", scale !== 1 ? `scale(${scale})` : null); + } + }, + pointR(d) { + const $$ = this; + const { config } = $$; + const pointR = config.point_r; + let r = pointR; + if ($$.isBubbleType(d)) { + r = $$.getBubbleR(d); + } else if (isFunction(pointR)) { + r = pointR.bind($$.api)(d); + } + d.r = r; + return r; + }, + pointExpandedR(d) { + const $$ = this; + const { config } = $$; + const scale = $$.isBubbleType(d) ? 1.15 : 1.75; + return config.point_focus_expand_enabled ? config.point_focus_expand_r || $$.pointR(d) * scale : $$.pointR(d); + }, + pointSelectR(d) { + const $$ = this; + const selectR = $$.config.point_select_r; + return isFunction(selectR) ? selectR(d) : selectR || $$.pointR(d) * 4; + }, + /** + * Check if point.focus.only option can be applied. + * @returns {boolean} + * @private + */ + isPointFocusOnly() { + const $$ = this; + return $$.config.point_focus_only && !$$.hasType("bubble") && !$$.hasType("scatter") && !$$.hasArcType(null, ["radar"]); + }, + isWithinCircle(node, r) { + const { state } = this; + const mouse = getPointer(state.event, node); + const element = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(node); + const prefix = this.isCirclePoint(node) ? "c" : ""; + const pointSensitivity = this.getPointSensitivity(element == null ? void 0 : element.datum()); + let cx = +element.attr(`${prefix}x`); + let cy = +element.attr(`${prefix}y`); + if (!(cx || cy) && node.nodeType === 1) { + const { x, y } = getBoundingRect(node); + cx = x; + cy = y; + } + return Math.sqrt( + Math.pow(cx - mouse[0], 2) + Math.pow(cy - mouse[1], 2) + ) < (r || pointSensitivity); + }, + /** + * Get data point sensitivity radius + * @param {object} d Data point object + * @returns {number} return the sensitivity value + */ + getPointSensitivity(d) { + const $$ = this; + let sensitivity = $$.config.point_sensitivity; + if (!d) { + return sensitivity; + } else if (isFunction(sensitivity)) { + sensitivity = sensitivity.call($$.api, d); + } else if (sensitivity === "radius") { + sensitivity = d.r; + } + return sensitivity; + }, + updatePointClass(d) { + const $$ = this; + const { circle } = $$.$el; + let pointClass = false; + if (isObject(d) || circle) { + pointClass = d === true ? circle.each(function(d2) { + let className = $$.getClass("circle", true)(d2); + if (this.getAttribute("class").indexOf($COMMON.EXPANDED) > -1) { + className += ` ${$COMMON.EXPANDED}`; + } + this.setAttribute("class", className); + }) : $$.getClass("circle", true)(d); + } + return pointClass; + }, + generateGetLinePoints(lineIndices, isSub) { + const $$ = this; + const { config } = $$; + const x = $$.getShapeX(0, lineIndices, isSub); + const y = $$.getShapeY(isSub); + const lineOffset = $$.getShapeOffset($$.isLineType, lineIndices, isSub); + const yScale = $$.getYScaleById.bind($$); + return (d, i) => { + const y0 = yScale.call($$, d.id, isSub)($$.getShapeYMin(d.id)); + const offset = lineOffset(d, i) || y0; + const posX = x(d); + let posY = y(d); + if (config.axis_rotated && (d.value > 0 && posY < y0 || d.value < 0 && y0 < posY)) { + posY = y0; + } + const point = [posX, posY - (y0 - offset)]; + return [ + point, + point, + // from here and below, needed for compatibility + point, + point + ]; + }; + }, + custom: { + create(element, id, fillStyleFn) { + return element.append("use").attr("xlink:href", `#${id}`).attr("class", this.updatePointClass.bind(this)).style("fill", fillStyleFn).node(); + }, + update(element, xPosFn, yPosFn, fillStyleFn, withTransition, flow, selectedCircles) { + const $$ = this; + const { width, height } = getBBox(element.node()); + const xPosFn2 = (d) => isValue(d.value) ? xPosFn(d) - width / 2 : 0; + const yPosFn2 = (d) => isValue(d.value) ? yPosFn(d) - height / 2 : 0; + let mainCircles = element; + if (withTransition) { + flow && mainCircles.attr("x", xPosFn2); + mainCircles = $$.$T(mainCircles, withTransition, getTransitionName()); + selectedCircles && $$.$T(selectedCircles, withTransition, getTransitionName()); + } + return mainCircles.attr("x", xPosFn2).attr("y", yPosFn2).style("fill", fillStyleFn); + } + }, + // 'circle' data point + circle: { + create(element, sizeFn, fillStyleFn) { + return element.append("circle").attr("class", this.updatePointClass.bind(this)).attr("r", sizeFn).style("fill", fillStyleFn).node(); + }, + update(element, xPosFn, yPosFn, fillStyleFn, withTransition, flow, selectedCircles) { + const $$ = this; + let mainCircles = element; + if ($$.hasType("bubble")) { + mainCircles.attr("r", $$.pointR.bind($$)); + } + if (withTransition) { + flow && mainCircles.attr("cx", xPosFn); + if (mainCircles.attr("cx")) { + mainCircles = $$.$T(mainCircles, withTransition, getTransitionName()); + } + selectedCircles && $$.$T(mainCircles, withTransition, getTransitionName()); + } + return mainCircles.attr("cx", xPosFn).attr("cy", yPosFn).style("fill", fillStyleFn); + } + }, + // 'rectangle' data point + rectangle: { + create(element, sizeFn, fillStyleFn) { + const rectSizeFn = (d) => sizeFn(d) * 2; + return element.append("rect").attr("class", this.updatePointClass.bind(this)).attr("width", rectSizeFn).attr("height", rectSizeFn).style("fill", fillStyleFn).node(); + }, + update(element, xPosFn, yPosFn, fillStyleFn, withTransition, flow, selectedCircles) { + const $$ = this; + const r = $$.config.point_r; + const rectXPosFn = (d) => xPosFn(d) - r; + const rectYPosFn = (d) => yPosFn(d) - r; + let mainCircles = element; + if (withTransition) { + flow && mainCircles.attr("x", rectXPosFn); + mainCircles = $$.$T(mainCircles, withTransition, getTransitionName()); + selectedCircles && $$.$T(selectedCircles, withTransition, getTransitionName()); + } + return mainCircles.attr("x", rectXPosFn).attr("y", rectYPosFn).style("fill", fillStyleFn); + } + } +}); + +;// ./src/ChartInternal/shape/point.common.ts + + + +function _hasValidPointDrawMethods(point) { + return isObjectType(point) && isFunction(point.create) && isFunction(point.update); +} +function _insertPointInfoDefs(point, id) { + var _a; + const $$ = this; + const copyAttr = (from, target) => { + const attribs = from.attributes; + for (let i = 0, name; name = attribs[i]; i++) { + name = name.name; + target.setAttribute(name, from.getAttribute(name)); + } + }; + const doc = new DOMParser().parseFromString(sanitize(point), "image/svg+xml"); + const node = doc.documentElement; + const clone = browser_doc.createElementNS(external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.namespaces.svg, node.nodeName.toLowerCase()); + clone.id = id; + clone.style.fill = "inherit"; + clone.style.stroke = "inherit"; + copyAttr(node, clone); + if ((_a = node.childNodes) == null ? void 0 : _a.length) { + const parent = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(clone); + if ("innerHTML" in clone) { + parent.html(sanitize(node.innerHTML)); + } else { + toArray(node.childNodes).forEach((v) => { + copyAttr(v, parent.append(v.tagName).node()); + }); + } + } + $$.$el.defs.node().appendChild(clone); +} +/* harmony default export */ var point_common = ({ + /** + * Check if point type option is valid + * @param {string} type point type + * @returns {boolean} + * @private + */ + hasValidPointType(type) { + return /^(circle|rect(angle)?|polygon|ellipse|use)$/i.test(type || this.config.point_type); + }, + /** + * Check if pattern point is set to be used on legend + * @returns {boolean} + * @private + */ + hasLegendDefsPoint() { + var _a; + const { config } = this; + return config.legend_show && ((_a = config.point_pattern) == null ? void 0 : _a.length) && config.legend_usePoint; + }, + getDefsPointId(id) { + const { state: { datetimeId } } = this; + return `${datetimeId}-point${id}`; + }, + /** + * Get validated point pattern array + * @returns {Array} Array of point types + * @private + */ + getValidPointPattern() { + const { config } = this; + const validPointType = /^(circle|rect(angle)?)$/i.test(config.point_type) ? config.point_type : "circle"; + return notEmpty(config.point_pattern) ? config.point_pattern : [validPointType]; + }, + /** + * Get generate point function + * @returns {function} + * @private + */ + generatePoint() { + const $$ = this; + const { $el, config } = $$; + const ids = []; + const pattern = $$.getValidPointPattern(); + return function(method, context, ...args) { + return function(d) { + var _a, _b, _c, _d; + const id = $$.getTargetSelectorSuffix(d.id || ((_a = d.data) == null ? void 0 : _a.id) || d); + const element = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this); + ids.indexOf(id) < 0 && ids.push(id); + let point = pattern[ids.indexOf(id) % pattern.length]; + if ($$.hasValidPointType(point)) { + point = $$[point]; + } else if (!_hasValidPointDrawMethods(point || config.point_type)) { + const pointId = $$.getDefsPointId(id); + const defsPoint = $el.defs.select(`#${pointId}`); + if (defsPoint.size() < 1) { + _insertPointInfoDefs.call($$, point, pointId); + } + if (method === "create") { + return (_b = $$.custom) == null ? void 0 : _b.create.bind(context)(element, pointId, ...args); + } else if (method === "update") { + return (_c = $$.custom) == null ? void 0 : _c.update.bind(context)(element, ...args); + } + } + return (_d = point[method]) == null ? void 0 : _d.bind(context)(element, ...args); + }; + }; + } +}); + +;// ./src/ChartInternal/shape/polar.ts + + +function getDataMax($$) { + const levelMax = $$.config.polar_level_max; + let dataMax = $$.getMinMaxData().max[0].value; + if (levelMax && levelMax > dataMax) { + dataMax = levelMax; + } + return dataMax; +} +/* harmony default export */ var polar = ({ + /** + * Initialize polar + * @private + */ + initPolar() { + const $$ = this; + const { $el: { arcs }, config } = $$; + const levelTextShow = config.polar_level_text_show; + const levelTextBgColor = config.polar_level_text_backgroundColor; + arcs.levels = arcs.append("g").attr("class", $LEVEL.levels); + if (levelTextShow && levelTextBgColor) { + $$.generateTextBGColorFilter(levelTextBgColor); + } + }, + /** + * Get polar outer radius according to the data value + * @param {object} d Data object + * @param {numbet} outerRadius Outer radius + * @returns {number} outer radius + * @private + */ + getPolarOuterRadius(d, outerRadius) { + var _a; + const dataMax = getDataMax(this); + return ((_a = d == null ? void 0 : d.data.values[0].value) != null ? _a : 0) / dataMax * outerRadius; + }, + /** + * Update polar based on given data array + * @param {object} targets Data object + * @private + */ + updateTargetsForPolar(targets) { + this.updateTargetsForArc(targets); + }, + /** + * Called whenever redraw happens + * @private + */ + redrawPolar() { + const $$ = this; + const { config } = $$; + config.polar_level_show && $$.updatePolarLevel(); + }, + /** + * Update polar level circle + * @private + */ + updatePolarLevel() { + const $$ = this; + const { config, state, $el: { arcs: { levels } } } = $$; + const depth = config.polar_level_depth; + const dataMax = getDataMax($$); + const levelData = getRange(0, depth); + const outerRadius = state.radius; + const levelRatio = levelData.map((l) => outerRadius * ((l + 1) / depth)); + const levelTextFormat = (config.polar_level_text_format || function() { + }).bind($$.api); + const level = levels.selectAll(`.${$LEVEL.level}`).data(levelData); + level.exit().remove(); + const levelEnter = level.enter().append("g").attr("class", (d, i) => `${$LEVEL.level} ${$LEVEL.level}-${i}`); + levelEnter.append("circle"); + levelEnter.merge(level).selectAll("circle").style("visibility", config.polar_level_show ? null : "hidden").attr("cx", 0).attr("cy", 0).attr("r", (d) => levelRatio[d]); + if (config.polar_level_text_show) { + const levelTextBackgroundColor = config.polar_level_text_backgroundColor; + const defsId = `#${state.datetimeId}-labels-bg${$$.getTargetSelectorSuffix(levelTextBackgroundColor)}`; + levelEnter.append("text").style("text-anchor", "middle"); + levelEnter.merge(level).selectAll("text").attr("dy", (d) => -levelRatio[d] + 5).attr("filter", levelTextBackgroundColor ? `url(${defsId})` : null).text((d) => levelTextFormat(dataMax / levelData.length * (d + 1))); + } + } +}); + +;// ./src/ChartInternal/shape/radar.ts + + + + +function _getPosition(isClockwise, type, edge, pos, range, ratio) { + const index = isClockwise && pos > 0 ? edge - pos : pos; + const r = 2 * Math.PI; + const func = type === "x" ? Math.sin : Math.cos; + return range * (1 - ratio * func(index * r / edge)); +} +const cacheKeyPoints = KEY.radarPoints; +const cacheKeyTextWidth = KEY.radarTextWidth; +/* harmony default export */ var radar = ({ + initRadar() { + const $$ = this; + const { config, state: { current }, $el } = $$; + if ($$.hasType("radar")) { + $el.radar = $el.main.select(`.${$COMMON.chart}`).append("g").attr("class", $RADAR.chartRadars); + $el.radar.levels = $el.radar.append("g").attr("class", $LEVEL.levels); + $el.radar.axes = $el.radar.append("g").attr("class", $AXIS.axis); + $el.radar.shapes = $el.radar.append("g").attr("class", $SHAPE.shapes); + current.dataMax = config.radar_axis_max || $$.getMinMaxData().max[0].value; + if (config.radar_axis_text_show) { + config.interaction_enabled && $$.bindRadarEvent(); + $$.updateRadarLevel(); + $$.updateRadarAxes(); + } + } + }, + getRadarSize() { + const $$ = this; + const { config, state: { arcWidth, arcHeight } } = $$; + const padding = config.axis_x_categories.length < 4 ? -20 : 10; + const size = (Math.min(arcWidth, arcHeight) - padding) / 2; + return [size, size]; + }, + updateTargetsForRadar(targets) { + const $$ = this; + const { config } = $$; + if (isEmpty(config.axis_x_categories)) { + config.axis_x_categories = getRange(0, getMinMax("max", targets.map( + (v) => v.values.length + ))); + } + $$.generateRadarPoints(); + }, + getRadarPosition(type, index, range, ratio) { + const $$ = this; + const { config } = $$; + const [width, height] = $$.getRadarSize(); + const edge = config.axis_x_categories.length; + const isClockwise = config.radar_direction_clockwise; + const pos = toArray(type).map( + (v) => _getPosition( + isClockwise, + v, + edge, + index, + isDefined(range) ? range : type === "x" ? width : height, + isNumber(ratio) ? ratio : config.radar_size_ratio + ) + ); + return pos.length === 1 ? pos[0] : pos; + }, + /** + * Generate data points + * @private + */ + generateRadarPoints() { + const $$ = this; + const targets = $$.data.targets; + const [width, height] = $$.getRadarSize(); + const points = $$.cache.get(cacheKeyPoints) || {}; + const size = points._size; + if (!size || size.width !== width && size.height !== height) { + targets.forEach((d) => { + points[d.id] = d.values.map((v, i) => $$.getRadarPosition(["x", "y"], i, void 0, $$.getRatio("radar", v))); + }); + points._size = { width, height }; + $$.cache.add(cacheKeyPoints, points); + } + }, + redrawRadar() { + const $$ = this; + const { radar, main } = $$.$el; + const translate = $$.getTranslate("radar"); + if (translate) { + radar.attr("transform", translate); + main.select(`.${$TEXT.chartTexts}`).attr("transform", translate); + $$.generateRadarPoints(); + $$.updateRadarLevel(); + $$.updateRadarAxes(); + $$.updateRadarShape(); + } + }, + generateGetRadarPoints() { + const points = this.cache.get(cacheKeyPoints); + return (d, i) => { + const point = points[d.id][i]; + return [ + point, + point, + point, + point + ]; + }; + }, + updateRadarLevel() { + const $$ = this; + const { config, state, $el: { radar } } = $$; + const [width, height] = $$.getRadarSize(); + const depth = config.radar_level_depth; + const edge = config.axis_x_categories.length; + const showText = config.radar_level_text_show; + const radarLevels = radar.levels; + const levelData = getRange(0, depth); + const radius = config.radar_size_ratio * Math.min(width, height); + const levelRatio = levelData.map((l) => radius * ((l + 1) / depth)); + const levelTextFormat = (config.radar_level_text_format || function() { + }).bind($$.api); + const points = levelData.map((v) => { + const range = levelRatio[v]; + const pos = getRange(0, edge).map( + (i) => $$.getRadarPosition(["x", "y"], i, range, 1).join(",") + ); + return pos.join(" "); + }); + const level = radarLevels.selectAll(`.${$LEVEL.level}`).data(levelData); + level.exit().remove(); + const levelEnter = level.enter().append("g").attr("class", (d, i) => `${$LEVEL.level} ${$LEVEL.level}-${i}`); + levelEnter.append("polygon").style("visibility", config.radar_level_show ? null : "hidden"); + if (showText) { + if (radarLevels.select("text").empty()) { + radarLevels.append("text").attr("dx", "-.5em").attr("dy", "-.7em").style("text-anchor", "end").text(() => levelTextFormat(0)); + } + levelEnter.append("text").attr("dx", "-.5em").style("text-anchor", "end").text( + (d) => levelTextFormat( + state.current.dataMax / levelData.length * (d + 1) + ) + ); + } + levelEnter.merge(level).attr( + "transform", + (d) => `translate(${width - levelRatio[d]}, ${height - levelRatio[d]})` + ).selectAll("polygon").attr("points", (d) => points[d]); + if (showText) { + radarLevels.selectAll("text").attr("x", (d) => isUndefined(d) ? width : points[d].split(",")[0]).attr("y", (d) => isUndefined(d) ? height : 0); + } + }, + updateRadarAxes() { + const $$ = this; + const { config, $el: { radar } } = $$; + const [width, height] = $$.getRadarSize(); + const categories = config.axis_x_categories; + let axis = radar.axes.selectAll("g").data(categories); + axis.exit().remove(); + const axisEnter = axis.enter().append("g").attr("class", (d, i) => `${$AXIS.axis}-${i}`); + config.radar_axis_line_show && axisEnter.append("line"); + config.radar_axis_text_show && axisEnter.append("text"); + axis = axisEnter.merge(axis); + if (config.radar_axis_line_show) { + axis.select("line").attr("x1", width).attr("y1", height).attr("x2", (d, i) => $$.getRadarPosition("x", i)).attr("y2", (d, i) => $$.getRadarPosition("y", i)); + } + if (config.radar_axis_text_show) { + const { x = 0, y = 0 } = config.radar_axis_text_position; + const textWidth = $$.cache.get(cacheKeyTextWidth) || 0; + axis.select("text").style("text-anchor", "middle").attr("dy", ".5em").call((selection) => { + selection.each(function(d) { + setTextValue((0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(this), String(d), [-0.6, 1.2]); + }); + }).datum((d, i) => ({ index: i })).attr("transform", function(d) { + if (isUndefined(this.width)) { + this.width = getBoundingRect(this, true).width / 2; + } + let posX = $$.getRadarPosition("x", d.index, void 0, 1); + let posY = Math.round($$.getRadarPosition("y", d.index, void 0, 1)); + if (posX > width) { + posX += this.width + x; + } else if (Math.round(posX) < width) { + posX -= this.width + x; + } + if (posY > height) { + if (posY / 2 === height && this.firstChild.tagName === "tspan") { + this.firstChild.setAttribute("dy", "0em"); + } + posY += y; + } else if (posY < height) { + posY -= y; + } + return `translate(${posX} ${posY})`; + }); + if (!textWidth) { + const widths = [radar.axes, radar.levels].map((v) => getPathBox(v.node()).width); + if (widths.every((v) => v > 0)) { + $$.cache.add(cacheKeyTextWidth, widths[0] - widths[1]); + } + } + } + }, + bindRadarEvent() { + const $$ = this; + const { config, state, $el: { radar, svg } } = $$; + const focusOnly = $$.isPointFocusOnly(); + const { inputType, transiting } = state; + const isMouse = inputType === "mouse"; + const hide = (event) => { + state.event = event; + if (!config.interaction_onout) { + return; + } + const index = $$.getDataIndexFromEvent(event); + const noIndex = isUndefined(index); + if (isMouse || noIndex) { + $$.hideTooltip(); + focusOnly ? $$.hideCircleFocus() : $$.unexpandCircles(); + if (isMouse) { + $$.setOverOut(false, index); + } else if (noIndex) { + $$.callOverOutForTouch(); + } + } + }; + radar.axes.on(isMouse ? "mouseover " : "touchstart", (event) => { + if (transiting) { + return; + } + state.event = event; + const index = $$.getDataIndexFromEvent(event); + $$.selectRectForSingle(svg.node(), index); + isMouse ? $$.setOverOut(true, index) : $$.callOverOutForTouch(index); + }, isMouse ? void 0 : { passive: true }).on("mouseout", isMouse ? hide : null); + if (!isMouse) { + svg.on("touchstart", hide, { passive: true }); + } + }, + updateRadarShape() { + const $$ = this; + const targets = $$.data.targets.filter((d) => $$.isRadarType(d)); + const points = $$.cache.get(cacheKeyPoints); + const areas = $$.$el.radar.shapes.selectAll("polygon").data($$.filterNullish(targets)); + const areasEnter = areas.enter().append("g").attr("class", $$.getChartClass("Radar")); + $$.$T(areas.exit()).remove(); + areasEnter.append("polygon").merge(areas).style("fill", $$.color).style("stroke", $$.color).attr("points", (d) => points[d.id].join(" ")); + $$.updateTargetForCircle(targets, areasEnter); + }, + /** + * Get data point x coordinate + * @param {object} d Data object + * @returns {number} + * @private + */ + radarCircleX(d) { + return this.cache.get(cacheKeyPoints)[d.id][d.index][0]; + }, + /** + * Get data point y coordinate + * @param {object} d Data object + * @returns {number} + * @private + */ + radarCircleY(d) { + return this.cache.get(cacheKeyPoints)[d.id][d.index][1]; + } +}); + +// EXTERNAL MODULE: external {"commonjs":"d3-hierarchy","commonjs2":"d3-hierarchy","amd":"d3-hierarchy","root":"d3"} +var external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_ = __webpack_require__(14); +;// ./src/ChartInternal/shape/treemap.ts + + + + + +function position(group, root) { + const $$ = this; + const { scale: { x, y }, state: { width } } = $$; + group.selectAll("g").attr("transform", (d) => `translate(${d === root ? "0,0" : `${x(d.x0)},${y(d.y0)}`})`).select("rect").attr("width", (d) => d === root ? width : x(d.x1) - x(d.x0)).attr("height", (d) => d === root ? 0 : y(d.y1) - y(d.y0)); +} +function convertDataToTreemapData(data) { + const $$ = this; + return data.map((d) => { + const { id, values } = d; + const { value } = values[0]; + return { + name: id, + id, + // needed to keep compatibility on whole code logic + value, + ratio: $$.getRatio("treemap", values[0]) + }; + }); +} +function getHierachyData(data) { + const $$ = this; + const hierarchyData = (0,external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.hierarchy)(data).sum((d) => d.value); + const sortFn = $$.getSortCompareFn(true); + return [ + $$.treemap( + sortFn ? hierarchyData.sort(sortFn) : hierarchyData + ) + ]; +} +/* harmony default export */ var treemap = ({ + initTreemap() { + const $$ = this; + const { + $el, + state: { + current: { width, height }, + clip, + datetimeId + } + } = $$; + clip.id = `${datetimeId}-clip`; + $$.treemap = (0,external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemap)().tile($$.getTreemapTile()); + $el.defs.append("clipPath").attr("id", clip.id).append("rect").attr("width", width).attr("height", height); + $el.treemap = $el.main.select(`.${$COMMON.chart}`).attr("clip-path", `url(#${clip.id})`).append("g").classed($TREEMAP.chartTreemaps, true); + $$.bindTreemapEvent(); + }, + /** + * Bind events + * @private + */ + bindTreemapEvent() { + const $$ = this; + const { $el, config, state } = $$; + const getTarget = (event) => { + var _a; + const target = event.isTrusted ? event.target : (_a = state.eventReceiver.rect) == null ? void 0 : _a.node(); + let data; + if (/^rect$/i.test(target.tagName)) { + state.event = event; + data = (0,external_commonjs_d3_selection_commonjs2_d3_selection_amd_d3_selection_root_d3_.select)(target).datum(); + } + return data == null ? void 0 : data.data; + }; + if (config.interaction_enabled) { + const isTouch = state.inputType === "touch"; + $el.treemap.on(isTouch ? "touchstart" : "mouseover mousemove", (event) => { + const data = getTarget(event); + if (data) { + $$.showTooltip([data], event.currentTarget); + /^(touchstart|mouseover)$/.test(event.type) && $$.setOverOut(true, data); + } + }, isTouch ? { passive: true } : void 0).on(isTouch ? "touchend" : "mouseout", (event) => { + const data = getTarget(event); + if (config.interaction_onout) { + $$.hideTooltip(); + $$.setOverOut(false, data); + } + }); + } + }, + /** + * Get tiling function + * @returns {function} + * @private + */ + getTreemapTile() { + var _a, _b; + const $$ = this; + const { config, state: { current: { width, height } } } = $$; + const tile = (_b = { + binary: external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemapBinary, + dice: external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemapDice, + slice: external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemapSlice, + sliceDice: external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemapSliceDice, + squarify: external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemapSquarify, + resquarify: external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemapResquarify + }[(_a = config.treemap_tile) != null ? _a : "binary"]) != null ? _b : external_commonjs_d3_hierarchy_commonjs2_d3_hierarchy_amd_d3_hierarchy_root_d3_.treemapBinary; + return (node, x0, y0, x1, y1) => { + tile(node, 0, 0, width, height); + for (const child of node.children) { + child.x0 = x0 + child.x0 / width * (x1 - x0); + child.x1 = x0 + child.x1 / width * (x1 - x0); + child.y0 = y0 + child.y0 / height * (y1 - y0); + child.y1 = y0 + child.y1 / height * (y1 - y0); + } + }; + }, + /** + * Get treemap hierarchy data + * @param {Array} targets Data targets + * @returns {object} + * @private + */ + getTreemapData(targets) { + const $$ = this; + return { + name: "root", + children: convertDataToTreemapData.bind($$)( + $$.filterTargetsToShow(targets.filter($$.isTreemapType, $$)) + ) + }; + }, + /** + * Update treemap data + * @param {Array} targets Data targets + * @private + */ + updateTargetsForTreemap(targets) { + const $$ = this; + const { $el: { treemap } } = $$; + const treemapData = getHierachyData.call($$, $$.getTreemapData(targets != null ? targets : $$.data.targets)); + treemap.data($$.filterNullish(treemapData)); + }, + /** + * Render treemap + * @param {number} durationForExit Duration for exit transition + * @private + */ + updateTreemap(durationForExit) { + const $$ = this; + const { $el, $T } = $$; + const data = $el.treemap.datum(); + const classChartTreemap = $$.getChartClass("Treemap"); + const classTreemap = $$.getClass("treemap", true); + const treemap = $el.treemap.selectAll("g").data(data.children); + $T(treemap.exit(), durationForExit).style("opacity", "0").remove(); + treemap.enter().append("g").append("rect"); + $el.treemap.selectAll("g").attr("class", classChartTreemap).select("rect").attr("class", classTreemap).attr("fill", (d) => $$.color(d.data.name)); + }, + /** + * Generate treemap coordinate points data + * @returns {Array} Array of coordinate points + * @private + */ + generateGetTreemapPoints() { + const $$ = this; + const { $el, scale: { x, y } } = $$; + const points = {}; + $el.treemap.selectAll("g").each((d) => { + points[d.data.name] = [ + [x(d.x0), y(d.y0)], + [x(d.x1), y(d.y1)] + ]; + }); + return (d) => points[d.id]; + }, + /** + * Redraw treemap + * @param {boolean} withTransition With or without transition + * @returns {Array} Selections + * @private + */ + redrawTreemap(withTransition) { + const $$ = this; + const { $el, state: { current: { width, height } } } = $$; + $el.defs.select("rect").attr("width", width).attr("height", height); + return [ + $$.$T($el.treemap, withTransition, getRandom()).call(position.bind($$), $el.treemap.datum()) + ]; + }, + /** + * Get treemap data label format function + * @param {object} d Data object + * @returns {function} Label formatter function + * @private + */ + treemapDataLabelFormat(d) { + const $$ = this; + const { $el: { treemap }, config, scale: { x, y } } = $$; + const { id, value } = d; + const format = config.treemap_label_format; + const ratio = $$.getRatio("treemap", d); + const percentValue = (ratio * 100).toFixed(2); + const meetLabelThreshold = config.treemap_label_show && meetsLabelThreshold.call($$, ratio, "treemap") ? null : "0"; + const treemapNode = treemap.selectAll("g").filter((node) => node.data.id === id).datum(); + let width = 0; + let height = 0; + if (treemapNode) { + const { x0, x1, y0, y1 } = treemapNode; + width = x(x1) - x(x0); + height = y(y1) - y(y0); + } + return function(node) { + node.style("opacity", meetLabelThreshold); + return isFunction(format) ? format.bind($$.api)(value, ratio, id, { width, height }) : `${id} +${percentValue}%`; + }; + } +}); + +;// ./src/config/Options/common/point.ts +/* harmony default export */ var common_point = ({ + /** + * Set point options + * @name point + * @memberof Options + * @type {object} + * @property {object} point Point object + * @property {boolean} [point.show=true] Whether to show each point in line. + * @property {number|function} [point.r=2.5] The radius size of each point. + * - **NOTE:** Disabled for 'bubble' type + * @property {boolean|object} [point.radialGradient=false] Set the radial gradient on point.<br><br> + * Or customize by giving below object value: + * - cx {number}: `cx` value (default: `0.3`) + * - cy {number}: `cy` value (default: `0.3`) + * - r {number}: `r` value (default: `0.7`) + * - stops {Array}: Each item should be having `[offset, stop-color, stop-opacity]` values. + * - (default: `[[0.1, $DATA_COLOR, 1], [0.9, $DATA_COLOR, 0]]`) + * @property {boolean} [point.focus.expand.enabled=true] Whether to expand each point on focus. + * @property {number} [point.focus.expand.r=point.r*1.75] The radius size of each point on focus. + * - **NOTE:** For 'bubble' type, the default is `bubbleSize*1.15` + * @property {boolean} [point.focus.only=false] Show point only when is focused. + * @property {number|null} [point.opacity=undefined] Set point opacity value. + * - **NOTE:** + * - `null` will make to not set inline 'opacity' css prop. + * - when no value(or undefined) is set, it defaults to set opacity value according its chart types. + * @property {number|string|function} [point.sensitivity=10] The sensitivity value for interaction boundary. + * - **Available Values:** + * - {number}: Absolute sensitivity value which is the distance from the data point in pixel. + * - "radius": sensitivity based on point's radius + * - Function: callback for each point to determine the sensitivity<br> + * ```js + * sensitivity: function(d) { + * // ex. of argument d: + * // ==> {x: 2, value: 55, id: 'data3', index: 2, r: 19.820624179302296} + * + * // returning d.r, will make sensitivity same as point's radius value. + * return d.r; + * } + * ``` + * @property {number} [point.select.r=point.r*4] The radius size of each point on selected. + * @property {string} [point.type="circle"] The type of point to be drawn + * - **NOTE:** + * - If chart has 'bubble' type, only circle can be used. + * - For IE, non circle point expansions are not supported due to lack of transform support. + * - **Available Values:** + * - circle + * - rectangle + * @property {Array} [point.pattern=[]] The type of point or svg shape as string, to be drawn for each line + * - **NOTE:** + * - This is an `experimental` feature and can have some unexpected behaviors. + * - If chart has 'bubble' type, only circle can be used. + * - For IE, non circle point expansions are not supported due to lack of transform support. + * - Only common SVG tags are allowed to prevent XSS attacks. If creating charts from user input, it is recommended to sanitize input values to avoid potential vulnerabilities. + * - **Available Values:** + * - circle + * - rectangle + * - svg shape tag interpreted as string<br> + * (ex. `<polygon points='2.5 0 0 5 5 5'></polygon>`) + * @see [Demo: point type](https://naver.github.io/billboard.js/demo/#Point.RectanglePoints) + * @see [Demo: point focus only](https://naver.github.io/billboard.js/demo/#Point.FocusOnly) + * @see [Demo: point radialGradient](https://naver.github.io/billboard.js/demo/#Point.RadialGradientPoint) + * @see [Demo: point sensitivity](https://naver.github.io/billboard.js/demo/#Point.PointSensitivity) + * @example + * point: { + * show: false, + * r: 5, + * + * // or customize the radius + * r: function(d) { + * ... + * return r; + * }, + * + * // will generate following radialGradient: + * // for more info: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/radialGradient + * // <radualGradient cx="0.3" cy="0.3" r="0.7"> + * // <stop offset="0.1" stop-color="$DATA_COLOR" stop-opacity="1"></stop> + * // <stop offset="0.9" stop-color="$DATA_COLOR" stop-opacity="0"></stop> + * // </radialrGradient> + * radialGradient: true, + * + * // Or customized gradient + * radialGradient: { + * cx: 0.3, // cx attributes + * cy: 0.5, // cy attributes + * r: 0.7, // r attributes + * stops: [ + * // offset, stop-color, stop-opacity + * [0, "#7cb5ec", 1], + * + * // setting 'null' for stop-color, will set its original data color + * [0.5, null, 0], + * + * // setting 'function' for stop-color, will pass data id as argument. + * // It should return color string or null value + * [1, function(id) { return id === "data1" ? "red" : "blue"; }, 0], + * ] + * }, + * + * focus: { + * expand: { + * enabled: true, + * r: 1 + * }, + * only: true + * }, + * + * // do not set inline 'opacity' css prop setting + * opacity: null, + * + * // set every data point's opacity value + * opacity: 0.7, + * + * select: { + * r: 3 + * }, + * + * // having lower value, means how closer to be for interaction + * sensitivity: 3, + * + * // sensitivity based on point's radius + * sensitivity: "radius", + * + * // callback for each point to determine the sensitivity + * sensitivity: function(d) { + * // ex. of argument d: + * // ==> {x: 2, value: 55, id: 'data3', index: 2, r: 19.820624179302296} + * + * // returning d.r, will make sensitivity same as point's radius value. + * return d.r; + * } + * + * // valid values are "circle" or "rectangle" + * type: "rectangle", + * + * // or indicate as pattern + * pattern: [ + * "circle", + * "rectangle", + * "<polygon points='0 6 4 0 -4 0'></polygon>" + * ], + * } + */ + point_show: true, + point_r: 2.5, + point_radialGradient: false, + point_sensitivity: 10, + point_focus_expand_enabled: true, + point_focus_expand_r: void 0, + point_focus_only: false, + point_opacity: void 0, + point_pattern: [], + point_select_r: void 0, + point_type: "circle" +}); + +;// ./src/config/Options/shape/area.ts +/* harmony default export */ var Options_shape_area = ({ + /** + * Set area options + * @name area + * @memberof Options + * @type {object} + * @property {object} area Area object + * @property {boolean} [area.above=false] Set background area `above` the data chart line. + * @property {boolean} [area.below=false] Set background area `below` the data chart line. + * - **NOTE**: Can't be used along with `above` option. When above & below options are set to true, `above` will be prioritized. + * @property {boolean} [area.front=true] Set area node to be positioned over line node. + * @property {boolean|object} [area.linearGradient=false] Set the linear gradient on area.<br><br> + * Or customize by giving below object value: + * - x {Array}: `x1`, `x2` value (default: `[0, 0]`) + * - y {Array}: `y1`, `y2` value (default: `[0, 1]`) + * - stops {Array}: Each item should be having `[offset, stop-color, stop-opacity]` values. + * - (default: `[[0, $DATA_COLOR, 1], [1, $DATA_COLOR, 0]]`) + * @property {boolean} [area.zerobased=true] Set if min or max value will be 0 on area chart. + * @see [MDN's <linearGradient>](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/linearGradient), [<stop>](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/stop) + * @see [Demo](https://naver.github.io/billboard.js/demo/#Chart.AreaChart) + * @see [Demo: above](https://naver.github.io/billboard.js/demo/#AreaChartOptions.Above) + * @see [Demo: below](https://naver.github.io/billboard.js/demo/#AreaChartOptions.Below) + * @see [Demo: linearGradient](https://naver.github.io/billboard.js/demo/#AreaChartOptions.LinearGradient) + * @example + * area: { + * above: true, + * below: false, + * zerobased: false, + * + * // <g class='bb-areas'> will be positioned behind the line <g class='bb-lines'> in stacking order + * front: false, + * + * // will generate following linearGradient: + * // for more info: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/linearGradient + * // <linearGradient x1="0" x2="0" y1="0" y2="1"> + * // <stop offset="0" stop-color="$DATA_COLOR" stop-opacity="1"></stop> + * // <stop offset="1" stop-color="$DATA_COLOR" stop-opacity="0"></stop> + * // </linearGradient> + * linearGradient: true, + * + * // Or customized gradient + * linearGradient: { + * x: [0, 0], // x1, x2 attributes + * y: [0, 0], // y1, y2 attributes + * stops: [ + * // offset, stop-color, stop-opacity + * [0, "#7cb5ec", 1], + * + * // setting 'null' for stop-color, will set its original data color + * [0.5, null, 0], + * + * // setting 'function' for stop-color, will pass data id as argument. + * // It should return color string or null value + * [1, function(id) { return id === "data1" ? "red" : "blue"; }, 0], + * ] + * } + * } + */ + area_above: false, + area_below: false, + area_front: true, + area_linearGradient: false, + area_zerobased: true +}); + +;// ./src/config/Options/shape/bar.ts +/* harmony default export */ var shape_bar = ({ + /** + * Set bar options + * @name bar + * @memberof Options + * @type {object} + * @property {object} bar Bar object + * @property {boolean} [bar.front=false] Set 'bar' to be positioned over(on the top) other shapes elements. + * @property {number} [bar.indices.removeNull=false] Remove nullish data on bar indices positions. + * @property {number} [bar.label.threshold=0] Set threshold ratio to show/hide labels. + * @property {boolean|object} [bar.linearGradient=false] Set the linear gradient on bar.<br><br> + * Or customize by giving below object value: + * - x {Array}: `x1`, `x2` value (default: `[0, 0]`) + * - y {Array}: `y1`, `y2` value (default: `[0, 1]`) + * - stops {Array}: Each item should be having `[offset, stop-color, stop-opacity]` values. + * - (default: `[[0, $DATA_COLOR, 1], [1, $DATA_COLOR, 0]]`) + * @property {boolean} [bar.overlap=false] Bars will be rendered at same position, which will be overlapped each other. (for non-grouped bars only) + * @property {number} [bar.padding=0] The padding pixel value between each bar. + * @property {number} [bar.radius] Set the radius of bar edge in pixel. + * @property {number} [bar.radius.ratio] Set the radius ratio of bar edge in relative the bar's width. + * @property {number} [bar.sensitivity=2] The sensitivity offset value for interaction boundary. + * @property {number|function|object} [bar.width] Change the width of bar chart. + * @property {number} [bar.width.ratio=0.6] Change the width of bar chart by ratio. + * - **NOTE:** Criteria for ratio. + * - When x ticks count is same with the data count, the baseline for ratio is the minimum interval value of x ticks. + * - ex. when timeseries x values are: [2024-01-01, 2024-02-01, 2024-03-01], the minimum interval will be `2024-02-01 ~ 2024-03-01` + * - if the minimum interval is 30px, then ratio=1 means 30px. + * - When x ticks count is lower than the data count, the baseline will be calculated as `chart width / data count`. + * - ex. when chart width is 500, data count is 5, then ratio=1 means 100px. + * @property {number} [bar.width.max] The maximum width value for ratio. + * @property {number} [bar.width.dataname] Change the width of bar for indicated dataset only. + * @property {number} [bar.width.dataname.ratio=0.6] Change the width of bar chart by ratio. + * - **NOTE:** + * - Works only for non-stacked bar + * @property {number} [bar.width.dataname.max] The maximum width value for ratio. + * @property {boolean} [bar.zerobased=true] Set if min or max value will be 0 on bar chart. + * @see [Demo: bar front](https://naver.github.io/billboard.js/demo/#BarChartOptions.BarFront) + * @see [Demo: bar indices](https://naver.github.io/billboard.js/demo/#BarChartOptions.BarIndices) + * @see [Demo: bar overlap](https://naver.github.io/billboard.js/demo/#BarChartOptions.BarOverlap) + * @see [Demo: bar padding](https://naver.github.io/billboard.js/demo/#BarChartOptions.BarPadding) + * @see [Demo: bar radius](https://naver.github.io/billboard.js/demo/#BarChartOptions.BarRadius) + * @see [Demo: bar width](https://naver.github.io/billboard.js/demo/#BarChartOptions.BarWidth) + * @see [Demo: bar width variant](https://naver.github.io/billboard.js/demo/#BarChartOptions.BarWidthVariant) + * @example + * bar: { + * // make bar shape to be positioned over the other shape elements + * front: true, + * + * // remove nullish data on bar indices positions + * indices: { + * removeNull: true + * }, + * + * // will generate following linearGradient: + * // for more info: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/linearGradient + * // <linearGradient x1="0" x2="0" y1="0" y2="1"> + * // <stop offset="0" stop-color="$DATA_COLOR" stop-opacity="1"></stop> + * // <stop offset="1" stop-color="$DATA_COLOR" stop-opacity="0"></stop> + * // </linearGradient> + * linearGradient: true, + * + * // Or customized gradient + * linearGradient: { + * x: [0, 0], // x1, x2 attributes + * y: [0, 0], // y1, y2 attributes + * stops: [ + * // offset, stop-color, stop-opacity + * [0, "#7cb5ec", 1], + * + * // setting 'null' for stop-color, will set its original data color + * [0.5, null, 0], + * + * // setting 'function' for stop-color, will pass data id as argument. + * // It should return color string or null value + * [1, function(id) { return id === "data1" ? "red" : "blue"; }, 0], + * ] + * }, + * + * // remove nullish da + * overlap: true, + * + * padding: 1, + * + * // bar radius + * radius: 10, + * // or + * radius: { + * ratio: 0.5 + * } + * + * label: { + * // 0.1(10%) ratio value means, the minimum ratio to show text label relative to the y Axis domain range value. + * // if data value is below than 0.1, text label will be hidden. + * threshold: 0.1, + * }, + * + * // will not have offset between each bar elements for interaction + * sensitivity: 0, + * + * width: 10, + * + * // or specify width callback. The callback will receive width, targetsNum, maxDataCount as arguments. + * // - width: chart area width + * // - targetsNum: number of targets + * // - maxDataCount: maximum data count among targets + * width: function(width, targetsNum, maxDataCount) { + * return width / (targetsNum * maxDataCount); + * } + * + * // or specify ratio & max + * width: { + * ratio: 0.2, + * max: 20 + * }, + * + * // or specify width per dataset + * width: { + * data1: 20, + * data2: { + * ratio: 0.2, + * max: 20 + * } + * }, + * + * zerobased: false + * } + */ + bar_connectLine: false, + bar_front: false, + bar_indices_removeNull: false, + bar_label_threshold: 0, + bar_linearGradient: false, + bar_overlap: false, + bar_padding: 0, + bar_radius: void 0, + bar_radius_ratio: void 0, + bar_sensitivity: 2, + bar_width: void 0, + bar_width_ratio: 0.6, + bar_width_max: void 0, + bar_zerobased: true +}); + +;// ./src/config/Options/shape/bubble.ts +/* harmony default export */ var shape_bubble = ({ + /** + * Set bubble options + * @name bubble + * @memberof Options + * @type {object} + * @property {object} bubble bubble object + * @property {number|function} [bubble.maxR=35] Set the max bubble radius value + * @property {boolean} [bubble.zerobased=false] Set if min or max value will be 0 on bubble chart. + * @example + * bubble: { + * // ex) If 100 is the highest value among data bound, the representation bubble of 100 will have radius of 50. + * // And the lesser will have radius relatively from the max value. + * maxR: 50, + * + * // or set radius callback + * maxR: function(d) { + * // ex. of d param - {x: Fri Oct 06 2017 00:00:00 GMT+0900, value: 80, id: "data2", index: 5} + * ... + * return Math.sqrt(d.value * 2); + * }, + * zerobased: false + * } + */ + bubble_maxR: 35, + bubble_zerobased: false +}); + +;// ./src/config/Options/shape/candlestick.ts +/* harmony default export */ var shape_candlestick = ({ + /** + * Set candlestick options + * @name candlestick + * @memberof Options + * @type {object} + * @property {object} candlestick Candlestick object + * @property {number} [candlestick.width] Change the width. + * @property {number} [candlestick.width.ratio=0.6] Change the width by ratio. + * @property {number} [candlestick.width.max] The maximum width value for ratio. + * @property {number} [candlestick.width.dataname] Change the width for indicated dataset only. + * @property {number} [candlestick.width.dataname.ratio=0.6] Change the width of bar chart by ratio. + * @property {number} [candlestick.width.dataname.max] The maximum width value for ratio. + * @property {object} [candlestick.color] Color setting. + * @property {string|object} [candlestick.color.down] Change down(bearish) value color. + * @property {string} [candlestick.color.down.dataname] Change down value color for indicated dataset only. + * + * @see [Demo](https://naver.github.io/billboard.js/demo/##Chart.CandlestickChart) + * @example + * candlestick: { + * width: 10, + * + * // or + * width: { + * ratio: 0.2, + * max: 20 + * }, + * + * // or specify width per dataset + * width: { + * data1: 20, + * data2: { + * ratio: 0.2, + * max: 20 + * } + * }, + * color: { + * // specify bearish color + * down: "red", + * + * // or specify color per dataset + * down: { + * data1: "red", + * data2: "blue", + * } + * } + * } + */ + candlestick_width: void 0, + candlestick_width_ratio: 0.6, + candlestick_width_max: void 0, + candlestick_color_down: "red" +}); + +;// ./src/config/Options/shape/line.ts +/* harmony default export */ var shape_line = ({ + /** + * Set line options + * @name line + * @memberof Options + * @type {object} + * @property {object} line Line object + * @property {boolean} [line.connectNull=false] Set if null data point will be connected or not.<br> + * If true set, the region of null data will be connected without any data point. If false set, the region of null data will not be connected and get empty. + * @property {Array} [line.classes=undefined] If set, used to set a css class on each line. + * @property {boolean} [line.step.type=step] Change step type for step chart.<br> + * **Available values:** + * - step + * - step-before + * - step-after + * @property {boolean} [line.step.tooltipMatch=false] Set to `true` for `step-before` and `step-after` types to have cursor/tooltip match to hovered step's point instead of nearest point. + * @property {boolean|Array} [line.point=true] Set to false to not draw points on linecharts. Or pass an array of line ids to draw points for. + * @property {boolean} [line.zerobased=false] Set if min or max value will be 0 on line chart. + * @example + * line: { + * connectNull: true, + * classes: [ + * "line-class1", + * "line-class2" + * ], + * step: { + * type: "step-after", + * + * // to have cursor/tooltip match to hovered step's point instead of nearest point. + * tooltipMatch: true + * }, + * + * // hide all data points ('point.show=false' also has similar effect) + * point: false, + * + * // show data points for only indicated data + * point: [ + * "data1", "data3" + * ], + * + * zerobased: false + * } + */ + line_connectNull: false, + line_step_type: "step", + line_step_tooltipMatch: false, + line_zerobased: false, + line_classes: void 0, + line_point: true +}); + +;// ./src/config/Options/shape/scatter.ts +/* harmony default export */ var scatter = ({ + /** + * Set scatter options + * @name scatter + * @memberof Options + * @type {object} + * @property {object} [scatter] scatter object + * @property {boolean} [scatter.zerobased=false] Set if min or max value will be 0 on scatter chart. + * @example + * scatter: { + * connectNull: true, + * step: { + * type: "step-after" + * }, + * + * // hide all data points ('point.show=false' also has similar effect) + * point: false, + * + * // show data points for only indicated data + * point: [ + * "data1", "data3" + * ], + * + * zerobased: false + * } + */ + scatter_zerobased: false +}); + +;// ./src/config/Options/shape/spline.ts +/* harmony default export */ var spline = ({ + /** + * Set spline options + * - **Available interpolation type values:** + * - basis (d3.curveBasis) + * - basis-closed (d3.curveBasisClosed) + * - basis-open (d3.curveBasisOpen) + * - bundle (d3.curveBundle) + * - cardinal (d3.curveCardinal) + * - cardinal-closed (d3.curveCardinalClosed) + * - cardinal-open (d3.curveCardinalOpen) + * - catmull-rom (d3.curveCatmullRom) + * - catmull-rom-closed (d3.curveCatmullRomClosed) + * - catmull-rom-open (d3.curveCatmullRomOpen) + * - monotone-x (d3.curveMonotoneX) + * - monotone-y (d3.curveMonotoneY) + * - natural (d3.curveNatural) + * - linear-closed (d3.curveLinearClosed) + * - linear (d3.curveLinear) + * - step (d3.curveStep) + * - step-after (d3.curveStepAfter) + * - step-before (d3.curveStepBefore) + * @name spline + * @memberof Options + * @type {object} + * @property {object} spline Spline object + * @property {object} spline.interpolation Spline interpolation object + * @property {string} [spline.interpolation.type="cardinal"] Interpolation type + * @see [Interpolation (d3 v4)](http://bl.ocks.org/emmasaunders/c25a147970def2b02d8c7c2719dc7502) + * @example + * spline: { + * interpolation: { + * type: "cardinal" + * } + * } + */ + spline_interpolation_type: "cardinal" +}); + +;// ./src/config/Options/shape/arc.ts +/* harmony default export */ var shape_arc = ({ + /** + * Set arc options + * @name arc + * @memberof Options + * @type {object} + * @property {object} arc Arc object + * @property {number|function} [arc.cornerRadius=0] Set corner radius of Arc(donut/gauge/pie/polar) shape. + * - **NOTE:** + * - Corner radius can't surpass the `(outerRadius - innerRadius) /2` of indicated shape. + * @property {number} [arc.cornerRadius.ratio=0] Set ratio relative of outer radius. + * @property {object} [arc.needle] Set needle options. + * @property {boolean} [arc.needle.show=false] Show or hide needle. + * @property {string} [arc.needle.color] Set needle filled color. + * @property {function} [arc.needle.path] Set custom needle path function. + * - **NOTE:** + * - The path should be starting from 0,0 (which is center) to top center coordinate. + * - The function will receive, `length`{number} parameter which indicating the needle length in pixel relative to radius. + * @property {number} [arc.needle.value] Set needle value. + * - **NOTE:** + * - For single gauge chart, needle will point the data value by default, otherwise will point 0(zero). + * @property {number} [arc.needle.length=100] Set needle length in percentages relative to radius. + * @property {object} [arc.needle.top] Set needle top options. + * @property {number} [arc.needle.top.rx=0] Set needle top [rx radius value](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#elliptical_arc_curve). + * @property {number} [arc.needle.top.ry=0] Set needle top [ry radius value](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#elliptical_arc_curve). + * @property {number} [arc.needle.top.width=0] Set needle top width in pixel. + * @property {object} [arc.needle.bottom] Set needle bottom options. + * @property {number} [arc.needle.bottom.rx=1] Set needle bottom [rx radius value](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#elliptical_arc_curve). + * @property {number} [arc.needle.bottom.ry=1] Set needle bottom [ry radius value](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#elliptical_arc_curve). + * @property {number} [arc.needle.bottom.width=15] Set needle bottom width in pixel. + * @property {number} [arc.needle.bottom.len=0] Set needle bottom length in pixel. Setting this value, will make bottom larger starting from center. + * @property {object} [arc.rangeText] Set rangeText options. + * @property {Array} [arc.rangeText.values] Set range text values to be shown around Arc. + * - When `unit: 'absolute'`: Given values are treated as absolute values. + * - When `unit: '%'`: Given values are treated as percentages. + * @property {string} [arc.rangeText.unit="absolute"] Specify the range text unit. + * - "absolute": Show absolute value + * - "%": Show percentage value + * @property {boolean} [arc.rangeText.fixed=false] Set if range text shown will be fixed w/o data toggle update. Only available for gauge chart. + * @property {function} [arc.rangeText.format] Set format function for the range text. + * @property {number} [arc.rangeText.position] Set position function or object for the range text. + * @see [Demo: Donut corner radius](https://naver.github.io/billboard.js/demo/#DonutChartOptions.DonutCornerRadius) + * @see [Demo: Donut corner radius](https://naver.github.io/billboard.js/demo/#PieChartOptions.CornerRadius) + * @see [Demo: Donut needle](https://naver.github.io/billboard.js/demo/#DonutChartOptions.DonutNeedle) + * @see [Demo: Donut RangeText](https://naver.github.io/billboard.js/demo/#DonutChartOptions.DonutRangeText) + * @see [Demo: Gauge corner radius](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeCornerRadius) + * @see [Demo: Gauge needle](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeNeedle) + * @see [Demo: Gauge RangeText](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeRangeText) + * @example + * arc: { + * cornerRadius: 12, + * + * // can customize corner radius for each data with function callback + * // + * // The function will receive: + * // - id {string}: Data id + * // - value {number}: Data value + * // - outerRadius {number}: Outer radius value + * cornerRadius: function(id, value, outerRadius) { + * return (id === "data1" && value > 10) ? + * 50 : outerRadius * 1.2; + * }, + * + * // set ratio relative of outer radius + * cornerRadius: { + * ratio: 0.5 + * }, + * + * needle: { + * show: true, + * color: "red", // any valid CSS color + * path: function(length) { + * const len = length - 20; + * + * // will return upper arrow shape path + * // Note: The path should begun from '0,0' coordinate to top center. + * const path = `M 0 -${len + 20} + * L -12 -${len} + * L -5 -${len} + * L -5 0 + * A 1 1 0 0 0 5 0 + * L 5 -${len} + * L 12 -${len} Z`; + * + * return path; + * }, + * value: 40, // will make needle to point value 40. + * length: 80, // needle length in percentages relative to radius. + * + * top: { + * // rx and ry are the two radii of the ellipse; + * // https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#elliptical_arc_curve + * rx: 1, + * ry: 1, + * width: 5 + * }, + * bottom: { + * // rx and ry are the two radii of the ellipse; + * // https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#elliptical_arc_curve + * rx: 1, + * ry: 1, + * width: 10 + * len: 10 + * } + * }, + * + * rangeText: { + * values: [15, 30, 50, 75, 95], + * unit: "%", + * fixed: false, // only available for gauge chart + * format: function(v) { + * return v === 15 ? "Fifteen" : v; + * }, + * + * position: function(v) { + * return v === 15 ? {x: 20, y: 10} : null; // can return one props value also. + * }, + * position: {x: 10, y: 15}, + * position: {x: 10} + * } + * } + */ + arc_cornerRadius: 0, + arc_cornerRadius_ratio: 0, + arc_needle_show: false, + arc_needle_color: void 0, + arc_needle_value: void 0, + arc_needle_path: void 0, + arc_needle_length: 100, + arc_needle_top_rx: 0, + arc_needle_top_ry: 0, + arc_needle_top_width: 0, + arc_needle_bottom_rx: 1, + arc_needle_bottom_ry: 1, + arc_needle_bottom_width: 15, + arc_needle_bottom_len: 0, + arc_rangeText_values: void 0, + arc_rangeText_unit: "absolute", + arc_rangeText_fixed: false, + arc_rangeText_format: void 0, + arc_rangeText_position: void 0 +}); + +;// ./src/config/Options/shape/donut.ts +/* harmony default export */ var donut = ({ + /** + * Set donut options + * @name donut + * @memberof Options + * @type {object} + * @property {object} donut Donut object + * @property {boolean} [donut.label.show=true] Show or hide label on each donut piece. + * @property {function} [donut.label.format] Set formatter for the label on each donut piece. + * @property {number} [donut.label.threshold=0.05] Set threshold ratio to show/hide labels. + * @property {number|function} [donut.label.ratio=undefined] Set ratio of labels position. + * @property {boolean|object} [donut.label.line=false] Enable label with lines (displayed outside with connector lines). + * - `true`: Enable label with lines with default settings + * - `false`: Labels are displayed inside the donut slices (default behavior). + * - `{show: boolean, distance: number, text: boolean}`: Enable label with lines with custom settings. When object member is not provided, it will be set to default values. + * @property {boolean} [donut.label.line.show=true] Show or hide connector lines. + * @property {number} [donut.label.line.distance=20] Set the distance of the horizontal part of the connector line in pixels. + * @property {boolean|function} [donut.label.line.text=true] Show text at the end of the connector line (outside the shape). + * - `true`: show data "id" text + * - `false`: use default formatter(label.format) to show text + * - `function(value, ratio, id)`: Custom formatter function for the text. + * - **NOTE:** When the viewport size decreases, the size is adjusted based on the shape, so text may appear clipped. In this case, consider setting `overflow: visible` on the SVG node. + * @property {object|function} [donut.label.image] Set image to be displayed next to the label text.<br><br> + * When function is specified, will receives 3 arguments such as `v, id, i` and it must return an image object with `url`, `width`, `height`, and optional `pos` properties.<br><br> + * The arguments are:<br> + * - `v` is the value of the data point where the label is shown. + * - `id` is the id of the data where the label is shown. + * - `i` is the index of the data series point where the label is shown. + * @property {string} donut.label.image.url Image URL path. Can use placeholder `{=ID}` which will be replaced with the data ID. + * @property {number} donut.label.image.width Image width in pixels. + * @property {number} donut.label.image.height Image height in pixels. + * @property {object} [donut.label.image.pos] Image position relative to the label text. + * @property {number} [donut.label.image.pos.x=0] x coordinate position, relative the original. + * @property {number} [donut.label.image.pos.y=0] y coordinate position, relative the original. + * @property {boolean} [donut.expand=true] Enable or disable expanding donut pieces. + * @property {number} [donut.expand.rate=0.98] Set expand rate. + * @property {number} [donut.expand.duration=50] Set expand transition time in ms. + * @property {number} [donut.width] Set width of donut chart. + * @property {string} [donut.title=""] Set title of donut chart. Use `\n` character for line break. + * - **NOTE:** + * - When `arc.needle.show=true` is set, special template `{=NEEDLE_VALUE}` can be used inside the title text to show current needle value. + * @property {number} [donut.padAngle=0] Set padding between data. + * @property {number} [donut.startingAngle=0] Set starting angle where data draws. + * @see [Demo: Corner Radius](https://naver.github.io/billboard.js/demo/#DonutChartOptions.DonutCornerRadius) + * @see [Demo: Needle](https://naver.github.io/billboard.js/demo/#DonutChartOptions.DonutNeedle) + * @see [Demo: Range Text](https://naver.github.io/billboard.js/demo/#DonutChartOptions.DonutRangeText) + * @see [Demo: Label Image](https://naver.github.io/billboard.js/demo/#DonutChartOptions.LabelImage) + * @see [Demo: Label Line](https://naver.github.io/billboard.js/demo/#DonutChartOptions.LabelLine) + * @see [Demo: Label Ratio](https://naver.github.io/billboard.js/demo/#DonutChartOptions.LabelRatio) + * @see [Demo: Multiline Label](https://naver.github.io/billboard.js/demo/#DonutChartOptions.MultilineLabel) + * @see [Demo: Multiline Title](https://naver.github.io/billboard.js/demo/#DonutChartOptions.MultilineTitle) + * @see [Demo: Pad Angle](https://naver.github.io/billboard.js/demo/#DonutChartOptions.padAngle) + * @see [Demo: Starting Angle](https://naver.github.io/billboard.js/demo/#DonutChartOptions.StartingAngle) + * + * @example + * donut: { + * label: { + * show: false, + * format: function(value, ratio, id) { + * return d3.format("$")(value); + * + * // to multiline, return with '\n' character + * // return value +"%\nLine1\n2Line2"; + * }, + * + * // 0.1(10%) ratio value means, the minimum ratio to show text label relative to the total value. + * // if data value is below than 0.1, text label will be hidden. + * threshold: 0.1, + * + * // set ratio callback. Should return ratio value + * ratio: function(d, radius, h) { + * ... + * return ratio; + * }, + * // or set ratio number + * ratio: 0.5, + * + * // Enable label with lines (displayed outside with connector lines) + * line: false, // default - labels inside + * line: true, // enable label with lines with default settings + * line: { // enable label with lines with custom settings + * show: true, + * distance: 20, // horizontal line distance in pixels + * + * // show text at the end of connector line (outside the shape) + * text: true, // use default formatter + * text: function(value, ratio, id) { // custom formatter + * return d3.format(".1%")(ratio); + * } + * }, + * + * // set image to be displayed next to the label text + * image: { + * url: "./sample.svg", + * + * // use placeholder to dynamically set image URL based on data ID + * url: "./images/{=ID}.svg", // will be replaced to "./images/data1.svg", "./images/data2.svg", etc. + * width: 35, + * height: 35, + * pos: { + * x: 0, + * y: 0 + * } + * }, + * + * // or use function to return image configuration dynamically + * image: function(v, id, i) { + * // Return different images based on value + * if (v > 500) { + * return { + * url: "./high-value.svg", + * width: 40, + * height: 40, + * pos: { x: 0, y: 0 } + * }; + * } else if (v > 100) { + * return { + * url: "./medium-value.svg", + * width: 30, + * height: 30, + * pos: { x: 0, y: 0 } + * }; + * } else if(v < 5) { + * // Return falsy value in case of don't want to show image + * return null; + * } else { + * return { + * url: "./low-value.svg", + * width: 20, + * height: 20, + * pos: { x: 0, y: 0 } + * }; + * } + * } + * }, + * + * // disable expand transition for interaction + * expand: false, + * + * expand: { + * // set duration of expand transition to 500ms. + * duration: 500, + * + * // set expand area rate + * rate: 1 + * }, + * + * width: 10, + * padAngle: 0.2, + * startingAngle: 1, + * title: "Donut Title" + * + * // when 'arc.needle.show=true' is set, can show current needle value. + * title: "Needle value:\n{=NEEDLE_VALUE}", + * + * // title with line break + * title: "Title1\nTitle2" + * } + */ + donut_label_show: true, + donut_label_format: void 0, + donut_label_threshold: 0.05, + donut_label_line: false, + donut_label_image: void 0, + donut_label_ratio: void 0, + donut_width: void 0, + donut_title: "", + donut_expand: {}, + donut_expand_rate: 0.98, + donut_expand_duration: 50, + donut_padAngle: 0, + donut_startingAngle: 0 +}); + +;// ./src/config/Options/shape/funnel.ts +/* harmony default export */ var shape_funnel = ({ + /** + * Set funnel options + * @name funnel + * @memberof Options + * @type {object} + * @property {object} funnel Funnel object + * @property {number} [funnel.neck.width=0] Set funnel neck width. + * @property {number} [funnel.neck.height=0] Set funnel neck height. + * @property {number} [funnel.neck.width.ratio] Set funnel neck width in ratio. + * @property {number} [funnel.neck.height.ratio] Set funnel neck height in ratio. + * @see [Demo](https://naver.github.io/billboard.js/demo/#Chart.PolarChart) + * @example + * funnel: { + * neck: { + * width: 200, + * height: 100, + * + * // or specify as ratio value (relative to the chart size) + * width: { + * ratio: 0.5 + * }, + * height: { + * ratio: 0.5 + * } + * } + * } + */ + funnel_neck_width: 0, + funnel_neck_height: 0 +}); + +;// ./src/config/Options/shape/gauge.ts +/* harmony default export */ var shape_gauge = ({ + /** + * Set gauge options + * @name gauge + * @memberof Options + * @type {object} + * @property {object} gauge Gauge object + * @property {boolean} [gauge.background=""] Set background color. (The `.bb-chart-arcs-background` element) + * @property {boolean} [gauge.fullCircle=false] Show full circle as donut. When set to 'true', the max label will not be showed due to start and end points are same location. + * @property {boolean} [gauge.label.show=true] Show or hide label on gauge. + * @property {function} [gauge.label.extents] Set customized min/max label text. + * @property {function} [gauge.label.format] Set formatter for the label on gauge. Label text can be multilined with `\n` character.<br> + * Will pass following arguments to the given function: + * - value {number}: absolute value + * - ratio {number}: value's ratio + * - id {string}: data's id value + * @property {number|function} [gauge.label.ratio=undefined] Set ratio of labels position. + * @property {number} [gauge.label.threshold=0] Set threshold ratio to show/hide labels. + * @property {boolean|object} [gauge.label.line=false] Enable label with lines (displayed outside with connector lines). + * - **NOTE:** Only applicable for single gauge (not for `gauge.type="multi"`). + * - `true`: Enable label with lines with default settings + * - `false`: Labels are displayed inside the gauge (default behavior). + * - `{show: boolean, distance: number, text: boolean}`: Enable label with lines with custom settings. When object member is not provided, it will be set to default values. + * @property {boolean} [gauge.label.line.show=true] Show or hide connector lines. + * @property {number} [gauge.label.line.distance=20] Set the distance of the horizontal part of the connector line in pixels. + * @property {boolean|function} [gauge.label.line.text=true] Show text at the end of the connector line (outside the shape). + * - `true`: show data "id" text + * - `false`: use default formatter(label.format) to show text + * - `function(value, ratio, id)`: Custom formatter function for the text. + * - **NOTE:** When the viewport size decreases, the size is adjusted based on the shape, so text may appear clipped. In this case, consider setting `overflow: visible` on the SVG node. + * @property {object|function} [gauge.label.image] Set image to be displayed next to the label text.<br><br> + * When function is specified, will receives 3 arguments such as `v, id, i` and it must return an image object with `url`, `width`, `height`, and optional `pos` properties.<br><br> + * The arguments are:<br> + * - `v` is the value of the data point where the label is shown. + * - `id` is the id of the data where the label is shown. + * - `i` is the index of the data series point where the label is shown. + * @property {string} gauge.label.image.url Image URL path. Can use placeholder `{=ID}` which will be replaced with the data ID. + * @property {number} gauge.label.image.width Image width in pixels. + * @property {number} gauge.label.image.height Image height in pixels. + * @property {object} [gauge.label.image.pos] Image position relative to the label text. + * @property {number} [gauge.label.image.pos.x=0] x coordinate position, relative the original. + * @property {number} [gauge.label.image.pos.y=0] y coordinate position, relative the original. + * @property {boolean} [gauge.expand=true] Enable or disable expanding gauge. + * @property {number} [gauge.expand.rate=0.98] Set expand rate. + * @property {number} [gauge.expand.duration=50] Set the expand transition time in milliseconds. + * @property {boolean} [gauge.enforceMinMax=false] Enforce to given min/max value. + * - **Note:** Only works for single data series. + * - When `gauge.min=50` and given value is `30`, gauge will render as empty value. + * - When `gauge.max=100` and given value is `120`, gauge will render till 100, not surpassing max value. + * @property {number} [gauge.min=0] Set min value of the gauge. + * @property {number} [gauge.max=100] Set max value of the gauge. + * @property {number} [gauge.startingAngle=-1 * Math.PI / 2] Set starting angle where data draws. + * + * **Limitations:** + * - when `gauge.fullCircle=false`: + * - -1 * Math.PI / 2 <= startingAngle <= Math.PI / 2 + * - `startingAngle <= -1 * Math.PI / 2` defaults to `-1 * Math.PI / 2` + * - `startingAngle >= Math.PI / 2` defaults to `Math.PI / 2` + * - when `gauge.fullCircle=true`: + * - -1 * Math.PI < startingAngle < Math.PI + * - `startingAngle < -1 * Math.PI` defaults to `Math.PI` + * - `startingAngle > Math.PI` defaults to `Math.PI` + * @property {number} [gauge.arcLength=100] Set the length of the arc to be drawn in percent from -100 to 100.<br> + * Negative value will draw the arc **counterclockwise**. Need to be used in conjunction with `gauge.fullCircle=true`. + * + * **Limitations:** + * - -100 <= arcLength (in percent) <= 100 + * - 'arcLength < -100' defaults to -100 + * - 'arcLength > 100' defaults to 100 + * @property {string} [gauge.title=""] Set title of gauge chart. Use `\n` character for line break. + * - **NOTE:** + * - When `arc.needle.show=true` is set, special template `{=NEEDLE_VALUE}` can be used inside the title text to show current needle value. + * @property {string} [gauge.units] Set units of the gauge. + * @property {number} [gauge.width] Set width of gauge chart. + * @property {string} [gauge.type="single"] Set type of gauge to be displayed.<br><br> + * **Available Values:** + * - single + * - multi + * @property {number} [gauge.arcs.minWidth=5] Set minimal width of gauge arcs until the innerRadius disappears. + * @see [Demo: enforceMinMax, min/max](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeMinMax) + * @see [Demo: archLength](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeArcLength) + * @see [Demo: startingAngle](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeStartingAngle) + * @see [Demo: label image](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeLabelImage) + * @see [Demo: label line](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeLabelLine) + * @see [Demo: label ratio](https://naver.github.io/billboard.js/demo/#GaugeChartOptions.GaugeLabelRatio) + * @example + * gauge: { + * background: "#eee", // will set 'fill' css prop for '.bb-chart-arcs-background' classed element. + * fullCircle: false, + * label: { + * show: false, + * format: function(value, ratio, id) { + * return value; + * + * // to multiline, return with '\n' character + * // return value +"%\nLine1\n2Line2"; + * }, + * + * extents: function(value, isMax) { + * return (isMax ? "Max:" : "Min:") + value; + * }, + * + * // 0.1(10%) ratio value means, the minimum ratio to show text label relative to the total value. + * // if data value is below than 0.1, text label will be hidden. + * threshold: 0.1, + * + * // Enable label with lines (displayed outside with connector lines) + * // NOTE: Only works with single gauge (not gauge.type="multi") + * line: true, // enable label with lines with default settings + * line: { // enable label with lines with custom settings + * show: true, // enable lines (default: true when line is enabled) + * distance: 30, // distance of horizontal line in pixels (default: 20) + * + * // show text at the end of connector line (outside the shape) + * text: true, // use default formatter + * text: function(value, ratio, id) { // custom formatter + * return d3.format(".1%")(ratio); + * } + * }, + * + * // set ratio callback. Should return ratio value + * ratio: function(d, radius, h) { + * ... + * return ratio; + * }, + * // or set ratio number + * ratio: 0.5, + * + * // set image to be displayed next to the label text + * image: { + * url: "./sample.svg", + * + * // use placeholder to dynamically set image URL based on data ID + * url: "./images/{=ID}.svg", // will be replaced to "./images/data1.svg", "./images/data2.svg", etc. + * width: 35, + * height: 35, + * pos: { + * x: 0, + * y: 0 + * } + * }, + * + * // or use function to return image configuration dynamically + * image: function(v, id, i) { + * // Return different images based on value + * if (v > 500) { + * return { + * url: "./high-value.svg", + * width: 40, + * height: 40, + * pos: { x: 0, y: 0 } + * }; + * } else if (v > 100) { + * return { + * url: "./medium-value.svg", + * width: 30, + * height: 30, + * pos: { x: 0, y: 0 } + * }; + * } else if(v < 5) { + * // Return falsy value in case of don't want to show image + * return null; + * } else { + * return { + * url: "./low-value.svg", + * width: 20, + * height: 20, + * pos: { x: 0, y: 0 } + * }; + * } + * } + * }, + * + * // disable expand transition for interaction + * expand: false, + * + * expand: { + * // set duration of expand transition to 500ms. + * duration: 500, + * + * // set expand area rate + * rate: 1 + * }, + * + * // enforce min/max value. + * // when given value < min, will render as empty value. + * // when value > max, will render to given max value not surpassing it. + * enforceMinMax: true, + * + * min: -100, + * max: 200, + * type: "single" // or 'multi' + * title: "Title Text", + * + * // when 'arc.needle.show=true' is set, can show current needle value. + * title: "Needle value:\n{=NEEDLE_VALUE}", + * + * units: "%", + * width: 10, + * startingAngle: -1 * Math.PI / 2, + * arcLength: 100, + * arcs: { + * minWidth: 5 + * } + * } + */ + gauge_background: "", + gauge_fullCircle: false, + gauge_label_show: true, + gauge_label_extents: void 0, + gauge_label_format: void 0, + gauge_label_ratio: void 0, + gauge_label_threshold: 0, + gauge_label_line: false, + gauge_label_image: void 0, + gauge_enforceMinMax: false, + gauge_min: 0, + gauge_max: 100, + gauge_type: "single", + gauge_startingAngle: -1 * Math.PI / 2, + gauge_arcLength: 100, + gauge_title: "", + gauge_units: void 0, + gauge_width: void 0, + gauge_arcs_minWidth: 5, + gauge_expand: {}, + gauge_expand_rate: 0.98, + gauge_expand_duration: 50 +}); + +;// ./src/config/Options/shape/pie.ts +/* harmony default export */ var pie = ({ + /** + * Set pie options + * @name pie + * @memberof Options + * @type {object} + * @property {object} pie Pie object + * @property {boolean} [pie.label.show=true] Show or hide label on each pie piece. + * @property {function} [pie.label.format] Set formatter for the label on each pie piece. + * @property {number|function} [pie.label.ratio=undefined] Set ratio of labels position. + * @property {number} [pie.label.threshold=0.05] Set threshold ratio to show/hide labels. + * @property {boolean|object} [pie.label.line=false] Enable label with lines (displayed outside with connector lines). + * - `true`: Enable label with lines with default settings + * - `false`: Labels are displayed inside the pie slices (default behavior). + * - `{show: boolean, distance: number, text: boolean}`: Enable label with lines with custom settings. When object member is not provided, it will be set to default values. + * @property {boolean} [pie.label.line.show=true] Show or hide connector lines. + * @property {number} [pie.label.line.distance=20] Set the distance of the horizontal part of the connector line in pixels. + * @property {boolean|function} [pie.label.line.text=true] Show text at the end of the connector line (outside the shape). + * - `true`: show data "id" text + * - `false`: use default formatter(label.format) to show text + * - `function(value, ratio, id)`: Custom formatter function for the text. + * - **NOTE:** When the viewport size decreases, the size is adjusted based on the shape, so text may appear clipped. In this case, consider setting `overflow: visible` on the SVG node. + * @property {object|function} [pie.label.image] Set image to be displayed next to the label text.<br><br> + * When function is specified, will receives 3 arguments such as `v, id, i` and it must return an image object with `url`, `width`, `height`, and optional `pos` properties.<br><br> + * The arguments are:<br> + * - `v` is the value of the data point where the label is shown. + * - `id` is the id of the data where the label is shown. + * - `i` is the index of the data series point where the label is shown. + * @property {string} pie.label.image.url Image URL path. Can use placeholder `{=ID}` which will be replaced with the data ID. + * @property {number} pie.label.image.width Image width in pixels. + * @property {number} pie.label.image.height Image height in pixels. + * @property {object} [pie.label.image.pos] Image position relative to the label text. + * @property {number} [pie.label.image.pos.x=0] x coordinate position, relative the original. + * @property {number} [pie.label.image.pos.y=0] y coordinate position, relative the original. + * @property {boolean|object} [pie.expand=true] Enable or disable expanding pie pieces. + * @property {number} [pie.expand.rate=0.98] Set expand rate. + * @property {number} [pie.expand.duration=50] Set expand transition time in ms. + * @property {number|object} [pie.innerRadius=0] Sets the inner radius of pie arc. + * @property {number|object|undefined} [pie.outerRadius=undefined] Sets the outer radius of pie arc. + * @property {number} [pie.padAngle=0] Set padding between data. + * @property {number} [pie.padding=0] Sets the gap between pie arcs. + * @property {number} [pie.startingAngle=0] Set starting angle where data draws. + * @see [Demo: expand.rate](https://naver.github.io/billboard.js/demo/#PieChartOptions.ExpandRate) + * @see [Demo: innerRadius](https://naver.github.io/billboard.js/demo/#PieChartOptions.InnerRadius) + * @see [Demo: outerRadius](https://naver.github.io/billboard.js/demo/#PieChartOptions.OuterRadius) + * @see [Demo: startingAngle](https://naver.github.io/billboard.js/demo/#PieChartOptions.StartingAngle) + * @see [Demo: label image](https://naver.github.io/billboard.js/demo/#PieChartOptions.LabelImage) + * @see [Demo: label line](https://naver.github.io/billboard.js/demo/#PieChartOptions.LabelLine) + * @example + * pie: { + * label: { + * show: false, + * format: function(value, ratio, id) { + * return d3.format("$")(value); + * + * // to multiline, return with '\n' character + * // return value +"%\nLine1\n2Line2"; + * }, + * + * // 0.1(10%) ratio value means, the minimum ratio to show text label relative to the total value. + * // if data value is below than 0.1, text label will be hidden. + * threshold: 0.1, + * + * // set ratio callback. Should return ratio value + * ratio: function(d, radius, h) { + * ... + * return ratio; + * }, + * // or set ratio number + * ratio: 0.5, + * + * // Enable label with lines (displayed outside with connector lines) + * line: false, // default - labels inside + * line: true, // enable label with lines with default settings + * line: { // enable label with lines with custom settings + * show: true, + * distance: 20, // horizontal line distance in pixels + * + * // show text at the end of connector line (outside the shape) + * text: true, // use default formatter + * text: function(value, ratio, id) { // custom formatter + * return d3.format(".1%")(ratio); + * } + * }, + * + * // set image to be displayed next to the label text + * image: { + * url: "./sample.svg", + * + * // use placeholder to dynamically set image URL based on data ID + * url: "./images/{=ID}.svg", // will be replaced to "./images/data1.svg", "./images/data2.svg", etc. + * width: 35, + * height: 35, + * pos: { + * x: 0, + * y: 0 + * } + * }, + * + * // or use function to return image configuration dynamically + * image: function(v, id, i) { + * // Return different images based on value + * if (v > 500) { + * return { + * url: "./high-value.svg", + * width: 40, + * height: 40, + * pos: { x: 0, y: 0 } + * }; + * } else if (v > 100) { + * return { + * url: "./medium-value.svg", + * width: 30, + * height: 30, + * pos: { x: 0, y: 0 } + * }; + * } else if(v < 5) { + * // Return falsy value in case of don't want to show image + * return null; + * } else { + * return { + * url: "./low-value.svg", + * width: 20, + * height: 20, + * pos: { x: 0, y: 0 } + * }; + * } + * } + * }, + * + * // disable expand transition for interaction + * expand: false, + * + * expand: { + * // set duration of expand transition to 500ms. + * duration: 500, + * + * // set expand area rate + * rate: 1 + * }, + * + * innerRadius: 0, + * + * // set different innerRadius for each data + * innerRadius: { + * data1: 10, + * data2: 0 + * }, + * + * outerRadius: 100, + * + * // set different outerRadius for each data + * outerRadius: { + * data1: 50, + * data2: 100 + * } + * + * padAngle: 0.1, + * padding: 0, + * startingAngle: 1 + * } + */ + pie_label_show: true, + pie_label_format: void 0, + pie_label_ratio: void 0, + pie_label_threshold: 0.05, + pie_label_line: false, + pie_label_image: void 0, + pie_expand: {}, + pie_expand_rate: 0.98, + pie_expand_duration: 50, + pie_innerRadius: 0, + pie_outerRadius: void 0, + pie_padAngle: 0, + pie_padding: 0, + pie_startingAngle: 0 +}); + +;// ./src/config/Options/shape/polar.ts +/* harmony default export */ var shape_polar = ({ + /** + * Set polar options + * @name polar + * @memberof Options + * @type {object} + * @property {object} polar Polar object + * @property {boolean} [polar.label.show=true] Show or hide label on each polar piece. + * @property {function} [polar.label.format] Set formatter for the label on each polar piece. + * @property {number} [polar.label.threshold=0.05] Set threshold ratio to show/hide labels. + * @property {number|function} [polar.label.ratio=undefined] Set ratio of labels position. + * @property {boolean|object} [polar.label.line=false] Enable label with lines (displayed outside with connector lines). + * - `true`: Enable label with lines with default settings + * - `false`: Labels are displayed inside the polar slices (default behavior). + * - `{show: boolean, distance: number, text: boolean}`: Enable label with lines with custom settings. When object member is not provided, it will be set to default values. + * @property {boolean} [polar.label.line.show=true] Show or hide connector lines. + * @property {number} [polar.label.line.distance=20] Set the distance of the horizontal part of the connector line in pixels. + * @property {boolean|function} [polar.label.line.text=true] Show text at the end of the connector line (outside the shape). + * - `true`: show data "id" text + * - `false`: use default formatter(label.format) to show text + * - `function(value, ratio, id)`: Custom formatter function for the text. + * - **NOTE:** When the viewport size decreases, the size is adjusted based on the shape, so text may appear clipped. In this case, consider setting `overflow: visible` on the SVG node. + * @property {object|function} [polar.label.image] Set image to be displayed next to the label text.<br><br> + * When function is specified, will receives 3 arguments such as `v, id, i` and it must return an image object with `url`, `width`, `height`, and optional `pos` properties.<br><br> + * The arguments are:<br> + * - `v` is the value of the data point where the label is shown. + * - `id` is the id of the data where the label is shown. + * - `i` is the index of the data series point where the label is shown. + * @property {string} polar.label.image.url Image URL path. Can use placeholder `{=ID}` which will be replaced with the data ID. + * @property {number} polar.label.image.width Image width in pixels. + * @property {number} polar.label.image.height Image height in pixels. + * @property {object} [polar.label.image.pos] Image position relative to the label text. + * @property {number} [polar.label.image.pos.x=0] x coordinate position, relative the original. + * @property {number} [polar.label.image.pos.y=0] y coordinate position, relative the original. + * @property {number} [polar.level.depth=3] Set the level depth. + * @property {boolean} [polar.level.show=true] Show or hide level. + * @property {string} [polar.level.text.backgroundColor="#fff"] Set label text's background color. + * @property {function} [polar.level.text.format] Set format function for the level value.<br>- Default value: `(x) => x % 1 === 0 ? x : x.toFixed(2)` + * @property {boolean} [polar.level.text.show=true] Show or hide level text. + * @property {number} [polar.padAngle=0] Set padding between data. + * @property {number} [polar.padding=0] Sets the gap between pie arcs. + * @property {number} [polar.startingAngle=0] Set starting angle where data draws. + * @see [Demo](https://naver.github.io/billboard.js/demo/#Chart.PolarChart) + * @see [Demo: label image](https://naver.github.io/billboard.js/demo/#PolarChartOptions.LabelImage) + * @see [Demo: label line](https://naver.github.io/billboard.js/demo/#PolarChartOptions.LabelLine) + * @example + * polar: { + * label: { + * show: false, + * format: function(value, ratio, id) { + * return d3.format("$")(value); + * + * // to multiline, return with '\n' character + * // return value +"%\nLine1\n2Line2"; + * }, + * + * // 0.1(10%) ratio value means, the minimum ratio to show text label relative to the total value. + * // if data value is below than 0.1, text label will be hidden. + * threshold: 0.1, + * + * // set ratio callback. Should return ratio value + * ratio: function(d, radius, h) { + * ... + * return ratio; + * }, + * // or set ratio number + * ratio: 0.5, + * + * // Enable label with lines (displayed outside with connector lines) + * line: false, // default - labels inside + * line: true, // enable label with lines with default settings + * line: { // enable label with lines with custom settings + * show: true, + * distance: 20, // horizontal line distance in pixels + * + * // show text at the end of connector line (outside the shape) + * text: true, // use default formatter + * text: function(value, ratio, id) { // custom formatter + * return d3.format(".1%")(ratio); + * } + * }, + * + * // set image to be displayed next to the label text + * image: { + * url: "./sample.svg", + * + * // use placeholder to dynamically set image URL based on data ID + * url: "./images/{=ID}.svg", // will be replaced to "./images/data1.svg", "./images/data2.svg", etc. + * width: 35, + * height: 35, + * pos: { + * x: 0, + * y: 0 + * } + * }, + * + * // or use function to return image configuration dynamically + * image: function(v, id, i) { + * // Return different images based on value + * if (v > 500) { + * return { + * url: "./high-value.svg", + * width: 40, + * height: 40, + * pos: { x: 0, y: 0 } + * }; + * } else if (v > 100) { + * return { + * url: "./medium-value.svg", + * width: 30, + * height: 30, + * pos: { x: 0, y: 0 } + * }; + * } else if(v < 5) { + * // Return falsy value in case of don't want to show image + * return null; + * } else { + * return { + * url: "./low-value.svg", + * width: 20, + * height: 20, + * pos: { x: 0, y: 0 } + * }; + * } + * } + * }, + * level: { + * depth: 3, + * max: 500, + * show: true, + * text: { + * format: function(x) { + * return x + "%"; + * }, + * show: true, + * backgroundColor: "red" + * } + * }, + * padAngle: 0.1, + * padding: 0, + * startingAngle: 1 + * } + */ + polar_label_show: true, + polar_label_format: void 0, + polar_label_threshold: 0.05, + polar_label_line: false, + polar_label_image: void 0, + polar_label_ratio: void 0, + polar_level_depth: 3, + polar_level_max: void 0, + polar_level_show: true, + polar_level_text_backgroundColor: "#fff", + polar_level_text_format: (x) => x % 1 === 0 ? x : x.toFixed(2), + polar_level_text_show: true, + polar_padAngle: 0, + polar_padding: 0, + polar_startingAngle: 0 +}); + +;// ./src/config/Options/shape/radar.ts +/* harmony default export */ var shape_radar = ({ + /** + * Set radar options + * - **NOTE:** + * > When x tick text contains `\n`, it's used as line break. + * @name radar + * @memberof Options + * @type {object} + * @property {object} radar Radar object + * @property {number} [radar.axis.max=undefined] The max value of axis. If not given, it'll take the max value from the given data. + * @property {boolean} [radar.axis.line.show=true] Show or hide axis line. + * @property {number} [radar.axis.text.position.x=0] x coordinate position, relative the original. + * @property {number} [radar.axis.text.position.y=0] y coordinate position, relative the original. + * @property {boolean} [radar.axis.text.show=true] Show or hide axis text. + * @property {boolean} [radar.direction.clockwise=false] Set the direction to be drawn. + * @property {number} [radar.level.depth=3] Set the level depth. + * @property {boolean} [radar.level.show=true] Show or hide level. + * @property {function} [radar.level.text.format] Set format function for the level value.<br>- Default value: `(x) => x % 1 === 0 ? x : x.toFixed(2)` + * @property {boolean} [radar.level.text.show=true] Show or hide level text. + * @property {number} [radar.size.ratio=0.87] Set size ratio. + * @see [Demo](https://naver.github.io/billboard.js/demo/#Chart.RadarChart) + * @see [Demo: radar axis](https://naver.github.io/billboard.js/demo/#RadarChartOptions.RadarAxis) + * @see [Demo: radar level](https://naver.github.io/billboard.js/demo/#RadarChartOptions.RadarLevel) + * @see [Demo: radar size](https://naver.github.io/billboard.js/demo/#RadarChartOptions.RadarSize) + * @see [Demo: radar axis multiline](https://naver.github.io/billboard.js/demo/#RadarChartOptions.RadarAxisMultiline) + * @example + * radar: { + * axis: { + * max: 50, + * line: { + * show: false + * }, + * text: { + * position: { + * x: 0, + * y: 0 + * }, + * show: false + * } + * }, + * direction: { + * clockwise: true + * }, + * level: { + * show: false, + * text: { + * format: function(x) { + * return x + "%"; + * }, + * show: true + * } + * }, + * size: { + * ratio: 0.7 + * } + * } + */ + radar_axis_max: void 0, + radar_axis_line_show: true, + radar_axis_text_show: true, + radar_axis_text_position: {}, + radar_level_depth: 3, + radar_level_show: true, + radar_level_text_format: (x) => x % 1 === 0 ? x : x.toFixed(2), + radar_level_text_show: true, + radar_size_ratio: 0.87, + radar_direction_clockwise: false +}); + +;// ./src/config/Options/shape/treemap.ts +/* harmony default export */ var shape_treemap = ({ + /** + * Set treemap options + * @name treemap + * @memberof Options + * @type {object} + * @property {object} treemap Treemap object + * @property {string} [treemap.tile="binary"] Treemap tile type + * - **Available tile type values:** + * - binary ([d3.treemapBinary](https://github.com/d3/d3-hierarchy/blob/main/README.md#treemapBinary)) + * - dice ([d3.treemapDice](https://github.com/d3/d3-hierarchy/blob/main/README.md#treemapDice)) + * - slice ([d3.treemapSlice](https://github.com/d3/d3-hierarchy/blob/main/README.md#treemapSlice)) + * - sliceDice ([d3.treemapSliceDice](https://github.com/d3/d3-hierarchy/blob/main/README.md#treemapSliceDice)) + * - squrify ([d3.treemapSquarify](https://github.com/d3/d3-hierarchy/blob/main/README.md#treemapSquarify)) + * - resquarify ([d3.treemapResquarify](https://github.com/d3/d3-hierarchy/blob/main/README.md#treemapResquarify)) + * @property {function} [treemap.label.format] Set formatter for the label text.<br> + * - **Arguments:** + * - `value {number}`: Data value + * - `ratio {number}`: The `ratio` of how much space this tile occupies relative to the total area (0~1) + * - `id {string}`: Data id + * - `size {object}`: Tile size `{width, height}` in pixels + * @property {number} [treemap.label.threshold=0.05] Set threshold ratio to show/hide labels text. + * @property {number} [treemap.label.show=true] Show or hide label text. + * @see [Demo: treemap](https://naver.github.io/billboard.js/demo/#Chart.TreemapChart) + * @example + * treemap: { + * // "binary", "dice", "slice", "sliceDice", "squrify", "resquarify" + * tile: "dice", + * + * label: { + * // show or hide label text + * show: false, + * + * // Example 1: Format with currency + * format: function(value, ratio, id, size) { + * // size: {width, height} - tile size in pixels + * return d3.format("$")(value); + * }, + * + * // Example 2: Show different content based on tile size + * format: function(value, ratio, id, size) { + * if (size.width > 100 && size.height > 50) { + * return `${id}\n${d3.format("$")(value)}\n(${(ratio * 100).toFixed(1)}%)`; + * } else if (size.width > 50) { + * return `${id}\n${d3.format("$")(value)}`; + * } else { + * return d3.format("$")(value); + * } + * }, + * + * // Example 3: Include tile dimensions in label + * format: function(value, ratio, id, size) { + * return `${id}\n${value}\n${size.width.toFixed(0)}x${size.height.toFixed(0)}px`; + * }, + * + * // Example 4: Conditional formatting based on ratio + * format: function(value, ratio, id, size) { + * return ratio > 0.1 ? + * `${id}\n${value} (${(ratio * 100).toFixed(1)}%)` : + * value; + * }, + * + * // set ratio number + * ratio: 0.05 + * } + * } + */ + treemap_tile: "binary", + treemap_label_format: void 0, + treemap_label_threshold: 0.05, + treemap_label_show: true +}); + +;// ./src/config/resolver/shape.ts + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +function extendAxis(module, option) { + extend(ChartInternal.prototype, Object.values(internal).concat(module)); + extend(Chart.prototype, api); + Options.setOptions(Object.values(options).concat(option || [])); +} +function extendLine(module, option) { + extendAxis([point_common, point, line].concat(module || [])); + Options.setOptions([common_point, shape_line].concat(option || [])); +} +function extendArc(module, option) { + extend(ChartInternal.prototype, [arc, point_common].concat(module || [])); + Options.setOptions([common_point].concat(option || [])); +} +let resolver_shape_area = () => (extendLine(shape_area, [Options_shape_area]), (resolver_shape_area = () => TYPE.AREA)()); +let areaLineRange = () => (extendLine(shape_area, [Options_shape_area]), (areaLineRange = () => TYPE.AREA_LINE_RANGE)()); +let areaStepRange = () => (extendLine(shape_area, [Options_shape_area]), (areaStepRange = () => TYPE.AREA_STEP_RANGE)()); +let areaSpline = () => (extendLine(shape_area, [Options_shape_area, spline]), (areaSpline = () => TYPE.AREA_SPLINE)()); +let areaSplineRange = () => (extendLine(shape_area, [Options_shape_area, spline]), (areaSplineRange = () => TYPE.AREA_SPLINE_RANGE)()); +let areaStep = () => (extendLine(shape_area, [Options_shape_area]), (areaStep = () => TYPE.AREA_STEP)()); +let resolver_shape_line = () => (extendLine(), (resolver_shape_line = () => TYPE.LINE)()); +let shape_spline = () => (extendLine(void 0, [spline]), (shape_spline = () => TYPE.SPLINE)()); +let step = () => (extendLine(), (step = () => TYPE.STEP)()); +let shape_donut = () => (extendArc(void 0, [shape_arc, donut]), (shape_donut = () => TYPE.DONUT)()); +let resolver_shape_gauge = () => (extendArc([gauge], [shape_arc, shape_gauge]), (resolver_shape_gauge = () => TYPE.GAUGE)()); +let shape_pie = () => (extendArc(void 0, [shape_arc, pie]), (shape_pie = () => TYPE.PIE)()); +let resolver_shape_polar = () => (extendArc([polar], [shape_arc, shape_polar]), (resolver_shape_polar = () => TYPE.POLAR)()); +let resolver_shape_radar = () => (extendArc( + [internal.eventrect, point, radar], + [common_point, shape_radar, { axis_x_categories: options.optAxis.axis_x_categories }] +), (resolver_shape_radar = () => TYPE.RADAR)()); +let resolver_shape_bar = () => (extendAxis([bar, point_common], [shape_bar, common_point]), (resolver_shape_bar = () => TYPE.BAR)()); +let resolver_shape_bubble = () => (extendAxis( + [point_common, point, bubble], + [shape_bubble, common_point] +), (resolver_shape_bubble = () => TYPE.BUBBLE)()); +let resolver_shape_candlestick = () => (extendAxis( + [candlestick, point_common], + [shape_candlestick, common_point] +), (resolver_shape_candlestick = () => TYPE.CANDLESTICK)()); +let shape_scatter = () => (extendAxis( + [point_common, point], + [common_point, scatter] +), (shape_scatter = () => TYPE.SCATTER)()); +let resolver_shape_funnel = () => (extendArc([funnel], [shape_funnel]), (resolver_shape_funnel = () => TYPE.FUNNEL)()); +let resolver_shape_treemap = () => (extendAxis([treemap], [shape_treemap]), (resolver_shape_treemap = () => TYPE.TREEMAP)()); + +;// ./src/core.ts + + +let defaults = /* @__PURE__ */ Object.create(null); +const bb = { + /** + * Version information + * @property {string} version version + * @example + * bb.version; // "1.0.0" + * @memberof bb + */ + version: "3.18.0", + /** + * Generate chart + * - **NOTE:** Bear in mind for the possibility of ***throwing an error***, during the generation when: + * - Unused option value is given. + * - ex) For `data.type="pie"` option, setting 'axis' option can cause unexpected generation error. + * - Insufficient value is given for certain option used. + * - ex) `data: { x: "x", columns: [["x"], ["data1", 30, 200, 100]] }` + * @param {Options} config chart options + * @memberof bb + * @returns {Chart} + * @see {@link Options} for different generation options + * @see {@link Chart} for different methods API + * @example + * <!-- chart holder --> + * <div id="LineChart"></div> + * @example + * // Generate chart with options + * var chart = bb.generate({ + * "bindto": "#LineChart" + * "data": { + * "columns": [ + * ["data1", 30, 200, 100, 400, 150, 250], + * ["data2", 50, 20, 10, 40, 15, 25] + * ], + * "type": "line" + * } + * }); + * + * // call some API + * // ex) get the data of 'data1' + * chart.data("data1"); + * @example + * // Generate chart by importing ESM + * // Import types to be used only, where this will make smaller bundle size. + * import bb, { + * area, + * areaLineRange, + * areaSpline, + * areaSplineRange, + * areaStep, + * bar, + * bubble, + * donut, + * gauge, + * line, + * pie, + * polar, + * radar, + * scatter, + * spline, + * step + * } + * + * bb.generate({ + * "bindto": "#LineChart" + * "data": { + * "columns": [ + * ["data1", 30, 200, 100, 400, 150, 250], + * ["data2", 50, 20, 10, 40, 15, 25] + * ] + * }, + * type: line(), + * + * // or + * types: { + * data1: bar(), + * data2: step() + * } + * }); + */ + generate(config) { + const options = mergeObj(/* @__PURE__ */ Object.create(null), defaults, config); + const inst = new Chart(options); + inst.internal.charts = this.instance; + this.instance.push(inst); + return inst; + }, + /** + * Set or get global default options. + * - **NOTE:** + * - The options values settings are valid within page context only. + * - If is called multiple times, will override the last value. + * @param {Options} options chart options + * @memberof bb + * @returns {Options} + * @see {@link Options} + * @example + * // Set same option value as for `.generate()` + * bb.defaults({ + * data: { + * type: "bar" + * } + * }); + * + * bb.defaults(); // {data:{type: "bar"}} + * + * // data.type defaults to 'bar' + * var chart = bb.generate({ ... }); + */ + defaults(options) { + if (isObject(options)) { + defaults = options; + } + return defaults; + }, + /** + * An array containing instance created + * @property {Array} instance instance array + * @example + * // generate charts + * var chart1 = bb.generate(...); + * var chart2 = bb.generate(...); + * + * bb.instance; // [ chart1, chart2, ... ] + * @memberof bb + */ + instance: [], + /** + * Namespace for plugins + * @property {object} plugin plugin namespace + * @example + * // Stanford diagram plugin + * bb.plugin.stanford; + * @memberof bb + */ + plugin: {} +}; + + +;// ./src/index.ts + + +Object.keys(resolver_shape_namespaceObject).forEach((v) => resolver_shape_namespaceObject[v]()); +Object.keys(resolver_interaction_namespaceObject).forEach((v) => resolver_interaction_namespaceObject[v]()); + + +}(); +/******/ return __webpack_exports__; +/******/ })() +; +}); \ No newline at end of file diff --git a/vulnerablecode/static/js/billboard.js.ABOUT b/vulnerablecode/static/js/billboard.js.ABOUT new file mode 100644 index 000000000..b24348f58 --- /dev/null +++ b/vulnerablecode/static/js/billboard.js.ABOUT @@ -0,0 +1,17 @@ +about_resource: billboard.js +name: billboard.js +version: 3.18.0 +download_url: https://registry.npmjs.org/billboard.js/-/billboard.js-3.18.0.tgz +license_expression: mit +homepage_url: https://naver.github.io/billboard.js/ +owner: NAVER Corp. +description: Re-usable easy interface JavaScript chart library, based on D3 v4+ +attribute: yes +package_url: pkg:npm/billboard.js@3.18.0 +licenses: + - key: mit + name: MIT License + file: billboard.js.LICENSE + + + diff --git a/vulnerablecode/static/js/billboard.js.LICENSE b/vulnerablecode/static/js/billboard.js.LICENSE new file mode 100644 index 000000000..7252101c5 --- /dev/null +++ b/vulnerablecode/static/js/billboard.js.LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2017 ~ present NAVER Corp. +Copyright (c) 2013 Masayuki Tanaka + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vulnerablecode/static/js/d3.js b/vulnerablecode/static/js/d3.js new file mode 100644 index 000000000..6c6bf89df --- /dev/null +++ b/vulnerablecode/static/js/d3.js @@ -0,0 +1,20625 @@ +// https://d3js.org v7.9.0 Copyright 2010-2023 Mike Bostock +(function (global, factory) { +typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : +typeof define === 'function' && define.amd ? define(['exports'], factory) : +(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3 = global.d3 || {})); +})(this, (function (exports) { 'use strict'; + +var version = "7.9.0"; + +function ascending$3(a, b) { + return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; +} + +function descending$2(a, b) { + return a == null || b == null ? NaN + : b < a ? -1 + : b > a ? 1 + : b >= a ? 0 + : NaN; +} + +function bisector(f) { + let compare1, compare2, delta; + + // If an accessor is specified, promote it to a comparator. In this case we + // can test whether the search value is (self-) comparable. We can’t do this + // for a comparator (except for specific, known comparators) because we can’t + // tell if the comparator is symmetric, and an asymmetric comparator can’t be + // used to test whether a single value is comparable. + if (f.length !== 2) { + compare1 = ascending$3; + compare2 = (d, x) => ascending$3(f(d), x); + delta = (d, x) => f(d) - x; + } else { + compare1 = f === ascending$3 || f === descending$2 ? f : zero$1; + compare2 = f; + delta = f; + } + + function left(a, x, lo = 0, hi = a.length) { + if (lo < hi) { + if (compare1(x, x) !== 0) return hi; + do { + const mid = (lo + hi) >>> 1; + if (compare2(a[mid], x) < 0) lo = mid + 1; + else hi = mid; + } while (lo < hi); + } + return lo; + } + + function right(a, x, lo = 0, hi = a.length) { + if (lo < hi) { + if (compare1(x, x) !== 0) return hi; + do { + const mid = (lo + hi) >>> 1; + if (compare2(a[mid], x) <= 0) lo = mid + 1; + else hi = mid; + } while (lo < hi); + } + return lo; + } + + function center(a, x, lo = 0, hi = a.length) { + const i = left(a, x, lo, hi - 1); + return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i; + } + + return {left, center, right}; +} + +function zero$1() { + return 0; +} + +function number$3(x) { + return x === null ? NaN : +x; +} + +function* numbers(values, valueof) { + if (valueof === undefined) { + for (let value of values) { + if (value != null && (value = +value) >= value) { + yield value; + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { + yield value; + } + } + } +} + +const ascendingBisect = bisector(ascending$3); +const bisectRight = ascendingBisect.right; +const bisectLeft = ascendingBisect.left; +const bisectCenter = bisector(number$3).center; +var bisect = bisectRight; + +function blur(values, r) { + if (!((r = +r) >= 0)) throw new RangeError("invalid r"); + let length = values.length; + if (!((length = Math.floor(length)) >= 0)) throw new RangeError("invalid length"); + if (!length || !r) return values; + const blur = blurf(r); + const temp = values.slice(); + blur(values, temp, 0, length, 1); + blur(temp, values, 0, length, 1); + blur(values, temp, 0, length, 1); + return values; +} + +const blur2 = Blur2(blurf); + +const blurImage = Blur2(blurfImage); + +function Blur2(blur) { + return function(data, rx, ry = rx) { + if (!((rx = +rx) >= 0)) throw new RangeError("invalid rx"); + if (!((ry = +ry) >= 0)) throw new RangeError("invalid ry"); + let {data: values, width, height} = data; + if (!((width = Math.floor(width)) >= 0)) throw new RangeError("invalid width"); + if (!((height = Math.floor(height !== undefined ? height : values.length / width)) >= 0)) throw new RangeError("invalid height"); + if (!width || !height || (!rx && !ry)) return data; + const blurx = rx && blur(rx); + const blury = ry && blur(ry); + const temp = values.slice(); + if (blurx && blury) { + blurh(blurx, temp, values, width, height); + blurh(blurx, values, temp, width, height); + blurh(blurx, temp, values, width, height); + blurv(blury, values, temp, width, height); + blurv(blury, temp, values, width, height); + blurv(blury, values, temp, width, height); + } else if (blurx) { + blurh(blurx, values, temp, width, height); + blurh(blurx, temp, values, width, height); + blurh(blurx, values, temp, width, height); + } else if (blury) { + blurv(blury, values, temp, width, height); + blurv(blury, temp, values, width, height); + blurv(blury, values, temp, width, height); + } + return data; + }; +} + +function blurh(blur, T, S, w, h) { + for (let y = 0, n = w * h; y < n;) { + blur(T, S, y, y += w, 1); + } +} + +function blurv(blur, T, S, w, h) { + for (let x = 0, n = w * h; x < w; ++x) { + blur(T, S, x, x + n, w); + } +} + +function blurfImage(radius) { + const blur = blurf(radius); + return (T, S, start, stop, step) => { + start <<= 2, stop <<= 2, step <<= 2; + blur(T, S, start + 0, stop + 0, step); + blur(T, S, start + 1, stop + 1, step); + blur(T, S, start + 2, stop + 2, step); + blur(T, S, start + 3, stop + 3, step); + }; +} + +// Given a target array T, a source array S, sets each value T[i] to the average +// of {S[i - r], …, S[i], …, S[i + r]}, where r = ⌊radius⌋, start <= i < stop, +// for each i, i + step, i + 2 * step, etc., and where S[j] is clamped between +// S[start] (inclusive) and S[stop] (exclusive). If the given radius is not an +// integer, S[i - r - 1] and S[i + r + 1] are added to the sum, each weighted +// according to r - ⌊radius⌋. +function blurf(radius) { + const radius0 = Math.floor(radius); + if (radius0 === radius) return bluri(radius); + const t = radius - radius0; + const w = 2 * radius + 1; + return (T, S, start, stop, step) => { // stop must be aligned! + if (!((stop -= step) >= start)) return; // inclusive stop + let sum = radius0 * S[start]; + const s0 = step * radius0; + const s1 = s0 + step; + for (let i = start, j = start + s0; i < j; i += step) { + sum += S[Math.min(stop, i)]; + } + for (let i = start, j = stop; i <= j; i += step) { + sum += S[Math.min(stop, i + s0)]; + T[i] = (sum + t * (S[Math.max(start, i - s1)] + S[Math.min(stop, i + s1)])) / w; + sum -= S[Math.max(start, i - s0)]; + } + }; +} + +// Like blurf, but optimized for integer radius. +function bluri(radius) { + const w = 2 * radius + 1; + return (T, S, start, stop, step) => { // stop must be aligned! + if (!((stop -= step) >= start)) return; // inclusive stop + let sum = radius * S[start]; + const s = step * radius; + for (let i = start, j = start + s; i < j; i += step) { + sum += S[Math.min(stop, i)]; + } + for (let i = start, j = stop; i <= j; i += step) { + sum += S[Math.min(stop, i + s)]; + T[i] = sum / w; + sum -= S[Math.max(start, i - s)]; + } + }; +} + +function count$1(values, valueof) { + let count = 0; + if (valueof === undefined) { + for (let value of values) { + if (value != null && (value = +value) >= value) { + ++count; + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { + ++count; + } + } + } + return count; +} + +function length$3(array) { + return array.length | 0; +} + +function empty$2(length) { + return !(length > 0); +} + +function arrayify(values) { + return typeof values !== "object" || "length" in values ? values : Array.from(values); +} + +function reducer(reduce) { + return values => reduce(...values); +} + +function cross$2(...values) { + const reduce = typeof values[values.length - 1] === "function" && reducer(values.pop()); + values = values.map(arrayify); + const lengths = values.map(length$3); + const j = values.length - 1; + const index = new Array(j + 1).fill(0); + const product = []; + if (j < 0 || lengths.some(empty$2)) return product; + while (true) { + product.push(index.map((j, i) => values[i][j])); + let i = j; + while (++index[i] === lengths[i]) { + if (i === 0) return reduce ? product.map(reduce) : product; + index[i--] = 0; + } + } +} + +function cumsum(values, valueof) { + var sum = 0, index = 0; + return Float64Array.from(values, valueof === undefined + ? v => (sum += +v || 0) + : v => (sum += +valueof(v, index++, values) || 0)); +} + +function variance(values, valueof) { + let count = 0; + let delta; + let mean = 0; + let sum = 0; + if (valueof === undefined) { + for (let value of values) { + if (value != null && (value = +value) >= value) { + delta = value - mean; + mean += delta / ++count; + sum += delta * (value - mean); + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { + delta = value - mean; + mean += delta / ++count; + sum += delta * (value - mean); + } + } + } + if (count > 1) return sum / (count - 1); +} + +function deviation(values, valueof) { + const v = variance(values, valueof); + return v ? Math.sqrt(v) : v; +} + +function extent$1(values, valueof) { + let min; + let max; + if (valueof === undefined) { + for (const value of values) { + if (value != null) { + if (min === undefined) { + if (value >= value) min = max = value; + } else { + if (min > value) min = value; + if (max < value) max = value; + } + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null) { + if (min === undefined) { + if (value >= value) min = max = value; + } else { + if (min > value) min = value; + if (max < value) max = value; + } + } + } + } + return [min, max]; +} + +// https://github.com/python/cpython/blob/a74eea238f5baba15797e2e8b570d153bc8690a7/Modules/mathmodule.c#L1423 +class Adder { + constructor() { + this._partials = new Float64Array(32); + this._n = 0; + } + add(x) { + const p = this._partials; + let i = 0; + for (let j = 0; j < this._n && j < 32; j++) { + const y = p[j], + hi = x + y, + lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x); + if (lo) p[i++] = lo; + x = hi; + } + p[i] = x; + this._n = i + 1; + return this; + } + valueOf() { + const p = this._partials; + let n = this._n, x, y, lo, hi = 0; + if (n > 0) { + hi = p[--n]; + while (n > 0) { + x = hi; + y = p[--n]; + hi = x + y; + lo = y - (hi - x); + if (lo) break; + } + if (n > 0 && ((lo < 0 && p[n - 1] < 0) || (lo > 0 && p[n - 1] > 0))) { + y = lo * 2; + x = hi + y; + if (y == x - hi) hi = x; + } + } + return hi; + } +} + +function fsum(values, valueof) { + const adder = new Adder(); + if (valueof === undefined) { + for (let value of values) { + if (value = +value) { + adder.add(value); + } + } + } else { + let index = -1; + for (let value of values) { + if (value = +valueof(value, ++index, values)) { + adder.add(value); + } + } + } + return +adder; +} + +function fcumsum(values, valueof) { + const adder = new Adder(); + let index = -1; + return Float64Array.from(values, valueof === undefined + ? v => adder.add(+v || 0) + : v => adder.add(+valueof(v, ++index, values) || 0) + ); +} + +class InternMap extends Map { + constructor(entries, key = keyof) { + super(); + Object.defineProperties(this, {_intern: {value: new Map()}, _key: {value: key}}); + if (entries != null) for (const [key, value] of entries) this.set(key, value); + } + get(key) { + return super.get(intern_get(this, key)); + } + has(key) { + return super.has(intern_get(this, key)); + } + set(key, value) { + return super.set(intern_set(this, key), value); + } + delete(key) { + return super.delete(intern_delete(this, key)); + } +} + +class InternSet extends Set { + constructor(values, key = keyof) { + super(); + Object.defineProperties(this, {_intern: {value: new Map()}, _key: {value: key}}); + if (values != null) for (const value of values) this.add(value); + } + has(value) { + return super.has(intern_get(this, value)); + } + add(value) { + return super.add(intern_set(this, value)); + } + delete(value) { + return super.delete(intern_delete(this, value)); + } +} + +function intern_get({_intern, _key}, value) { + const key = _key(value); + return _intern.has(key) ? _intern.get(key) : value; +} + +function intern_set({_intern, _key}, value) { + const key = _key(value); + if (_intern.has(key)) return _intern.get(key); + _intern.set(key, value); + return value; +} + +function intern_delete({_intern, _key}, value) { + const key = _key(value); + if (_intern.has(key)) { + value = _intern.get(key); + _intern.delete(key); + } + return value; +} + +function keyof(value) { + return value !== null && typeof value === "object" ? value.valueOf() : value; +} + +function identity$9(x) { + return x; +} + +function group(values, ...keys) { + return nest(values, identity$9, identity$9, keys); +} + +function groups(values, ...keys) { + return nest(values, Array.from, identity$9, keys); +} + +function flatten$1(groups, keys) { + for (let i = 1, n = keys.length; i < n; ++i) { + groups = groups.flatMap(g => g.pop().map(([key, value]) => [...g, key, value])); + } + return groups; +} + +function flatGroup(values, ...keys) { + return flatten$1(groups(values, ...keys), keys); +} + +function flatRollup(values, reduce, ...keys) { + return flatten$1(rollups(values, reduce, ...keys), keys); +} + +function rollup(values, reduce, ...keys) { + return nest(values, identity$9, reduce, keys); +} + +function rollups(values, reduce, ...keys) { + return nest(values, Array.from, reduce, keys); +} + +function index$4(values, ...keys) { + return nest(values, identity$9, unique, keys); +} + +function indexes(values, ...keys) { + return nest(values, Array.from, unique, keys); +} + +function unique(values) { + if (values.length !== 1) throw new Error("duplicate key"); + return values[0]; +} + +function nest(values, map, reduce, keys) { + return (function regroup(values, i) { + if (i >= keys.length) return reduce(values); + const groups = new InternMap(); + const keyof = keys[i++]; + let index = -1; + for (const value of values) { + const key = keyof(value, ++index, values); + const group = groups.get(key); + if (group) group.push(value); + else groups.set(key, [value]); + } + for (const [key, values] of groups) { + groups.set(key, regroup(values, i)); + } + return map(groups); + })(values, 0); +} + +function permute(source, keys) { + return Array.from(keys, key => source[key]); +} + +function sort(values, ...F) { + if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable"); + values = Array.from(values); + let [f] = F; + if ((f && f.length !== 2) || F.length > 1) { + const index = Uint32Array.from(values, (d, i) => i); + if (F.length > 1) { + F = F.map(f => values.map(f)); + index.sort((i, j) => { + for (const f of F) { + const c = ascendingDefined(f[i], f[j]); + if (c) return c; + } + }); + } else { + f = values.map(f); + index.sort((i, j) => ascendingDefined(f[i], f[j])); + } + return permute(values, index); + } + return values.sort(compareDefined(f)); +} + +function compareDefined(compare = ascending$3) { + if (compare === ascending$3) return ascendingDefined; + if (typeof compare !== "function") throw new TypeError("compare is not a function"); + return (a, b) => { + const x = compare(a, b); + if (x || x === 0) return x; + return (compare(b, b) === 0) - (compare(a, a) === 0); + }; +} + +function ascendingDefined(a, b) { + return (a == null || !(a >= a)) - (b == null || !(b >= b)) || (a < b ? -1 : a > b ? 1 : 0); +} + +function groupSort(values, reduce, key) { + return (reduce.length !== 2 + ? sort(rollup(values, reduce, key), (([ak, av], [bk, bv]) => ascending$3(av, bv) || ascending$3(ak, bk))) + : sort(group(values, key), (([ak, av], [bk, bv]) => reduce(av, bv) || ascending$3(ak, bk)))) + .map(([key]) => key); +} + +var array$5 = Array.prototype; + +var slice$3 = array$5.slice; + +function constant$b(x) { + return () => x; +} + +const e10 = Math.sqrt(50), + e5 = Math.sqrt(10), + e2 = Math.sqrt(2); + +function tickSpec(start, stop, count) { + const step = (stop - start) / Math.max(0, count), + power = Math.floor(Math.log10(step)), + error = step / Math.pow(10, power), + factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1; + let i1, i2, inc; + if (power < 0) { + inc = Math.pow(10, -power) / factor; + i1 = Math.round(start * inc); + i2 = Math.round(stop * inc); + if (i1 / inc < start) ++i1; + if (i2 / inc > stop) --i2; + inc = -inc; + } else { + inc = Math.pow(10, power) * factor; + i1 = Math.round(start / inc); + i2 = Math.round(stop / inc); + if (i1 * inc < start) ++i1; + if (i2 * inc > stop) --i2; + } + if (i2 < i1 && 0.5 <= count && count < 2) return tickSpec(start, stop, count * 2); + return [i1, i2, inc]; +} + +function ticks(start, stop, count) { + stop = +stop, start = +start, count = +count; + if (!(count > 0)) return []; + if (start === stop) return [start]; + const reverse = stop < start, [i1, i2, inc] = reverse ? tickSpec(stop, start, count) : tickSpec(start, stop, count); + if (!(i2 >= i1)) return []; + const n = i2 - i1 + 1, ticks = new Array(n); + if (reverse) { + if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) / -inc; + else for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) * inc; + } else { + if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) / -inc; + else for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) * inc; + } + return ticks; +} + +function tickIncrement(start, stop, count) { + stop = +stop, start = +start, count = +count; + return tickSpec(start, stop, count)[2]; +} + +function tickStep(start, stop, count) { + stop = +stop, start = +start, count = +count; + const reverse = stop < start, inc = reverse ? tickIncrement(stop, start, count) : tickIncrement(start, stop, count); + return (reverse ? -1 : 1) * (inc < 0 ? 1 / -inc : inc); +} + +function nice$1(start, stop, count) { + let prestep; + while (true) { + const step = tickIncrement(start, stop, count); + if (step === prestep || step === 0 || !isFinite(step)) { + return [start, stop]; + } else if (step > 0) { + start = Math.floor(start / step) * step; + stop = Math.ceil(stop / step) * step; + } else if (step < 0) { + start = Math.ceil(start * step) / step; + stop = Math.floor(stop * step) / step; + } + prestep = step; + } +} + +function thresholdSturges(values) { + return Math.max(1, Math.ceil(Math.log(count$1(values)) / Math.LN2) + 1); +} + +function bin() { + var value = identity$9, + domain = extent$1, + threshold = thresholdSturges; + + function histogram(data) { + if (!Array.isArray(data)) data = Array.from(data); + + var i, + n = data.length, + x, + step, + values = new Array(n); + + for (i = 0; i < n; ++i) { + values[i] = value(data[i], i, data); + } + + var xz = domain(values), + x0 = xz[0], + x1 = xz[1], + tz = threshold(values, x0, x1); + + // Convert number of thresholds into uniform thresholds, and nice the + // default domain accordingly. + if (!Array.isArray(tz)) { + const max = x1, tn = +tz; + if (domain === extent$1) [x0, x1] = nice$1(x0, x1, tn); + tz = ticks(x0, x1, tn); + + // If the domain is aligned with the first tick (which it will by + // default), then we can use quantization rather than bisection to bin + // values, which is substantially faster. + if (tz[0] <= x0) step = tickIncrement(x0, x1, tn); + + // If the last threshold is coincident with the domain’s upper bound, the + // last bin will be zero-width. If the default domain is used, and this + // last threshold is coincident with the maximum input value, we can + // extend the niced upper bound by one tick to ensure uniform bin widths; + // otherwise, we simply remove the last threshold. Note that we don’t + // coerce values or the domain to numbers, and thus must be careful to + // compare order (>=) rather than strict equality (===)! + if (tz[tz.length - 1] >= x1) { + if (max >= x1 && domain === extent$1) { + const step = tickIncrement(x0, x1, tn); + if (isFinite(step)) { + if (step > 0) { + x1 = (Math.floor(x1 / step) + 1) * step; + } else if (step < 0) { + x1 = (Math.ceil(x1 * -step) + 1) / -step; + } + } + } else { + tz.pop(); + } + } + } + + // Remove any thresholds outside the domain. + // Be careful not to mutate an array owned by the user! + var m = tz.length, a = 0, b = m; + while (tz[a] <= x0) ++a; + while (tz[b - 1] > x1) --b; + if (a || b < m) tz = tz.slice(a, b), m = b - a; + + var bins = new Array(m + 1), + bin; + + // Initialize bins. + for (i = 0; i <= m; ++i) { + bin = bins[i] = []; + bin.x0 = i > 0 ? tz[i - 1] : x0; + bin.x1 = i < m ? tz[i] : x1; + } + + // Assign data to bins by value, ignoring any outside the domain. + if (isFinite(step)) { + if (step > 0) { + for (i = 0; i < n; ++i) { + if ((x = values[i]) != null && x0 <= x && x <= x1) { + bins[Math.min(m, Math.floor((x - x0) / step))].push(data[i]); + } + } + } else if (step < 0) { + for (i = 0; i < n; ++i) { + if ((x = values[i]) != null && x0 <= x && x <= x1) { + const j = Math.floor((x0 - x) * step); + bins[Math.min(m, j + (tz[j] <= x))].push(data[i]); // handle off-by-one due to rounding + } + } + } + } else { + for (i = 0; i < n; ++i) { + if ((x = values[i]) != null && x0 <= x && x <= x1) { + bins[bisect(tz, x, 0, m)].push(data[i]); + } + } + } + + return bins; + } + + histogram.value = function(_) { + return arguments.length ? (value = typeof _ === "function" ? _ : constant$b(_), histogram) : value; + }; + + histogram.domain = function(_) { + return arguments.length ? (domain = typeof _ === "function" ? _ : constant$b([_[0], _[1]]), histogram) : domain; + }; + + histogram.thresholds = function(_) { + return arguments.length ? (threshold = typeof _ === "function" ? _ : constant$b(Array.isArray(_) ? slice$3.call(_) : _), histogram) : threshold; + }; + + return histogram; +} + +function max$3(values, valueof) { + let max; + if (valueof === undefined) { + for (const value of values) { + if (value != null + && (max < value || (max === undefined && value >= value))) { + max = value; + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null + && (max < value || (max === undefined && value >= value))) { + max = value; + } + } + } + return max; +} + +function maxIndex(values, valueof) { + let max; + let maxIndex = -1; + let index = -1; + if (valueof === undefined) { + for (const value of values) { + ++index; + if (value != null + && (max < value || (max === undefined && value >= value))) { + max = value, maxIndex = index; + } + } + } else { + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null + && (max < value || (max === undefined && value >= value))) { + max = value, maxIndex = index; + } + } + } + return maxIndex; +} + +function min$2(values, valueof) { + let min; + if (valueof === undefined) { + for (const value of values) { + if (value != null + && (min > value || (min === undefined && value >= value))) { + min = value; + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null + && (min > value || (min === undefined && value >= value))) { + min = value; + } + } + } + return min; +} + +function minIndex(values, valueof) { + let min; + let minIndex = -1; + let index = -1; + if (valueof === undefined) { + for (const value of values) { + ++index; + if (value != null + && (min > value || (min === undefined && value >= value))) { + min = value, minIndex = index; + } + } + } else { + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null + && (min > value || (min === undefined && value >= value))) { + min = value, minIndex = index; + } + } + } + return minIndex; +} + +// Based on https://github.com/mourner/quickselect +// ISC license, Copyright 2018 Vladimir Agafonkin. +function quickselect(array, k, left = 0, right = Infinity, compare) { + k = Math.floor(k); + left = Math.floor(Math.max(0, left)); + right = Math.floor(Math.min(array.length - 1, right)); + + if (!(left <= k && k <= right)) return array; + + compare = compare === undefined ? ascendingDefined : compareDefined(compare); + + while (right > left) { + if (right - left > 600) { + const n = right - left + 1; + const m = k - left + 1; + const z = Math.log(n); + const s = 0.5 * Math.exp(2 * z / 3); + const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1); + const newLeft = Math.max(left, Math.floor(k - m * s / n + sd)); + const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd)); + quickselect(array, k, newLeft, newRight, compare); + } + + const t = array[k]; + let i = left; + let j = right; + + swap$1(array, left, k); + if (compare(array[right], t) > 0) swap$1(array, left, right); + + while (i < j) { + swap$1(array, i, j), ++i, --j; + while (compare(array[i], t) < 0) ++i; + while (compare(array[j], t) > 0) --j; + } + + if (compare(array[left], t) === 0) swap$1(array, left, j); + else ++j, swap$1(array, j, right); + + if (j <= k) left = j + 1; + if (k <= j) right = j - 1; + } + + return array; +} + +function swap$1(array, i, j) { + const t = array[i]; + array[i] = array[j]; + array[j] = t; +} + +function greatest(values, compare = ascending$3) { + let max; + let defined = false; + if (compare.length === 1) { + let maxValue; + for (const element of values) { + const value = compare(element); + if (defined + ? ascending$3(value, maxValue) > 0 + : ascending$3(value, value) === 0) { + max = element; + maxValue = value; + defined = true; + } + } + } else { + for (const value of values) { + if (defined + ? compare(value, max) > 0 + : compare(value, value) === 0) { + max = value; + defined = true; + } + } + } + return max; +} + +function quantile$1(values, p, valueof) { + values = Float64Array.from(numbers(values, valueof)); + if (!(n = values.length) || isNaN(p = +p)) return; + if (p <= 0 || n < 2) return min$2(values); + if (p >= 1) return max$3(values); + var n, + i = (n - 1) * p, + i0 = Math.floor(i), + value0 = max$3(quickselect(values, i0).subarray(0, i0 + 1)), + value1 = min$2(values.subarray(i0 + 1)); + return value0 + (value1 - value0) * (i - i0); +} + +function quantileSorted(values, p, valueof = number$3) { + if (!(n = values.length) || isNaN(p = +p)) return; + if (p <= 0 || n < 2) return +valueof(values[0], 0, values); + if (p >= 1) return +valueof(values[n - 1], n - 1, values); + var n, + i = (n - 1) * p, + i0 = Math.floor(i), + value0 = +valueof(values[i0], i0, values), + value1 = +valueof(values[i0 + 1], i0 + 1, values); + return value0 + (value1 - value0) * (i - i0); +} + +function quantileIndex(values, p, valueof = number$3) { + if (isNaN(p = +p)) return; + numbers = Float64Array.from(values, (_, i) => number$3(valueof(values[i], i, values))); + if (p <= 0) return minIndex(numbers); + if (p >= 1) return maxIndex(numbers); + var numbers, + index = Uint32Array.from(values, (_, i) => i), + j = numbers.length - 1, + i = Math.floor(j * p); + quickselect(index, i, 0, j, (i, j) => ascendingDefined(numbers[i], numbers[j])); + i = greatest(index.subarray(0, i + 1), (i) => numbers[i]); + return i >= 0 ? i : -1; +} + +function thresholdFreedmanDiaconis(values, min, max) { + const c = count$1(values), d = quantile$1(values, 0.75) - quantile$1(values, 0.25); + return c && d ? Math.ceil((max - min) / (2 * d * Math.pow(c, -1 / 3))) : 1; +} + +function thresholdScott(values, min, max) { + const c = count$1(values), d = deviation(values); + return c && d ? Math.ceil((max - min) * Math.cbrt(c) / (3.49 * d)) : 1; +} + +function mean(values, valueof) { + let count = 0; + let sum = 0; + if (valueof === undefined) { + for (let value of values) { + if (value != null && (value = +value) >= value) { + ++count, sum += value; + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { + ++count, sum += value; + } + } + } + if (count) return sum / count; +} + +function median(values, valueof) { + return quantile$1(values, 0.5, valueof); +} + +function medianIndex(values, valueof) { + return quantileIndex(values, 0.5, valueof); +} + +function* flatten(arrays) { + for (const array of arrays) { + yield* array; + } +} + +function merge(arrays) { + return Array.from(flatten(arrays)); +} + +function mode(values, valueof) { + const counts = new InternMap(); + if (valueof === undefined) { + for (let value of values) { + if (value != null && value >= value) { + counts.set(value, (counts.get(value) || 0) + 1); + } + } + } else { + let index = -1; + for (let value of values) { + if ((value = valueof(value, ++index, values)) != null && value >= value) { + counts.set(value, (counts.get(value) || 0) + 1); + } + } + } + let modeValue; + let modeCount = 0; + for (const [value, count] of counts) { + if (count > modeCount) { + modeCount = count; + modeValue = value; + } + } + return modeValue; +} + +function pairs(values, pairof = pair) { + const pairs = []; + let previous; + let first = false; + for (const value of values) { + if (first) pairs.push(pairof(previous, value)); + previous = value; + first = true; + } + return pairs; +} + +function pair(a, b) { + return [a, b]; +} + +function range$2(start, stop, step) { + start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; + + var i = -1, + n = Math.max(0, Math.ceil((stop - start) / step)) | 0, + range = new Array(n); + + while (++i < n) { + range[i] = start + i * step; + } + + return range; +} + +function rank(values, valueof = ascending$3) { + if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable"); + let V = Array.from(values); + const R = new Float64Array(V.length); + if (valueof.length !== 2) V = V.map(valueof), valueof = ascending$3; + const compareIndex = (i, j) => valueof(V[i], V[j]); + let k, r; + values = Uint32Array.from(V, (_, i) => i); + // Risky chaining due to Safari 14 https://github.com/d3/d3-array/issues/123 + values.sort(valueof === ascending$3 ? (i, j) => ascendingDefined(V[i], V[j]) : compareDefined(compareIndex)); + values.forEach((j, i) => { + const c = compareIndex(j, k === undefined ? j : k); + if (c >= 0) { + if (k === undefined || c > 0) k = j, r = i; + R[j] = r; + } else { + R[j] = NaN; + } + }); + return R; +} + +function least(values, compare = ascending$3) { + let min; + let defined = false; + if (compare.length === 1) { + let minValue; + for (const element of values) { + const value = compare(element); + if (defined + ? ascending$3(value, minValue) < 0 + : ascending$3(value, value) === 0) { + min = element; + minValue = value; + defined = true; + } + } + } else { + for (const value of values) { + if (defined + ? compare(value, min) < 0 + : compare(value, value) === 0) { + min = value; + defined = true; + } + } + } + return min; +} + +function leastIndex(values, compare = ascending$3) { + if (compare.length === 1) return minIndex(values, compare); + let minValue; + let min = -1; + let index = -1; + for (const value of values) { + ++index; + if (min < 0 + ? compare(value, value) === 0 + : compare(value, minValue) < 0) { + minValue = value; + min = index; + } + } + return min; +} + +function greatestIndex(values, compare = ascending$3) { + if (compare.length === 1) return maxIndex(values, compare); + let maxValue; + let max = -1; + let index = -1; + for (const value of values) { + ++index; + if (max < 0 + ? compare(value, value) === 0 + : compare(value, maxValue) > 0) { + maxValue = value; + max = index; + } + } + return max; +} + +function scan(values, compare) { + const index = leastIndex(values, compare); + return index < 0 ? undefined : index; +} + +var shuffle$1 = shuffler(Math.random); + +function shuffler(random) { + return function shuffle(array, i0 = 0, i1 = array.length) { + let m = i1 - (i0 = +i0); + while (m) { + const i = random() * m-- | 0, t = array[m + i0]; + array[m + i0] = array[i + i0]; + array[i + i0] = t; + } + return array; + }; +} + +function sum$2(values, valueof) { + let sum = 0; + if (valueof === undefined) { + for (let value of values) { + if (value = +value) { + sum += value; + } + } + } else { + let index = -1; + for (let value of values) { + if (value = +valueof(value, ++index, values)) { + sum += value; + } + } + } + return sum; +} + +function transpose(matrix) { + if (!(n = matrix.length)) return []; + for (var i = -1, m = min$2(matrix, length$2), transpose = new Array(m); ++i < m;) { + for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) { + row[j] = matrix[j][i]; + } + } + return transpose; +} + +function length$2(d) { + return d.length; +} + +function zip() { + return transpose(arguments); +} + +function every(values, test) { + if (typeof test !== "function") throw new TypeError("test is not a function"); + let index = -1; + for (const value of values) { + if (!test(value, ++index, values)) { + return false; + } + } + return true; +} + +function some(values, test) { + if (typeof test !== "function") throw new TypeError("test is not a function"); + let index = -1; + for (const value of values) { + if (test(value, ++index, values)) { + return true; + } + } + return false; +} + +function filter$1(values, test) { + if (typeof test !== "function") throw new TypeError("test is not a function"); + const array = []; + let index = -1; + for (const value of values) { + if (test(value, ++index, values)) { + array.push(value); + } + } + return array; +} + +function map$1(values, mapper) { + if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable"); + if (typeof mapper !== "function") throw new TypeError("mapper is not a function"); + return Array.from(values, (value, index) => mapper(value, index, values)); +} + +function reduce(values, reducer, value) { + if (typeof reducer !== "function") throw new TypeError("reducer is not a function"); + const iterator = values[Symbol.iterator](); + let done, next, index = -1; + if (arguments.length < 3) { + ({done, value} = iterator.next()); + if (done) return; + ++index; + } + while (({done, value: next} = iterator.next()), !done) { + value = reducer(value, next, ++index, values); + } + return value; +} + +function reverse$1(values) { + if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable"); + return Array.from(values).reverse(); +} + +function difference(values, ...others) { + values = new InternSet(values); + for (const other of others) { + for (const value of other) { + values.delete(value); + } + } + return values; +} + +function disjoint(values, other) { + const iterator = other[Symbol.iterator](), set = new InternSet(); + for (const v of values) { + if (set.has(v)) return false; + let value, done; + while (({value, done} = iterator.next())) { + if (done) break; + if (Object.is(v, value)) return false; + set.add(value); + } + } + return true; +} + +function intersection(values, ...others) { + values = new InternSet(values); + others = others.map(set$2); + out: for (const value of values) { + for (const other of others) { + if (!other.has(value)) { + values.delete(value); + continue out; + } + } + } + return values; +} + +function set$2(values) { + return values instanceof InternSet ? values : new InternSet(values); +} + +function superset(values, other) { + const iterator = values[Symbol.iterator](), set = new Set(); + for (const o of other) { + const io = intern(o); + if (set.has(io)) continue; + let value, done; + while (({value, done} = iterator.next())) { + if (done) return false; + const ivalue = intern(value); + set.add(ivalue); + if (Object.is(io, ivalue)) break; + } + } + return true; +} + +function intern(value) { + return value !== null && typeof value === "object" ? value.valueOf() : value; +} + +function subset(values, other) { + return superset(other, values); +} + +function union(...others) { + const set = new InternSet(); + for (const other of others) { + for (const o of other) { + set.add(o); + } + } + return set; +} + +function identity$8(x) { + return x; +} + +var top = 1, + right = 2, + bottom = 3, + left = 4, + epsilon$6 = 1e-6; + +function translateX(x) { + return "translate(" + x + ",0)"; +} + +function translateY(y) { + return "translate(0," + y + ")"; +} + +function number$2(scale) { + return d => +scale(d); +} + +function center$1(scale, offset) { + offset = Math.max(0, scale.bandwidth() - offset * 2) / 2; + if (scale.round()) offset = Math.round(offset); + return d => +scale(d) + offset; +} + +function entering() { + return !this.__axis; +} + +function axis(orient, scale) { + var tickArguments = [], + tickValues = null, + tickFormat = null, + tickSizeInner = 6, + tickSizeOuter = 6, + tickPadding = 3, + offset = typeof window !== "undefined" && window.devicePixelRatio > 1 ? 0 : 0.5, + k = orient === top || orient === left ? -1 : 1, + x = orient === left || orient === right ? "x" : "y", + transform = orient === top || orient === bottom ? translateX : translateY; + + function axis(context) { + var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues, + format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$8) : tickFormat, + spacing = Math.max(tickSizeInner, 0) + tickPadding, + range = scale.range(), + range0 = +range[0] + offset, + range1 = +range[range.length - 1] + offset, + position = (scale.bandwidth ? center$1 : number$2)(scale.copy(), offset), + selection = context.selection ? context.selection() : context, + path = selection.selectAll(".domain").data([null]), + tick = selection.selectAll(".tick").data(values, scale).order(), + tickExit = tick.exit(), + tickEnter = tick.enter().append("g").attr("class", "tick"), + line = tick.select("line"), + text = tick.select("text"); + + path = path.merge(path.enter().insert("path", ".tick") + .attr("class", "domain") + .attr("stroke", "currentColor")); + + tick = tick.merge(tickEnter); + + line = line.merge(tickEnter.append("line") + .attr("stroke", "currentColor") + .attr(x + "2", k * tickSizeInner)); + + text = text.merge(tickEnter.append("text") + .attr("fill", "currentColor") + .attr(x, k * spacing) + .attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em")); + + if (context !== selection) { + path = path.transition(context); + tick = tick.transition(context); + line = line.transition(context); + text = text.transition(context); + + tickExit = tickExit.transition(context) + .attr("opacity", epsilon$6) + .attr("transform", function(d) { return isFinite(d = position(d)) ? transform(d + offset) : this.getAttribute("transform"); }); + + tickEnter + .attr("opacity", epsilon$6) + .attr("transform", function(d) { var p = this.parentNode.__axis; return transform((p && isFinite(p = p(d)) ? p : position(d)) + offset); }); + } + + tickExit.remove(); + + path + .attr("d", orient === left || orient === right + ? (tickSizeOuter ? "M" + k * tickSizeOuter + "," + range0 + "H" + offset + "V" + range1 + "H" + k * tickSizeOuter : "M" + offset + "," + range0 + "V" + range1) + : (tickSizeOuter ? "M" + range0 + "," + k * tickSizeOuter + "V" + offset + "H" + range1 + "V" + k * tickSizeOuter : "M" + range0 + "," + offset + "H" + range1)); + + tick + .attr("opacity", 1) + .attr("transform", function(d) { return transform(position(d) + offset); }); + + line + .attr(x + "2", k * tickSizeInner); + + text + .attr(x, k * spacing) + .text(format); + + selection.filter(entering) + .attr("fill", "none") + .attr("font-size", 10) + .attr("font-family", "sans-serif") + .attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle"); + + selection + .each(function() { this.__axis = position; }); + } + + axis.scale = function(_) { + return arguments.length ? (scale = _, axis) : scale; + }; + + axis.ticks = function() { + return tickArguments = Array.from(arguments), axis; + }; + + axis.tickArguments = function(_) { + return arguments.length ? (tickArguments = _ == null ? [] : Array.from(_), axis) : tickArguments.slice(); + }; + + axis.tickValues = function(_) { + return arguments.length ? (tickValues = _ == null ? null : Array.from(_), axis) : tickValues && tickValues.slice(); + }; + + axis.tickFormat = function(_) { + return arguments.length ? (tickFormat = _, axis) : tickFormat; + }; + + axis.tickSize = function(_) { + return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner; + }; + + axis.tickSizeInner = function(_) { + return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner; + }; + + axis.tickSizeOuter = function(_) { + return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter; + }; + + axis.tickPadding = function(_) { + return arguments.length ? (tickPadding = +_, axis) : tickPadding; + }; + + axis.offset = function(_) { + return arguments.length ? (offset = +_, axis) : offset; + }; + + return axis; +} + +function axisTop(scale) { + return axis(top, scale); +} + +function axisRight(scale) { + return axis(right, scale); +} + +function axisBottom(scale) { + return axis(bottom, scale); +} + +function axisLeft(scale) { + return axis(left, scale); +} + +var noop$3 = {value: () => {}}; + +function dispatch() { + for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) { + if (!(t = arguments[i] + "") || (t in _) || /[\s.]/.test(t)) throw new Error("illegal type: " + t); + _[t] = []; + } + return new Dispatch(_); +} + +function Dispatch(_) { + this._ = _; +} + +function parseTypenames$1(typenames, types) { + return typenames.trim().split(/^|\s+/).map(function(t) { + var name = "", i = t.indexOf("."); + if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); + if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t); + return {type: t, name: name}; + }); +} + +Dispatch.prototype = dispatch.prototype = { + constructor: Dispatch, + on: function(typename, callback) { + var _ = this._, + T = parseTypenames$1(typename + "", _), + t, + i = -1, + n = T.length; + + // If no callback was specified, return the callback of the given type and name. + if (arguments.length < 2) { + while (++i < n) if ((t = (typename = T[i]).type) && (t = get$1(_[t], typename.name))) return t; + return; + } + + // If a type was specified, set the callback for the given type and name. + // Otherwise, if a null callback was specified, remove callbacks of the given name. + if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback); + while (++i < n) { + if (t = (typename = T[i]).type) _[t] = set$1(_[t], typename.name, callback); + else if (callback == null) for (t in _) _[t] = set$1(_[t], typename.name, null); + } + + return this; + }, + copy: function() { + var copy = {}, _ = this._; + for (var t in _) copy[t] = _[t].slice(); + return new Dispatch(copy); + }, + call: function(type, that) { + if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2]; + if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); + for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); + }, + apply: function(type, that, args) { + if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); + for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); + } +}; + +function get$1(type, name) { + for (var i = 0, n = type.length, c; i < n; ++i) { + if ((c = type[i]).name === name) { + return c.value; + } + } +} + +function set$1(type, name, callback) { + for (var i = 0, n = type.length; i < n; ++i) { + if (type[i].name === name) { + type[i] = noop$3, type = type.slice(0, i).concat(type.slice(i + 1)); + break; + } + } + if (callback != null) type.push({name: name, value: callback}); + return type; +} + +var xhtml = "http://www.w3.org/1999/xhtml"; + +var namespaces = { + svg: "http://www.w3.org/2000/svg", + xhtml: xhtml, + xlink: "http://www.w3.org/1999/xlink", + xml: "http://www.w3.org/XML/1998/namespace", + xmlns: "http://www.w3.org/2000/xmlns/" +}; + +function namespace(name) { + var prefix = name += "", i = prefix.indexOf(":"); + if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); + return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name; // eslint-disable-line no-prototype-builtins +} + +function creatorInherit(name) { + return function() { + var document = this.ownerDocument, + uri = this.namespaceURI; + return uri === xhtml && document.documentElement.namespaceURI === xhtml + ? document.createElement(name) + : document.createElementNS(uri, name); + }; +} + +function creatorFixed(fullname) { + return function() { + return this.ownerDocument.createElementNS(fullname.space, fullname.local); + }; +} + +function creator(name) { + var fullname = namespace(name); + return (fullname.local + ? creatorFixed + : creatorInherit)(fullname); +} + +function none$2() {} + +function selector(selector) { + return selector == null ? none$2 : function() { + return this.querySelector(selector); + }; +} + +function selection_select(select) { + if (typeof select !== "function") select = selector(select); + + for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { + if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { + if ("__data__" in node) subnode.__data__ = node.__data__; + subgroup[i] = subnode; + } + } + } + + return new Selection$1(subgroups, this._parents); +} + +// Given something array like (or null), returns something that is strictly an +// array. This is used to ensure that array-like objects passed to d3.selectAll +// or selection.selectAll are converted into proper arrays when creating a +// selection; we don’t ever want to create a selection backed by a live +// HTMLCollection or NodeList. However, note that selection.selectAll will use a +// static NodeList as a group, since it safely derived from querySelectorAll. +function array$4(x) { + return x == null ? [] : Array.isArray(x) ? x : Array.from(x); +} + +function empty$1() { + return []; +} + +function selectorAll(selector) { + return selector == null ? empty$1 : function() { + return this.querySelectorAll(selector); + }; +} + +function arrayAll(select) { + return function() { + return array$4(select.apply(this, arguments)); + }; +} + +function selection_selectAll(select) { + if (typeof select === "function") select = arrayAll(select); + else select = selectorAll(select); + + for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { + if (node = group[i]) { + subgroups.push(select.call(node, node.__data__, i, group)); + parents.push(node); + } + } + } + + return new Selection$1(subgroups, parents); +} + +function matcher(selector) { + return function() { + return this.matches(selector); + }; +} + +function childMatcher(selector) { + return function(node) { + return node.matches(selector); + }; +} + +var find$1 = Array.prototype.find; + +function childFind(match) { + return function() { + return find$1.call(this.children, match); + }; +} + +function childFirst() { + return this.firstElementChild; +} + +function selection_selectChild(match) { + return this.select(match == null ? childFirst + : childFind(typeof match === "function" ? match : childMatcher(match))); +} + +var filter = Array.prototype.filter; + +function children() { + return Array.from(this.children); +} + +function childrenFilter(match) { + return function() { + return filter.call(this.children, match); + }; +} + +function selection_selectChildren(match) { + return this.selectAll(match == null ? children + : childrenFilter(typeof match === "function" ? match : childMatcher(match))); +} + +function selection_filter(match) { + if (typeof match !== "function") match = matcher(match); + + for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { + if ((node = group[i]) && match.call(node, node.__data__, i, group)) { + subgroup.push(node); + } + } + } + + return new Selection$1(subgroups, this._parents); +} + +function sparse(update) { + return new Array(update.length); +} + +function selection_enter() { + return new Selection$1(this._enter || this._groups.map(sparse), this._parents); +} + +function EnterNode(parent, datum) { + this.ownerDocument = parent.ownerDocument; + this.namespaceURI = parent.namespaceURI; + this._next = null; + this._parent = parent; + this.__data__ = datum; +} + +EnterNode.prototype = { + constructor: EnterNode, + appendChild: function(child) { return this._parent.insertBefore(child, this._next); }, + insertBefore: function(child, next) { return this._parent.insertBefore(child, next); }, + querySelector: function(selector) { return this._parent.querySelector(selector); }, + querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); } +}; + +function constant$a(x) { + return function() { + return x; + }; +} + +function bindIndex(parent, group, enter, update, exit, data) { + var i = 0, + node, + groupLength = group.length, + dataLength = data.length; + + // Put any non-null nodes that fit into update. + // Put any null nodes into enter. + // Put any remaining data into enter. + for (; i < dataLength; ++i) { + if (node = group[i]) { + node.__data__ = data[i]; + update[i] = node; + } else { + enter[i] = new EnterNode(parent, data[i]); + } + } + + // Put any non-null nodes that don’t fit into exit. + for (; i < groupLength; ++i) { + if (node = group[i]) { + exit[i] = node; + } + } +} + +function bindKey(parent, group, enter, update, exit, data, key) { + var i, + node, + nodeByKeyValue = new Map, + groupLength = group.length, + dataLength = data.length, + keyValues = new Array(groupLength), + keyValue; + + // Compute the key for each node. + // If multiple nodes have the same key, the duplicates are added to exit. + for (i = 0; i < groupLength; ++i) { + if (node = group[i]) { + keyValues[i] = keyValue = key.call(node, node.__data__, i, group) + ""; + if (nodeByKeyValue.has(keyValue)) { + exit[i] = node; + } else { + nodeByKeyValue.set(keyValue, node); + } + } + } + + // Compute the key for each datum. + // If there a node associated with this key, join and add it to update. + // If there is not (or the key is a duplicate), add it to enter. + for (i = 0; i < dataLength; ++i) { + keyValue = key.call(parent, data[i], i, data) + ""; + if (node = nodeByKeyValue.get(keyValue)) { + update[i] = node; + node.__data__ = data[i]; + nodeByKeyValue.delete(keyValue); + } else { + enter[i] = new EnterNode(parent, data[i]); + } + } + + // Add any remaining nodes that were not bound to data to exit. + for (i = 0; i < groupLength; ++i) { + if ((node = group[i]) && (nodeByKeyValue.get(keyValues[i]) === node)) { + exit[i] = node; + } + } +} + +function datum(node) { + return node.__data__; +} + +function selection_data(value, key) { + if (!arguments.length) return Array.from(this, datum); + + var bind = key ? bindKey : bindIndex, + parents = this._parents, + groups = this._groups; + + if (typeof value !== "function") value = constant$a(value); + + for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) { + var parent = parents[j], + group = groups[j], + groupLength = group.length, + data = arraylike(value.call(parent, parent && parent.__data__, j, parents)), + dataLength = data.length, + enterGroup = enter[j] = new Array(dataLength), + updateGroup = update[j] = new Array(dataLength), + exitGroup = exit[j] = new Array(groupLength); + + bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); + + // Now connect the enter nodes to their following update node, such that + // appendChild can insert the materialized enter node before this node, + // rather than at the end of the parent node. + for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) { + if (previous = enterGroup[i0]) { + if (i0 >= i1) i1 = i0 + 1; + while (!(next = updateGroup[i1]) && ++i1 < dataLength); + previous._next = next || null; + } + } + } + + update = new Selection$1(update, parents); + update._enter = enter; + update._exit = exit; + return update; +} + +// Given some data, this returns an array-like view of it: an object that +// exposes a length property and allows numeric indexing. Note that unlike +// selectAll, this isn’t worried about “live” collections because the resulting +// array will only be used briefly while data is being bound. (It is possible to +// cause the data to change while iterating by using a key function, but please +// don’t; we’d rather avoid a gratuitous copy.) +function arraylike(data) { + return typeof data === "object" && "length" in data + ? data // Array, TypedArray, NodeList, array-like + : Array.from(data); // Map, Set, iterable, string, or anything else +} + +function selection_exit() { + return new Selection$1(this._exit || this._groups.map(sparse), this._parents); +} + +function selection_join(onenter, onupdate, onexit) { + var enter = this.enter(), update = this, exit = this.exit(); + if (typeof onenter === "function") { + enter = onenter(enter); + if (enter) enter = enter.selection(); + } else { + enter = enter.append(onenter + ""); + } + if (onupdate != null) { + update = onupdate(update); + if (update) update = update.selection(); + } + if (onexit == null) exit.remove(); else onexit(exit); + return enter && update ? enter.merge(update).order() : update; +} + +function selection_merge(context) { + var selection = context.selection ? context.selection() : context; + + for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { + for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { + if (node = group0[i] || group1[i]) { + merge[i] = node; + } + } + } + + for (; j < m0; ++j) { + merges[j] = groups0[j]; + } + + return new Selection$1(merges, this._parents); +} + +function selection_order() { + + for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) { + for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) { + if (node = group[i]) { + if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next); + next = node; + } + } + } + + return this; +} + +function selection_sort(compare) { + if (!compare) compare = ascending$2; + + function compareNode(a, b) { + return a && b ? compare(a.__data__, b.__data__) : !a - !b; + } + + for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) { + if (node = group[i]) { + sortgroup[i] = node; + } + } + sortgroup.sort(compareNode); + } + + return new Selection$1(sortgroups, this._parents).order(); +} + +function ascending$2(a, b) { + return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; +} + +function selection_call() { + var callback = arguments[0]; + arguments[0] = this; + callback.apply(null, arguments); + return this; +} + +function selection_nodes() { + return Array.from(this); +} + +function selection_node() { + + for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { + for (var group = groups[j], i = 0, n = group.length; i < n; ++i) { + var node = group[i]; + if (node) return node; + } + } + + return null; +} + +function selection_size() { + let size = 0; + for (const node of this) ++size; // eslint-disable-line no-unused-vars + return size; +} + +function selection_empty() { + return !this.node(); +} + +function selection_each(callback) { + + for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { + for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { + if (node = group[i]) callback.call(node, node.__data__, i, group); + } + } + + return this; +} + +function attrRemove$1(name) { + return function() { + this.removeAttribute(name); + }; +} + +function attrRemoveNS$1(fullname) { + return function() { + this.removeAttributeNS(fullname.space, fullname.local); + }; +} + +function attrConstant$1(name, value) { + return function() { + this.setAttribute(name, value); + }; +} + +function attrConstantNS$1(fullname, value) { + return function() { + this.setAttributeNS(fullname.space, fullname.local, value); + }; +} + +function attrFunction$1(name, value) { + return function() { + var v = value.apply(this, arguments); + if (v == null) this.removeAttribute(name); + else this.setAttribute(name, v); + }; +} + +function attrFunctionNS$1(fullname, value) { + return function() { + var v = value.apply(this, arguments); + if (v == null) this.removeAttributeNS(fullname.space, fullname.local); + else this.setAttributeNS(fullname.space, fullname.local, v); + }; +} + +function selection_attr(name, value) { + var fullname = namespace(name); + + if (arguments.length < 2) { + var node = this.node(); + return fullname.local + ? node.getAttributeNS(fullname.space, fullname.local) + : node.getAttribute(fullname); + } + + return this.each((value == null + ? (fullname.local ? attrRemoveNS$1 : attrRemove$1) : (typeof value === "function" + ? (fullname.local ? attrFunctionNS$1 : attrFunction$1) + : (fullname.local ? attrConstantNS$1 : attrConstant$1)))(fullname, value)); +} + +function defaultView(node) { + return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node + || (node.document && node) // node is a Window + || node.defaultView; // node is a Document +} + +function styleRemove$1(name) { + return function() { + this.style.removeProperty(name); + }; +} + +function styleConstant$1(name, value, priority) { + return function() { + this.style.setProperty(name, value, priority); + }; +} + +function styleFunction$1(name, value, priority) { + return function() { + var v = value.apply(this, arguments); + if (v == null) this.style.removeProperty(name); + else this.style.setProperty(name, v, priority); + }; +} + +function selection_style(name, value, priority) { + return arguments.length > 1 + ? this.each((value == null + ? styleRemove$1 : typeof value === "function" + ? styleFunction$1 + : styleConstant$1)(name, value, priority == null ? "" : priority)) + : styleValue(this.node(), name); +} + +function styleValue(node, name) { + return node.style.getPropertyValue(name) + || defaultView(node).getComputedStyle(node, null).getPropertyValue(name); +} + +function propertyRemove(name) { + return function() { + delete this[name]; + }; +} + +function propertyConstant(name, value) { + return function() { + this[name] = value; + }; +} + +function propertyFunction(name, value) { + return function() { + var v = value.apply(this, arguments); + if (v == null) delete this[name]; + else this[name] = v; + }; +} + +function selection_property(name, value) { + return arguments.length > 1 + ? this.each((value == null + ? propertyRemove : typeof value === "function" + ? propertyFunction + : propertyConstant)(name, value)) + : this.node()[name]; +} + +function classArray(string) { + return string.trim().split(/^|\s+/); +} + +function classList(node) { + return node.classList || new ClassList(node); +} + +function ClassList(node) { + this._node = node; + this._names = classArray(node.getAttribute("class") || ""); +} + +ClassList.prototype = { + add: function(name) { + var i = this._names.indexOf(name); + if (i < 0) { + this._names.push(name); + this._node.setAttribute("class", this._names.join(" ")); + } + }, + remove: function(name) { + var i = this._names.indexOf(name); + if (i >= 0) { + this._names.splice(i, 1); + this._node.setAttribute("class", this._names.join(" ")); + } + }, + contains: function(name) { + return this._names.indexOf(name) >= 0; + } +}; + +function classedAdd(node, names) { + var list = classList(node), i = -1, n = names.length; + while (++i < n) list.add(names[i]); +} + +function classedRemove(node, names) { + var list = classList(node), i = -1, n = names.length; + while (++i < n) list.remove(names[i]); +} + +function classedTrue(names) { + return function() { + classedAdd(this, names); + }; +} + +function classedFalse(names) { + return function() { + classedRemove(this, names); + }; +} + +function classedFunction(names, value) { + return function() { + (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names); + }; +} + +function selection_classed(name, value) { + var names = classArray(name + ""); + + if (arguments.length < 2) { + var list = classList(this.node()), i = -1, n = names.length; + while (++i < n) if (!list.contains(names[i])) return false; + return true; + } + + return this.each((typeof value === "function" + ? classedFunction : value + ? classedTrue + : classedFalse)(names, value)); +} + +function textRemove() { + this.textContent = ""; +} + +function textConstant$1(value) { + return function() { + this.textContent = value; + }; +} + +function textFunction$1(value) { + return function() { + var v = value.apply(this, arguments); + this.textContent = v == null ? "" : v; + }; +} + +function selection_text(value) { + return arguments.length + ? this.each(value == null + ? textRemove : (typeof value === "function" + ? textFunction$1 + : textConstant$1)(value)) + : this.node().textContent; +} + +function htmlRemove() { + this.innerHTML = ""; +} + +function htmlConstant(value) { + return function() { + this.innerHTML = value; + }; +} + +function htmlFunction(value) { + return function() { + var v = value.apply(this, arguments); + this.innerHTML = v == null ? "" : v; + }; +} + +function selection_html(value) { + return arguments.length + ? this.each(value == null + ? htmlRemove : (typeof value === "function" + ? htmlFunction + : htmlConstant)(value)) + : this.node().innerHTML; +} + +function raise() { + if (this.nextSibling) this.parentNode.appendChild(this); +} + +function selection_raise() { + return this.each(raise); +} + +function lower() { + if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild); +} + +function selection_lower() { + return this.each(lower); +} + +function selection_append(name) { + var create = typeof name === "function" ? name : creator(name); + return this.select(function() { + return this.appendChild(create.apply(this, arguments)); + }); +} + +function constantNull() { + return null; +} + +function selection_insert(name, before) { + var create = typeof name === "function" ? name : creator(name), + select = before == null ? constantNull : typeof before === "function" ? before : selector(before); + return this.select(function() { + return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null); + }); +} + +function remove() { + var parent = this.parentNode; + if (parent) parent.removeChild(this); +} + +function selection_remove() { + return this.each(remove); +} + +function selection_cloneShallow() { + var clone = this.cloneNode(false), parent = this.parentNode; + return parent ? parent.insertBefore(clone, this.nextSibling) : clone; +} + +function selection_cloneDeep() { + var clone = this.cloneNode(true), parent = this.parentNode; + return parent ? parent.insertBefore(clone, this.nextSibling) : clone; +} + +function selection_clone(deep) { + return this.select(deep ? selection_cloneDeep : selection_cloneShallow); +} + +function selection_datum(value) { + return arguments.length + ? this.property("__data__", value) + : this.node().__data__; +} + +function contextListener(listener) { + return function(event) { + listener.call(this, event, this.__data__); + }; +} + +function parseTypenames(typenames) { + return typenames.trim().split(/^|\s+/).map(function(t) { + var name = "", i = t.indexOf("."); + if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); + return {type: t, name: name}; + }); +} + +function onRemove(typename) { + return function() { + var on = this.__on; + if (!on) return; + for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { + if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) { + this.removeEventListener(o.type, o.listener, o.options); + } else { + on[++i] = o; + } + } + if (++i) on.length = i; + else delete this.__on; + }; +} + +function onAdd(typename, value, options) { + return function() { + var on = this.__on, o, listener = contextListener(value); + if (on) for (var j = 0, m = on.length; j < m; ++j) { + if ((o = on[j]).type === typename.type && o.name === typename.name) { + this.removeEventListener(o.type, o.listener, o.options); + this.addEventListener(o.type, o.listener = listener, o.options = options); + o.value = value; + return; + } + } + this.addEventListener(typename.type, listener, options); + o = {type: typename.type, name: typename.name, value: value, listener: listener, options: options}; + if (!on) this.__on = [o]; + else on.push(o); + }; +} + +function selection_on(typename, value, options) { + var typenames = parseTypenames(typename + ""), i, n = typenames.length, t; + + if (arguments.length < 2) { + var on = this.node().__on; + if (on) for (var j = 0, m = on.length, o; j < m; ++j) { + for (i = 0, o = on[j]; i < n; ++i) { + if ((t = typenames[i]).type === o.type && t.name === o.name) { + return o.value; + } + } + } + return; + } + + on = value ? onAdd : onRemove; + for (i = 0; i < n; ++i) this.each(on(typenames[i], value, options)); + return this; +} + +function dispatchEvent(node, type, params) { + var window = defaultView(node), + event = window.CustomEvent; + + if (typeof event === "function") { + event = new event(type, params); + } else { + event = window.document.createEvent("Event"); + if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail; + else event.initEvent(type, false, false); + } + + node.dispatchEvent(event); +} + +function dispatchConstant(type, params) { + return function() { + return dispatchEvent(this, type, params); + }; +} + +function dispatchFunction(type, params) { + return function() { + return dispatchEvent(this, type, params.apply(this, arguments)); + }; +} + +function selection_dispatch(type, params) { + return this.each((typeof params === "function" + ? dispatchFunction + : dispatchConstant)(type, params)); +} + +function* selection_iterator() { + for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { + for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { + if (node = group[i]) yield node; + } + } +} + +var root$1 = [null]; + +function Selection$1(groups, parents) { + this._groups = groups; + this._parents = parents; +} + +function selection() { + return new Selection$1([[document.documentElement]], root$1); +} + +function selection_selection() { + return this; +} + +Selection$1.prototype = selection.prototype = { + constructor: Selection$1, + select: selection_select, + selectAll: selection_selectAll, + selectChild: selection_selectChild, + selectChildren: selection_selectChildren, + filter: selection_filter, + data: selection_data, + enter: selection_enter, + exit: selection_exit, + join: selection_join, + merge: selection_merge, + selection: selection_selection, + order: selection_order, + sort: selection_sort, + call: selection_call, + nodes: selection_nodes, + node: selection_node, + size: selection_size, + empty: selection_empty, + each: selection_each, + attr: selection_attr, + style: selection_style, + property: selection_property, + classed: selection_classed, + text: selection_text, + html: selection_html, + raise: selection_raise, + lower: selection_lower, + append: selection_append, + insert: selection_insert, + remove: selection_remove, + clone: selection_clone, + datum: selection_datum, + on: selection_on, + dispatch: selection_dispatch, + [Symbol.iterator]: selection_iterator +}; + +function select(selector) { + return typeof selector === "string" + ? new Selection$1([[document.querySelector(selector)]], [document.documentElement]) + : new Selection$1([[selector]], root$1); +} + +function create$1(name) { + return select(creator(name).call(document.documentElement)); +} + +var nextId = 0; + +function local$1() { + return new Local; +} + +function Local() { + this._ = "@" + (++nextId).toString(36); +} + +Local.prototype = local$1.prototype = { + constructor: Local, + get: function(node) { + var id = this._; + while (!(id in node)) if (!(node = node.parentNode)) return; + return node[id]; + }, + set: function(node, value) { + return node[this._] = value; + }, + remove: function(node) { + return this._ in node && delete node[this._]; + }, + toString: function() { + return this._; + } +}; + +function sourceEvent(event) { + let sourceEvent; + while (sourceEvent = event.sourceEvent) event = sourceEvent; + return event; +} + +function pointer(event, node) { + event = sourceEvent(event); + if (node === undefined) node = event.currentTarget; + if (node) { + var svg = node.ownerSVGElement || node; + if (svg.createSVGPoint) { + var point = svg.createSVGPoint(); + point.x = event.clientX, point.y = event.clientY; + point = point.matrixTransform(node.getScreenCTM().inverse()); + return [point.x, point.y]; + } + if (node.getBoundingClientRect) { + var rect = node.getBoundingClientRect(); + return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop]; + } + } + return [event.pageX, event.pageY]; +} + +function pointers(events, node) { + if (events.target) { // i.e., instanceof Event, not TouchList or iterable + events = sourceEvent(events); + if (node === undefined) node = events.currentTarget; + events = events.touches || [events]; + } + return Array.from(events, event => pointer(event, node)); +} + +function selectAll(selector) { + return typeof selector === "string" + ? new Selection$1([document.querySelectorAll(selector)], [document.documentElement]) + : new Selection$1([array$4(selector)], root$1); +} + +// These are typically used in conjunction with noevent to ensure that we can +// preventDefault on the event. +const nonpassive = {passive: false}; +const nonpassivecapture = {capture: true, passive: false}; + +function nopropagation$2(event) { + event.stopImmediatePropagation(); +} + +function noevent$2(event) { + event.preventDefault(); + event.stopImmediatePropagation(); +} + +function dragDisable(view) { + var root = view.document.documentElement, + selection = select(view).on("dragstart.drag", noevent$2, nonpassivecapture); + if ("onselectstart" in root) { + selection.on("selectstart.drag", noevent$2, nonpassivecapture); + } else { + root.__noselect = root.style.MozUserSelect; + root.style.MozUserSelect = "none"; + } +} + +function yesdrag(view, noclick) { + var root = view.document.documentElement, + selection = select(view).on("dragstart.drag", null); + if (noclick) { + selection.on("click.drag", noevent$2, nonpassivecapture); + setTimeout(function() { selection.on("click.drag", null); }, 0); + } + if ("onselectstart" in root) { + selection.on("selectstart.drag", null); + } else { + root.style.MozUserSelect = root.__noselect; + delete root.__noselect; + } +} + +var constant$9 = x => () => x; + +function DragEvent(type, { + sourceEvent, + subject, + target, + identifier, + active, + x, y, dx, dy, + dispatch +}) { + Object.defineProperties(this, { + type: {value: type, enumerable: true, configurable: true}, + sourceEvent: {value: sourceEvent, enumerable: true, configurable: true}, + subject: {value: subject, enumerable: true, configurable: true}, + target: {value: target, enumerable: true, configurable: true}, + identifier: {value: identifier, enumerable: true, configurable: true}, + active: {value: active, enumerable: true, configurable: true}, + x: {value: x, enumerable: true, configurable: true}, + y: {value: y, enumerable: true, configurable: true}, + dx: {value: dx, enumerable: true, configurable: true}, + dy: {value: dy, enumerable: true, configurable: true}, + _: {value: dispatch} + }); +} + +DragEvent.prototype.on = function() { + var value = this._.on.apply(this._, arguments); + return value === this._ ? this : value; +}; + +// Ignore right-click, since that should open the context menu. +function defaultFilter$2(event) { + return !event.ctrlKey && !event.button; +} + +function defaultContainer() { + return this.parentNode; +} + +function defaultSubject(event, d) { + return d == null ? {x: event.x, y: event.y} : d; +} + +function defaultTouchable$2() { + return navigator.maxTouchPoints || ("ontouchstart" in this); +} + +function drag() { + var filter = defaultFilter$2, + container = defaultContainer, + subject = defaultSubject, + touchable = defaultTouchable$2, + gestures = {}, + listeners = dispatch("start", "drag", "end"), + active = 0, + mousedownx, + mousedowny, + mousemoving, + touchending, + clickDistance2 = 0; + + function drag(selection) { + selection + .on("mousedown.drag", mousedowned) + .filter(touchable) + .on("touchstart.drag", touchstarted) + .on("touchmove.drag", touchmoved, nonpassive) + .on("touchend.drag touchcancel.drag", touchended) + .style("touch-action", "none") + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); + } + + function mousedowned(event, d) { + if (touchending || !filter.call(this, event, d)) return; + var gesture = beforestart(this, container.call(this, event, d), event, d, "mouse"); + if (!gesture) return; + select(event.view) + .on("mousemove.drag", mousemoved, nonpassivecapture) + .on("mouseup.drag", mouseupped, nonpassivecapture); + dragDisable(event.view); + nopropagation$2(event); + mousemoving = false; + mousedownx = event.clientX; + mousedowny = event.clientY; + gesture("start", event); + } + + function mousemoved(event) { + noevent$2(event); + if (!mousemoving) { + var dx = event.clientX - mousedownx, dy = event.clientY - mousedowny; + mousemoving = dx * dx + dy * dy > clickDistance2; + } + gestures.mouse("drag", event); + } + + function mouseupped(event) { + select(event.view).on("mousemove.drag mouseup.drag", null); + yesdrag(event.view, mousemoving); + noevent$2(event); + gestures.mouse("end", event); + } + + function touchstarted(event, d) { + if (!filter.call(this, event, d)) return; + var touches = event.changedTouches, + c = container.call(this, event, d), + n = touches.length, i, gesture; + + for (i = 0; i < n; ++i) { + if (gesture = beforestart(this, c, event, d, touches[i].identifier, touches[i])) { + nopropagation$2(event); + gesture("start", event, touches[i]); + } + } + } + + function touchmoved(event) { + var touches = event.changedTouches, + n = touches.length, i, gesture; + + for (i = 0; i < n; ++i) { + if (gesture = gestures[touches[i].identifier]) { + noevent$2(event); + gesture("drag", event, touches[i]); + } + } + } + + function touchended(event) { + var touches = event.changedTouches, + n = touches.length, i, gesture; + + if (touchending) clearTimeout(touchending); + touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! + for (i = 0; i < n; ++i) { + if (gesture = gestures[touches[i].identifier]) { + nopropagation$2(event); + gesture("end", event, touches[i]); + } + } + } + + function beforestart(that, container, event, d, identifier, touch) { + var dispatch = listeners.copy(), + p = pointer(touch || event, container), dx, dy, + s; + + if ((s = subject.call(that, new DragEvent("beforestart", { + sourceEvent: event, + target: drag, + identifier, + active, + x: p[0], + y: p[1], + dx: 0, + dy: 0, + dispatch + }), d)) == null) return; + + dx = s.x - p[0] || 0; + dy = s.y - p[1] || 0; + + return function gesture(type, event, touch) { + var p0 = p, n; + switch (type) { + case "start": gestures[identifier] = gesture, n = active++; break; + case "end": delete gestures[identifier], --active; // falls through + case "drag": p = pointer(touch || event, container), n = active; break; + } + dispatch.call( + type, + that, + new DragEvent(type, { + sourceEvent: event, + subject: s, + target: drag, + identifier, + active: n, + x: p[0] + dx, + y: p[1] + dy, + dx: p[0] - p0[0], + dy: p[1] - p0[1], + dispatch + }), + d + ); + }; + } + + drag.filter = function(_) { + return arguments.length ? (filter = typeof _ === "function" ? _ : constant$9(!!_), drag) : filter; + }; + + drag.container = function(_) { + return arguments.length ? (container = typeof _ === "function" ? _ : constant$9(_), drag) : container; + }; + + drag.subject = function(_) { + return arguments.length ? (subject = typeof _ === "function" ? _ : constant$9(_), drag) : subject; + }; + + drag.touchable = function(_) { + return arguments.length ? (touchable = typeof _ === "function" ? _ : constant$9(!!_), drag) : touchable; + }; + + drag.on = function() { + var value = listeners.on.apply(listeners, arguments); + return value === listeners ? drag : value; + }; + + drag.clickDistance = function(_) { + return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2); + }; + + return drag; +} + +function define(constructor, factory, prototype) { + constructor.prototype = factory.prototype = prototype; + prototype.constructor = constructor; +} + +function extend(parent, definition) { + var prototype = Object.create(parent.prototype); + for (var key in definition) prototype[key] = definition[key]; + return prototype; +} + +function Color() {} + +var darker = 0.7; +var brighter = 1 / darker; + +var reI = "\\s*([+-]?\\d+)\\s*", + reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*", + reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*", + reHex = /^#([0-9a-f]{3,8})$/, + reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`), + reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`), + reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`), + reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`), + reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`), + reHslaPercent = new RegExp(`^hsla\\(${reN},${reP},${reP},${reN}\\)$`); + +var named = { + aliceblue: 0xf0f8ff, + antiquewhite: 0xfaebd7, + aqua: 0x00ffff, + aquamarine: 0x7fffd4, + azure: 0xf0ffff, + beige: 0xf5f5dc, + bisque: 0xffe4c4, + black: 0x000000, + blanchedalmond: 0xffebcd, + blue: 0x0000ff, + blueviolet: 0x8a2be2, + brown: 0xa52a2a, + burlywood: 0xdeb887, + cadetblue: 0x5f9ea0, + chartreuse: 0x7fff00, + chocolate: 0xd2691e, + coral: 0xff7f50, + cornflowerblue: 0x6495ed, + cornsilk: 0xfff8dc, + crimson: 0xdc143c, + cyan: 0x00ffff, + darkblue: 0x00008b, + darkcyan: 0x008b8b, + darkgoldenrod: 0xb8860b, + darkgray: 0xa9a9a9, + darkgreen: 0x006400, + darkgrey: 0xa9a9a9, + darkkhaki: 0xbdb76b, + darkmagenta: 0x8b008b, + darkolivegreen: 0x556b2f, + darkorange: 0xff8c00, + darkorchid: 0x9932cc, + darkred: 0x8b0000, + darksalmon: 0xe9967a, + darkseagreen: 0x8fbc8f, + darkslateblue: 0x483d8b, + darkslategray: 0x2f4f4f, + darkslategrey: 0x2f4f4f, + darkturquoise: 0x00ced1, + darkviolet: 0x9400d3, + deeppink: 0xff1493, + deepskyblue: 0x00bfff, + dimgray: 0x696969, + dimgrey: 0x696969, + dodgerblue: 0x1e90ff, + firebrick: 0xb22222, + floralwhite: 0xfffaf0, + forestgreen: 0x228b22, + fuchsia: 0xff00ff, + gainsboro: 0xdcdcdc, + ghostwhite: 0xf8f8ff, + gold: 0xffd700, + goldenrod: 0xdaa520, + gray: 0x808080, + green: 0x008000, + greenyellow: 0xadff2f, + grey: 0x808080, + honeydew: 0xf0fff0, + hotpink: 0xff69b4, + indianred: 0xcd5c5c, + indigo: 0x4b0082, + ivory: 0xfffff0, + khaki: 0xf0e68c, + lavender: 0xe6e6fa, + lavenderblush: 0xfff0f5, + lawngreen: 0x7cfc00, + lemonchiffon: 0xfffacd, + lightblue: 0xadd8e6, + lightcoral: 0xf08080, + lightcyan: 0xe0ffff, + lightgoldenrodyellow: 0xfafad2, + lightgray: 0xd3d3d3, + lightgreen: 0x90ee90, + lightgrey: 0xd3d3d3, + lightpink: 0xffb6c1, + lightsalmon: 0xffa07a, + lightseagreen: 0x20b2aa, + lightskyblue: 0x87cefa, + lightslategray: 0x778899, + lightslategrey: 0x778899, + lightsteelblue: 0xb0c4de, + lightyellow: 0xffffe0, + lime: 0x00ff00, + limegreen: 0x32cd32, + linen: 0xfaf0e6, + magenta: 0xff00ff, + maroon: 0x800000, + mediumaquamarine: 0x66cdaa, + mediumblue: 0x0000cd, + mediumorchid: 0xba55d3, + mediumpurple: 0x9370db, + mediumseagreen: 0x3cb371, + mediumslateblue: 0x7b68ee, + mediumspringgreen: 0x00fa9a, + mediumturquoise: 0x48d1cc, + mediumvioletred: 0xc71585, + midnightblue: 0x191970, + mintcream: 0xf5fffa, + mistyrose: 0xffe4e1, + moccasin: 0xffe4b5, + navajowhite: 0xffdead, + navy: 0x000080, + oldlace: 0xfdf5e6, + olive: 0x808000, + olivedrab: 0x6b8e23, + orange: 0xffa500, + orangered: 0xff4500, + orchid: 0xda70d6, + palegoldenrod: 0xeee8aa, + palegreen: 0x98fb98, + paleturquoise: 0xafeeee, + palevioletred: 0xdb7093, + papayawhip: 0xffefd5, + peachpuff: 0xffdab9, + peru: 0xcd853f, + pink: 0xffc0cb, + plum: 0xdda0dd, + powderblue: 0xb0e0e6, + purple: 0x800080, + rebeccapurple: 0x663399, + red: 0xff0000, + rosybrown: 0xbc8f8f, + royalblue: 0x4169e1, + saddlebrown: 0x8b4513, + salmon: 0xfa8072, + sandybrown: 0xf4a460, + seagreen: 0x2e8b57, + seashell: 0xfff5ee, + sienna: 0xa0522d, + silver: 0xc0c0c0, + skyblue: 0x87ceeb, + slateblue: 0x6a5acd, + slategray: 0x708090, + slategrey: 0x708090, + snow: 0xfffafa, + springgreen: 0x00ff7f, + steelblue: 0x4682b4, + tan: 0xd2b48c, + teal: 0x008080, + thistle: 0xd8bfd8, + tomato: 0xff6347, + turquoise: 0x40e0d0, + violet: 0xee82ee, + wheat: 0xf5deb3, + white: 0xffffff, + whitesmoke: 0xf5f5f5, + yellow: 0xffff00, + yellowgreen: 0x9acd32 +}; + +define(Color, color, { + copy(channels) { + return Object.assign(new this.constructor, this, channels); + }, + displayable() { + return this.rgb().displayable(); + }, + hex: color_formatHex, // Deprecated! Use color.formatHex. + formatHex: color_formatHex, + formatHex8: color_formatHex8, + formatHsl: color_formatHsl, + formatRgb: color_formatRgb, + toString: color_formatRgb +}); + +function color_formatHex() { + return this.rgb().formatHex(); +} + +function color_formatHex8() { + return this.rgb().formatHex8(); +} + +function color_formatHsl() { + return hslConvert(this).formatHsl(); +} + +function color_formatRgb() { + return this.rgb().formatRgb(); +} + +function color(format) { + var m, l; + format = (format + "").trim().toLowerCase(); + return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) // #ff0000 + : l === 3 ? new Rgb((m >> 8 & 0xf) | (m >> 4 & 0xf0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1) // #f00 + : l === 8 ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (m & 0xff) / 0xff) // #ff000000 + : l === 4 ? rgba((m >> 12 & 0xf) | (m >> 8 & 0xf0), (m >> 8 & 0xf) | (m >> 4 & 0xf0), (m >> 4 & 0xf) | (m & 0xf0), (((m & 0xf) << 4) | (m & 0xf)) / 0xff) // #f000 + : null) // invalid hex + : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0) + : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) + : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) + : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) + : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) + : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) + : named.hasOwnProperty(format) ? rgbn(named[format]) // eslint-disable-line no-prototype-builtins + : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) + : null; +} + +function rgbn(n) { + return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); +} + +function rgba(r, g, b, a) { + if (a <= 0) r = g = b = NaN; + return new Rgb(r, g, b, a); +} + +function rgbConvert(o) { + if (!(o instanceof Color)) o = color(o); + if (!o) return new Rgb; + o = o.rgb(); + return new Rgb(o.r, o.g, o.b, o.opacity); +} + +function rgb(r, g, b, opacity) { + return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity); +} + +function Rgb(r, g, b, opacity) { + this.r = +r; + this.g = +g; + this.b = +b; + this.opacity = +opacity; +} + +define(Rgb, rgb, extend(Color, { + brighter(k) { + k = k == null ? brighter : Math.pow(brighter, k); + return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); + }, + darker(k) { + k = k == null ? darker : Math.pow(darker, k); + return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); + }, + rgb() { + return this; + }, + clamp() { + return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity)); + }, + displayable() { + return (-0.5 <= this.r && this.r < 255.5) + && (-0.5 <= this.g && this.g < 255.5) + && (-0.5 <= this.b && this.b < 255.5) + && (0 <= this.opacity && this.opacity <= 1); + }, + hex: rgb_formatHex, // Deprecated! Use color.formatHex. + formatHex: rgb_formatHex, + formatHex8: rgb_formatHex8, + formatRgb: rgb_formatRgb, + toString: rgb_formatRgb +})); + +function rgb_formatHex() { + return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}`; +} + +function rgb_formatHex8() { + return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`; +} + +function rgb_formatRgb() { + const a = clampa(this.opacity); + return `${a === 1 ? "rgb(" : "rgba("}${clampi(this.r)}, ${clampi(this.g)}, ${clampi(this.b)}${a === 1 ? ")" : `, ${a})`}`; +} + +function clampa(opacity) { + return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity)); +} + +function clampi(value) { + return Math.max(0, Math.min(255, Math.round(value) || 0)); +} + +function hex(value) { + value = clampi(value); + return (value < 16 ? "0" : "") + value.toString(16); +} + +function hsla(h, s, l, a) { + if (a <= 0) h = s = l = NaN; + else if (l <= 0 || l >= 1) h = s = NaN; + else if (s <= 0) h = NaN; + return new Hsl(h, s, l, a); +} + +function hslConvert(o) { + if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); + if (!(o instanceof Color)) o = color(o); + if (!o) return new Hsl; + if (o instanceof Hsl) return o; + o = o.rgb(); + var r = o.r / 255, + g = o.g / 255, + b = o.b / 255, + min = Math.min(r, g, b), + max = Math.max(r, g, b), + h = NaN, + s = max - min, + l = (max + min) / 2; + if (s) { + if (r === max) h = (g - b) / s + (g < b) * 6; + else if (g === max) h = (b - r) / s + 2; + else h = (r - g) / s + 4; + s /= l < 0.5 ? max + min : 2 - max - min; + h *= 60; + } else { + s = l > 0 && l < 1 ? 0 : h; + } + return new Hsl(h, s, l, o.opacity); +} + +function hsl$2(h, s, l, opacity) { + return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity); +} + +function Hsl(h, s, l, opacity) { + this.h = +h; + this.s = +s; + this.l = +l; + this.opacity = +opacity; +} + +define(Hsl, hsl$2, extend(Color, { + brighter(k) { + k = k == null ? brighter : Math.pow(brighter, k); + return new Hsl(this.h, this.s, this.l * k, this.opacity); + }, + darker(k) { + k = k == null ? darker : Math.pow(darker, k); + return new Hsl(this.h, this.s, this.l * k, this.opacity); + }, + rgb() { + var h = this.h % 360 + (this.h < 0) * 360, + s = isNaN(h) || isNaN(this.s) ? 0 : this.s, + l = this.l, + m2 = l + (l < 0.5 ? l : 1 - l) * s, + m1 = 2 * l - m2; + return new Rgb( + hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), + hsl2rgb(h, m1, m2), + hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), + this.opacity + ); + }, + clamp() { + return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity)); + }, + displayable() { + return (0 <= this.s && this.s <= 1 || isNaN(this.s)) + && (0 <= this.l && this.l <= 1) + && (0 <= this.opacity && this.opacity <= 1); + }, + formatHsl() { + const a = clampa(this.opacity); + return `${a === 1 ? "hsl(" : "hsla("}${clamph(this.h)}, ${clampt(this.s) * 100}%, ${clampt(this.l) * 100}%${a === 1 ? ")" : `, ${a})`}`; + } +})); + +function clamph(value) { + value = (value || 0) % 360; + return value < 0 ? value + 360 : value; +} + +function clampt(value) { + return Math.max(0, Math.min(1, value || 0)); +} + +/* From FvD 13.37, CSS Color Module Level 3 */ +function hsl2rgb(h, m1, m2) { + return (h < 60 ? m1 + (m2 - m1) * h / 60 + : h < 180 ? m2 + : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 + : m1) * 255; +} + +const radians$1 = Math.PI / 180; +const degrees$2 = 180 / Math.PI; + +// https://observablehq.com/@mbostock/lab-and-rgb +const K = 18, + Xn = 0.96422, + Yn = 1, + Zn = 0.82521, + t0$1 = 4 / 29, + t1$1 = 6 / 29, + t2 = 3 * t1$1 * t1$1, + t3 = t1$1 * t1$1 * t1$1; + +function labConvert(o) { + if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); + if (o instanceof Hcl) return hcl2lab(o); + if (!(o instanceof Rgb)) o = rgbConvert(o); + var r = rgb2lrgb(o.r), + g = rgb2lrgb(o.g), + b = rgb2lrgb(o.b), + y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn), x, z; + if (r === g && g === b) x = z = y; else { + x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn); + z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn); + } + return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); +} + +function gray(l, opacity) { + return new Lab(l, 0, 0, opacity == null ? 1 : opacity); +} + +function lab$1(l, a, b, opacity) { + return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity); +} + +function Lab(l, a, b, opacity) { + this.l = +l; + this.a = +a; + this.b = +b; + this.opacity = +opacity; +} + +define(Lab, lab$1, extend(Color, { + brighter(k) { + return new Lab(this.l + K * (k == null ? 1 : k), this.a, this.b, this.opacity); + }, + darker(k) { + return new Lab(this.l - K * (k == null ? 1 : k), this.a, this.b, this.opacity); + }, + rgb() { + var y = (this.l + 16) / 116, + x = isNaN(this.a) ? y : y + this.a / 500, + z = isNaN(this.b) ? y : y - this.b / 200; + x = Xn * lab2xyz(x); + y = Yn * lab2xyz(y); + z = Zn * lab2xyz(z); + return new Rgb( + lrgb2rgb( 3.1338561 * x - 1.6168667 * y - 0.4906146 * z), + lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z), + lrgb2rgb( 0.0719453 * x - 0.2289914 * y + 1.4052427 * z), + this.opacity + ); + } +})); + +function xyz2lab(t) { + return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0$1; +} + +function lab2xyz(t) { + return t > t1$1 ? t * t * t : t2 * (t - t0$1); +} + +function lrgb2rgb(x) { + return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); +} + +function rgb2lrgb(x) { + return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); +} + +function hclConvert(o) { + if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); + if (!(o instanceof Lab)) o = labConvert(o); + if (o.a === 0 && o.b === 0) return new Hcl(NaN, 0 < o.l && o.l < 100 ? 0 : NaN, o.l, o.opacity); + var h = Math.atan2(o.b, o.a) * degrees$2; + return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); +} + +function lch(l, c, h, opacity) { + return arguments.length === 1 ? hclConvert(l) : new Hcl(h, c, l, opacity == null ? 1 : opacity); +} + +function hcl$2(h, c, l, opacity) { + return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity); +} + +function Hcl(h, c, l, opacity) { + this.h = +h; + this.c = +c; + this.l = +l; + this.opacity = +opacity; +} + +function hcl2lab(o) { + if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity); + var h = o.h * radians$1; + return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); +} + +define(Hcl, hcl$2, extend(Color, { + brighter(k) { + return new Hcl(this.h, this.c, this.l + K * (k == null ? 1 : k), this.opacity); + }, + darker(k) { + return new Hcl(this.h, this.c, this.l - K * (k == null ? 1 : k), this.opacity); + }, + rgb() { + return hcl2lab(this).rgb(); + } +})); + +var A = -0.14861, + B$1 = +1.78277, + C = -0.29227, + D$1 = -0.90649, + E = +1.97294, + ED = E * D$1, + EB = E * B$1, + BC_DA = B$1 * C - D$1 * A; + +function cubehelixConvert(o) { + if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity); + if (!(o instanceof Rgb)) o = rgbConvert(o); + var r = o.r / 255, + g = o.g / 255, + b = o.b / 255, + l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), + bl = b - l, + k = (E * (g - l) - C * bl) / D$1, + s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1 + h = s ? Math.atan2(k, bl) * degrees$2 - 120 : NaN; + return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); +} + +function cubehelix$3(h, s, l, opacity) { + return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); +} + +function Cubehelix(h, s, l, opacity) { + this.h = +h; + this.s = +s; + this.l = +l; + this.opacity = +opacity; +} + +define(Cubehelix, cubehelix$3, extend(Color, { + brighter(k) { + k = k == null ? brighter : Math.pow(brighter, k); + return new Cubehelix(this.h, this.s, this.l * k, this.opacity); + }, + darker(k) { + k = k == null ? darker : Math.pow(darker, k); + return new Cubehelix(this.h, this.s, this.l * k, this.opacity); + }, + rgb() { + var h = isNaN(this.h) ? 0 : (this.h + 120) * radians$1, + l = +this.l, + a = isNaN(this.s) ? 0 : this.s * l * (1 - l), + cosh = Math.cos(h), + sinh = Math.sin(h); + return new Rgb( + 255 * (l + a * (A * cosh + B$1 * sinh)), + 255 * (l + a * (C * cosh + D$1 * sinh)), + 255 * (l + a * (E * cosh)), + this.opacity + ); + } +})); + +function basis$1(t1, v0, v1, v2, v3) { + var t2 = t1 * t1, t3 = t2 * t1; + return ((1 - 3 * t1 + 3 * t2 - t3) * v0 + + (4 - 6 * t2 + 3 * t3) * v1 + + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 + + t3 * v3) / 6; +} + +function basis$2(values) { + var n = values.length - 1; + return function(t) { + var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), + v1 = values[i], + v2 = values[i + 1], + v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, + v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1; + return basis$1((t - i / n) * n, v0, v1, v2, v3); + }; +} + +function basisClosed$1(values) { + var n = values.length; + return function(t) { + var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), + v0 = values[(i + n - 1) % n], + v1 = values[i % n], + v2 = values[(i + 1) % n], + v3 = values[(i + 2) % n]; + return basis$1((t - i / n) * n, v0, v1, v2, v3); + }; +} + +var constant$8 = x => () => x; + +function linear$2(a, d) { + return function(t) { + return a + t * d; + }; +} + +function exponential$1(a, b, y) { + return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { + return Math.pow(a + t * b, y); + }; +} + +function hue$1(a, b) { + var d = b - a; + return d ? linear$2(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$8(isNaN(a) ? b : a); +} + +function gamma$1(y) { + return (y = +y) === 1 ? nogamma : function(a, b) { + return b - a ? exponential$1(a, b, y) : constant$8(isNaN(a) ? b : a); + }; +} + +function nogamma(a, b) { + var d = b - a; + return d ? linear$2(a, d) : constant$8(isNaN(a) ? b : a); +} + +var interpolateRgb = (function rgbGamma(y) { + var color = gamma$1(y); + + function rgb$1(start, end) { + var r = color((start = rgb(start)).r, (end = rgb(end)).r), + g = color(start.g, end.g), + b = color(start.b, end.b), + opacity = nogamma(start.opacity, end.opacity); + return function(t) { + start.r = r(t); + start.g = g(t); + start.b = b(t); + start.opacity = opacity(t); + return start + ""; + }; + } + + rgb$1.gamma = rgbGamma; + + return rgb$1; +})(1); + +function rgbSpline(spline) { + return function(colors) { + var n = colors.length, + r = new Array(n), + g = new Array(n), + b = new Array(n), + i, color; + for (i = 0; i < n; ++i) { + color = rgb(colors[i]); + r[i] = color.r || 0; + g[i] = color.g || 0; + b[i] = color.b || 0; + } + r = spline(r); + g = spline(g); + b = spline(b); + color.opacity = 1; + return function(t) { + color.r = r(t); + color.g = g(t); + color.b = b(t); + return color + ""; + }; + }; +} + +var rgbBasis = rgbSpline(basis$2); +var rgbBasisClosed = rgbSpline(basisClosed$1); + +function numberArray(a, b) { + if (!b) b = []; + var n = a ? Math.min(b.length, a.length) : 0, + c = b.slice(), + i; + return function(t) { + for (i = 0; i < n; ++i) c[i] = a[i] * (1 - t) + b[i] * t; + return c; + }; +} + +function isNumberArray(x) { + return ArrayBuffer.isView(x) && !(x instanceof DataView); +} + +function array$3(a, b) { + return (isNumberArray(b) ? numberArray : genericArray)(a, b); +} + +function genericArray(a, b) { + var nb = b ? b.length : 0, + na = a ? Math.min(nb, a.length) : 0, + x = new Array(na), + c = new Array(nb), + i; + + for (i = 0; i < na; ++i) x[i] = interpolate$2(a[i], b[i]); + for (; i < nb; ++i) c[i] = b[i]; + + return function(t) { + for (i = 0; i < na; ++i) c[i] = x[i](t); + return c; + }; +} + +function date$1(a, b) { + var d = new Date; + return a = +a, b = +b, function(t) { + return d.setTime(a * (1 - t) + b * t), d; + }; +} + +function interpolateNumber(a, b) { + return a = +a, b = +b, function(t) { + return a * (1 - t) + b * t; + }; +} + +function object$1(a, b) { + var i = {}, + c = {}, + k; + + if (a === null || typeof a !== "object") a = {}; + if (b === null || typeof b !== "object") b = {}; + + for (k in b) { + if (k in a) { + i[k] = interpolate$2(a[k], b[k]); + } else { + c[k] = b[k]; + } + } + + return function(t) { + for (k in i) c[k] = i[k](t); + return c; + }; +} + +var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, + reB = new RegExp(reA.source, "g"); + +function zero(b) { + return function() { + return b; + }; +} + +function one(b) { + return function(t) { + return b(t) + ""; + }; +} + +function interpolateString(a, b) { + var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b + am, // current match in a + bm, // current match in b + bs, // string preceding current number in b, if any + i = -1, // index in s + s = [], // string constants and placeholders + q = []; // number interpolators + + // Coerce inputs to strings. + a = a + "", b = b + ""; + + // Interpolate pairs of numbers in a & b. + while ((am = reA.exec(a)) + && (bm = reB.exec(b))) { + if ((bs = bm.index) > bi) { // a string precedes the next number in b + bs = b.slice(bi, bs); + if (s[i]) s[i] += bs; // coalesce with previous string + else s[++i] = bs; + } + if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match + if (s[i]) s[i] += bm; // coalesce with previous string + else s[++i] = bm; + } else { // interpolate non-matching numbers + s[++i] = null; + q.push({i: i, x: interpolateNumber(am, bm)}); + } + bi = reB.lastIndex; + } + + // Add remains of b. + if (bi < b.length) { + bs = b.slice(bi); + if (s[i]) s[i] += bs; // coalesce with previous string + else s[++i] = bs; + } + + // Special optimization for only a single match. + // Otherwise, interpolate each of the numbers and rejoin the string. + return s.length < 2 ? (q[0] + ? one(q[0].x) + : zero(b)) + : (b = q.length, function(t) { + for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); + return s.join(""); + }); +} + +function interpolate$2(a, b) { + var t = typeof b, c; + return b == null || t === "boolean" ? constant$8(b) + : (t === "number" ? interpolateNumber + : t === "string" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString) + : b instanceof color ? interpolateRgb + : b instanceof Date ? date$1 + : isNumberArray(b) ? numberArray + : Array.isArray(b) ? genericArray + : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object$1 + : interpolateNumber)(a, b); +} + +function discrete(range) { + var n = range.length; + return function(t) { + return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))]; + }; +} + +function hue(a, b) { + var i = hue$1(+a, +b); + return function(t) { + var x = i(t); + return x - 360 * Math.floor(x / 360); + }; +} + +function interpolateRound(a, b) { + return a = +a, b = +b, function(t) { + return Math.round(a * (1 - t) + b * t); + }; +} + +var degrees$1 = 180 / Math.PI; + +var identity$7 = { + translateX: 0, + translateY: 0, + rotate: 0, + skewX: 0, + scaleX: 1, + scaleY: 1 +}; + +function decompose(a, b, c, d, e, f) { + var scaleX, scaleY, skewX; + if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX; + if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX; + if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY; + if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX; + return { + translateX: e, + translateY: f, + rotate: Math.atan2(b, a) * degrees$1, + skewX: Math.atan(skewX) * degrees$1, + scaleX: scaleX, + scaleY: scaleY + }; +} + +var svgNode; + +/* eslint-disable no-undef */ +function parseCss(value) { + const m = new (typeof DOMMatrix === "function" ? DOMMatrix : WebKitCSSMatrix)(value + ""); + return m.isIdentity ? identity$7 : decompose(m.a, m.b, m.c, m.d, m.e, m.f); +} + +function parseSvg(value) { + if (value == null) return identity$7; + if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g"); + svgNode.setAttribute("transform", value); + if (!(value = svgNode.transform.baseVal.consolidate())) return identity$7; + value = value.matrix; + return decompose(value.a, value.b, value.c, value.d, value.e, value.f); +} + +function interpolateTransform(parse, pxComma, pxParen, degParen) { + + function pop(s) { + return s.length ? s.pop() + " " : ""; + } + + function translate(xa, ya, xb, yb, s, q) { + if (xa !== xb || ya !== yb) { + var i = s.push("translate(", null, pxComma, null, pxParen); + q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)}); + } else if (xb || yb) { + s.push("translate(" + xb + pxComma + yb + pxParen); + } + } + + function rotate(a, b, s, q) { + if (a !== b) { + if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path + q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: interpolateNumber(a, b)}); + } else if (b) { + s.push(pop(s) + "rotate(" + b + degParen); + } + } + + function skewX(a, b, s, q) { + if (a !== b) { + q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: interpolateNumber(a, b)}); + } else if (b) { + s.push(pop(s) + "skewX(" + b + degParen); + } + } + + function scale(xa, ya, xb, yb, s, q) { + if (xa !== xb || ya !== yb) { + var i = s.push(pop(s) + "scale(", null, ",", null, ")"); + q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)}); + } else if (xb !== 1 || yb !== 1) { + s.push(pop(s) + "scale(" + xb + "," + yb + ")"); + } + } + + return function(a, b) { + var s = [], // string constants and placeholders + q = []; // number interpolators + a = parse(a), b = parse(b); + translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q); + rotate(a.rotate, b.rotate, s, q); + skewX(a.skewX, b.skewX, s, q); + scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); + a = b = null; // gc + return function(t) { + var i = -1, n = q.length, o; + while (++i < n) s[(o = q[i]).i] = o.x(t); + return s.join(""); + }; + }; +} + +var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)"); +var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")"); + +var epsilon2$1 = 1e-12; + +function cosh(x) { + return ((x = Math.exp(x)) + 1 / x) / 2; +} + +function sinh(x) { + return ((x = Math.exp(x)) - 1 / x) / 2; +} + +function tanh(x) { + return ((x = Math.exp(2 * x)) - 1) / (x + 1); +} + +var interpolateZoom = (function zoomRho(rho, rho2, rho4) { + + // p0 = [ux0, uy0, w0] + // p1 = [ux1, uy1, w1] + function zoom(p0, p1) { + var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], + ux1 = p1[0], uy1 = p1[1], w1 = p1[2], + dx = ux1 - ux0, + dy = uy1 - uy0, + d2 = dx * dx + dy * dy, + i, + S; + + // Special case for u0 ≅ u1. + if (d2 < epsilon2$1) { + S = Math.log(w1 / w0) / rho; + i = function(t) { + return [ + ux0 + t * dx, + uy0 + t * dy, + w0 * Math.exp(rho * t * S) + ]; + }; + } + + // General case. + else { + var d1 = Math.sqrt(d2), + b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), + b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), + r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), + r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); + S = (r1 - r0) / rho; + i = function(t) { + var s = t * S, + coshr0 = cosh(r0), + u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0)); + return [ + ux0 + u * dx, + uy0 + u * dy, + w0 * coshr0 / cosh(rho * s + r0) + ]; + }; + } + + i.duration = S * 1000 * rho / Math.SQRT2; + + return i; + } + + zoom.rho = function(_) { + var _1 = Math.max(1e-3, +_), _2 = _1 * _1, _4 = _2 * _2; + return zoomRho(_1, _2, _4); + }; + + return zoom; +})(Math.SQRT2, 2, 4); + +function hsl(hue) { + return function(start, end) { + var h = hue((start = hsl$2(start)).h, (end = hsl$2(end)).h), + s = nogamma(start.s, end.s), + l = nogamma(start.l, end.l), + opacity = nogamma(start.opacity, end.opacity); + return function(t) { + start.h = h(t); + start.s = s(t); + start.l = l(t); + start.opacity = opacity(t); + return start + ""; + }; + } +} + +var hsl$1 = hsl(hue$1); +var hslLong = hsl(nogamma); + +function lab(start, end) { + var l = nogamma((start = lab$1(start)).l, (end = lab$1(end)).l), + a = nogamma(start.a, end.a), + b = nogamma(start.b, end.b), + opacity = nogamma(start.opacity, end.opacity); + return function(t) { + start.l = l(t); + start.a = a(t); + start.b = b(t); + start.opacity = opacity(t); + return start + ""; + }; +} + +function hcl(hue) { + return function(start, end) { + var h = hue((start = hcl$2(start)).h, (end = hcl$2(end)).h), + c = nogamma(start.c, end.c), + l = nogamma(start.l, end.l), + opacity = nogamma(start.opacity, end.opacity); + return function(t) { + start.h = h(t); + start.c = c(t); + start.l = l(t); + start.opacity = opacity(t); + return start + ""; + }; + } +} + +var hcl$1 = hcl(hue$1); +var hclLong = hcl(nogamma); + +function cubehelix$1(hue) { + return (function cubehelixGamma(y) { + y = +y; + + function cubehelix(start, end) { + var h = hue((start = cubehelix$3(start)).h, (end = cubehelix$3(end)).h), + s = nogamma(start.s, end.s), + l = nogamma(start.l, end.l), + opacity = nogamma(start.opacity, end.opacity); + return function(t) { + start.h = h(t); + start.s = s(t); + start.l = l(Math.pow(t, y)); + start.opacity = opacity(t); + return start + ""; + }; + } + + cubehelix.gamma = cubehelixGamma; + + return cubehelix; + })(1); +} + +var cubehelix$2 = cubehelix$1(hue$1); +var cubehelixLong = cubehelix$1(nogamma); + +function piecewise(interpolate, values) { + if (values === undefined) values = interpolate, interpolate = interpolate$2; + var i = 0, n = values.length - 1, v = values[0], I = new Array(n < 0 ? 0 : n); + while (i < n) I[i] = interpolate(v, v = values[++i]); + return function(t) { + var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n))); + return I[i](t - i); + }; +} + +function quantize$1(interpolator, n) { + var samples = new Array(n); + for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1)); + return samples; +} + +var frame = 0, // is an animation frame pending? + timeout$1 = 0, // is a timeout pending? + interval$1 = 0, // are any timers active? + pokeDelay = 1000, // how frequently we check for clock skew + taskHead, + taskTail, + clockLast = 0, + clockNow = 0, + clockSkew = 0, + clock = typeof performance === "object" && performance.now ? performance : Date, + setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); }; + +function now() { + return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew); +} + +function clearNow() { + clockNow = 0; +} + +function Timer() { + this._call = + this._time = + this._next = null; +} + +Timer.prototype = timer.prototype = { + constructor: Timer, + restart: function(callback, delay, time) { + if (typeof callback !== "function") throw new TypeError("callback is not a function"); + time = (time == null ? now() : +time) + (delay == null ? 0 : +delay); + if (!this._next && taskTail !== this) { + if (taskTail) taskTail._next = this; + else taskHead = this; + taskTail = this; + } + this._call = callback; + this._time = time; + sleep(); + }, + stop: function() { + if (this._call) { + this._call = null; + this._time = Infinity; + sleep(); + } + } +}; + +function timer(callback, delay, time) { + var t = new Timer; + t.restart(callback, delay, time); + return t; +} + +function timerFlush() { + now(); // Get the current time, if not already set. + ++frame; // Pretend we’ve set an alarm, if we haven’t already. + var t = taskHead, e; + while (t) { + if ((e = clockNow - t._time) >= 0) t._call.call(undefined, e); + t = t._next; + } + --frame; +} + +function wake() { + clockNow = (clockLast = clock.now()) + clockSkew; + frame = timeout$1 = 0; + try { + timerFlush(); + } finally { + frame = 0; + nap(); + clockNow = 0; + } +} + +function poke() { + var now = clock.now(), delay = now - clockLast; + if (delay > pokeDelay) clockSkew -= delay, clockLast = now; +} + +function nap() { + var t0, t1 = taskHead, t2, time = Infinity; + while (t1) { + if (t1._call) { + if (time > t1._time) time = t1._time; + t0 = t1, t1 = t1._next; + } else { + t2 = t1._next, t1._next = null; + t1 = t0 ? t0._next = t2 : taskHead = t2; + } + } + taskTail = t0; + sleep(time); +} + +function sleep(time) { + if (frame) return; // Soonest alarm already set, or will be. + if (timeout$1) timeout$1 = clearTimeout(timeout$1); + var delay = time - clockNow; // Strictly less than if we recomputed clockNow. + if (delay > 24) { + if (time < Infinity) timeout$1 = setTimeout(wake, time - clock.now() - clockSkew); + if (interval$1) interval$1 = clearInterval(interval$1); + } else { + if (!interval$1) clockLast = clock.now(), interval$1 = setInterval(poke, pokeDelay); + frame = 1, setFrame(wake); + } +} + +function timeout(callback, delay, time) { + var t = new Timer; + delay = delay == null ? 0 : +delay; + t.restart(elapsed => { + t.stop(); + callback(elapsed + delay); + }, delay, time); + return t; +} + +function interval(callback, delay, time) { + var t = new Timer, total = delay; + if (delay == null) return t.restart(callback, delay, time), t; + t._restart = t.restart; + t.restart = function(callback, delay, time) { + delay = +delay, time = time == null ? now() : +time; + t._restart(function tick(elapsed) { + elapsed += total; + t._restart(tick, total += delay, time); + callback(elapsed); + }, delay, time); + }; + t.restart(callback, delay, time); + return t; +} + +var emptyOn = dispatch("start", "end", "cancel", "interrupt"); +var emptyTween = []; + +var CREATED = 0; +var SCHEDULED = 1; +var STARTING = 2; +var STARTED = 3; +var RUNNING = 4; +var ENDING = 5; +var ENDED = 6; + +function schedule(node, name, id, index, group, timing) { + var schedules = node.__transition; + if (!schedules) node.__transition = {}; + else if (id in schedules) return; + create(node, id, { + name: name, + index: index, // For context during callback. + group: group, // For context during callback. + on: emptyOn, + tween: emptyTween, + time: timing.time, + delay: timing.delay, + duration: timing.duration, + ease: timing.ease, + timer: null, + state: CREATED + }); +} + +function init(node, id) { + var schedule = get(node, id); + if (schedule.state > CREATED) throw new Error("too late; already scheduled"); + return schedule; +} + +function set(node, id) { + var schedule = get(node, id); + if (schedule.state > STARTED) throw new Error("too late; already running"); + return schedule; +} + +function get(node, id) { + var schedule = node.__transition; + if (!schedule || !(schedule = schedule[id])) throw new Error("transition not found"); + return schedule; +} + +function create(node, id, self) { + var schedules = node.__transition, + tween; + + // Initialize the self timer when the transition is created. + // Note the actual delay is not known until the first callback! + schedules[id] = self; + self.timer = timer(schedule, 0, self.time); + + function schedule(elapsed) { + self.state = SCHEDULED; + self.timer.restart(start, self.delay, self.time); + + // If the elapsed delay is less than our first sleep, start immediately. + if (self.delay <= elapsed) start(elapsed - self.delay); + } + + function start(elapsed) { + var i, j, n, o; + + // If the state is not SCHEDULED, then we previously errored on start. + if (self.state !== SCHEDULED) return stop(); + + for (i in schedules) { + o = schedules[i]; + if (o.name !== self.name) continue; + + // While this element already has a starting transition during this frame, + // defer starting an interrupting transition until that transition has a + // chance to tick (and possibly end); see d3/d3-transition#54! + if (o.state === STARTED) return timeout(start); + + // Interrupt the active transition, if any. + if (o.state === RUNNING) { + o.state = ENDED; + o.timer.stop(); + o.on.call("interrupt", node, node.__data__, o.index, o.group); + delete schedules[i]; + } + + // Cancel any pre-empted transitions. + else if (+i < id) { + o.state = ENDED; + o.timer.stop(); + o.on.call("cancel", node, node.__data__, o.index, o.group); + delete schedules[i]; + } + } + + // Defer the first tick to end of the current frame; see d3/d3#1576. + // Note the transition may be canceled after start and before the first tick! + // Note this must be scheduled before the start event; see d3/d3-transition#16! + // Assuming this is successful, subsequent callbacks go straight to tick. + timeout(function() { + if (self.state === STARTED) { + self.state = RUNNING; + self.timer.restart(tick, self.delay, self.time); + tick(elapsed); + } + }); + + // Dispatch the start event. + // Note this must be done before the tween are initialized. + self.state = STARTING; + self.on.call("start", node, node.__data__, self.index, self.group); + if (self.state !== STARTING) return; // interrupted + self.state = STARTED; + + // Initialize the tween, deleting null tween. + tween = new Array(n = self.tween.length); + for (i = 0, j = -1; i < n; ++i) { + if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) { + tween[++j] = o; + } + } + tween.length = j + 1; + } + + function tick(elapsed) { + var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1), + i = -1, + n = tween.length; + + while (++i < n) { + tween[i].call(node, t); + } + + // Dispatch the end event. + if (self.state === ENDING) { + self.on.call("end", node, node.__data__, self.index, self.group); + stop(); + } + } + + function stop() { + self.state = ENDED; + self.timer.stop(); + delete schedules[id]; + for (var i in schedules) return; // eslint-disable-line no-unused-vars + delete node.__transition; + } +} + +function interrupt(node, name) { + var schedules = node.__transition, + schedule, + active, + empty = true, + i; + + if (!schedules) return; + + name = name == null ? null : name + ""; + + for (i in schedules) { + if ((schedule = schedules[i]).name !== name) { empty = false; continue; } + active = schedule.state > STARTING && schedule.state < ENDING; + schedule.state = ENDED; + schedule.timer.stop(); + schedule.on.call(active ? "interrupt" : "cancel", node, node.__data__, schedule.index, schedule.group); + delete schedules[i]; + } + + if (empty) delete node.__transition; +} + +function selection_interrupt(name) { + return this.each(function() { + interrupt(this, name); + }); +} + +function tweenRemove(id, name) { + var tween0, tween1; + return function() { + var schedule = set(this, id), + tween = schedule.tween; + + // If this node shared tween with the previous node, + // just assign the updated shared tween and we’re done! + // Otherwise, copy-on-write. + if (tween !== tween0) { + tween1 = tween0 = tween; + for (var i = 0, n = tween1.length; i < n; ++i) { + if (tween1[i].name === name) { + tween1 = tween1.slice(); + tween1.splice(i, 1); + break; + } + } + } + + schedule.tween = tween1; + }; +} + +function tweenFunction(id, name, value) { + var tween0, tween1; + if (typeof value !== "function") throw new Error; + return function() { + var schedule = set(this, id), + tween = schedule.tween; + + // If this node shared tween with the previous node, + // just assign the updated shared tween and we’re done! + // Otherwise, copy-on-write. + if (tween !== tween0) { + tween1 = (tween0 = tween).slice(); + for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) { + if (tween1[i].name === name) { + tween1[i] = t; + break; + } + } + if (i === n) tween1.push(t); + } + + schedule.tween = tween1; + }; +} + +function transition_tween(name, value) { + var id = this._id; + + name += ""; + + if (arguments.length < 2) { + var tween = get(this.node(), id).tween; + for (var i = 0, n = tween.length, t; i < n; ++i) { + if ((t = tween[i]).name === name) { + return t.value; + } + } + return null; + } + + return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value)); +} + +function tweenValue(transition, name, value) { + var id = transition._id; + + transition.each(function() { + var schedule = set(this, id); + (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments); + }); + + return function(node) { + return get(node, id).value[name]; + }; +} + +function interpolate$1(a, b) { + var c; + return (typeof b === "number" ? interpolateNumber + : b instanceof color ? interpolateRgb + : (c = color(b)) ? (b = c, interpolateRgb) + : interpolateString)(a, b); +} + +function attrRemove(name) { + return function() { + this.removeAttribute(name); + }; +} + +function attrRemoveNS(fullname) { + return function() { + this.removeAttributeNS(fullname.space, fullname.local); + }; +} + +function attrConstant(name, interpolate, value1) { + var string00, + string1 = value1 + "", + interpolate0; + return function() { + var string0 = this.getAttribute(name); + return string0 === string1 ? null + : string0 === string00 ? interpolate0 + : interpolate0 = interpolate(string00 = string0, value1); + }; +} + +function attrConstantNS(fullname, interpolate, value1) { + var string00, + string1 = value1 + "", + interpolate0; + return function() { + var string0 = this.getAttributeNS(fullname.space, fullname.local); + return string0 === string1 ? null + : string0 === string00 ? interpolate0 + : interpolate0 = interpolate(string00 = string0, value1); + }; +} + +function attrFunction(name, interpolate, value) { + var string00, + string10, + interpolate0; + return function() { + var string0, value1 = value(this), string1; + if (value1 == null) return void this.removeAttribute(name); + string0 = this.getAttribute(name); + string1 = value1 + ""; + return string0 === string1 ? null + : string0 === string00 && string1 === string10 ? interpolate0 + : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1)); + }; +} + +function attrFunctionNS(fullname, interpolate, value) { + var string00, + string10, + interpolate0; + return function() { + var string0, value1 = value(this), string1; + if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local); + string0 = this.getAttributeNS(fullname.space, fullname.local); + string1 = value1 + ""; + return string0 === string1 ? null + : string0 === string00 && string1 === string10 ? interpolate0 + : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1)); + }; +} + +function transition_attr(name, value) { + var fullname = namespace(name), i = fullname === "transform" ? interpolateTransformSvg : interpolate$1; + return this.attrTween(name, typeof value === "function" + ? (fullname.local ? attrFunctionNS : attrFunction)(fullname, i, tweenValue(this, "attr." + name, value)) + : value == null ? (fullname.local ? attrRemoveNS : attrRemove)(fullname) + : (fullname.local ? attrConstantNS : attrConstant)(fullname, i, value)); +} + +function attrInterpolate(name, i) { + return function(t) { + this.setAttribute(name, i.call(this, t)); + }; +} + +function attrInterpolateNS(fullname, i) { + return function(t) { + this.setAttributeNS(fullname.space, fullname.local, i.call(this, t)); + }; +} + +function attrTweenNS(fullname, value) { + var t0, i0; + function tween() { + var i = value.apply(this, arguments); + if (i !== i0) t0 = (i0 = i) && attrInterpolateNS(fullname, i); + return t0; + } + tween._value = value; + return tween; +} + +function attrTween(name, value) { + var t0, i0; + function tween() { + var i = value.apply(this, arguments); + if (i !== i0) t0 = (i0 = i) && attrInterpolate(name, i); + return t0; + } + tween._value = value; + return tween; +} + +function transition_attrTween(name, value) { + var key = "attr." + name; + if (arguments.length < 2) return (key = this.tween(key)) && key._value; + if (value == null) return this.tween(key, null); + if (typeof value !== "function") throw new Error; + var fullname = namespace(name); + return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value)); +} + +function delayFunction(id, value) { + return function() { + init(this, id).delay = +value.apply(this, arguments); + }; +} + +function delayConstant(id, value) { + return value = +value, function() { + init(this, id).delay = value; + }; +} + +function transition_delay(value) { + var id = this._id; + + return arguments.length + ? this.each((typeof value === "function" + ? delayFunction + : delayConstant)(id, value)) + : get(this.node(), id).delay; +} + +function durationFunction(id, value) { + return function() { + set(this, id).duration = +value.apply(this, arguments); + }; +} + +function durationConstant(id, value) { + return value = +value, function() { + set(this, id).duration = value; + }; +} + +function transition_duration(value) { + var id = this._id; + + return arguments.length + ? this.each((typeof value === "function" + ? durationFunction + : durationConstant)(id, value)) + : get(this.node(), id).duration; +} + +function easeConstant(id, value) { + if (typeof value !== "function") throw new Error; + return function() { + set(this, id).ease = value; + }; +} + +function transition_ease(value) { + var id = this._id; + + return arguments.length + ? this.each(easeConstant(id, value)) + : get(this.node(), id).ease; +} + +function easeVarying(id, value) { + return function() { + var v = value.apply(this, arguments); + if (typeof v !== "function") throw new Error; + set(this, id).ease = v; + }; +} + +function transition_easeVarying(value) { + if (typeof value !== "function") throw new Error; + return this.each(easeVarying(this._id, value)); +} + +function transition_filter(match) { + if (typeof match !== "function") match = matcher(match); + + for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { + if ((node = group[i]) && match.call(node, node.__data__, i, group)) { + subgroup.push(node); + } + } + } + + return new Transition(subgroups, this._parents, this._name, this._id); +} + +function transition_merge(transition) { + if (transition._id !== this._id) throw new Error; + + for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { + for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { + if (node = group0[i] || group1[i]) { + merge[i] = node; + } + } + } + + for (; j < m0; ++j) { + merges[j] = groups0[j]; + } + + return new Transition(merges, this._parents, this._name, this._id); +} + +function start(name) { + return (name + "").trim().split(/^|\s+/).every(function(t) { + var i = t.indexOf("."); + if (i >= 0) t = t.slice(0, i); + return !t || t === "start"; + }); +} + +function onFunction(id, name, listener) { + var on0, on1, sit = start(name) ? init : set; + return function() { + var schedule = sit(this, id), + on = schedule.on; + + // If this node shared a dispatch with the previous node, + // just assign the updated shared dispatch and we’re done! + // Otherwise, copy-on-write. + if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener); + + schedule.on = on1; + }; +} + +function transition_on(name, listener) { + var id = this._id; + + return arguments.length < 2 + ? get(this.node(), id).on.on(name) + : this.each(onFunction(id, name, listener)); +} + +function removeFunction(id) { + return function() { + var parent = this.parentNode; + for (var i in this.__transition) if (+i !== id) return; + if (parent) parent.removeChild(this); + }; +} + +function transition_remove() { + return this.on("end.remove", removeFunction(this._id)); +} + +function transition_select(select) { + var name = this._name, + id = this._id; + + if (typeof select !== "function") select = selector(select); + + for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { + if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { + if ("__data__" in node) subnode.__data__ = node.__data__; + subgroup[i] = subnode; + schedule(subgroup[i], name, id, i, subgroup, get(node, id)); + } + } + } + + return new Transition(subgroups, this._parents, name, id); +} + +function transition_selectAll(select) { + var name = this._name, + id = this._id; + + if (typeof select !== "function") select = selectorAll(select); + + for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { + if (node = group[i]) { + for (var children = select.call(node, node.__data__, i, group), child, inherit = get(node, id), k = 0, l = children.length; k < l; ++k) { + if (child = children[k]) { + schedule(child, name, id, k, children, inherit); + } + } + subgroups.push(children); + parents.push(node); + } + } + } + + return new Transition(subgroups, parents, name, id); +} + +var Selection = selection.prototype.constructor; + +function transition_selection() { + return new Selection(this._groups, this._parents); +} + +function styleNull(name, interpolate) { + var string00, + string10, + interpolate0; + return function() { + var string0 = styleValue(this, name), + string1 = (this.style.removeProperty(name), styleValue(this, name)); + return string0 === string1 ? null + : string0 === string00 && string1 === string10 ? interpolate0 + : interpolate0 = interpolate(string00 = string0, string10 = string1); + }; +} + +function styleRemove(name) { + return function() { + this.style.removeProperty(name); + }; +} + +function styleConstant(name, interpolate, value1) { + var string00, + string1 = value1 + "", + interpolate0; + return function() { + var string0 = styleValue(this, name); + return string0 === string1 ? null + : string0 === string00 ? interpolate0 + : interpolate0 = interpolate(string00 = string0, value1); + }; +} + +function styleFunction(name, interpolate, value) { + var string00, + string10, + interpolate0; + return function() { + var string0 = styleValue(this, name), + value1 = value(this), + string1 = value1 + ""; + if (value1 == null) string1 = value1 = (this.style.removeProperty(name), styleValue(this, name)); + return string0 === string1 ? null + : string0 === string00 && string1 === string10 ? interpolate0 + : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1)); + }; +} + +function styleMaybeRemove(id, name) { + var on0, on1, listener0, key = "style." + name, event = "end." + key, remove; + return function() { + var schedule = set(this, id), + on = schedule.on, + listener = schedule.value[key] == null ? remove || (remove = styleRemove(name)) : undefined; + + // If this node shared a dispatch with the previous node, + // just assign the updated shared dispatch and we’re done! + // Otherwise, copy-on-write. + if (on !== on0 || listener0 !== listener) (on1 = (on0 = on).copy()).on(event, listener0 = listener); + + schedule.on = on1; + }; +} + +function transition_style(name, value, priority) { + var i = (name += "") === "transform" ? interpolateTransformCss : interpolate$1; + return value == null ? this + .styleTween(name, styleNull(name, i)) + .on("end.style." + name, styleRemove(name)) + : typeof value === "function" ? this + .styleTween(name, styleFunction(name, i, tweenValue(this, "style." + name, value))) + .each(styleMaybeRemove(this._id, name)) + : this + .styleTween(name, styleConstant(name, i, value), priority) + .on("end.style." + name, null); +} + +function styleInterpolate(name, i, priority) { + return function(t) { + this.style.setProperty(name, i.call(this, t), priority); + }; +} + +function styleTween(name, value, priority) { + var t, i0; + function tween() { + var i = value.apply(this, arguments); + if (i !== i0) t = (i0 = i) && styleInterpolate(name, i, priority); + return t; + } + tween._value = value; + return tween; +} + +function transition_styleTween(name, value, priority) { + var key = "style." + (name += ""); + if (arguments.length < 2) return (key = this.tween(key)) && key._value; + if (value == null) return this.tween(key, null); + if (typeof value !== "function") throw new Error; + return this.tween(key, styleTween(name, value, priority == null ? "" : priority)); +} + +function textConstant(value) { + return function() { + this.textContent = value; + }; +} + +function textFunction(value) { + return function() { + var value1 = value(this); + this.textContent = value1 == null ? "" : value1; + }; +} + +function transition_text(value) { + return this.tween("text", typeof value === "function" + ? textFunction(tweenValue(this, "text", value)) + : textConstant(value == null ? "" : value + "")); +} + +function textInterpolate(i) { + return function(t) { + this.textContent = i.call(this, t); + }; +} + +function textTween(value) { + var t0, i0; + function tween() { + var i = value.apply(this, arguments); + if (i !== i0) t0 = (i0 = i) && textInterpolate(i); + return t0; + } + tween._value = value; + return tween; +} + +function transition_textTween(value) { + var key = "text"; + if (arguments.length < 1) return (key = this.tween(key)) && key._value; + if (value == null) return this.tween(key, null); + if (typeof value !== "function") throw new Error; + return this.tween(key, textTween(value)); +} + +function transition_transition() { + var name = this._name, + id0 = this._id, + id1 = newId(); + + for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { + if (node = group[i]) { + var inherit = get(node, id0); + schedule(node, name, id1, i, group, { + time: inherit.time + inherit.delay + inherit.duration, + delay: 0, + duration: inherit.duration, + ease: inherit.ease + }); + } + } + } + + return new Transition(groups, this._parents, name, id1); +} + +function transition_end() { + var on0, on1, that = this, id = that._id, size = that.size(); + return new Promise(function(resolve, reject) { + var cancel = {value: reject}, + end = {value: function() { if (--size === 0) resolve(); }}; + + that.each(function() { + var schedule = set(this, id), + on = schedule.on; + + // If this node shared a dispatch with the previous node, + // just assign the updated shared dispatch and we’re done! + // Otherwise, copy-on-write. + if (on !== on0) { + on1 = (on0 = on).copy(); + on1._.cancel.push(cancel); + on1._.interrupt.push(cancel); + on1._.end.push(end); + } + + schedule.on = on1; + }); + + // The selection was empty, resolve end immediately + if (size === 0) resolve(); + }); +} + +var id = 0; + +function Transition(groups, parents, name, id) { + this._groups = groups; + this._parents = parents; + this._name = name; + this._id = id; +} + +function transition(name) { + return selection().transition(name); +} + +function newId() { + return ++id; +} + +var selection_prototype = selection.prototype; + +Transition.prototype = transition.prototype = { + constructor: Transition, + select: transition_select, + selectAll: transition_selectAll, + selectChild: selection_prototype.selectChild, + selectChildren: selection_prototype.selectChildren, + filter: transition_filter, + merge: transition_merge, + selection: transition_selection, + transition: transition_transition, + call: selection_prototype.call, + nodes: selection_prototype.nodes, + node: selection_prototype.node, + size: selection_prototype.size, + empty: selection_prototype.empty, + each: selection_prototype.each, + on: transition_on, + attr: transition_attr, + attrTween: transition_attrTween, + style: transition_style, + styleTween: transition_styleTween, + text: transition_text, + textTween: transition_textTween, + remove: transition_remove, + tween: transition_tween, + delay: transition_delay, + duration: transition_duration, + ease: transition_ease, + easeVarying: transition_easeVarying, + end: transition_end, + [Symbol.iterator]: selection_prototype[Symbol.iterator] +}; + +const linear$1 = t => +t; + +function quadIn(t) { + return t * t; +} + +function quadOut(t) { + return t * (2 - t); +} + +function quadInOut(t) { + return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; +} + +function cubicIn(t) { + return t * t * t; +} + +function cubicOut(t) { + return --t * t * t + 1; +} + +function cubicInOut(t) { + return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; +} + +var exponent$1 = 3; + +var polyIn = (function custom(e) { + e = +e; + + function polyIn(t) { + return Math.pow(t, e); + } + + polyIn.exponent = custom; + + return polyIn; +})(exponent$1); + +var polyOut = (function custom(e) { + e = +e; + + function polyOut(t) { + return 1 - Math.pow(1 - t, e); + } + + polyOut.exponent = custom; + + return polyOut; +})(exponent$1); + +var polyInOut = (function custom(e) { + e = +e; + + function polyInOut(t) { + return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; + } + + polyInOut.exponent = custom; + + return polyInOut; +})(exponent$1); + +var pi$4 = Math.PI, + halfPi$3 = pi$4 / 2; + +function sinIn(t) { + return (+t === 1) ? 1 : 1 - Math.cos(t * halfPi$3); +} + +function sinOut(t) { + return Math.sin(t * halfPi$3); +} + +function sinInOut(t) { + return (1 - Math.cos(pi$4 * t)) / 2; +} + +// tpmt is two power minus ten times t scaled to [0,1] +function tpmt(x) { + return (Math.pow(2, -10 * x) - 0.0009765625) * 1.0009775171065494; +} + +function expIn(t) { + return tpmt(1 - +t); +} + +function expOut(t) { + return 1 - tpmt(t); +} + +function expInOut(t) { + return ((t *= 2) <= 1 ? tpmt(1 - t) : 2 - tpmt(t - 1)) / 2; +} + +function circleIn(t) { + return 1 - Math.sqrt(1 - t * t); +} + +function circleOut(t) { + return Math.sqrt(1 - --t * t); +} + +function circleInOut(t) { + return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2; +} + +var b1 = 4 / 11, + b2 = 6 / 11, + b3 = 8 / 11, + b4 = 3 / 4, + b5 = 9 / 11, + b6 = 10 / 11, + b7 = 15 / 16, + b8 = 21 / 22, + b9 = 63 / 64, + b0 = 1 / b1 / b1; + +function bounceIn(t) { + return 1 - bounceOut(1 - t); +} + +function bounceOut(t) { + return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9; +} + +function bounceInOut(t) { + return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2; +} + +var overshoot = 1.70158; + +var backIn = (function custom(s) { + s = +s; + + function backIn(t) { + return (t = +t) * t * (s * (t - 1) + t); + } + + backIn.overshoot = custom; + + return backIn; +})(overshoot); + +var backOut = (function custom(s) { + s = +s; + + function backOut(t) { + return --t * t * ((t + 1) * s + t) + 1; + } + + backOut.overshoot = custom; + + return backOut; +})(overshoot); + +var backInOut = (function custom(s) { + s = +s; + + function backInOut(t) { + return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; + } + + backInOut.overshoot = custom; + + return backInOut; +})(overshoot); + +var tau$5 = 2 * Math.PI, + amplitude = 1, + period = 0.3; + +var elasticIn = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau$5); + + function elasticIn(t) { + return a * tpmt(-(--t)) * Math.sin((s - t) / p); + } + + elasticIn.amplitude = function(a) { return custom(a, p * tau$5); }; + elasticIn.period = function(p) { return custom(a, p); }; + + return elasticIn; +})(amplitude, period); + +var elasticOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau$5); + + function elasticOut(t) { + return 1 - a * tpmt(t = +t) * Math.sin((t + s) / p); + } + + elasticOut.amplitude = function(a) { return custom(a, p * tau$5); }; + elasticOut.period = function(p) { return custom(a, p); }; + + return elasticOut; +})(amplitude, period); + +var elasticInOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau$5); + + function elasticInOut(t) { + return ((t = t * 2 - 1) < 0 + ? a * tpmt(-t) * Math.sin((s - t) / p) + : 2 - a * tpmt(t) * Math.sin((s + t) / p)) / 2; + } + + elasticInOut.amplitude = function(a) { return custom(a, p * tau$5); }; + elasticInOut.period = function(p) { return custom(a, p); }; + + return elasticInOut; +})(amplitude, period); + +var defaultTiming = { + time: null, // Set on use. + delay: 0, + duration: 250, + ease: cubicInOut +}; + +function inherit(node, id) { + var timing; + while (!(timing = node.__transition) || !(timing = timing[id])) { + if (!(node = node.parentNode)) { + throw new Error(`transition ${id} not found`); + } + } + return timing; +} + +function selection_transition(name) { + var id, + timing; + + if (name instanceof Transition) { + id = name._id, name = name._name; + } else { + id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + ""; + } + + for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { + for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { + if (node = group[i]) { + schedule(node, name, id, i, group, timing || inherit(node, id)); + } + } + } + + return new Transition(groups, this._parents, name, id); +} + +selection.prototype.interrupt = selection_interrupt; +selection.prototype.transition = selection_transition; + +var root = [null]; + +function active(node, name) { + var schedules = node.__transition, + schedule, + i; + + if (schedules) { + name = name == null ? null : name + ""; + for (i in schedules) { + if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) { + return new Transition([[node]], root, name, +i); + } + } + } + + return null; +} + +var constant$7 = x => () => x; + +function BrushEvent(type, { + sourceEvent, + target, + selection, + mode, + dispatch +}) { + Object.defineProperties(this, { + type: {value: type, enumerable: true, configurable: true}, + sourceEvent: {value: sourceEvent, enumerable: true, configurable: true}, + target: {value: target, enumerable: true, configurable: true}, + selection: {value: selection, enumerable: true, configurable: true}, + mode: {value: mode, enumerable: true, configurable: true}, + _: {value: dispatch} + }); +} + +function nopropagation$1(event) { + event.stopImmediatePropagation(); +} + +function noevent$1(event) { + event.preventDefault(); + event.stopImmediatePropagation(); +} + +var MODE_DRAG = {name: "drag"}, + MODE_SPACE = {name: "space"}, + MODE_HANDLE = {name: "handle"}, + MODE_CENTER = {name: "center"}; + +const {abs: abs$3, max: max$2, min: min$1} = Math; + +function number1(e) { + return [+e[0], +e[1]]; +} + +function number2(e) { + return [number1(e[0]), number1(e[1])]; +} + +var X = { + name: "x", + handles: ["w", "e"].map(type), + input: function(x, e) { return x == null ? null : [[+x[0], e[0][1]], [+x[1], e[1][1]]]; }, + output: function(xy) { return xy && [xy[0][0], xy[1][0]]; } +}; + +var Y = { + name: "y", + handles: ["n", "s"].map(type), + input: function(y, e) { return y == null ? null : [[e[0][0], +y[0]], [e[1][0], +y[1]]]; }, + output: function(xy) { return xy && [xy[0][1], xy[1][1]]; } +}; + +var XY = { + name: "xy", + handles: ["n", "w", "e", "s", "nw", "ne", "sw", "se"].map(type), + input: function(xy) { return xy == null ? null : number2(xy); }, + output: function(xy) { return xy; } +}; + +var cursors = { + 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" +}; + +var flipX = { + e: "w", + w: "e", + nw: "ne", + ne: "nw", + se: "sw", + sw: "se" +}; + +var flipY = { + n: "s", + s: "n", + nw: "sw", + ne: "se", + se: "ne", + sw: "nw" +}; + +var signsX = { + overlay: +1, + selection: +1, + n: null, + e: +1, + s: null, + w: -1, + nw: -1, + ne: +1, + se: +1, + sw: -1 +}; + +var signsY = { + overlay: +1, + selection: +1, + n: -1, + e: null, + s: +1, + w: null, + nw: -1, + ne: -1, + se: +1, + sw: +1 +}; + +function type(t) { + return {type: t}; +} + +// Ignore right-click, since that should open the context menu. +function defaultFilter$1(event) { + return !event.ctrlKey && !event.button; +} + +function defaultExtent$1() { + var svg = this.ownerSVGElement || this; + if (svg.hasAttribute("viewBox")) { + svg = svg.viewBox.baseVal; + return [[svg.x, svg.y], [svg.x + svg.width, svg.y + svg.height]]; + } + return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]]; +} + +function defaultTouchable$1() { + return navigator.maxTouchPoints || ("ontouchstart" in this); +} + +// Like d3.local, but with the name “__brush” rather than auto-generated. +function local(node) { + while (!node.__brush) if (!(node = node.parentNode)) return; + return node.__brush; +} + +function empty(extent) { + return extent[0][0] === extent[1][0] + || extent[0][1] === extent[1][1]; +} + +function brushSelection(node) { + var state = node.__brush; + return state ? state.dim.output(state.selection) : null; +} + +function brushX() { + return brush$1(X); +} + +function brushY() { + return brush$1(Y); +} + +function brush() { + return brush$1(XY); +} + +function brush$1(dim) { + var extent = defaultExtent$1, + filter = defaultFilter$1, + touchable = defaultTouchable$1, + keys = true, + listeners = dispatch("start", "brush", "end"), + handleSize = 6, + touchending; + + function brush(group) { + var overlay = group + .property("__brush", initialize) + .selectAll(".overlay") + .data([type("overlay")]); + + overlay.enter().append("rect") + .attr("class", "overlay") + .attr("pointer-events", "all") + .attr("cursor", cursors.overlay) + .merge(overlay) + .each(function() { + var extent = local(this).extent; + select(this) + .attr("x", extent[0][0]) + .attr("y", extent[0][1]) + .attr("width", extent[1][0] - extent[0][0]) + .attr("height", extent[1][1] - extent[0][1]); + }); + + group.selectAll(".selection") + .data([type("selection")]) + .enter().append("rect") + .attr("class", "selection") + .attr("cursor", cursors.selection) + .attr("fill", "#777") + .attr("fill-opacity", 0.3) + .attr("stroke", "#fff") + .attr("shape-rendering", "crispEdges"); + + var handle = group.selectAll(".handle") + .data(dim.handles, function(d) { return d.type; }); + + handle.exit().remove(); + + handle.enter().append("rect") + .attr("class", function(d) { return "handle handle--" + d.type; }) + .attr("cursor", function(d) { return cursors[d.type]; }); + + group + .each(redraw) + .attr("fill", "none") + .attr("pointer-events", "all") + .on("mousedown.brush", started) + .filter(touchable) + .on("touchstart.brush", started) + .on("touchmove.brush", touchmoved) + .on("touchend.brush touchcancel.brush", touchended) + .style("touch-action", "none") + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); + } + + brush.move = function(group, selection, event) { + if (group.tween) { + group + .on("start.brush", function(event) { emitter(this, arguments).beforestart().start(event); }) + .on("interrupt.brush end.brush", function(event) { emitter(this, arguments).end(event); }) + .tween("brush", function() { + var that = this, + state = that.__brush, + emit = emitter(that, arguments), + selection0 = state.selection, + selection1 = dim.input(typeof selection === "function" ? selection.apply(this, arguments) : selection, state.extent), + i = interpolate$2(selection0, selection1); + + function tween(t) { + state.selection = t === 1 && selection1 === null ? null : i(t); + redraw.call(that); + emit.brush(); + } + + return selection0 !== null && selection1 !== null ? tween : tween(1); + }); + } else { + group + .each(function() { + var that = this, + args = arguments, + state = that.__brush, + selection1 = dim.input(typeof selection === "function" ? selection.apply(that, args) : selection, state.extent), + emit = emitter(that, args).beforestart(); + + interrupt(that); + state.selection = selection1 === null ? null : selection1; + redraw.call(that); + emit.start(event).brush(event).end(event); + }); + } + }; + + brush.clear = function(group, event) { + brush.move(group, null, event); + }; + + function redraw() { + var group = select(this), + selection = local(this).selection; + + if (selection) { + group.selectAll(".selection") + .style("display", null) + .attr("x", selection[0][0]) + .attr("y", selection[0][1]) + .attr("width", selection[1][0] - selection[0][0]) + .attr("height", selection[1][1] - selection[0][1]); + + group.selectAll(".handle") + .style("display", null) + .attr("x", function(d) { return d.type[d.type.length - 1] === "e" ? selection[1][0] - handleSize / 2 : selection[0][0] - handleSize / 2; }) + .attr("y", function(d) { return d.type[0] === "s" ? selection[1][1] - handleSize / 2 : selection[0][1] - handleSize / 2; }) + .attr("width", function(d) { return d.type === "n" || d.type === "s" ? selection[1][0] - selection[0][0] + handleSize : handleSize; }) + .attr("height", function(d) { return d.type === "e" || d.type === "w" ? selection[1][1] - selection[0][1] + handleSize : handleSize; }); + } + + else { + group.selectAll(".selection,.handle") + .style("display", "none") + .attr("x", null) + .attr("y", null) + .attr("width", null) + .attr("height", null); + } + } + + function emitter(that, args, clean) { + var emit = that.__brush.emitter; + return emit && (!clean || !emit.clean) ? emit : new Emitter(that, args, clean); + } + + function Emitter(that, args, clean) { + this.that = that; + this.args = args; + this.state = that.__brush; + this.active = 0; + this.clean = clean; + } + + Emitter.prototype = { + beforestart: function() { + if (++this.active === 1) this.state.emitter = this, this.starting = true; + return this; + }, + start: function(event, mode) { + if (this.starting) this.starting = false, this.emit("start", event, mode); + else this.emit("brush", event); + return this; + }, + brush: function(event, mode) { + this.emit("brush", event, mode); + return this; + }, + end: function(event, mode) { + if (--this.active === 0) delete this.state.emitter, this.emit("end", event, mode); + return this; + }, + emit: function(type, event, mode) { + var d = select(this.that).datum(); + listeners.call( + type, + this.that, + new BrushEvent(type, { + sourceEvent: event, + target: brush, + selection: dim.output(this.state.selection), + mode, + dispatch: listeners + }), + d + ); + } + }; + + function started(event) { + if (touchending && !event.touches) return; + if (!filter.apply(this, arguments)) return; + + var that = this, + type = event.target.__data__.type, + mode = (keys && event.metaKey ? type = "overlay" : type) === "selection" ? MODE_DRAG : (keys && event.altKey ? MODE_CENTER : MODE_HANDLE), + signX = dim === Y ? null : signsX[type], + signY = dim === X ? null : signsY[type], + state = local(that), + extent = state.extent, + selection = state.selection, + W = extent[0][0], w0, w1, + N = extent[0][1], n0, n1, + E = extent[1][0], e0, e1, + S = extent[1][1], s0, s1, + dx = 0, + dy = 0, + moving, + shifting = signX && signY && keys && event.shiftKey, + lockX, + lockY, + points = Array.from(event.touches || [event], t => { + const i = t.identifier; + t = pointer(t, that); + t.point0 = t.slice(); + t.identifier = i; + return t; + }); + + interrupt(that); + var emit = emitter(that, arguments, true).beforestart(); + + if (type === "overlay") { + if (selection) moving = true; + const pts = [points[0], points[1] || points[0]]; + state.selection = selection = [[ + w0 = dim === Y ? W : min$1(pts[0][0], pts[1][0]), + n0 = dim === X ? N : min$1(pts[0][1], pts[1][1]) + ], [ + e0 = dim === Y ? E : max$2(pts[0][0], pts[1][0]), + s0 = dim === X ? S : max$2(pts[0][1], pts[1][1]) + ]]; + if (points.length > 1) move(event); + } else { + w0 = selection[0][0]; + n0 = selection[0][1]; + e0 = selection[1][0]; + s0 = selection[1][1]; + } + + w1 = w0; + n1 = n0; + e1 = e0; + s1 = s0; + + var group = select(that) + .attr("pointer-events", "none"); + + var overlay = group.selectAll(".overlay") + .attr("cursor", cursors[type]); + + if (event.touches) { + emit.moved = moved; + emit.ended = ended; + } else { + var view = select(event.view) + .on("mousemove.brush", moved, true) + .on("mouseup.brush", ended, true); + if (keys) view + .on("keydown.brush", keydowned, true) + .on("keyup.brush", keyupped, true); + + dragDisable(event.view); + } + + redraw.call(that); + emit.start(event, mode.name); + + function moved(event) { + for (const p of event.changedTouches || [event]) { + for (const d of points) + if (d.identifier === p.identifier) d.cur = pointer(p, that); + } + if (shifting && !lockX && !lockY && points.length === 1) { + const point = points[0]; + if (abs$3(point.cur[0] - point[0]) > abs$3(point.cur[1] - point[1])) + lockY = true; + else + lockX = true; + } + for (const point of points) + if (point.cur) point[0] = point.cur[0], point[1] = point.cur[1]; + moving = true; + noevent$1(event); + move(event); + } + + function move(event) { + const point = points[0], point0 = point.point0; + var t; + + dx = point[0] - point0[0]; + dy = point[1] - point0[1]; + + switch (mode) { + case MODE_SPACE: + case MODE_DRAG: { + if (signX) dx = max$2(W - w0, min$1(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx; + if (signY) dy = max$2(N - n0, min$1(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy; + break; + } + case MODE_HANDLE: { + if (points[1]) { + if (signX) w1 = max$2(W, min$1(E, points[0][0])), e1 = max$2(W, min$1(E, points[1][0])), signX = 1; + if (signY) n1 = max$2(N, min$1(S, points[0][1])), s1 = max$2(N, min$1(S, points[1][1])), signY = 1; + } else { + if (signX < 0) dx = max$2(W - w0, min$1(E - w0, dx)), w1 = w0 + dx, e1 = e0; + else if (signX > 0) dx = max$2(W - e0, min$1(E - e0, dx)), w1 = w0, e1 = e0 + dx; + if (signY < 0) dy = max$2(N - n0, min$1(S - n0, dy)), n1 = n0 + dy, s1 = s0; + else if (signY > 0) dy = max$2(N - s0, min$1(S - s0, dy)), n1 = n0, s1 = s0 + dy; + } + break; + } + case MODE_CENTER: { + if (signX) w1 = max$2(W, min$1(E, w0 - dx * signX)), e1 = max$2(W, min$1(E, e0 + dx * signX)); + if (signY) n1 = max$2(N, min$1(S, n0 - dy * signY)), s1 = max$2(N, min$1(S, s0 + dy * signY)); + break; + } + } + + if (e1 < w1) { + signX *= -1; + t = w0, w0 = e0, e0 = t; + t = w1, w1 = e1, e1 = t; + if (type in flipX) overlay.attr("cursor", cursors[type = flipX[type]]); + } + + if (s1 < n1) { + signY *= -1; + t = n0, n0 = s0, s0 = t; + t = n1, n1 = s1, s1 = t; + if (type in flipY) overlay.attr("cursor", cursors[type = flipY[type]]); + } + + if (state.selection) selection = state.selection; // May be set by brush.move! + if (lockX) w1 = selection[0][0], e1 = selection[1][0]; + if (lockY) n1 = selection[0][1], s1 = selection[1][1]; + + if (selection[0][0] !== w1 + || selection[0][1] !== n1 + || selection[1][0] !== e1 + || selection[1][1] !== s1) { + state.selection = [[w1, n1], [e1, s1]]; + redraw.call(that); + emit.brush(event, mode.name); + } + } + + function ended(event) { + nopropagation$1(event); + if (event.touches) { + if (event.touches.length) return; + if (touchending) clearTimeout(touchending); + touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! + } else { + yesdrag(event.view, moving); + view.on("keydown.brush keyup.brush mousemove.brush mouseup.brush", null); + } + group.attr("pointer-events", "all"); + overlay.attr("cursor", cursors.overlay); + if (state.selection) selection = state.selection; // May be set by brush.move (on start)! + if (empty(selection)) state.selection = null, redraw.call(that); + emit.end(event, mode.name); + } + + function keydowned(event) { + switch (event.keyCode) { + case 16: { // SHIFT + shifting = signX && signY; + break; + } + case 18: { // ALT + if (mode === MODE_HANDLE) { + if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX; + if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY; + mode = MODE_CENTER; + move(event); + } + break; + } + case 32: { // SPACE; takes priority over ALT + if (mode === MODE_HANDLE || mode === MODE_CENTER) { + if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx; + if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy; + mode = MODE_SPACE; + overlay.attr("cursor", cursors.selection); + move(event); + } + break; + } + default: return; + } + noevent$1(event); + } + + function keyupped(event) { + switch (event.keyCode) { + case 16: { // SHIFT + if (shifting) { + lockX = lockY = shifting = false; + move(event); + } + break; + } + case 18: { // ALT + if (mode === MODE_CENTER) { + if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1; + if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1; + mode = MODE_HANDLE; + move(event); + } + break; + } + case 32: { // SPACE + if (mode === MODE_SPACE) { + if (event.altKey) { + if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX; + if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY; + mode = MODE_CENTER; + } else { + if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1; + if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1; + mode = MODE_HANDLE; + } + overlay.attr("cursor", cursors[type]); + move(event); + } + break; + } + default: return; + } + noevent$1(event); + } + } + + function touchmoved(event) { + emitter(this, arguments).moved(event); + } + + function touchended(event) { + emitter(this, arguments).ended(event); + } + + function initialize() { + var state = this.__brush || {selection: null}; + state.extent = number2(extent.apply(this, arguments)); + state.dim = dim; + return state; + } + + brush.extent = function(_) { + return arguments.length ? (extent = typeof _ === "function" ? _ : constant$7(number2(_)), brush) : extent; + }; + + brush.filter = function(_) { + return arguments.length ? (filter = typeof _ === "function" ? _ : constant$7(!!_), brush) : filter; + }; + + brush.touchable = function(_) { + return arguments.length ? (touchable = typeof _ === "function" ? _ : constant$7(!!_), brush) : touchable; + }; + + brush.handleSize = function(_) { + return arguments.length ? (handleSize = +_, brush) : handleSize; + }; + + brush.keyModifiers = function(_) { + return arguments.length ? (keys = !!_, brush) : keys; + }; + + brush.on = function() { + var value = listeners.on.apply(listeners, arguments); + return value === listeners ? brush : value; + }; + + return brush; +} + +var abs$2 = Math.abs; +var cos$2 = Math.cos; +var sin$2 = Math.sin; +var pi$3 = Math.PI; +var halfPi$2 = pi$3 / 2; +var tau$4 = pi$3 * 2; +var max$1 = Math.max; +var epsilon$5 = 1e-12; + +function range$1(i, j) { + return Array.from({length: j - i}, (_, k) => i + k); +} + +function compareValue(compare) { + return function(a, b) { + return compare( + a.source.value + a.target.value, + b.source.value + b.target.value + ); + }; +} + +function chord() { + return chord$1(false, false); +} + +function chordTranspose() { + return chord$1(false, true); +} + +function chordDirected() { + return chord$1(true, false); +} + +function chord$1(directed, transpose) { + var padAngle = 0, + sortGroups = null, + sortSubgroups = null, + sortChords = null; + + function chord(matrix) { + var n = matrix.length, + groupSums = new Array(n), + groupIndex = range$1(0, n), + chords = new Array(n * n), + groups = new Array(n), + k = 0, dx; + + matrix = Float64Array.from({length: n * n}, transpose + ? (_, i) => matrix[i % n][i / n | 0] + : (_, i) => matrix[i / n | 0][i % n]); + + // Compute the scaling factor from value to angle in [0, 2pi]. + for (let i = 0; i < n; ++i) { + let x = 0; + for (let j = 0; j < n; ++j) x += matrix[i * n + j] + directed * matrix[j * n + i]; + k += groupSums[i] = x; + } + k = max$1(0, tau$4 - padAngle * n) / k; + dx = k ? padAngle : tau$4 / n; + + // Compute the angles for each group and constituent chord. + { + let x = 0; + if (sortGroups) groupIndex.sort((a, b) => sortGroups(groupSums[a], groupSums[b])); + for (const i of groupIndex) { + const x0 = x; + if (directed) { + const subgroupIndex = range$1(~n + 1, n).filter(j => j < 0 ? matrix[~j * n + i] : matrix[i * n + j]); + if (sortSubgroups) subgroupIndex.sort((a, b) => sortSubgroups(a < 0 ? -matrix[~a * n + i] : matrix[i * n + a], b < 0 ? -matrix[~b * n + i] : matrix[i * n + b])); + for (const j of subgroupIndex) { + if (j < 0) { + const chord = chords[~j * n + i] || (chords[~j * n + i] = {source: null, target: null}); + chord.target = {index: i, startAngle: x, endAngle: x += matrix[~j * n + i] * k, value: matrix[~j * n + i]}; + } else { + const chord = chords[i * n + j] || (chords[i * n + j] = {source: null, target: null}); + chord.source = {index: i, startAngle: x, endAngle: x += matrix[i * n + j] * k, value: matrix[i * n + j]}; + } + } + groups[i] = {index: i, startAngle: x0, endAngle: x, value: groupSums[i]}; + } else { + const subgroupIndex = range$1(0, n).filter(j => matrix[i * n + j] || matrix[j * n + i]); + if (sortSubgroups) subgroupIndex.sort((a, b) => sortSubgroups(matrix[i * n + a], matrix[i * n + b])); + for (const j of subgroupIndex) { + let chord; + if (i < j) { + chord = chords[i * n + j] || (chords[i * n + j] = {source: null, target: null}); + chord.source = {index: i, startAngle: x, endAngle: x += matrix[i * n + j] * k, value: matrix[i * n + j]}; + } else { + chord = chords[j * n + i] || (chords[j * n + i] = {source: null, target: null}); + chord.target = {index: i, startAngle: x, endAngle: x += matrix[i * n + j] * k, value: matrix[i * n + j]}; + if (i === j) chord.source = chord.target; + } + if (chord.source && chord.target && chord.source.value < chord.target.value) { + const source = chord.source; + chord.source = chord.target; + chord.target = source; + } + } + groups[i] = {index: i, startAngle: x0, endAngle: x, value: groupSums[i]}; + } + x += dx; + } + } + + // Remove empty chords. + chords = Object.values(chords); + chords.groups = groups; + return sortChords ? chords.sort(sortChords) : chords; + } + + chord.padAngle = function(_) { + return arguments.length ? (padAngle = max$1(0, _), chord) : padAngle; + }; + + chord.sortGroups = function(_) { + return arguments.length ? (sortGroups = _, chord) : sortGroups; + }; + + chord.sortSubgroups = function(_) { + return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups; + }; + + chord.sortChords = function(_) { + return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._; + }; + + return chord; +} + +const pi$2 = Math.PI, + tau$3 = 2 * pi$2, + epsilon$4 = 1e-6, + tauEpsilon = tau$3 - epsilon$4; + +function append$1(strings) { + this._ += strings[0]; + for (let i = 1, n = strings.length; i < n; ++i) { + this._ += arguments[i] + strings[i]; + } +} + +function appendRound$1(digits) { + let d = Math.floor(digits); + if (!(d >= 0)) throw new Error(`invalid digits: ${digits}`); + if (d > 15) return append$1; + const k = 10 ** d; + return function(strings) { + this._ += strings[0]; + for (let i = 1, n = strings.length; i < n; ++i) { + this._ += Math.round(arguments[i] * k) / k + strings[i]; + } + }; +} + +let Path$1 = class Path { + constructor(digits) { + this._x0 = this._y0 = // start of current subpath + this._x1 = this._y1 = null; // end of current subpath + this._ = ""; + this._append = digits == null ? append$1 : appendRound$1(digits); + } + moveTo(x, y) { + this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}`; + } + closePath() { + if (this._x1 !== null) { + this._x1 = this._x0, this._y1 = this._y0; + this._append`Z`; + } + } + lineTo(x, y) { + this._append`L${this._x1 = +x},${this._y1 = +y}`; + } + quadraticCurveTo(x1, y1, x, y) { + this._append`Q${+x1},${+y1},${this._x1 = +x},${this._y1 = +y}`; + } + bezierCurveTo(x1, y1, x2, y2, x, y) { + this._append`C${+x1},${+y1},${+x2},${+y2},${this._x1 = +x},${this._y1 = +y}`; + } + arcTo(x1, y1, x2, y2, r) { + x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r; + + // Is the radius negative? Error. + if (r < 0) throw new Error(`negative radius: ${r}`); + + let x0 = this._x1, + y0 = this._y1, + x21 = x2 - x1, + y21 = y2 - y1, + x01 = x0 - x1, + y01 = y0 - y1, + l01_2 = x01 * x01 + y01 * y01; + + // Is this path empty? Move to (x1,y1). + if (this._x1 === null) { + this._append`M${this._x1 = x1},${this._y1 = y1}`; + } + + // Or, is (x1,y1) coincident with (x0,y0)? Do nothing. + else if (!(l01_2 > epsilon$4)); + + // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear? + // Equivalently, is (x1,y1) coincident with (x2,y2)? + // Or, is the radius zero? Line to (x1,y1). + else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$4) || !r) { + this._append`L${this._x1 = x1},${this._y1 = y1}`; + } + + // Otherwise, draw an arc! + else { + let x20 = x2 - x0, + y20 = y2 - y0, + l21_2 = x21 * x21 + y21 * y21, + l20_2 = x20 * x20 + y20 * y20, + l21 = Math.sqrt(l21_2), + l01 = Math.sqrt(l01_2), + l = r * Math.tan((pi$2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), + t01 = l / l01, + t21 = l / l21; + + // If the start tangent is not coincident with (x0,y0), line to. + if (Math.abs(t01 - 1) > epsilon$4) { + this._append`L${x1 + t01 * x01},${y1 + t01 * y01}`; + } + + this._append`A${r},${r},0,0,${+(y01 * x20 > x01 * y20)},${this._x1 = x1 + t21 * x21},${this._y1 = y1 + t21 * y21}`; + } + } + arc(x, y, r, a0, a1, ccw) { + x = +x, y = +y, r = +r, ccw = !!ccw; + + // Is the radius negative? Error. + if (r < 0) throw new Error(`negative radius: ${r}`); + + let dx = r * Math.cos(a0), + dy = r * Math.sin(a0), + x0 = x + dx, + y0 = y + dy, + cw = 1 ^ ccw, + da = ccw ? a0 - a1 : a1 - a0; + + // Is this path empty? Move to (x0,y0). + if (this._x1 === null) { + this._append`M${x0},${y0}`; + } + + // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0). + else if (Math.abs(this._x1 - x0) > epsilon$4 || Math.abs(this._y1 - y0) > epsilon$4) { + this._append`L${x0},${y0}`; + } + + // Is this arc empty? We’re done. + if (!r) return; + + // Does the angle go the wrong way? Flip the direction. + if (da < 0) da = da % tau$3 + tau$3; + + // Is this a complete circle? Draw two arcs to complete the circle. + if (da > tauEpsilon) { + this._append`A${r},${r},0,1,${cw},${x - dx},${y - dy}A${r},${r},0,1,${cw},${this._x1 = x0},${this._y1 = y0}`; + } + + // Is this arc non-empty? Draw an arc! + else if (da > epsilon$4) { + this._append`A${r},${r},0,${+(da >= pi$2)},${cw},${this._x1 = x + r * Math.cos(a1)},${this._y1 = y + r * Math.sin(a1)}`; + } + } + rect(x, y, w, h) { + this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}h${w = +w}v${+h}h${-w}Z`; + } + toString() { + return this._; + } +}; + +function path() { + return new Path$1; +} + +// Allow instanceof d3.path +path.prototype = Path$1.prototype; + +function pathRound(digits = 3) { + return new Path$1(+digits); +} + +var slice$2 = Array.prototype.slice; + +function constant$6(x) { + return function() { + return x; + }; +} + +function defaultSource$1(d) { + return d.source; +} + +function defaultTarget(d) { + return d.target; +} + +function defaultRadius$1(d) { + return d.radius; +} + +function defaultStartAngle(d) { + return d.startAngle; +} + +function defaultEndAngle(d) { + return d.endAngle; +} + +function defaultPadAngle() { + return 0; +} + +function defaultArrowheadRadius() { + return 10; +} + +function ribbon(headRadius) { + var source = defaultSource$1, + target = defaultTarget, + sourceRadius = defaultRadius$1, + targetRadius = defaultRadius$1, + startAngle = defaultStartAngle, + endAngle = defaultEndAngle, + padAngle = defaultPadAngle, + context = null; + + function ribbon() { + var buffer, + s = source.apply(this, arguments), + t = target.apply(this, arguments), + ap = padAngle.apply(this, arguments) / 2, + argv = slice$2.call(arguments), + sr = +sourceRadius.apply(this, (argv[0] = s, argv)), + sa0 = startAngle.apply(this, argv) - halfPi$2, + sa1 = endAngle.apply(this, argv) - halfPi$2, + tr = +targetRadius.apply(this, (argv[0] = t, argv)), + ta0 = startAngle.apply(this, argv) - halfPi$2, + ta1 = endAngle.apply(this, argv) - halfPi$2; + + if (!context) context = buffer = path(); + + if (ap > epsilon$5) { + if (abs$2(sa1 - sa0) > ap * 2 + epsilon$5) sa1 > sa0 ? (sa0 += ap, sa1 -= ap) : (sa0 -= ap, sa1 += ap); + else sa0 = sa1 = (sa0 + sa1) / 2; + if (abs$2(ta1 - ta0) > ap * 2 + epsilon$5) ta1 > ta0 ? (ta0 += ap, ta1 -= ap) : (ta0 -= ap, ta1 += ap); + else ta0 = ta1 = (ta0 + ta1) / 2; + } + + context.moveTo(sr * cos$2(sa0), sr * sin$2(sa0)); + context.arc(0, 0, sr, sa0, sa1); + if (sa0 !== ta0 || sa1 !== ta1) { + if (headRadius) { + var hr = +headRadius.apply(this, arguments), tr2 = tr - hr, ta2 = (ta0 + ta1) / 2; + context.quadraticCurveTo(0, 0, tr2 * cos$2(ta0), tr2 * sin$2(ta0)); + context.lineTo(tr * cos$2(ta2), tr * sin$2(ta2)); + context.lineTo(tr2 * cos$2(ta1), tr2 * sin$2(ta1)); + } else { + context.quadraticCurveTo(0, 0, tr * cos$2(ta0), tr * sin$2(ta0)); + context.arc(0, 0, tr, ta0, ta1); + } + } + context.quadraticCurveTo(0, 0, sr * cos$2(sa0), sr * sin$2(sa0)); + context.closePath(); + + if (buffer) return context = null, buffer + "" || null; + } + + if (headRadius) ribbon.headRadius = function(_) { + return arguments.length ? (headRadius = typeof _ === "function" ? _ : constant$6(+_), ribbon) : headRadius; + }; + + ribbon.radius = function(_) { + return arguments.length ? (sourceRadius = targetRadius = typeof _ === "function" ? _ : constant$6(+_), ribbon) : sourceRadius; + }; + + ribbon.sourceRadius = function(_) { + return arguments.length ? (sourceRadius = typeof _ === "function" ? _ : constant$6(+_), ribbon) : sourceRadius; + }; + + ribbon.targetRadius = function(_) { + return arguments.length ? (targetRadius = typeof _ === "function" ? _ : constant$6(+_), ribbon) : targetRadius; + }; + + ribbon.startAngle = function(_) { + return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant$6(+_), ribbon) : startAngle; + }; + + ribbon.endAngle = function(_) { + return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$6(+_), ribbon) : endAngle; + }; + + ribbon.padAngle = function(_) { + return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant$6(+_), ribbon) : padAngle; + }; + + ribbon.source = function(_) { + return arguments.length ? (source = _, ribbon) : source; + }; + + ribbon.target = function(_) { + return arguments.length ? (target = _, ribbon) : target; + }; + + ribbon.context = function(_) { + return arguments.length ? ((context = _ == null ? null : _), ribbon) : context; + }; + + return ribbon; +} + +function ribbon$1() { + return ribbon(); +} + +function ribbonArrow() { + return ribbon(defaultArrowheadRadius); +} + +var array$2 = Array.prototype; + +var slice$1 = array$2.slice; + +function ascending$1(a, b) { + return a - b; +} + +function area$3(ring) { + var i = 0, n = ring.length, area = ring[n - 1][1] * ring[0][0] - ring[n - 1][0] * ring[0][1]; + while (++i < n) area += ring[i - 1][1] * ring[i][0] - ring[i - 1][0] * ring[i][1]; + return area; +} + +var constant$5 = x => () => x; + +function contains$2(ring, hole) { + var i = -1, n = hole.length, c; + while (++i < n) if (c = ringContains(ring, hole[i])) return c; + return 0; +} + +function ringContains(ring, point) { + var x = point[0], y = point[1], contains = -1; + for (var i = 0, n = ring.length, j = n - 1; i < n; j = i++) { + var pi = ring[i], xi = pi[0], yi = pi[1], pj = ring[j], xj = pj[0], yj = pj[1]; + if (segmentContains(pi, pj, point)) return 0; + if (((yi > y) !== (yj > y)) && ((x < (xj - xi) * (y - yi) / (yj - yi) + xi))) contains = -contains; + } + return contains; +} + +function segmentContains(a, b, c) { + var i; return collinear$1(a, b, c) && within(a[i = +(a[0] === b[0])], c[i], b[i]); +} + +function collinear$1(a, b, c) { + return (b[0] - a[0]) * (c[1] - a[1]) === (c[0] - a[0]) * (b[1] - a[1]); +} + +function within(p, q, r) { + return p <= q && q <= r || r <= q && q <= p; +} + +function noop$2() {} + +var cases = [ + [], + [[[1.0, 1.5], [0.5, 1.0]]], + [[[1.5, 1.0], [1.0, 1.5]]], + [[[1.5, 1.0], [0.5, 1.0]]], + [[[1.0, 0.5], [1.5, 1.0]]], + [[[1.0, 1.5], [0.5, 1.0]], [[1.0, 0.5], [1.5, 1.0]]], + [[[1.0, 0.5], [1.0, 1.5]]], + [[[1.0, 0.5], [0.5, 1.0]]], + [[[0.5, 1.0], [1.0, 0.5]]], + [[[1.0, 1.5], [1.0, 0.5]]], + [[[0.5, 1.0], [1.0, 0.5]], [[1.5, 1.0], [1.0, 1.5]]], + [[[1.5, 1.0], [1.0, 0.5]]], + [[[0.5, 1.0], [1.5, 1.0]]], + [[[1.0, 1.5], [1.5, 1.0]]], + [[[0.5, 1.0], [1.0, 1.5]]], + [] +]; + +function Contours() { + var dx = 1, + dy = 1, + threshold = thresholdSturges, + smooth = smoothLinear; + + function contours(values) { + var tz = threshold(values); + + // Convert number of thresholds into uniform thresholds. + if (!Array.isArray(tz)) { + const e = extent$1(values, finite); + tz = ticks(...nice$1(e[0], e[1], tz), tz); + while (tz[tz.length - 1] >= e[1]) tz.pop(); + while (tz[1] < e[0]) tz.shift(); + } else { + tz = tz.slice().sort(ascending$1); + } + + return tz.map(value => contour(values, value)); + } + + // Accumulate, smooth contour rings, assign holes to exterior rings. + // Based on https://github.com/mbostock/shapefile/blob/v0.6.2/shp/polygon.js + function contour(values, value) { + const v = value == null ? NaN : +value; + if (isNaN(v)) throw new Error(`invalid value: ${value}`); + + var polygons = [], + holes = []; + + isorings(values, v, function(ring) { + smooth(ring, values, v); + if (area$3(ring) > 0) polygons.push([ring]); + else holes.push(ring); + }); + + holes.forEach(function(hole) { + for (var i = 0, n = polygons.length, polygon; i < n; ++i) { + if (contains$2((polygon = polygons[i])[0], hole) !== -1) { + polygon.push(hole); + return; + } + } + }); + + return { + type: "MultiPolygon", + value: value, + coordinates: polygons + }; + } + + // Marching squares with isolines stitched into rings. + // Based on https://github.com/topojson/topojson-client/blob/v3.0.0/src/stitch.js + function isorings(values, value, callback) { + var fragmentByStart = new Array, + fragmentByEnd = new Array, + x, y, t0, t1, t2, t3; + + // Special case for the first row (y = -1, t2 = t3 = 0). + x = y = -1; + t1 = above(values[0], value); + cases[t1 << 1].forEach(stitch); + while (++x < dx - 1) { + t0 = t1, t1 = above(values[x + 1], value); + cases[t0 | t1 << 1].forEach(stitch); + } + cases[t1 << 0].forEach(stitch); + + // General case for the intermediate rows. + while (++y < dy - 1) { + x = -1; + t1 = above(values[y * dx + dx], value); + t2 = above(values[y * dx], value); + cases[t1 << 1 | t2 << 2].forEach(stitch); + while (++x < dx - 1) { + t0 = t1, t1 = above(values[y * dx + dx + x + 1], value); + t3 = t2, t2 = above(values[y * dx + x + 1], value); + cases[t0 | t1 << 1 | t2 << 2 | t3 << 3].forEach(stitch); + } + cases[t1 | t2 << 3].forEach(stitch); + } + + // Special case for the last row (y = dy - 1, t0 = t1 = 0). + x = -1; + t2 = values[y * dx] >= value; + cases[t2 << 2].forEach(stitch); + while (++x < dx - 1) { + t3 = t2, t2 = above(values[y * dx + x + 1], value); + cases[t2 << 2 | t3 << 3].forEach(stitch); + } + cases[t2 << 3].forEach(stitch); + + function stitch(line) { + var start = [line[0][0] + x, line[0][1] + y], + end = [line[1][0] + x, line[1][1] + y], + startIndex = index(start), + endIndex = index(end), + f, g; + if (f = fragmentByEnd[startIndex]) { + if (g = fragmentByStart[endIndex]) { + delete fragmentByEnd[f.end]; + delete fragmentByStart[g.start]; + if (f === g) { + f.ring.push(end); + callback(f.ring); + } else { + fragmentByStart[f.start] = fragmentByEnd[g.end] = {start: f.start, end: g.end, ring: f.ring.concat(g.ring)}; + } + } else { + delete fragmentByEnd[f.end]; + f.ring.push(end); + fragmentByEnd[f.end = endIndex] = f; + } + } else if (f = fragmentByStart[endIndex]) { + if (g = fragmentByEnd[startIndex]) { + delete fragmentByStart[f.start]; + delete fragmentByEnd[g.end]; + if (f === g) { + f.ring.push(end); + callback(f.ring); + } else { + fragmentByStart[g.start] = fragmentByEnd[f.end] = {start: g.start, end: f.end, ring: g.ring.concat(f.ring)}; + } + } else { + delete fragmentByStart[f.start]; + f.ring.unshift(start); + fragmentByStart[f.start = startIndex] = f; + } + } else { + fragmentByStart[startIndex] = fragmentByEnd[endIndex] = {start: startIndex, end: endIndex, ring: [start, end]}; + } + } + } + + function index(point) { + return point[0] * 2 + point[1] * (dx + 1) * 4; + } + + function smoothLinear(ring, values, value) { + ring.forEach(function(point) { + var x = point[0], + y = point[1], + xt = x | 0, + yt = y | 0, + v1 = valid(values[yt * dx + xt]); + if (x > 0 && x < dx && xt === x) { + point[0] = smooth1(x, valid(values[yt * dx + xt - 1]), v1, value); + } + if (y > 0 && y < dy && yt === y) { + point[1] = smooth1(y, valid(values[(yt - 1) * dx + xt]), v1, value); + } + }); + } + + contours.contour = contour; + + contours.size = function(_) { + if (!arguments.length) return [dx, dy]; + var _0 = Math.floor(_[0]), _1 = Math.floor(_[1]); + if (!(_0 >= 0 && _1 >= 0)) throw new Error("invalid size"); + return dx = _0, dy = _1, contours; + }; + + contours.thresholds = function(_) { + return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant$5(slice$1.call(_)) : constant$5(_), contours) : threshold; + }; + + contours.smooth = function(_) { + return arguments.length ? (smooth = _ ? smoothLinear : noop$2, contours) : smooth === smoothLinear; + }; + + return contours; +} + +// When computing the extent, ignore infinite values (as well as invalid ones). +function finite(x) { + return isFinite(x) ? x : NaN; +} + +// Is the (possibly invalid) x greater than or equal to the (known valid) value? +// Treat any invalid value as below negative infinity. +function above(x, value) { + return x == null ? false : +x >= value; +} + +// During smoothing, treat any invalid value as negative infinity. +function valid(v) { + return v == null || isNaN(v = +v) ? -Infinity : v; +} + +function smooth1(x, v0, v1, value) { + const a = value - v0; + const b = v1 - v0; + const d = isFinite(a) || isFinite(b) ? a / b : Math.sign(a) / Math.sign(b); + return isNaN(d) ? x : x + d - 0.5; +} + +function defaultX$1(d) { + return d[0]; +} + +function defaultY$1(d) { + return d[1]; +} + +function defaultWeight() { + return 1; +} + +function density() { + var x = defaultX$1, + y = defaultY$1, + weight = defaultWeight, + dx = 960, + dy = 500, + r = 20, // blur radius + k = 2, // log2(grid cell size) + o = r * 3, // grid offset, to pad for blur + n = (dx + o * 2) >> k, // grid width + m = (dy + o * 2) >> k, // grid height + threshold = constant$5(20); + + function grid(data) { + var values = new Float32Array(n * m), + pow2k = Math.pow(2, -k), + i = -1; + + for (const d of data) { + var xi = (x(d, ++i, data) + o) * pow2k, + yi = (y(d, i, data) + o) * pow2k, + wi = +weight(d, i, data); + if (wi && xi >= 0 && xi < n && yi >= 0 && yi < m) { + var x0 = Math.floor(xi), + y0 = Math.floor(yi), + xt = xi - x0 - 0.5, + yt = yi - y0 - 0.5; + values[x0 + y0 * n] += (1 - xt) * (1 - yt) * wi; + values[x0 + 1 + y0 * n] += xt * (1 - yt) * wi; + values[x0 + 1 + (y0 + 1) * n] += xt * yt * wi; + values[x0 + (y0 + 1) * n] += (1 - xt) * yt * wi; + } + } + + blur2({data: values, width: n, height: m}, r * pow2k); + return values; + } + + function density(data) { + var values = grid(data), + tz = threshold(values), + pow4k = Math.pow(2, 2 * k); + + // Convert number of thresholds into uniform thresholds. + if (!Array.isArray(tz)) { + tz = ticks(Number.MIN_VALUE, max$3(values) / pow4k, tz); + } + + return Contours() + .size([n, m]) + .thresholds(tz.map(d => d * pow4k)) + (values) + .map((c, i) => (c.value = +tz[i], transform(c))); + } + + density.contours = function(data) { + var values = grid(data), + contours = Contours().size([n, m]), + pow4k = Math.pow(2, 2 * k), + contour = value => { + value = +value; + var c = transform(contours.contour(values, value * pow4k)); + c.value = value; // preserve exact threshold value + return c; + }; + Object.defineProperty(contour, "max", {get: () => max$3(values) / pow4k}); + return contour; + }; + + function transform(geometry) { + geometry.coordinates.forEach(transformPolygon); + return geometry; + } + + function transformPolygon(coordinates) { + coordinates.forEach(transformRing); + } + + function transformRing(coordinates) { + coordinates.forEach(transformPoint); + } + + // TODO Optimize. + function transformPoint(coordinates) { + coordinates[0] = coordinates[0] * Math.pow(2, k) - o; + coordinates[1] = coordinates[1] * Math.pow(2, k) - o; + } + + function resize() { + o = r * 3; + n = (dx + o * 2) >> k; + m = (dy + o * 2) >> k; + return density; + } + + density.x = function(_) { + return arguments.length ? (x = typeof _ === "function" ? _ : constant$5(+_), density) : x; + }; + + density.y = function(_) { + return arguments.length ? (y = typeof _ === "function" ? _ : constant$5(+_), density) : y; + }; + + density.weight = function(_) { + return arguments.length ? (weight = typeof _ === "function" ? _ : constant$5(+_), density) : weight; + }; + + density.size = function(_) { + if (!arguments.length) return [dx, dy]; + var _0 = +_[0], _1 = +_[1]; + if (!(_0 >= 0 && _1 >= 0)) throw new Error("invalid size"); + return dx = _0, dy = _1, resize(); + }; + + density.cellSize = function(_) { + if (!arguments.length) return 1 << k; + if (!((_ = +_) >= 1)) throw new Error("invalid cell size"); + return k = Math.floor(Math.log(_) / Math.LN2), resize(); + }; + + density.thresholds = function(_) { + return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant$5(slice$1.call(_)) : constant$5(_), density) : threshold; + }; + + density.bandwidth = function(_) { + if (!arguments.length) return Math.sqrt(r * (r + 1)); + if (!((_ = +_) >= 0)) throw new Error("invalid bandwidth"); + return r = (Math.sqrt(4 * _ * _ + 1) - 1) / 2, resize(); + }; + + return density; +} + +const epsilon$3 = 1.1102230246251565e-16; +const splitter = 134217729; +const resulterrbound = (3 + 8 * epsilon$3) * epsilon$3; + +// fast_expansion_sum_zeroelim routine from oritinal code +function sum$1(elen, e, flen, f, h) { + let Q, Qnew, hh, bvirt; + let enow = e[0]; + let fnow = f[0]; + let eindex = 0; + let findex = 0; + if ((fnow > enow) === (fnow > -enow)) { + Q = enow; + enow = e[++eindex]; + } else { + Q = fnow; + fnow = f[++findex]; + } + let hindex = 0; + if (eindex < elen && findex < flen) { + if ((fnow > enow) === (fnow > -enow)) { + Qnew = enow + Q; + hh = Q - (Qnew - enow); + enow = e[++eindex]; + } else { + Qnew = fnow + Q; + hh = Q - (Qnew - fnow); + fnow = f[++findex]; + } + Q = Qnew; + if (hh !== 0) { + h[hindex++] = hh; + } + while (eindex < elen && findex < flen) { + if ((fnow > enow) === (fnow > -enow)) { + Qnew = Q + enow; + bvirt = Qnew - Q; + hh = Q - (Qnew - bvirt) + (enow - bvirt); + enow = e[++eindex]; + } else { + Qnew = Q + fnow; + bvirt = Qnew - Q; + hh = Q - (Qnew - bvirt) + (fnow - bvirt); + fnow = f[++findex]; + } + Q = Qnew; + if (hh !== 0) { + h[hindex++] = hh; + } + } + } + while (eindex < elen) { + Qnew = Q + enow; + bvirt = Qnew - Q; + hh = Q - (Qnew - bvirt) + (enow - bvirt); + enow = e[++eindex]; + Q = Qnew; + if (hh !== 0) { + h[hindex++] = hh; + } + } + while (findex < flen) { + Qnew = Q + fnow; + bvirt = Qnew - Q; + hh = Q - (Qnew - bvirt) + (fnow - bvirt); + fnow = f[++findex]; + Q = Qnew; + if (hh !== 0) { + h[hindex++] = hh; + } + } + if (Q !== 0 || hindex === 0) { + h[hindex++] = Q; + } + return hindex; +} + +function estimate(elen, e) { + let Q = e[0]; + for (let i = 1; i < elen; i++) Q += e[i]; + return Q; +} + +function vec(n) { + return new Float64Array(n); +} + +const ccwerrboundA = (3 + 16 * epsilon$3) * epsilon$3; +const ccwerrboundB = (2 + 12 * epsilon$3) * epsilon$3; +const ccwerrboundC = (9 + 64 * epsilon$3) * epsilon$3 * epsilon$3; + +const B = vec(4); +const C1 = vec(8); +const C2 = vec(12); +const D = vec(16); +const u = vec(4); + +function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) { + let acxtail, acytail, bcxtail, bcytail; + let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3; + + const acx = ax - cx; + const bcx = bx - cx; + const acy = ay - cy; + const bcy = by - cy; + + s1 = acx * bcy; + c = splitter * acx; + ahi = c - (c - acx); + alo = acx - ahi; + c = splitter * bcy; + bhi = c - (c - bcy); + blo = bcy - bhi; + s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo); + t1 = acy * bcx; + c = splitter * acy; + ahi = c - (c - acy); + alo = acy - ahi; + c = splitter * bcx; + bhi = c - (c - bcx); + blo = bcx - bhi; + t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo); + _i = s0 - t0; + bvirt = s0 - _i; + B[0] = s0 - (_i + bvirt) + (bvirt - t0); + _j = s1 + _i; + bvirt = _j - s1; + _0 = s1 - (_j - bvirt) + (_i - bvirt); + _i = _0 - t1; + bvirt = _0 - _i; + B[1] = _0 - (_i + bvirt) + (bvirt - t1); + u3 = _j + _i; + bvirt = u3 - _j; + B[2] = _j - (u3 - bvirt) + (_i - bvirt); + B[3] = u3; + + let det = estimate(4, B); + let errbound = ccwerrboundB * detsum; + if (det >= errbound || -det >= errbound) { + return det; + } + + bvirt = ax - acx; + acxtail = ax - (acx + bvirt) + (bvirt - cx); + bvirt = bx - bcx; + bcxtail = bx - (bcx + bvirt) + (bvirt - cx); + bvirt = ay - acy; + acytail = ay - (acy + bvirt) + (bvirt - cy); + bvirt = by - bcy; + bcytail = by - (bcy + bvirt) + (bvirt - cy); + + if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) { + return det; + } + + errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det); + det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail); + if (det >= errbound || -det >= errbound) return det; + + s1 = acxtail * bcy; + c = splitter * acxtail; + ahi = c - (c - acxtail); + alo = acxtail - ahi; + c = splitter * bcy; + bhi = c - (c - bcy); + blo = bcy - bhi; + s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo); + t1 = acytail * bcx; + c = splitter * acytail; + ahi = c - (c - acytail); + alo = acytail - ahi; + c = splitter * bcx; + bhi = c - (c - bcx); + blo = bcx - bhi; + t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo); + _i = s0 - t0; + bvirt = s0 - _i; + u[0] = s0 - (_i + bvirt) + (bvirt - t0); + _j = s1 + _i; + bvirt = _j - s1; + _0 = s1 - (_j - bvirt) + (_i - bvirt); + _i = _0 - t1; + bvirt = _0 - _i; + u[1] = _0 - (_i + bvirt) + (bvirt - t1); + u3 = _j + _i; + bvirt = u3 - _j; + u[2] = _j - (u3 - bvirt) + (_i - bvirt); + u[3] = u3; + const C1len = sum$1(4, B, 4, u, C1); + + s1 = acx * bcytail; + c = splitter * acx; + ahi = c - (c - acx); + alo = acx - ahi; + c = splitter * bcytail; + bhi = c - (c - bcytail); + blo = bcytail - bhi; + s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo); + t1 = acy * bcxtail; + c = splitter * acy; + ahi = c - (c - acy); + alo = acy - ahi; + c = splitter * bcxtail; + bhi = c - (c - bcxtail); + blo = bcxtail - bhi; + t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo); + _i = s0 - t0; + bvirt = s0 - _i; + u[0] = s0 - (_i + bvirt) + (bvirt - t0); + _j = s1 + _i; + bvirt = _j - s1; + _0 = s1 - (_j - bvirt) + (_i - bvirt); + _i = _0 - t1; + bvirt = _0 - _i; + u[1] = _0 - (_i + bvirt) + (bvirt - t1); + u3 = _j + _i; + bvirt = u3 - _j; + u[2] = _j - (u3 - bvirt) + (_i - bvirt); + u[3] = u3; + const C2len = sum$1(C1len, C1, 4, u, C2); + + s1 = acxtail * bcytail; + c = splitter * acxtail; + ahi = c - (c - acxtail); + alo = acxtail - ahi; + c = splitter * bcytail; + bhi = c - (c - bcytail); + blo = bcytail - bhi; + s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo); + t1 = acytail * bcxtail; + c = splitter * acytail; + ahi = c - (c - acytail); + alo = acytail - ahi; + c = splitter * bcxtail; + bhi = c - (c - bcxtail); + blo = bcxtail - bhi; + t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo); + _i = s0 - t0; + bvirt = s0 - _i; + u[0] = s0 - (_i + bvirt) + (bvirt - t0); + _j = s1 + _i; + bvirt = _j - s1; + _0 = s1 - (_j - bvirt) + (_i - bvirt); + _i = _0 - t1; + bvirt = _0 - _i; + u[1] = _0 - (_i + bvirt) + (bvirt - t1); + u3 = _j + _i; + bvirt = u3 - _j; + u[2] = _j - (u3 - bvirt) + (_i - bvirt); + u[3] = u3; + const Dlen = sum$1(C2len, C2, 4, u, D); + + return D[Dlen - 1]; +} + +function orient2d(ax, ay, bx, by, cx, cy) { + const detleft = (ay - cy) * (bx - cx); + const detright = (ax - cx) * (by - cy); + const det = detleft - detright; + + const detsum = Math.abs(detleft + detright); + if (Math.abs(det) >= ccwerrboundA * detsum) return det; + + return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum); +} + +const EPSILON = Math.pow(2, -52); +const EDGE_STACK = new Uint32Array(512); + +class Delaunator { + + static from(points, getX = defaultGetX, getY = defaultGetY) { + const n = points.length; + const coords = new Float64Array(n * 2); + + for (let i = 0; i < n; i++) { + const p = points[i]; + coords[2 * i] = getX(p); + coords[2 * i + 1] = getY(p); + } + + return new Delaunator(coords); + } + + constructor(coords) { + const n = coords.length >> 1; + if (n > 0 && typeof coords[0] !== 'number') throw new Error('Expected coords to contain numbers.'); + + this.coords = coords; + + // arrays that will store the triangulation graph + const maxTriangles = Math.max(2 * n - 5, 0); + this._triangles = new Uint32Array(maxTriangles * 3); + this._halfedges = new Int32Array(maxTriangles * 3); + + // temporary arrays for tracking the edges of the advancing convex hull + this._hashSize = Math.ceil(Math.sqrt(n)); + this._hullPrev = new Uint32Array(n); // edge to prev edge + this._hullNext = new Uint32Array(n); // edge to next edge + this._hullTri = new Uint32Array(n); // edge to adjacent triangle + this._hullHash = new Int32Array(this._hashSize); // angular edge hash + + // temporary arrays for sorting points + this._ids = new Uint32Array(n); + this._dists = new Float64Array(n); + + this.update(); + } + + update() { + const {coords, _hullPrev: hullPrev, _hullNext: hullNext, _hullTri: hullTri, _hullHash: hullHash} = this; + const n = coords.length >> 1; + + // populate an array of point indices; calculate input data bbox + let minX = Infinity; + let minY = Infinity; + let maxX = -Infinity; + let maxY = -Infinity; + + for (let i = 0; i < n; i++) { + const x = coords[2 * i]; + const y = coords[2 * i + 1]; + if (x < minX) minX = x; + if (y < minY) minY = y; + if (x > maxX) maxX = x; + if (y > maxY) maxY = y; + this._ids[i] = i; + } + const cx = (minX + maxX) / 2; + const cy = (minY + maxY) / 2; + + let i0, i1, i2; + + // pick a seed point close to the center + for (let i = 0, minDist = Infinity; i < n; i++) { + const d = dist(cx, cy, coords[2 * i], coords[2 * i + 1]); + if (d < minDist) { + i0 = i; + minDist = d; + } + } + const i0x = coords[2 * i0]; + const i0y = coords[2 * i0 + 1]; + + // find the point closest to the seed + for (let i = 0, minDist = Infinity; i < n; i++) { + if (i === i0) continue; + const d = dist(i0x, i0y, coords[2 * i], coords[2 * i + 1]); + if (d < minDist && d > 0) { + i1 = i; + minDist = d; + } + } + let i1x = coords[2 * i1]; + let i1y = coords[2 * i1 + 1]; + + let minRadius = Infinity; + + // find the third point which forms the smallest circumcircle with the first two + for (let i = 0; i < n; i++) { + if (i === i0 || i === i1) continue; + const r = circumradius(i0x, i0y, i1x, i1y, coords[2 * i], coords[2 * i + 1]); + if (r < minRadius) { + i2 = i; + minRadius = r; + } + } + let i2x = coords[2 * i2]; + let i2y = coords[2 * i2 + 1]; + + if (minRadius === Infinity) { + // order collinear points by dx (or dy if all x are identical) + // and return the list as a hull + for (let i = 0; i < n; i++) { + this._dists[i] = (coords[2 * i] - coords[0]) || (coords[2 * i + 1] - coords[1]); + } + quicksort(this._ids, this._dists, 0, n - 1); + const hull = new Uint32Array(n); + let j = 0; + for (let i = 0, d0 = -Infinity; i < n; i++) { + const id = this._ids[i]; + const d = this._dists[id]; + if (d > d0) { + hull[j++] = id; + d0 = d; + } + } + this.hull = hull.subarray(0, j); + this.triangles = new Uint32Array(0); + this.halfedges = new Uint32Array(0); + return; + } + + // swap the order of the seed points for counter-clockwise orientation + if (orient2d(i0x, i0y, i1x, i1y, i2x, i2y) < 0) { + const i = i1; + const x = i1x; + const y = i1y; + i1 = i2; + i1x = i2x; + i1y = i2y; + i2 = i; + i2x = x; + i2y = y; + } + + const center = circumcenter(i0x, i0y, i1x, i1y, i2x, i2y); + this._cx = center.x; + this._cy = center.y; + + for (let i = 0; i < n; i++) { + this._dists[i] = dist(coords[2 * i], coords[2 * i + 1], center.x, center.y); + } + + // sort the points by distance from the seed triangle circumcenter + quicksort(this._ids, this._dists, 0, n - 1); + + // set up the seed triangle as the starting hull + this._hullStart = i0; + let hullSize = 3; + + hullNext[i0] = hullPrev[i2] = i1; + hullNext[i1] = hullPrev[i0] = i2; + hullNext[i2] = hullPrev[i1] = i0; + + hullTri[i0] = 0; + hullTri[i1] = 1; + hullTri[i2] = 2; + + hullHash.fill(-1); + hullHash[this._hashKey(i0x, i0y)] = i0; + hullHash[this._hashKey(i1x, i1y)] = i1; + hullHash[this._hashKey(i2x, i2y)] = i2; + + this.trianglesLen = 0; + this._addTriangle(i0, i1, i2, -1, -1, -1); + + for (let k = 0, xp, yp; k < this._ids.length; k++) { + const i = this._ids[k]; + const x = coords[2 * i]; + const y = coords[2 * i + 1]; + + // skip near-duplicate points + if (k > 0 && Math.abs(x - xp) <= EPSILON && Math.abs(y - yp) <= EPSILON) continue; + xp = x; + yp = y; + + // skip seed triangle points + if (i === i0 || i === i1 || i === i2) continue; + + // find a visible edge on the convex hull using edge hash + let start = 0; + for (let j = 0, key = this._hashKey(x, y); j < this._hashSize; j++) { + start = hullHash[(key + j) % this._hashSize]; + if (start !== -1 && start !== hullNext[start]) break; + } + + start = hullPrev[start]; + let e = start, q; + while (q = hullNext[e], orient2d(x, y, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1]) >= 0) { + e = q; + if (e === start) { + e = -1; + break; + } + } + if (e === -1) continue; // likely a near-duplicate point; skip it + + // add the first triangle from the point + let t = this._addTriangle(e, i, hullNext[e], -1, -1, hullTri[e]); + + // recursively flip triangles from the point until they satisfy the Delaunay condition + hullTri[i] = this._legalize(t + 2); + hullTri[e] = t; // keep track of boundary triangles on the hull + hullSize++; + + // walk forward through the hull, adding more triangles and flipping recursively + let n = hullNext[e]; + while (q = hullNext[n], orient2d(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1]) < 0) { + t = this._addTriangle(n, i, q, hullTri[i], -1, hullTri[n]); + hullTri[i] = this._legalize(t + 2); + hullNext[n] = n; // mark as removed + hullSize--; + n = q; + } + + // walk backward from the other side, adding more triangles and flipping + if (e === start) { + while (q = hullPrev[e], orient2d(x, y, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1]) < 0) { + t = this._addTriangle(q, i, e, -1, hullTri[e], hullTri[q]); + this._legalize(t + 2); + hullTri[q] = t; + hullNext[e] = e; // mark as removed + hullSize--; + e = q; + } + } + + // update the hull indices + this._hullStart = hullPrev[i] = e; + hullNext[e] = hullPrev[n] = i; + hullNext[i] = n; + + // save the two new edges in the hash table + hullHash[this._hashKey(x, y)] = i; + hullHash[this._hashKey(coords[2 * e], coords[2 * e + 1])] = e; + } + + this.hull = new Uint32Array(hullSize); + for (let i = 0, e = this._hullStart; i < hullSize; i++) { + this.hull[i] = e; + e = hullNext[e]; + } + + // trim typed triangle mesh arrays + this.triangles = this._triangles.subarray(0, this.trianglesLen); + this.halfedges = this._halfedges.subarray(0, this.trianglesLen); + } + + _hashKey(x, y) { + return Math.floor(pseudoAngle(x - this._cx, y - this._cy) * this._hashSize) % this._hashSize; + } + + _legalize(a) { + const {_triangles: triangles, _halfedges: halfedges, coords} = this; + + let i = 0; + let ar = 0; + + // recursion eliminated with a fixed-size stack + while (true) { + const b = halfedges[a]; + + /* if the pair of triangles doesn't satisfy the Delaunay condition + * (p1 is inside the circumcircle of [p0, pl, pr]), flip them, + * then do the same check/flip recursively for the new pair of triangles + * + * pl pl + * /||\ / \ + * al/ || \bl al/ \a + * / || \ / \ + * / a||b \ flip /___ar___\ + * p0\ || /p1 => p0\---bl---/p1 + * \ || / \ / + * ar\ || /br b\ /br + * \||/ \ / + * pr pr + */ + const a0 = a - a % 3; + ar = a0 + (a + 2) % 3; + + if (b === -1) { // convex hull edge + if (i === 0) break; + a = EDGE_STACK[--i]; + continue; + } + + const b0 = b - b % 3; + const al = a0 + (a + 1) % 3; + const bl = b0 + (b + 2) % 3; + + const p0 = triangles[ar]; + const pr = triangles[a]; + const pl = triangles[al]; + const p1 = triangles[bl]; + + const illegal = inCircle( + coords[2 * p0], coords[2 * p0 + 1], + coords[2 * pr], coords[2 * pr + 1], + coords[2 * pl], coords[2 * pl + 1], + coords[2 * p1], coords[2 * p1 + 1]); + + if (illegal) { + triangles[a] = p1; + triangles[b] = p0; + + const hbl = halfedges[bl]; + + // edge swapped on the other side of the hull (rare); fix the halfedge reference + if (hbl === -1) { + let e = this._hullStart; + do { + if (this._hullTri[e] === bl) { + this._hullTri[e] = a; + break; + } + e = this._hullPrev[e]; + } while (e !== this._hullStart); + } + this._link(a, hbl); + this._link(b, halfedges[ar]); + this._link(ar, bl); + + const br = b0 + (b + 1) % 3; + + // don't worry about hitting the cap: it can only happen on extremely degenerate input + if (i < EDGE_STACK.length) { + EDGE_STACK[i++] = br; + } + } else { + if (i === 0) break; + a = EDGE_STACK[--i]; + } + } + + return ar; + } + + _link(a, b) { + this._halfedges[a] = b; + if (b !== -1) this._halfedges[b] = a; + } + + // add a new triangle given vertex indices and adjacent half-edge ids + _addTriangle(i0, i1, i2, a, b, c) { + const t = this.trianglesLen; + + this._triangles[t] = i0; + this._triangles[t + 1] = i1; + this._triangles[t + 2] = i2; + + this._link(t, a); + this._link(t + 1, b); + this._link(t + 2, c); + + this.trianglesLen += 3; + + return t; + } +} + +// monotonically increases with real angle, but doesn't need expensive trigonometry +function pseudoAngle(dx, dy) { + const p = dx / (Math.abs(dx) + Math.abs(dy)); + return (dy > 0 ? 3 - p : 1 + p) / 4; // [0..1] +} + +function dist(ax, ay, bx, by) { + const dx = ax - bx; + const dy = ay - by; + return dx * dx + dy * dy; +} + +function inCircle(ax, ay, bx, by, cx, cy, px, py) { + const dx = ax - px; + const dy = ay - py; + const ex = bx - px; + const ey = by - py; + const fx = cx - px; + const fy = cy - py; + + const ap = dx * dx + dy * dy; + const bp = ex * ex + ey * ey; + const cp = fx * fx + fy * fy; + + return dx * (ey * cp - bp * fy) - + dy * (ex * cp - bp * fx) + + ap * (ex * fy - ey * fx) < 0; +} + +function circumradius(ax, ay, bx, by, cx, cy) { + const dx = bx - ax; + const dy = by - ay; + const ex = cx - ax; + const ey = cy - ay; + + const bl = dx * dx + dy * dy; + const cl = ex * ex + ey * ey; + const d = 0.5 / (dx * ey - dy * ex); + + const x = (ey * bl - dy * cl) * d; + const y = (dx * cl - ex * bl) * d; + + return x * x + y * y; +} + +function circumcenter(ax, ay, bx, by, cx, cy) { + const dx = bx - ax; + const dy = by - ay; + const ex = cx - ax; + const ey = cy - ay; + + const bl = dx * dx + dy * dy; + const cl = ex * ex + ey * ey; + const d = 0.5 / (dx * ey - dy * ex); + + const x = ax + (ey * bl - dy * cl) * d; + const y = ay + (dx * cl - ex * bl) * d; + + return {x, y}; +} + +function quicksort(ids, dists, left, right) { + if (right - left <= 20) { + for (let i = left + 1; i <= right; i++) { + const temp = ids[i]; + const tempDist = dists[temp]; + let j = i - 1; + while (j >= left && dists[ids[j]] > tempDist) ids[j + 1] = ids[j--]; + ids[j + 1] = temp; + } + } else { + const median = (left + right) >> 1; + let i = left + 1; + let j = right; + swap(ids, median, i); + if (dists[ids[left]] > dists[ids[right]]) swap(ids, left, right); + if (dists[ids[i]] > dists[ids[right]]) swap(ids, i, right); + if (dists[ids[left]] > dists[ids[i]]) swap(ids, left, i); + + const temp = ids[i]; + const tempDist = dists[temp]; + while (true) { + do i++; while (dists[ids[i]] < tempDist); + do j--; while (dists[ids[j]] > tempDist); + if (j < i) break; + swap(ids, i, j); + } + ids[left + 1] = ids[j]; + ids[j] = temp; + + if (right - i + 1 >= j - left) { + quicksort(ids, dists, i, right); + quicksort(ids, dists, left, j - 1); + } else { + quicksort(ids, dists, left, j - 1); + quicksort(ids, dists, i, right); + } + } +} + +function swap(arr, i, j) { + const tmp = arr[i]; + arr[i] = arr[j]; + arr[j] = tmp; +} + +function defaultGetX(p) { + return p[0]; +} +function defaultGetY(p) { + return p[1]; +} + +const epsilon$2 = 1e-6; + +class Path { + constructor() { + this._x0 = this._y0 = // start of current subpath + this._x1 = this._y1 = null; // end of current subpath + this._ = ""; + } + moveTo(x, y) { + this._ += `M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}`; + } + closePath() { + if (this._x1 !== null) { + this._x1 = this._x0, this._y1 = this._y0; + this._ += "Z"; + } + } + lineTo(x, y) { + this._ += `L${this._x1 = +x},${this._y1 = +y}`; + } + arc(x, y, r) { + x = +x, y = +y, r = +r; + const x0 = x + r; + const y0 = y; + if (r < 0) throw new Error("negative radius"); + if (this._x1 === null) this._ += `M${x0},${y0}`; + else if (Math.abs(this._x1 - x0) > epsilon$2 || Math.abs(this._y1 - y0) > epsilon$2) this._ += "L" + x0 + "," + y0; + if (!r) return; + this._ += `A${r},${r},0,1,1,${x - r},${y}A${r},${r},0,1,1,${this._x1 = x0},${this._y1 = y0}`; + } + rect(x, y, w, h) { + this._ += `M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}h${+w}v${+h}h${-w}Z`; + } + value() { + return this._ || null; + } +} + +class Polygon { + constructor() { + this._ = []; + } + moveTo(x, y) { + this._.push([x, y]); + } + closePath() { + this._.push(this._[0].slice()); + } + lineTo(x, y) { + this._.push([x, y]); + } + value() { + return this._.length ? this._ : null; + } +} + +class Voronoi { + constructor(delaunay, [xmin, ymin, xmax, ymax] = [0, 0, 960, 500]) { + if (!((xmax = +xmax) >= (xmin = +xmin)) || !((ymax = +ymax) >= (ymin = +ymin))) throw new Error("invalid bounds"); + this.delaunay = delaunay; + this._circumcenters = new Float64Array(delaunay.points.length * 2); + this.vectors = new Float64Array(delaunay.points.length * 2); + this.xmax = xmax, this.xmin = xmin; + this.ymax = ymax, this.ymin = ymin; + this._init(); + } + update() { + this.delaunay.update(); + this._init(); + return this; + } + _init() { + const {delaunay: {points, hull, triangles}, vectors} = this; + let bx, by; // lazily computed barycenter of the hull + + // Compute circumcenters. + const circumcenters = this.circumcenters = this._circumcenters.subarray(0, triangles.length / 3 * 2); + for (let i = 0, j = 0, n = triangles.length, x, y; i < n; i += 3, j += 2) { + const t1 = triangles[i] * 2; + const t2 = triangles[i + 1] * 2; + const t3 = triangles[i + 2] * 2; + const x1 = points[t1]; + const y1 = points[t1 + 1]; + const x2 = points[t2]; + const y2 = points[t2 + 1]; + const x3 = points[t3]; + const y3 = points[t3 + 1]; + + const dx = x2 - x1; + const dy = y2 - y1; + const ex = x3 - x1; + const ey = y3 - y1; + const ab = (dx * ey - dy * ex) * 2; + + if (Math.abs(ab) < 1e-9) { + // For a degenerate triangle, the circumcenter is at the infinity, in a + // direction orthogonal to the halfedge and away from the “center” of + // the diagram <bx, by>, defined as the hull’s barycenter. + if (bx === undefined) { + bx = by = 0; + for (const i of hull) bx += points[i * 2], by += points[i * 2 + 1]; + bx /= hull.length, by /= hull.length; + } + const a = 1e9 * Math.sign((bx - x1) * ey - (by - y1) * ex); + x = (x1 + x3) / 2 - a * ey; + y = (y1 + y3) / 2 + a * ex; + } else { + const d = 1 / ab; + const bl = dx * dx + dy * dy; + const cl = ex * ex + ey * ey; + x = x1 + (ey * bl - dy * cl) * d; + y = y1 + (dx * cl - ex * bl) * d; + } + circumcenters[j] = x; + circumcenters[j + 1] = y; + } + + // Compute exterior cell rays. + let h = hull[hull.length - 1]; + let p0, p1 = h * 4; + let x0, x1 = points[2 * h]; + let y0, y1 = points[2 * h + 1]; + vectors.fill(0); + for (let i = 0; i < hull.length; ++i) { + h = hull[i]; + p0 = p1, x0 = x1, y0 = y1; + p1 = h * 4, x1 = points[2 * h], y1 = points[2 * h + 1]; + vectors[p0 + 2] = vectors[p1] = y0 - y1; + vectors[p0 + 3] = vectors[p1 + 1] = x1 - x0; + } + } + render(context) { + const buffer = context == null ? context = new Path : undefined; + const {delaunay: {halfedges, inedges, hull}, circumcenters, vectors} = this; + if (hull.length <= 1) return null; + for (let i = 0, n = halfedges.length; i < n; ++i) { + const j = halfedges[i]; + if (j < i) continue; + const ti = Math.floor(i / 3) * 2; + const tj = Math.floor(j / 3) * 2; + const xi = circumcenters[ti]; + const yi = circumcenters[ti + 1]; + const xj = circumcenters[tj]; + const yj = circumcenters[tj + 1]; + this._renderSegment(xi, yi, xj, yj, context); + } + let h0, h1 = hull[hull.length - 1]; + for (let i = 0; i < hull.length; ++i) { + h0 = h1, h1 = hull[i]; + const t = Math.floor(inedges[h1] / 3) * 2; + const x = circumcenters[t]; + const y = circumcenters[t + 1]; + const v = h0 * 4; + const p = this._project(x, y, vectors[v + 2], vectors[v + 3]); + if (p) this._renderSegment(x, y, p[0], p[1], context); + } + return buffer && buffer.value(); + } + renderBounds(context) { + const buffer = context == null ? context = new Path : undefined; + context.rect(this.xmin, this.ymin, this.xmax - this.xmin, this.ymax - this.ymin); + return buffer && buffer.value(); + } + renderCell(i, context) { + const buffer = context == null ? context = new Path : undefined; + const points = this._clip(i); + if (points === null || !points.length) return; + context.moveTo(points[0], points[1]); + let n = points.length; + while (points[0] === points[n-2] && points[1] === points[n-1] && n > 1) n -= 2; + for (let i = 2; i < n; i += 2) { + if (points[i] !== points[i-2] || points[i+1] !== points[i-1]) + context.lineTo(points[i], points[i + 1]); + } + context.closePath(); + return buffer && buffer.value(); + } + *cellPolygons() { + const {delaunay: {points}} = this; + for (let i = 0, n = points.length / 2; i < n; ++i) { + const cell = this.cellPolygon(i); + if (cell) cell.index = i, yield cell; + } + } + cellPolygon(i) { + const polygon = new Polygon; + this.renderCell(i, polygon); + return polygon.value(); + } + _renderSegment(x0, y0, x1, y1, context) { + let S; + const c0 = this._regioncode(x0, y0); + const c1 = this._regioncode(x1, y1); + if (c0 === 0 && c1 === 0) { + context.moveTo(x0, y0); + context.lineTo(x1, y1); + } else if (S = this._clipSegment(x0, y0, x1, y1, c0, c1)) { + context.moveTo(S[0], S[1]); + context.lineTo(S[2], S[3]); + } + } + contains(i, x, y) { + if ((x = +x, x !== x) || (y = +y, y !== y)) return false; + return this.delaunay._step(i, x, y) === i; + } + *neighbors(i) { + const ci = this._clip(i); + if (ci) for (const j of this.delaunay.neighbors(i)) { + const cj = this._clip(j); + // find the common edge + if (cj) loop: for (let ai = 0, li = ci.length; ai < li; ai += 2) { + for (let aj = 0, lj = cj.length; aj < lj; aj += 2) { + if (ci[ai] === cj[aj] + && ci[ai + 1] === cj[aj + 1] + && ci[(ai + 2) % li] === cj[(aj + lj - 2) % lj] + && ci[(ai + 3) % li] === cj[(aj + lj - 1) % lj]) { + yield j; + break loop; + } + } + } + } + } + _cell(i) { + const {circumcenters, delaunay: {inedges, halfedges, triangles}} = this; + const e0 = inedges[i]; + if (e0 === -1) return null; // coincident point + const points = []; + let e = e0; + do { + const t = Math.floor(e / 3); + points.push(circumcenters[t * 2], circumcenters[t * 2 + 1]); + e = e % 3 === 2 ? e - 2 : e + 1; + if (triangles[e] !== i) break; // bad triangulation + e = halfedges[e]; + } while (e !== e0 && e !== -1); + return points; + } + _clip(i) { + // degenerate case (1 valid point: return the box) + if (i === 0 && this.delaunay.hull.length === 1) { + return [this.xmax, this.ymin, this.xmax, this.ymax, this.xmin, this.ymax, this.xmin, this.ymin]; + } + const points = this._cell(i); + if (points === null) return null; + const {vectors: V} = this; + const v = i * 4; + return this._simplify(V[v] || V[v + 1] + ? this._clipInfinite(i, points, V[v], V[v + 1], V[v + 2], V[v + 3]) + : this._clipFinite(i, points)); + } + _clipFinite(i, points) { + const n = points.length; + let P = null; + let x0, y0, x1 = points[n - 2], y1 = points[n - 1]; + let c0, c1 = this._regioncode(x1, y1); + let e0, e1 = 0; + for (let j = 0; j < n; j += 2) { + x0 = x1, y0 = y1, x1 = points[j], y1 = points[j + 1]; + c0 = c1, c1 = this._regioncode(x1, y1); + if (c0 === 0 && c1 === 0) { + e0 = e1, e1 = 0; + if (P) P.push(x1, y1); + else P = [x1, y1]; + } else { + let S, sx0, sy0, sx1, sy1; + if (c0 === 0) { + if ((S = this._clipSegment(x0, y0, x1, y1, c0, c1)) === null) continue; + [sx0, sy0, sx1, sy1] = S; + } else { + if ((S = this._clipSegment(x1, y1, x0, y0, c1, c0)) === null) continue; + [sx1, sy1, sx0, sy0] = S; + e0 = e1, e1 = this._edgecode(sx0, sy0); + if (e0 && e1) this._edge(i, e0, e1, P, P.length); + if (P) P.push(sx0, sy0); + else P = [sx0, sy0]; + } + e0 = e1, e1 = this._edgecode(sx1, sy1); + if (e0 && e1) this._edge(i, e0, e1, P, P.length); + if (P) P.push(sx1, sy1); + else P = [sx1, sy1]; + } + } + if (P) { + e0 = e1, e1 = this._edgecode(P[0], P[1]); + if (e0 && e1) this._edge(i, e0, e1, P, P.length); + } else if (this.contains(i, (this.xmin + this.xmax) / 2, (this.ymin + this.ymax) / 2)) { + return [this.xmax, this.ymin, this.xmax, this.ymax, this.xmin, this.ymax, this.xmin, this.ymin]; + } + return P; + } + _clipSegment(x0, y0, x1, y1, c0, c1) { + // for more robustness, always consider the segment in the same order + const flip = c0 < c1; + if (flip) [x0, y0, x1, y1, c0, c1] = [x1, y1, x0, y0, c1, c0]; + while (true) { + if (c0 === 0 && c1 === 0) return flip ? [x1, y1, x0, y0] : [x0, y0, x1, y1]; + if (c0 & c1) return null; + let x, y, c = c0 || c1; + if (c & 0b1000) x = x0 + (x1 - x0) * (this.ymax - y0) / (y1 - y0), y = this.ymax; + else if (c & 0b0100) x = x0 + (x1 - x0) * (this.ymin - y0) / (y1 - y0), y = this.ymin; + else if (c & 0b0010) y = y0 + (y1 - y0) * (this.xmax - x0) / (x1 - x0), x = this.xmax; + else y = y0 + (y1 - y0) * (this.xmin - x0) / (x1 - x0), x = this.xmin; + if (c0) x0 = x, y0 = y, c0 = this._regioncode(x0, y0); + else x1 = x, y1 = y, c1 = this._regioncode(x1, y1); + } + } + _clipInfinite(i, points, vx0, vy0, vxn, vyn) { + let P = Array.from(points), p; + if (p = this._project(P[0], P[1], vx0, vy0)) P.unshift(p[0], p[1]); + if (p = this._project(P[P.length - 2], P[P.length - 1], vxn, vyn)) P.push(p[0], p[1]); + if (P = this._clipFinite(i, P)) { + for (let j = 0, n = P.length, c0, c1 = this._edgecode(P[n - 2], P[n - 1]); j < n; j += 2) { + c0 = c1, c1 = this._edgecode(P[j], P[j + 1]); + if (c0 && c1) j = this._edge(i, c0, c1, P, j), n = P.length; + } + } else if (this.contains(i, (this.xmin + this.xmax) / 2, (this.ymin + this.ymax) / 2)) { + P = [this.xmin, this.ymin, this.xmax, this.ymin, this.xmax, this.ymax, this.xmin, this.ymax]; + } + return P; + } + _edge(i, e0, e1, P, j) { + while (e0 !== e1) { + let x, y; + switch (e0) { + case 0b0101: e0 = 0b0100; continue; // top-left + case 0b0100: e0 = 0b0110, x = this.xmax, y = this.ymin; break; // top + case 0b0110: e0 = 0b0010; continue; // top-right + case 0b0010: e0 = 0b1010, x = this.xmax, y = this.ymax; break; // right + case 0b1010: e0 = 0b1000; continue; // bottom-right + case 0b1000: e0 = 0b1001, x = this.xmin, y = this.ymax; break; // bottom + case 0b1001: e0 = 0b0001; continue; // bottom-left + case 0b0001: e0 = 0b0101, x = this.xmin, y = this.ymin; break; // left + } + // Note: this implicitly checks for out of bounds: if P[j] or P[j+1] are + // undefined, the conditional statement will be executed. + if ((P[j] !== x || P[j + 1] !== y) && this.contains(i, x, y)) { + P.splice(j, 0, x, y), j += 2; + } + } + return j; + } + _project(x0, y0, vx, vy) { + let t = Infinity, c, x, y; + if (vy < 0) { // top + if (y0 <= this.ymin) return null; + if ((c = (this.ymin - y0) / vy) < t) y = this.ymin, x = x0 + (t = c) * vx; + } else if (vy > 0) { // bottom + if (y0 >= this.ymax) return null; + if ((c = (this.ymax - y0) / vy) < t) y = this.ymax, x = x0 + (t = c) * vx; + } + if (vx > 0) { // right + if (x0 >= this.xmax) return null; + if ((c = (this.xmax - x0) / vx) < t) x = this.xmax, y = y0 + (t = c) * vy; + } else if (vx < 0) { // left + if (x0 <= this.xmin) return null; + if ((c = (this.xmin - x0) / vx) < t) x = this.xmin, y = y0 + (t = c) * vy; + } + return [x, y]; + } + _edgecode(x, y) { + return (x === this.xmin ? 0b0001 + : x === this.xmax ? 0b0010 : 0b0000) + | (y === this.ymin ? 0b0100 + : y === this.ymax ? 0b1000 : 0b0000); + } + _regioncode(x, y) { + return (x < this.xmin ? 0b0001 + : x > this.xmax ? 0b0010 : 0b0000) + | (y < this.ymin ? 0b0100 + : y > this.ymax ? 0b1000 : 0b0000); + } + _simplify(P) { + if (P && P.length > 4) { + for (let i = 0; i < P.length; i+= 2) { + const j = (i + 2) % P.length, k = (i + 4) % P.length; + if (P[i] === P[j] && P[j] === P[k] || P[i + 1] === P[j + 1] && P[j + 1] === P[k + 1]) { + P.splice(j, 2), i -= 2; + } + } + if (!P.length) P = null; + } + return P; + } +} + +const tau$2 = 2 * Math.PI, pow$2 = Math.pow; + +function pointX(p) { + return p[0]; +} + +function pointY(p) { + return p[1]; +} + +// A triangulation is collinear if all its triangles have a non-null area +function collinear(d) { + const {triangles, coords} = d; + for (let i = 0; i < triangles.length; i += 3) { + const a = 2 * triangles[i], + b = 2 * triangles[i + 1], + c = 2 * triangles[i + 2], + cross = (coords[c] - coords[a]) * (coords[b + 1] - coords[a + 1]) + - (coords[b] - coords[a]) * (coords[c + 1] - coords[a + 1]); + if (cross > 1e-10) return false; + } + return true; +} + +function jitter(x, y, r) { + return [x + Math.sin(x + y) * r, y + Math.cos(x - y) * r]; +} + +class Delaunay { + static from(points, fx = pointX, fy = pointY, that) { + return new Delaunay("length" in points + ? flatArray(points, fx, fy, that) + : Float64Array.from(flatIterable(points, fx, fy, that))); + } + constructor(points) { + this._delaunator = new Delaunator(points); + this.inedges = new Int32Array(points.length / 2); + this._hullIndex = new Int32Array(points.length / 2); + this.points = this._delaunator.coords; + this._init(); + } + update() { + this._delaunator.update(); + this._init(); + return this; + } + _init() { + const d = this._delaunator, points = this.points; + + // check for collinear + if (d.hull && d.hull.length > 2 && collinear(d)) { + this.collinear = Int32Array.from({length: points.length/2}, (_,i) => i) + .sort((i, j) => points[2 * i] - points[2 * j] || points[2 * i + 1] - points[2 * j + 1]); // for exact neighbors + const e = this.collinear[0], f = this.collinear[this.collinear.length - 1], + bounds = [ points[2 * e], points[2 * e + 1], points[2 * f], points[2 * f + 1] ], + r = 1e-8 * Math.hypot(bounds[3] - bounds[1], bounds[2] - bounds[0]); + for (let i = 0, n = points.length / 2; i < n; ++i) { + const p = jitter(points[2 * i], points[2 * i + 1], r); + points[2 * i] = p[0]; + points[2 * i + 1] = p[1]; + } + this._delaunator = new Delaunator(points); + } else { + delete this.collinear; + } + + const halfedges = this.halfedges = this._delaunator.halfedges; + const hull = this.hull = this._delaunator.hull; + const triangles = this.triangles = this._delaunator.triangles; + const inedges = this.inedges.fill(-1); + const hullIndex = this._hullIndex.fill(-1); + + // Compute an index from each point to an (arbitrary) incoming halfedge + // Used to give the first neighbor of each point; for this reason, + // on the hull we give priority to exterior halfedges + for (let e = 0, n = halfedges.length; e < n; ++e) { + const p = triangles[e % 3 === 2 ? e - 2 : e + 1]; + if (halfedges[e] === -1 || inedges[p] === -1) inedges[p] = e; + } + for (let i = 0, n = hull.length; i < n; ++i) { + hullIndex[hull[i]] = i; + } + + // degenerate case: 1 or 2 (distinct) points + if (hull.length <= 2 && hull.length > 0) { + this.triangles = new Int32Array(3).fill(-1); + this.halfedges = new Int32Array(3).fill(-1); + this.triangles[0] = hull[0]; + inedges[hull[0]] = 1; + if (hull.length === 2) { + inedges[hull[1]] = 0; + this.triangles[1] = hull[1]; + this.triangles[2] = hull[1]; + } + } + } + voronoi(bounds) { + return new Voronoi(this, bounds); + } + *neighbors(i) { + const {inedges, hull, _hullIndex, halfedges, triangles, collinear} = this; + + // degenerate case with several collinear points + if (collinear) { + const l = collinear.indexOf(i); + if (l > 0) yield collinear[l - 1]; + if (l < collinear.length - 1) yield collinear[l + 1]; + return; + } + + const e0 = inedges[i]; + if (e0 === -1) return; // coincident point + let e = e0, p0 = -1; + do { + yield p0 = triangles[e]; + e = e % 3 === 2 ? e - 2 : e + 1; + if (triangles[e] !== i) return; // bad triangulation + e = halfedges[e]; + if (e === -1) { + const p = hull[(_hullIndex[i] + 1) % hull.length]; + if (p !== p0) yield p; + return; + } + } while (e !== e0); + } + find(x, y, i = 0) { + if ((x = +x, x !== x) || (y = +y, y !== y)) return -1; + const i0 = i; + let c; + while ((c = this._step(i, x, y)) >= 0 && c !== i && c !== i0) i = c; + return c; + } + _step(i, x, y) { + const {inedges, hull, _hullIndex, halfedges, triangles, points} = this; + if (inedges[i] === -1 || !points.length) return (i + 1) % (points.length >> 1); + let c = i; + let dc = pow$2(x - points[i * 2], 2) + pow$2(y - points[i * 2 + 1], 2); + const e0 = inedges[i]; + let e = e0; + do { + let t = triangles[e]; + const dt = pow$2(x - points[t * 2], 2) + pow$2(y - points[t * 2 + 1], 2); + if (dt < dc) dc = dt, c = t; + e = e % 3 === 2 ? e - 2 : e + 1; + if (triangles[e] !== i) break; // bad triangulation + e = halfedges[e]; + if (e === -1) { + e = hull[(_hullIndex[i] + 1) % hull.length]; + if (e !== t) { + if (pow$2(x - points[e * 2], 2) + pow$2(y - points[e * 2 + 1], 2) < dc) return e; + } + break; + } + } while (e !== e0); + return c; + } + render(context) { + const buffer = context == null ? context = new Path : undefined; + const {points, halfedges, triangles} = this; + for (let i = 0, n = halfedges.length; i < n; ++i) { + const j = halfedges[i]; + if (j < i) continue; + const ti = triangles[i] * 2; + const tj = triangles[j] * 2; + context.moveTo(points[ti], points[ti + 1]); + context.lineTo(points[tj], points[tj + 1]); + } + this.renderHull(context); + return buffer && buffer.value(); + } + renderPoints(context, r) { + if (r === undefined && (!context || typeof context.moveTo !== "function")) r = context, context = null; + r = r == undefined ? 2 : +r; + const buffer = context == null ? context = new Path : undefined; + const {points} = this; + for (let i = 0, n = points.length; i < n; i += 2) { + const x = points[i], y = points[i + 1]; + context.moveTo(x + r, y); + context.arc(x, y, r, 0, tau$2); + } + return buffer && buffer.value(); + } + renderHull(context) { + const buffer = context == null ? context = new Path : undefined; + const {hull, points} = this; + const h = hull[0] * 2, n = hull.length; + context.moveTo(points[h], points[h + 1]); + for (let i = 1; i < n; ++i) { + const h = 2 * hull[i]; + context.lineTo(points[h], points[h + 1]); + } + context.closePath(); + return buffer && buffer.value(); + } + hullPolygon() { + const polygon = new Polygon; + this.renderHull(polygon); + return polygon.value(); + } + renderTriangle(i, context) { + const buffer = context == null ? context = new Path : undefined; + const {points, triangles} = this; + const t0 = triangles[i *= 3] * 2; + const t1 = triangles[i + 1] * 2; + const t2 = triangles[i + 2] * 2; + context.moveTo(points[t0], points[t0 + 1]); + context.lineTo(points[t1], points[t1 + 1]); + context.lineTo(points[t2], points[t2 + 1]); + context.closePath(); + return buffer && buffer.value(); + } + *trianglePolygons() { + const {triangles} = this; + for (let i = 0, n = triangles.length / 3; i < n; ++i) { + yield this.trianglePolygon(i); + } + } + trianglePolygon(i) { + const polygon = new Polygon; + this.renderTriangle(i, polygon); + return polygon.value(); + } +} + +function flatArray(points, fx, fy, that) { + const n = points.length; + const array = new Float64Array(n * 2); + for (let i = 0; i < n; ++i) { + const p = points[i]; + array[i * 2] = fx.call(that, p, i, points); + array[i * 2 + 1] = fy.call(that, p, i, points); + } + return array; +} + +function* flatIterable(points, fx, fy, that) { + let i = 0; + for (const p of points) { + yield fx.call(that, p, i, points); + yield fy.call(that, p, i, points); + ++i; + } +} + +var EOL = {}, + EOF = {}, + QUOTE = 34, + NEWLINE = 10, + RETURN = 13; + +function objectConverter(columns) { + return new Function("d", "return {" + columns.map(function(name, i) { + return JSON.stringify(name) + ": d[" + i + "] || \"\""; + }).join(",") + "}"); +} + +function customConverter(columns, f) { + var object = objectConverter(columns); + return function(row, i) { + return f(object(row), i, columns); + }; +} + +// Compute unique columns in order of discovery. +function inferColumns(rows) { + var columnSet = Object.create(null), + columns = []; + + rows.forEach(function(row) { + for (var column in row) { + if (!(column in columnSet)) { + columns.push(columnSet[column] = column); + } + } + }); + + return columns; +} + +function pad$1(value, width) { + var s = value + "", length = s.length; + return length < width ? new Array(width - length + 1).join(0) + s : s; +} + +function formatYear$1(year) { + return year < 0 ? "-" + pad$1(-year, 6) + : year > 9999 ? "+" + pad$1(year, 6) + : pad$1(year, 4); +} + +function formatDate(date) { + var hours = date.getUTCHours(), + minutes = date.getUTCMinutes(), + seconds = date.getUTCSeconds(), + milliseconds = date.getUTCMilliseconds(); + return isNaN(date) ? "Invalid Date" + : formatYear$1(date.getUTCFullYear()) + "-" + pad$1(date.getUTCMonth() + 1, 2) + "-" + pad$1(date.getUTCDate(), 2) + + (milliseconds ? "T" + pad$1(hours, 2) + ":" + pad$1(minutes, 2) + ":" + pad$1(seconds, 2) + "." + pad$1(milliseconds, 3) + "Z" + : seconds ? "T" + pad$1(hours, 2) + ":" + pad$1(minutes, 2) + ":" + pad$1(seconds, 2) + "Z" + : minutes || hours ? "T" + pad$1(hours, 2) + ":" + pad$1(minutes, 2) + "Z" + : ""); +} + +function dsvFormat(delimiter) { + var reFormat = new RegExp("[\"" + delimiter + "\n\r]"), + DELIMITER = delimiter.charCodeAt(0); + + function parse(text, f) { + var convert, columns, rows = parseRows(text, function(row, i) { + if (convert) return convert(row, i - 1); + columns = row, convert = f ? customConverter(row, f) : objectConverter(row); + }); + rows.columns = columns || []; + return rows; + } + + function parseRows(text, f) { + var rows = [], // output rows + N = text.length, + I = 0, // current character index + n = 0, // current line number + t, // current token + eof = N <= 0, // current token followed by EOF? + eol = false; // current token followed by EOL? + + // Strip the trailing newline. + if (text.charCodeAt(N - 1) === NEWLINE) --N; + if (text.charCodeAt(N - 1) === RETURN) --N; + + function token() { + if (eof) return EOF; + if (eol) return eol = false, EOL; + + // Unescape quotes. + var i, j = I, c; + if (text.charCodeAt(j) === QUOTE) { + while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE); + if ((i = I) >= N) eof = true; + else if ((c = text.charCodeAt(I++)) === NEWLINE) eol = true; + else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; } + return text.slice(j + 1, i - 1).replace(/""/g, "\""); + } + + // Find next delimiter or newline. + while (I < N) { + if ((c = text.charCodeAt(i = I++)) === NEWLINE) eol = true; + else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; } + else if (c !== DELIMITER) continue; + return text.slice(j, i); + } + + // Return last token before EOF. + return eof = true, text.slice(j, N); + } + + while ((t = token()) !== EOF) { + var row = []; + while (t !== EOL && t !== EOF) row.push(t), t = token(); + if (f && (row = f(row, n++)) == null) continue; + rows.push(row); + } + + return rows; + } + + function preformatBody(rows, columns) { + return rows.map(function(row) { + return columns.map(function(column) { + return formatValue(row[column]); + }).join(delimiter); + }); + } + + function format(rows, columns) { + if (columns == null) columns = inferColumns(rows); + return [columns.map(formatValue).join(delimiter)].concat(preformatBody(rows, columns)).join("\n"); + } + + function formatBody(rows, columns) { + if (columns == null) columns = inferColumns(rows); + return preformatBody(rows, columns).join("\n"); + } + + function formatRows(rows) { + return rows.map(formatRow).join("\n"); + } + + function formatRow(row) { + return row.map(formatValue).join(delimiter); + } + + function formatValue(value) { + return value == null ? "" + : value instanceof Date ? formatDate(value) + : reFormat.test(value += "") ? "\"" + value.replace(/"/g, "\"\"") + "\"" + : value; + } + + return { + parse: parse, + parseRows: parseRows, + format: format, + formatBody: formatBody, + formatRows: formatRows, + formatRow: formatRow, + formatValue: formatValue + }; +} + +var csv$1 = dsvFormat(","); + +var csvParse = csv$1.parse; +var csvParseRows = csv$1.parseRows; +var csvFormat = csv$1.format; +var csvFormatBody = csv$1.formatBody; +var csvFormatRows = csv$1.formatRows; +var csvFormatRow = csv$1.formatRow; +var csvFormatValue = csv$1.formatValue; + +var tsv$1 = dsvFormat("\t"); + +var tsvParse = tsv$1.parse; +var tsvParseRows = tsv$1.parseRows; +var tsvFormat = tsv$1.format; +var tsvFormatBody = tsv$1.formatBody; +var tsvFormatRows = tsv$1.formatRows; +var tsvFormatRow = tsv$1.formatRow; +var tsvFormatValue = tsv$1.formatValue; + +function autoType(object) { + for (var key in object) { + var value = object[key].trim(), number, m; + if (!value) value = null; + else if (value === "true") value = true; + else if (value === "false") value = false; + else if (value === "NaN") value = NaN; + else if (!isNaN(number = +value)) value = number; + else if (m = value.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/)) { + if (fixtz && !!m[4] && !m[7]) value = value.replace(/-/g, "/").replace(/T/, " "); + value = new Date(value); + } + else continue; + object[key] = value; + } + return object; +} + +// https://github.com/d3/d3-dsv/issues/45 +const fixtz = new Date("2019-01-01T00:00").getHours() || new Date("2019-07-01T00:00").getHours(); + +function responseBlob(response) { + if (!response.ok) throw new Error(response.status + " " + response.statusText); + return response.blob(); +} + +function blob(input, init) { + return fetch(input, init).then(responseBlob); +} + +function responseArrayBuffer(response) { + if (!response.ok) throw new Error(response.status + " " + response.statusText); + return response.arrayBuffer(); +} + +function buffer(input, init) { + return fetch(input, init).then(responseArrayBuffer); +} + +function responseText(response) { + if (!response.ok) throw new Error(response.status + " " + response.statusText); + return response.text(); +} + +function text(input, init) { + return fetch(input, init).then(responseText); +} + +function dsvParse(parse) { + return function(input, init, row) { + if (arguments.length === 2 && typeof init === "function") row = init, init = undefined; + return text(input, init).then(function(response) { + return parse(response, row); + }); + }; +} + +function dsv(delimiter, input, init, row) { + if (arguments.length === 3 && typeof init === "function") row = init, init = undefined; + var format = dsvFormat(delimiter); + return text(input, init).then(function(response) { + return format.parse(response, row); + }); +} + +var csv = dsvParse(csvParse); +var tsv = dsvParse(tsvParse); + +function image(input, init) { + return new Promise(function(resolve, reject) { + var image = new Image; + for (var key in init) image[key] = init[key]; + image.onerror = reject; + image.onload = function() { resolve(image); }; + image.src = input; + }); +} + +function responseJson(response) { + if (!response.ok) throw new Error(response.status + " " + response.statusText); + if (response.status === 204 || response.status === 205) return; + return response.json(); +} + +function json(input, init) { + return fetch(input, init).then(responseJson); +} + +function parser(type) { + return (input, init) => text(input, init) + .then(text => (new DOMParser).parseFromString(text, type)); +} + +var xml = parser("application/xml"); + +var html = parser("text/html"); + +var svg = parser("image/svg+xml"); + +function center(x, y) { + var nodes, strength = 1; + + if (x == null) x = 0; + if (y == null) y = 0; + + function force() { + var i, + n = nodes.length, + node, + sx = 0, + sy = 0; + + for (i = 0; i < n; ++i) { + node = nodes[i], sx += node.x, sy += node.y; + } + + for (sx = (sx / n - x) * strength, sy = (sy / n - y) * strength, i = 0; i < n; ++i) { + node = nodes[i], node.x -= sx, node.y -= sy; + } + } + + force.initialize = function(_) { + nodes = _; + }; + + force.x = function(_) { + return arguments.length ? (x = +_, force) : x; + }; + + force.y = function(_) { + return arguments.length ? (y = +_, force) : y; + }; + + force.strength = function(_) { + return arguments.length ? (strength = +_, force) : strength; + }; + + return force; +} + +function tree_add(d) { + const x = +this._x.call(null, d), + y = +this._y.call(null, d); + return add(this.cover(x, y), x, y, d); +} + +function add(tree, x, y, d) { + if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points + + var parent, + node = tree._root, + leaf = {data: d}, + x0 = tree._x0, + y0 = tree._y0, + x1 = tree._x1, + y1 = tree._y1, + xm, + ym, + xp, + yp, + right, + bottom, + i, + j; + + // If the tree is empty, initialize the root as a leaf. + if (!node) return tree._root = leaf, tree; + + // Find the existing leaf for the new point, or add it. + while (node.length) { + if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; + if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; + if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree; + } + + // Is the new point is exactly coincident with the existing point? + xp = +tree._x.call(null, node.data); + yp = +tree._y.call(null, node.data); + if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree; + + // Otherwise, split the leaf node until the old and new point are separated. + do { + parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4); + if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; + if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; + } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm))); + return parent[j] = node, parent[i] = leaf, tree; +} + +function addAll(data) { + var d, i, n = data.length, + x, + y, + xz = new Array(n), + yz = new Array(n), + x0 = Infinity, + y0 = Infinity, + x1 = -Infinity, + y1 = -Infinity; + + // Compute the points and their extent. + for (i = 0; i < n; ++i) { + if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue; + xz[i] = x; + yz[i] = y; + if (x < x0) x0 = x; + if (x > x1) x1 = x; + if (y < y0) y0 = y; + if (y > y1) y1 = y; + } + + // If there were no (valid) points, abort. + if (x0 > x1 || y0 > y1) return this; + + // Expand the tree to cover the new points. + this.cover(x0, y0).cover(x1, y1); + + // Add the new points. + for (i = 0; i < n; ++i) { + add(this, xz[i], yz[i], data[i]); + } + + return this; +} + +function tree_cover(x, y) { + if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points + + var x0 = this._x0, + y0 = this._y0, + x1 = this._x1, + y1 = this._y1; + + // If the quadtree has no extent, initialize them. + // Integer extent are necessary so that if we later double the extent, + // the existing quadrant boundaries don’t change due to floating point error! + if (isNaN(x0)) { + x1 = (x0 = Math.floor(x)) + 1; + y1 = (y0 = Math.floor(y)) + 1; + } + + // Otherwise, double repeatedly to cover. + else { + var z = x1 - x0 || 1, + node = this._root, + parent, + i; + + while (x0 > x || x >= x1 || y0 > y || y >= y1) { + i = (y < y0) << 1 | (x < x0); + parent = new Array(4), parent[i] = node, node = parent, z *= 2; + switch (i) { + case 0: x1 = x0 + z, y1 = y0 + z; break; + case 1: x0 = x1 - z, y1 = y0 + z; break; + case 2: x1 = x0 + z, y0 = y1 - z; break; + case 3: x0 = x1 - z, y0 = y1 - z; break; + } + } + + if (this._root && this._root.length) this._root = node; + } + + this._x0 = x0; + this._y0 = y0; + this._x1 = x1; + this._y1 = y1; + return this; +} + +function tree_data() { + var data = []; + this.visit(function(node) { + if (!node.length) do data.push(node.data); while (node = node.next) + }); + return data; +} + +function tree_extent(_) { + return arguments.length + ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) + : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]]; +} + +function Quad(node, x0, y0, x1, y1) { + this.node = node; + this.x0 = x0; + this.y0 = y0; + this.x1 = x1; + this.y1 = y1; +} + +function tree_find(x, y, radius) { + var data, + x0 = this._x0, + y0 = this._y0, + x1, + y1, + x2, + y2, + x3 = this._x1, + y3 = this._y1, + quads = [], + node = this._root, + q, + i; + + if (node) quads.push(new Quad(node, x0, y0, x3, y3)); + if (radius == null) radius = Infinity; + else { + x0 = x - radius, y0 = y - radius; + x3 = x + radius, y3 = y + radius; + radius *= radius; + } + + while (q = quads.pop()) { + + // Stop searching if this quadrant can’t contain a closer node. + if (!(node = q.node) + || (x1 = q.x0) > x3 + || (y1 = q.y0) > y3 + || (x2 = q.x1) < x0 + || (y2 = q.y1) < y0) continue; + + // Bisect the current quadrant. + if (node.length) { + var xm = (x1 + x2) / 2, + ym = (y1 + y2) / 2; + + quads.push( + new Quad(node[3], xm, ym, x2, y2), + new Quad(node[2], x1, ym, xm, y2), + new Quad(node[1], xm, y1, x2, ym), + new Quad(node[0], x1, y1, xm, ym) + ); + + // Visit the closest quadrant first. + if (i = (y >= ym) << 1 | (x >= xm)) { + q = quads[quads.length - 1]; + quads[quads.length - 1] = quads[quads.length - 1 - i]; + quads[quads.length - 1 - i] = q; + } + } + + // Visit this point. (Visiting coincident points isn’t necessary!) + else { + var dx = x - +this._x.call(null, node.data), + dy = y - +this._y.call(null, node.data), + d2 = dx * dx + dy * dy; + if (d2 < radius) { + var d = Math.sqrt(radius = d2); + x0 = x - d, y0 = y - d; + x3 = x + d, y3 = y + d; + data = node.data; + } + } + } + + return data; +} + +function tree_remove(d) { + if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points + + var parent, + node = this._root, + retainer, + previous, + next, + x0 = this._x0, + y0 = this._y0, + x1 = this._x1, + y1 = this._y1, + x, + y, + xm, + ym, + right, + bottom, + i, + j; + + // If the tree is empty, initialize the root as a leaf. + if (!node) return this; + + // Find the leaf node for the point. + // While descending, also retain the deepest parent with a non-removed sibling. + if (node.length) while (true) { + if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; + if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; + if (!(parent = node, node = node[i = bottom << 1 | right])) return this; + if (!node.length) break; + if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i; + } + + // Find the point to remove. + while (node.data !== d) if (!(previous = node, node = node.next)) return this; + if (next = node.next) delete node.next; + + // If there are multiple coincident points, remove just the point. + if (previous) return (next ? previous.next = next : delete previous.next), this; + + // If this is the root point, remove it. + if (!parent) return this._root = next, this; + + // Remove this leaf. + next ? parent[i] = next : delete parent[i]; + + // If the parent now contains exactly one leaf, collapse superfluous parents. + if ((node = parent[0] || parent[1] || parent[2] || parent[3]) + && node === (parent[3] || parent[2] || parent[1] || parent[0]) + && !node.length) { + if (retainer) retainer[j] = node; + else this._root = node; + } + + return this; +} + +function removeAll(data) { + for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]); + return this; +} + +function tree_root() { + return this._root; +} + +function tree_size() { + var size = 0; + this.visit(function(node) { + if (!node.length) do ++size; while (node = node.next) + }); + return size; +} + +function tree_visit(callback) { + var quads = [], q, node = this._root, child, x0, y0, x1, y1; + if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1)); + while (q = quads.pop()) { + if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) { + var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; + if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); + if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); + if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); + if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); + } + } + return this; +} + +function tree_visitAfter(callback) { + var quads = [], next = [], q; + if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1)); + while (q = quads.pop()) { + var node = q.node; + if (node.length) { + var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; + if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); + if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); + if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); + if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); + } + next.push(q); + } + while (q = next.pop()) { + callback(q.node, q.x0, q.y0, q.x1, q.y1); + } + return this; +} + +function defaultX(d) { + return d[0]; +} + +function tree_x(_) { + return arguments.length ? (this._x = _, this) : this._x; +} + +function defaultY(d) { + return d[1]; +} + +function tree_y(_) { + return arguments.length ? (this._y = _, this) : this._y; +} + +function quadtree(nodes, x, y) { + var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN); + return nodes == null ? tree : tree.addAll(nodes); +} + +function Quadtree(x, y, x0, y0, x1, y1) { + this._x = x; + this._y = y; + this._x0 = x0; + this._y0 = y0; + this._x1 = x1; + this._y1 = y1; + this._root = undefined; +} + +function leaf_copy(leaf) { + var copy = {data: leaf.data}, next = copy; + while (leaf = leaf.next) next = next.next = {data: leaf.data}; + return copy; +} + +var treeProto = quadtree.prototype = Quadtree.prototype; + +treeProto.copy = function() { + var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), + node = this._root, + nodes, + child; + + if (!node) return copy; + + if (!node.length) return copy._root = leaf_copy(node), copy; + + nodes = [{source: node, target: copy._root = new Array(4)}]; + while (node = nodes.pop()) { + for (var i = 0; i < 4; ++i) { + if (child = node.source[i]) { + if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)}); + else node.target[i] = leaf_copy(child); + } + } + } + + return copy; +}; + +treeProto.add = tree_add; +treeProto.addAll = addAll; +treeProto.cover = tree_cover; +treeProto.data = tree_data; +treeProto.extent = tree_extent; +treeProto.find = tree_find; +treeProto.remove = tree_remove; +treeProto.removeAll = removeAll; +treeProto.root = tree_root; +treeProto.size = tree_size; +treeProto.visit = tree_visit; +treeProto.visitAfter = tree_visitAfter; +treeProto.x = tree_x; +treeProto.y = tree_y; + +function constant$4(x) { + return function() { + return x; + }; +} + +function jiggle(random) { + return (random() - 0.5) * 1e-6; +} + +function x$3(d) { + return d.x + d.vx; +} + +function y$3(d) { + return d.y + d.vy; +} + +function collide(radius) { + var nodes, + radii, + random, + strength = 1, + iterations = 1; + + if (typeof radius !== "function") radius = constant$4(radius == null ? 1 : +radius); + + function force() { + var i, n = nodes.length, + tree, + node, + xi, + yi, + ri, + ri2; + + for (var k = 0; k < iterations; ++k) { + tree = quadtree(nodes, x$3, y$3).visitAfter(prepare); + for (i = 0; i < n; ++i) { + node = nodes[i]; + ri = radii[node.index], ri2 = ri * ri; + xi = node.x + node.vx; + yi = node.y + node.vy; + tree.visit(apply); + } + } + + function apply(quad, x0, y0, x1, y1) { + var data = quad.data, rj = quad.r, r = ri + rj; + if (data) { + if (data.index > node.index) { + var x = xi - data.x - data.vx, + y = yi - data.y - data.vy, + l = x * x + y * y; + if (l < r * r) { + if (x === 0) x = jiggle(random), l += x * x; + if (y === 0) y = jiggle(random), l += y * y; + l = (r - (l = Math.sqrt(l))) / l * strength; + node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj)); + node.vy += (y *= l) * r; + data.vx -= x * (r = 1 - r); + data.vy -= y * r; + } + } + return; + } + return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r; + } + } + + function prepare(quad) { + if (quad.data) return quad.r = radii[quad.data.index]; + for (var i = quad.r = 0; i < 4; ++i) { + if (quad[i] && quad[i].r > quad.r) { + quad.r = quad[i].r; + } + } + } + + function initialize() { + if (!nodes) return; + var i, n = nodes.length, node; + radii = new Array(n); + for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes); + } + + force.initialize = function(_nodes, _random) { + nodes = _nodes; + random = _random; + initialize(); + }; + + force.iterations = function(_) { + return arguments.length ? (iterations = +_, force) : iterations; + }; + + force.strength = function(_) { + return arguments.length ? (strength = +_, force) : strength; + }; + + force.radius = function(_) { + return arguments.length ? (radius = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : radius; + }; + + return force; +} + +function index$3(d) { + return d.index; +} + +function find(nodeById, nodeId) { + var node = nodeById.get(nodeId); + if (!node) throw new Error("node not found: " + nodeId); + return node; +} + +function link$2(links) { + var id = index$3, + strength = defaultStrength, + strengths, + distance = constant$4(30), + distances, + nodes, + count, + bias, + random, + iterations = 1; + + if (links == null) links = []; + + function defaultStrength(link) { + return 1 / Math.min(count[link.source.index], count[link.target.index]); + } + + function force(alpha) { + for (var k = 0, n = links.length; k < iterations; ++k) { + for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) { + link = links[i], source = link.source, target = link.target; + x = target.x + target.vx - source.x - source.vx || jiggle(random); + y = target.y + target.vy - source.y - source.vy || jiggle(random); + l = Math.sqrt(x * x + y * y); + l = (l - distances[i]) / l * alpha * strengths[i]; + x *= l, y *= l; + target.vx -= x * (b = bias[i]); + target.vy -= y * b; + source.vx += x * (b = 1 - b); + source.vy += y * b; + } + } + } + + function initialize() { + if (!nodes) return; + + var i, + n = nodes.length, + m = links.length, + nodeById = new Map(nodes.map((d, i) => [id(d, i, nodes), d])), + link; + + for (i = 0, count = new Array(n); i < m; ++i) { + link = links[i], link.index = i; + if (typeof link.source !== "object") link.source = find(nodeById, link.source); + if (typeof link.target !== "object") link.target = find(nodeById, link.target); + count[link.source.index] = (count[link.source.index] || 0) + 1; + count[link.target.index] = (count[link.target.index] || 0) + 1; + } + + for (i = 0, bias = new Array(m); i < m; ++i) { + link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]); + } + + strengths = new Array(m), initializeStrength(); + distances = new Array(m), initializeDistance(); + } + + function initializeStrength() { + if (!nodes) return; + + for (var i = 0, n = links.length; i < n; ++i) { + strengths[i] = +strength(links[i], i, links); + } + } + + function initializeDistance() { + if (!nodes) return; + + for (var i = 0, n = links.length; i < n; ++i) { + distances[i] = +distance(links[i], i, links); + } + } + + force.initialize = function(_nodes, _random) { + nodes = _nodes; + random = _random; + initialize(); + }; + + force.links = function(_) { + return arguments.length ? (links = _, initialize(), force) : links; + }; + + force.id = function(_) { + return arguments.length ? (id = _, force) : id; + }; + + force.iterations = function(_) { + return arguments.length ? (iterations = +_, force) : iterations; + }; + + force.strength = function(_) { + return arguments.length ? (strength = typeof _ === "function" ? _ : constant$4(+_), initializeStrength(), force) : strength; + }; + + force.distance = function(_) { + return arguments.length ? (distance = typeof _ === "function" ? _ : constant$4(+_), initializeDistance(), force) : distance; + }; + + return force; +} + +// https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use +const a$2 = 1664525; +const c$4 = 1013904223; +const m$1 = 4294967296; // 2^32 + +function lcg$2() { + let s = 1; + return () => (s = (a$2 * s + c$4) % m$1) / m$1; +} + +function x$2(d) { + return d.x; +} + +function y$2(d) { + return d.y; +} + +var initialRadius = 10, + initialAngle = Math.PI * (3 - Math.sqrt(5)); + +function simulation(nodes) { + var simulation, + alpha = 1, + alphaMin = 0.001, + alphaDecay = 1 - Math.pow(alphaMin, 1 / 300), + alphaTarget = 0, + velocityDecay = 0.6, + forces = new Map(), + stepper = timer(step), + event = dispatch("tick", "end"), + random = lcg$2(); + + if (nodes == null) nodes = []; + + function step() { + tick(); + event.call("tick", simulation); + if (alpha < alphaMin) { + stepper.stop(); + event.call("end", simulation); + } + } + + function tick(iterations) { + var i, n = nodes.length, node; + + if (iterations === undefined) iterations = 1; + + for (var k = 0; k < iterations; ++k) { + alpha += (alphaTarget - alpha) * alphaDecay; + + forces.forEach(function(force) { + force(alpha); + }); + + for (i = 0; i < n; ++i) { + node = nodes[i]; + if (node.fx == null) node.x += node.vx *= velocityDecay; + else node.x = node.fx, node.vx = 0; + if (node.fy == null) node.y += node.vy *= velocityDecay; + else node.y = node.fy, node.vy = 0; + } + } + + return simulation; + } + + function initializeNodes() { + for (var i = 0, n = nodes.length, node; i < n; ++i) { + node = nodes[i], node.index = i; + if (node.fx != null) node.x = node.fx; + if (node.fy != null) node.y = node.fy; + if (isNaN(node.x) || isNaN(node.y)) { + var radius = initialRadius * Math.sqrt(0.5 + i), angle = i * initialAngle; + node.x = radius * Math.cos(angle); + node.y = radius * Math.sin(angle); + } + if (isNaN(node.vx) || isNaN(node.vy)) { + node.vx = node.vy = 0; + } + } + } + + function initializeForce(force) { + if (force.initialize) force.initialize(nodes, random); + return force; + } + + initializeNodes(); + + return simulation = { + tick: tick, + + restart: function() { + return stepper.restart(step), simulation; + }, + + stop: function() { + return stepper.stop(), simulation; + }, + + nodes: function(_) { + return arguments.length ? (nodes = _, initializeNodes(), forces.forEach(initializeForce), simulation) : nodes; + }, + + alpha: function(_) { + return arguments.length ? (alpha = +_, simulation) : alpha; + }, + + alphaMin: function(_) { + return arguments.length ? (alphaMin = +_, simulation) : alphaMin; + }, + + alphaDecay: function(_) { + return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay; + }, + + alphaTarget: function(_) { + return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget; + }, + + velocityDecay: function(_) { + return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay; + }, + + randomSource: function(_) { + return arguments.length ? (random = _, forces.forEach(initializeForce), simulation) : random; + }, + + force: function(name, _) { + return arguments.length > 1 ? ((_ == null ? forces.delete(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name); + }, + + find: function(x, y, radius) { + var i = 0, + n = nodes.length, + dx, + dy, + d2, + node, + closest; + + if (radius == null) radius = Infinity; + else radius *= radius; + + for (i = 0; i < n; ++i) { + node = nodes[i]; + dx = x - node.x; + dy = y - node.y; + d2 = dx * dx + dy * dy; + if (d2 < radius) closest = node, radius = d2; + } + + return closest; + }, + + on: function(name, _) { + return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name); + } + }; +} + +function manyBody() { + var nodes, + node, + random, + alpha, + strength = constant$4(-30), + strengths, + distanceMin2 = 1, + distanceMax2 = Infinity, + theta2 = 0.81; + + function force(_) { + var i, n = nodes.length, tree = quadtree(nodes, x$2, y$2).visitAfter(accumulate); + for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply); + } + + function initialize() { + if (!nodes) return; + var i, n = nodes.length, node; + strengths = new Array(n); + for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes); + } + + function accumulate(quad) { + var strength = 0, q, c, weight = 0, x, y, i; + + // For internal nodes, accumulate forces from child quadrants. + if (quad.length) { + for (x = y = i = 0; i < 4; ++i) { + if ((q = quad[i]) && (c = Math.abs(q.value))) { + strength += q.value, weight += c, x += c * q.x, y += c * q.y; + } + } + quad.x = x / weight; + quad.y = y / weight; + } + + // For leaf nodes, accumulate forces from coincident quadrants. + else { + q = quad; + q.x = q.data.x; + q.y = q.data.y; + do strength += strengths[q.data.index]; + while (q = q.next); + } + + quad.value = strength; + } + + function apply(quad, x1, _, x2) { + if (!quad.value) return true; + + var x = quad.x - node.x, + y = quad.y - node.y, + w = x2 - x1, + l = x * x + y * y; + + // Apply the Barnes-Hut approximation if possible. + // Limit forces for very close nodes; randomize direction if coincident. + if (w * w / theta2 < l) { + if (l < distanceMax2) { + if (x === 0) x = jiggle(random), l += x * x; + if (y === 0) y = jiggle(random), l += y * y; + if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); + node.vx += x * quad.value * alpha / l; + node.vy += y * quad.value * alpha / l; + } + return true; + } + + // Otherwise, process points directly. + else if (quad.length || l >= distanceMax2) return; + + // Limit forces for very close nodes; randomize direction if coincident. + if (quad.data !== node || quad.next) { + if (x === 0) x = jiggle(random), l += x * x; + if (y === 0) y = jiggle(random), l += y * y; + if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); + } + + do if (quad.data !== node) { + w = strengths[quad.data.index] * alpha / l; + node.vx += x * w; + node.vy += y * w; + } while (quad = quad.next); + } + + force.initialize = function(_nodes, _random) { + nodes = _nodes; + random = _random; + initialize(); + }; + + force.strength = function(_) { + return arguments.length ? (strength = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : strength; + }; + + force.distanceMin = function(_) { + return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2); + }; + + force.distanceMax = function(_) { + return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2); + }; + + force.theta = function(_) { + return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2); + }; + + return force; +} + +function radial$1(radius, x, y) { + var nodes, + strength = constant$4(0.1), + strengths, + radiuses; + + if (typeof radius !== "function") radius = constant$4(+radius); + if (x == null) x = 0; + if (y == null) y = 0; + + function force(alpha) { + for (var i = 0, n = nodes.length; i < n; ++i) { + var node = nodes[i], + dx = node.x - x || 1e-6, + dy = node.y - y || 1e-6, + r = Math.sqrt(dx * dx + dy * dy), + k = (radiuses[i] - r) * strengths[i] * alpha / r; + node.vx += dx * k; + node.vy += dy * k; + } + } + + function initialize() { + if (!nodes) return; + var i, n = nodes.length; + strengths = new Array(n); + radiuses = new Array(n); + for (i = 0; i < n; ++i) { + radiuses[i] = +radius(nodes[i], i, nodes); + strengths[i] = isNaN(radiuses[i]) ? 0 : +strength(nodes[i], i, nodes); + } + } + + force.initialize = function(_) { + nodes = _, initialize(); + }; + + force.strength = function(_) { + return arguments.length ? (strength = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : strength; + }; + + force.radius = function(_) { + return arguments.length ? (radius = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : radius; + }; + + force.x = function(_) { + return arguments.length ? (x = +_, force) : x; + }; + + force.y = function(_) { + return arguments.length ? (y = +_, force) : y; + }; + + return force; +} + +function x$1(x) { + var strength = constant$4(0.1), + nodes, + strengths, + xz; + + if (typeof x !== "function") x = constant$4(x == null ? 0 : +x); + + function force(alpha) { + for (var i = 0, n = nodes.length, node; i < n; ++i) { + node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha; + } + } + + function initialize() { + if (!nodes) return; + var i, n = nodes.length; + strengths = new Array(n); + xz = new Array(n); + for (i = 0; i < n; ++i) { + strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); + } + } + + force.initialize = function(_) { + nodes = _; + initialize(); + }; + + force.strength = function(_) { + return arguments.length ? (strength = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : strength; + }; + + force.x = function(_) { + return arguments.length ? (x = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : x; + }; + + return force; +} + +function y$1(y) { + var strength = constant$4(0.1), + nodes, + strengths, + yz; + + if (typeof y !== "function") y = constant$4(y == null ? 0 : +y); + + function force(alpha) { + for (var i = 0, n = nodes.length, node; i < n; ++i) { + node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha; + } + } + + function initialize() { + if (!nodes) return; + var i, n = nodes.length; + strengths = new Array(n); + yz = new Array(n); + for (i = 0; i < n; ++i) { + strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); + } + } + + force.initialize = function(_) { + nodes = _; + initialize(); + }; + + force.strength = function(_) { + return arguments.length ? (strength = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : strength; + }; + + force.y = function(_) { + return arguments.length ? (y = typeof _ === "function" ? _ : constant$4(+_), initialize(), force) : y; + }; + + return force; +} + +function formatDecimal(x) { + return Math.abs(x = Math.round(x)) >= 1e21 + ? x.toLocaleString("en").replace(/,/g, "") + : x.toString(10); +} + +// Computes the decimal coefficient and exponent of the specified number x with +// significant digits p, where x is positive and p is in [1, 21] or undefined. +// For example, formatDecimalParts(1.23) returns ["123", 0]. +function formatDecimalParts(x, p) { + if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity + var i, coefficient = x.slice(0, i); + + // The string returned by toExponential either has the form \d\.\d+e[-+]\d+ + // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3). + return [ + coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, + +x.slice(i + 1) + ]; +} + +function exponent(x) { + return x = formatDecimalParts(Math.abs(x)), x ? x[1] : NaN; +} + +function formatGroup(grouping, thousands) { + return function(value, width) { + var i = value.length, + t = [], + j = 0, + g = grouping[0], + length = 0; + + while (i > 0 && g > 0) { + if (length + g + 1 > width) g = Math.max(1, width - length); + t.push(value.substring(i -= g, i + g)); + if ((length += g + 1) > width) break; + g = grouping[j = (j + 1) % grouping.length]; + } + + return t.reverse().join(thousands); + }; +} + +function formatNumerals(numerals) { + return function(value) { + return value.replace(/[0-9]/g, function(i) { + return numerals[+i]; + }); + }; +} + +// [[fill]align][sign][symbol][0][width][,][.precision][~][type] +var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i; + +function formatSpecifier(specifier) { + if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier); + var match; + return new FormatSpecifier({ + fill: match[1], + align: match[2], + sign: match[3], + symbol: match[4], + zero: match[5], + width: match[6], + comma: match[7], + precision: match[8] && match[8].slice(1), + trim: match[9], + type: match[10] + }); +} + +formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof + +function FormatSpecifier(specifier) { + this.fill = specifier.fill === undefined ? " " : specifier.fill + ""; + this.align = specifier.align === undefined ? ">" : specifier.align + ""; + this.sign = specifier.sign === undefined ? "-" : specifier.sign + ""; + this.symbol = specifier.symbol === undefined ? "" : specifier.symbol + ""; + this.zero = !!specifier.zero; + this.width = specifier.width === undefined ? undefined : +specifier.width; + this.comma = !!specifier.comma; + this.precision = specifier.precision === undefined ? undefined : +specifier.precision; + this.trim = !!specifier.trim; + this.type = specifier.type === undefined ? "" : specifier.type + ""; +} + +FormatSpecifier.prototype.toString = function() { + return this.fill + + this.align + + this.sign + + this.symbol + + (this.zero ? "0" : "") + + (this.width === undefined ? "" : Math.max(1, this.width | 0)) + + (this.comma ? "," : "") + + (this.precision === undefined ? "" : "." + Math.max(0, this.precision | 0)) + + (this.trim ? "~" : "") + + this.type; +}; + +// Trims insignificant zeros, e.g., replaces 1.2000k with 1.2k. +function formatTrim(s) { + out: for (var n = s.length, i = 1, i0 = -1, i1; i < n; ++i) { + switch (s[i]) { + case ".": i0 = i1 = i; break; + case "0": if (i0 === 0) i0 = i; i1 = i; break; + default: if (!+s[i]) break out; if (i0 > 0) i0 = 0; break; + } + } + return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s; +} + +var prefixExponent; + +function formatPrefixAuto(x, p) { + var d = formatDecimalParts(x, p); + if (!d) return x + ""; + var coefficient = d[0], + exponent = d[1], + i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, + n = coefficient.length; + return i === n ? coefficient + : i > n ? coefficient + new Array(i - n + 1).join("0") + : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) + : "0." + new Array(1 - i).join("0") + formatDecimalParts(x, Math.max(0, p + i - 1))[0]; // less than 1y! +} + +function formatRounded(x, p) { + var d = formatDecimalParts(x, p); + if (!d) return x + ""; + var coefficient = d[0], + exponent = d[1]; + return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient + : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) + : coefficient + new Array(exponent - coefficient.length + 2).join("0"); +} + +var formatTypes = { + "%": (x, p) => (x * 100).toFixed(p), + "b": (x) => Math.round(x).toString(2), + "c": (x) => x + "", + "d": formatDecimal, + "e": (x, p) => x.toExponential(p), + "f": (x, p) => x.toFixed(p), + "g": (x, p) => x.toPrecision(p), + "o": (x) => Math.round(x).toString(8), + "p": (x, p) => formatRounded(x * 100, p), + "r": formatRounded, + "s": formatPrefixAuto, + "X": (x) => Math.round(x).toString(16).toUpperCase(), + "x": (x) => Math.round(x).toString(16) +}; + +function identity$6(x) { + return x; +} + +var map = Array.prototype.map, + prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"]; + +function formatLocale$1(locale) { + var group = locale.grouping === undefined || locale.thousands === undefined ? identity$6 : formatGroup(map.call(locale.grouping, Number), locale.thousands + ""), + currencyPrefix = locale.currency === undefined ? "" : locale.currency[0] + "", + currencySuffix = locale.currency === undefined ? "" : locale.currency[1] + "", + decimal = locale.decimal === undefined ? "." : locale.decimal + "", + numerals = locale.numerals === undefined ? identity$6 : formatNumerals(map.call(locale.numerals, String)), + percent = locale.percent === undefined ? "%" : locale.percent + "", + minus = locale.minus === undefined ? "−" : locale.minus + "", + nan = locale.nan === undefined ? "NaN" : locale.nan + ""; + + function newFormat(specifier) { + specifier = formatSpecifier(specifier); + + var fill = specifier.fill, + align = specifier.align, + sign = specifier.sign, + symbol = specifier.symbol, + zero = specifier.zero, + width = specifier.width, + comma = specifier.comma, + precision = specifier.precision, + trim = specifier.trim, + type = specifier.type; + + // The "n" type is an alias for ",g". + if (type === "n") comma = true, type = "g"; + + // The "" type, and any invalid type, is an alias for ".12~g". + else if (!formatTypes[type]) precision === undefined && (precision = 12), trim = true, type = "g"; + + // If zero fill is specified, padding goes after sign and before digits. + if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "="; + + // Compute the prefix and suffix. + // For SI-prefix, the suffix is lazily computed. + var prefix = symbol === "$" ? currencyPrefix : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", + suffix = symbol === "$" ? currencySuffix : /[%p]/.test(type) ? percent : ""; + + // What format function should we use? + // Is this an integer type? + // Can this type generate exponential notation? + var formatType = formatTypes[type], + maybeSuffix = /[defgprs%]/.test(type); + + // Set the default precision if not specified, + // or clamp the specified precision to the supported range. + // For significant precision, it must be in [1, 21]. + // For fixed precision, it must be in [0, 20]. + precision = precision === undefined ? 6 + : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) + : Math.max(0, Math.min(20, precision)); + + function format(value) { + var valuePrefix = prefix, + valueSuffix = suffix, + i, n, c; + + if (type === "c") { + valueSuffix = formatType(value) + valueSuffix; + value = ""; + } else { + value = +value; + + // Determine the sign. -0 is not less than 0, but 1 / -0 is! + var valueNegative = value < 0 || 1 / value < 0; + + // Perform the initial formatting. + value = isNaN(value) ? nan : formatType(Math.abs(value), precision); + + // Trim insignificant zeros. + if (trim) value = formatTrim(value); + + // If a negative value rounds to zero after formatting, and no explicit positive sign is requested, hide the sign. + if (valueNegative && +value === 0 && sign !== "+") valueNegative = false; + + // Compute the prefix and suffix. + valuePrefix = (valueNegative ? (sign === "(" ? sign : minus) : sign === "-" || sign === "(" ? "" : sign) + valuePrefix; + valueSuffix = (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : ""); + + // Break the formatted value into the integer “value” part that can be + // grouped, and fractional or exponential “suffix” part that is not. + if (maybeSuffix) { + i = -1, n = value.length; + while (++i < n) { + if (c = value.charCodeAt(i), 48 > c || c > 57) { + valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix; + value = value.slice(0, i); + break; + } + } + } + } + + // If the fill character is not "0", grouping is applied before padding. + if (comma && !zero) value = group(value, Infinity); + + // Compute the padding. + var length = valuePrefix.length + value.length + valueSuffix.length, + padding = length < width ? new Array(width - length + 1).join(fill) : ""; + + // If the fill character is "0", grouping is applied after padding. + if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = ""; + + // Reconstruct the final output based on the desired alignment. + switch (align) { + case "<": value = valuePrefix + value + valueSuffix + padding; break; + case "=": value = valuePrefix + padding + value + valueSuffix; break; + case "^": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break; + default: value = padding + valuePrefix + value + valueSuffix; break; + } + + return numerals(value); + } + + format.toString = function() { + return specifier + ""; + }; + + return format; + } + + function formatPrefix(specifier, value) { + var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)), + e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3, + k = Math.pow(10, -e), + prefix = prefixes[8 + e / 3]; + return function(value) { + return f(k * value) + prefix; + }; + } + + return { + format: newFormat, + formatPrefix: formatPrefix + }; +} + +var locale$1; +exports.format = void 0; +exports.formatPrefix = void 0; + +defaultLocale$1({ + thousands: ",", + grouping: [3], + currency: ["$", ""] +}); + +function defaultLocale$1(definition) { + locale$1 = formatLocale$1(definition); + exports.format = locale$1.format; + exports.formatPrefix = locale$1.formatPrefix; + return locale$1; +} + +function precisionFixed(step) { + return Math.max(0, -exponent(Math.abs(step))); +} + +function precisionPrefix(step, value) { + return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step))); +} + +function precisionRound(step, max) { + step = Math.abs(step), max = Math.abs(max) - step; + return Math.max(0, exponent(max) - exponent(step)) + 1; +} + +var epsilon$1 = 1e-6; +var epsilon2 = 1e-12; +var pi$1 = Math.PI; +var halfPi$1 = pi$1 / 2; +var quarterPi = pi$1 / 4; +var tau$1 = pi$1 * 2; + +var degrees = 180 / pi$1; +var radians = pi$1 / 180; + +var abs$1 = Math.abs; +var atan = Math.atan; +var atan2$1 = Math.atan2; +var cos$1 = Math.cos; +var ceil = Math.ceil; +var exp = Math.exp; +var hypot = Math.hypot; +var log$1 = Math.log; +var pow$1 = Math.pow; +var sin$1 = Math.sin; +var sign$1 = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }; +var sqrt$2 = Math.sqrt; +var tan = Math.tan; + +function acos$1(x) { + return x > 1 ? 0 : x < -1 ? pi$1 : Math.acos(x); +} + +function asin$1(x) { + return x > 1 ? halfPi$1 : x < -1 ? -halfPi$1 : Math.asin(x); +} + +function haversin(x) { + return (x = sin$1(x / 2)) * x; +} + +function noop$1() {} + +function streamGeometry(geometry, stream) { + if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) { + streamGeometryType[geometry.type](geometry, stream); + } +} + +var streamObjectType = { + Feature: function(object, stream) { + streamGeometry(object.geometry, stream); + }, + FeatureCollection: function(object, stream) { + var features = object.features, i = -1, n = features.length; + while (++i < n) streamGeometry(features[i].geometry, stream); + } +}; + +var streamGeometryType = { + Sphere: function(object, stream) { + stream.sphere(); + }, + Point: function(object, stream) { + object = object.coordinates; + stream.point(object[0], object[1], object[2]); + }, + MultiPoint: function(object, stream) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]); + }, + LineString: function(object, stream) { + streamLine(object.coordinates, stream, 0); + }, + MultiLineString: function(object, stream) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) streamLine(coordinates[i], stream, 0); + }, + Polygon: function(object, stream) { + streamPolygon(object.coordinates, stream); + }, + MultiPolygon: function(object, stream) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) streamPolygon(coordinates[i], stream); + }, + GeometryCollection: function(object, stream) { + var geometries = object.geometries, i = -1, n = geometries.length; + while (++i < n) streamGeometry(geometries[i], stream); + } +}; + +function streamLine(coordinates, stream, closed) { + var i = -1, n = coordinates.length - closed, coordinate; + stream.lineStart(); + while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]); + stream.lineEnd(); +} + +function streamPolygon(coordinates, stream) { + var i = -1, n = coordinates.length; + stream.polygonStart(); + while (++i < n) streamLine(coordinates[i], stream, 1); + stream.polygonEnd(); +} + +function geoStream(object, stream) { + if (object && streamObjectType.hasOwnProperty(object.type)) { + streamObjectType[object.type](object, stream); + } else { + streamGeometry(object, stream); + } +} + +var areaRingSum$1 = new Adder(); + +// hello? + +var areaSum$1 = new Adder(), + lambda00$2, + phi00$2, + lambda0$2, + cosPhi0$1, + sinPhi0$1; + +var areaStream$1 = { + point: noop$1, + lineStart: noop$1, + lineEnd: noop$1, + polygonStart: function() { + areaRingSum$1 = new Adder(); + areaStream$1.lineStart = areaRingStart$1; + areaStream$1.lineEnd = areaRingEnd$1; + }, + polygonEnd: function() { + var areaRing = +areaRingSum$1; + areaSum$1.add(areaRing < 0 ? tau$1 + areaRing : areaRing); + this.lineStart = this.lineEnd = this.point = noop$1; + }, + sphere: function() { + areaSum$1.add(tau$1); + } +}; + +function areaRingStart$1() { + areaStream$1.point = areaPointFirst$1; +} + +function areaRingEnd$1() { + areaPoint$1(lambda00$2, phi00$2); +} + +function areaPointFirst$1(lambda, phi) { + areaStream$1.point = areaPoint$1; + lambda00$2 = lambda, phi00$2 = phi; + lambda *= radians, phi *= radians; + lambda0$2 = lambda, cosPhi0$1 = cos$1(phi = phi / 2 + quarterPi), sinPhi0$1 = sin$1(phi); +} + +function areaPoint$1(lambda, phi) { + lambda *= radians, phi *= radians; + phi = phi / 2 + quarterPi; // half the angular distance from south pole + + // Spherical excess E for a spherical triangle with vertices: south pole, + // previous point, current point. Uses a formula derived from Cagnoli’s + // theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2). + var dLambda = lambda - lambda0$2, + sdLambda = dLambda >= 0 ? 1 : -1, + adLambda = sdLambda * dLambda, + cosPhi = cos$1(phi), + sinPhi = sin$1(phi), + k = sinPhi0$1 * sinPhi, + u = cosPhi0$1 * cosPhi + k * cos$1(adLambda), + v = k * sdLambda * sin$1(adLambda); + areaRingSum$1.add(atan2$1(v, u)); + + // Advance the previous points. + lambda0$2 = lambda, cosPhi0$1 = cosPhi, sinPhi0$1 = sinPhi; +} + +function area$2(object) { + areaSum$1 = new Adder(); + geoStream(object, areaStream$1); + return areaSum$1 * 2; +} + +function spherical(cartesian) { + return [atan2$1(cartesian[1], cartesian[0]), asin$1(cartesian[2])]; +} + +function cartesian(spherical) { + var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi); + return [cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)]; +} + +function cartesianDot(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} + +function cartesianCross(a, b) { + return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]; +} + +// TODO return a +function cartesianAddInPlace(a, b) { + a[0] += b[0], a[1] += b[1], a[2] += b[2]; +} + +function cartesianScale(vector, k) { + return [vector[0] * k, vector[1] * k, vector[2] * k]; +} + +// TODO return d +function cartesianNormalizeInPlace(d) { + var l = sqrt$2(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]); + d[0] /= l, d[1] /= l, d[2] /= l; +} + +var lambda0$1, phi0, lambda1, phi1, // bounds + lambda2, // previous lambda-coordinate + lambda00$1, phi00$1, // first point + p0, // previous 3D point + deltaSum, + ranges, + range; + +var boundsStream$2 = { + point: boundsPoint$1, + lineStart: boundsLineStart, + lineEnd: boundsLineEnd, + polygonStart: function() { + boundsStream$2.point = boundsRingPoint; + boundsStream$2.lineStart = boundsRingStart; + boundsStream$2.lineEnd = boundsRingEnd; + deltaSum = new Adder(); + areaStream$1.polygonStart(); + }, + polygonEnd: function() { + areaStream$1.polygonEnd(); + boundsStream$2.point = boundsPoint$1; + boundsStream$2.lineStart = boundsLineStart; + boundsStream$2.lineEnd = boundsLineEnd; + if (areaRingSum$1 < 0) lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90); + else if (deltaSum > epsilon$1) phi1 = 90; + else if (deltaSum < -epsilon$1) phi0 = -90; + range[0] = lambda0$1, range[1] = lambda1; + }, + sphere: function() { + lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90); + } +}; + +function boundsPoint$1(lambda, phi) { + ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]); + if (phi < phi0) phi0 = phi; + if (phi > phi1) phi1 = phi; +} + +function linePoint(lambda, phi) { + var p = cartesian([lambda * radians, phi * radians]); + if (p0) { + var normal = cartesianCross(p0, p), + equatorial = [normal[1], -normal[0], 0], + inflection = cartesianCross(equatorial, normal); + cartesianNormalizeInPlace(inflection); + inflection = spherical(inflection); + var delta = lambda - lambda2, + sign = delta > 0 ? 1 : -1, + lambdai = inflection[0] * degrees * sign, + phii, + antimeridian = abs$1(delta) > 180; + if (antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) { + phii = inflection[1] * degrees; + if (phii > phi1) phi1 = phii; + } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) { + phii = -inflection[1] * degrees; + if (phii < phi0) phi0 = phii; + } else { + if (phi < phi0) phi0 = phi; + if (phi > phi1) phi1 = phi; + } + if (antimeridian) { + if (lambda < lambda2) { + if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda; + } else { + if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda; + } + } else { + if (lambda1 >= lambda0$1) { + if (lambda < lambda0$1) lambda0$1 = lambda; + if (lambda > lambda1) lambda1 = lambda; + } else { + if (lambda > lambda2) { + if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda; + } else { + if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda; + } + } + } + } else { + ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]); + } + if (phi < phi0) phi0 = phi; + if (phi > phi1) phi1 = phi; + p0 = p, lambda2 = lambda; +} + +function boundsLineStart() { + boundsStream$2.point = linePoint; +} + +function boundsLineEnd() { + range[0] = lambda0$1, range[1] = lambda1; + boundsStream$2.point = boundsPoint$1; + p0 = null; +} + +function boundsRingPoint(lambda, phi) { + if (p0) { + var delta = lambda - lambda2; + deltaSum.add(abs$1(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta); + } else { + lambda00$1 = lambda, phi00$1 = phi; + } + areaStream$1.point(lambda, phi); + linePoint(lambda, phi); +} + +function boundsRingStart() { + areaStream$1.lineStart(); +} + +function boundsRingEnd() { + boundsRingPoint(lambda00$1, phi00$1); + areaStream$1.lineEnd(); + if (abs$1(deltaSum) > epsilon$1) lambda0$1 = -(lambda1 = 180); + range[0] = lambda0$1, range[1] = lambda1; + p0 = null; +} + +// Finds the left-right distance between two longitudes. +// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want +// the distance between ±180° to be 360°. +function angle(lambda0, lambda1) { + return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1; +} + +function rangeCompare(a, b) { + return a[0] - b[0]; +} + +function rangeContains(range, x) { + return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x; +} + +function bounds(feature) { + var i, n, a, b, merged, deltaMax, delta; + + phi1 = lambda1 = -(lambda0$1 = phi0 = Infinity); + ranges = []; + geoStream(feature, boundsStream$2); + + // First, sort ranges by their minimum longitudes. + if (n = ranges.length) { + ranges.sort(rangeCompare); + + // Then, merge any ranges that overlap. + for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) { + b = ranges[i]; + if (rangeContains(a, b[0]) || rangeContains(a, b[1])) { + if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1]; + if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0]; + } else { + merged.push(a = b); + } + } + + // Finally, find the largest gap between the merged ranges. + // The final bounding box will be the inverse of this gap. + for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) { + b = merged[i]; + if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0$1 = b[0], lambda1 = a[1]; + } + } + + ranges = range = null; + + return lambda0$1 === Infinity || phi0 === Infinity + ? [[NaN, NaN], [NaN, NaN]] + : [[lambda0$1, phi0], [lambda1, phi1]]; +} + +var W0, W1, + X0$1, Y0$1, Z0$1, + X1$1, Y1$1, Z1$1, + X2$1, Y2$1, Z2$1, + lambda00, phi00, // first point + x0$4, y0$4, z0; // previous point + +var centroidStream$1 = { + sphere: noop$1, + point: centroidPoint$1, + lineStart: centroidLineStart$1, + lineEnd: centroidLineEnd$1, + polygonStart: function() { + centroidStream$1.lineStart = centroidRingStart$1; + centroidStream$1.lineEnd = centroidRingEnd$1; + }, + polygonEnd: function() { + centroidStream$1.lineStart = centroidLineStart$1; + centroidStream$1.lineEnd = centroidLineEnd$1; + } +}; + +// Arithmetic mean of Cartesian vectors. +function centroidPoint$1(lambda, phi) { + lambda *= radians, phi *= radians; + var cosPhi = cos$1(phi); + centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)); +} + +function centroidPointCartesian(x, y, z) { + ++W0; + X0$1 += (x - X0$1) / W0; + Y0$1 += (y - Y0$1) / W0; + Z0$1 += (z - Z0$1) / W0; +} + +function centroidLineStart$1() { + centroidStream$1.point = centroidLinePointFirst; +} + +function centroidLinePointFirst(lambda, phi) { + lambda *= radians, phi *= radians; + var cosPhi = cos$1(phi); + x0$4 = cosPhi * cos$1(lambda); + y0$4 = cosPhi * sin$1(lambda); + z0 = sin$1(phi); + centroidStream$1.point = centroidLinePoint; + centroidPointCartesian(x0$4, y0$4, z0); +} + +function centroidLinePoint(lambda, phi) { + lambda *= radians, phi *= radians; + var cosPhi = cos$1(phi), + x = cosPhi * cos$1(lambda), + y = cosPhi * sin$1(lambda), + z = sin$1(phi), + w = atan2$1(sqrt$2((w = y0$4 * z - z0 * y) * w + (w = z0 * x - x0$4 * z) * w + (w = x0$4 * y - y0$4 * x) * w), x0$4 * x + y0$4 * y + z0 * z); + W1 += w; + X1$1 += w * (x0$4 + (x0$4 = x)); + Y1$1 += w * (y0$4 + (y0$4 = y)); + Z1$1 += w * (z0 + (z0 = z)); + centroidPointCartesian(x0$4, y0$4, z0); +} + +function centroidLineEnd$1() { + centroidStream$1.point = centroidPoint$1; +} + +// See J. E. Brock, The Inertia Tensor for a Spherical Triangle, +// J. Applied Mechanics 42, 239 (1975). +function centroidRingStart$1() { + centroidStream$1.point = centroidRingPointFirst; +} + +function centroidRingEnd$1() { + centroidRingPoint(lambda00, phi00); + centroidStream$1.point = centroidPoint$1; +} + +function centroidRingPointFirst(lambda, phi) { + lambda00 = lambda, phi00 = phi; + lambda *= radians, phi *= radians; + centroidStream$1.point = centroidRingPoint; + var cosPhi = cos$1(phi); + x0$4 = cosPhi * cos$1(lambda); + y0$4 = cosPhi * sin$1(lambda); + z0 = sin$1(phi); + centroidPointCartesian(x0$4, y0$4, z0); +} + +function centroidRingPoint(lambda, phi) { + lambda *= radians, phi *= radians; + var cosPhi = cos$1(phi), + x = cosPhi * cos$1(lambda), + y = cosPhi * sin$1(lambda), + z = sin$1(phi), + cx = y0$4 * z - z0 * y, + cy = z0 * x - x0$4 * z, + cz = x0$4 * y - y0$4 * x, + m = hypot(cx, cy, cz), + w = asin$1(m), // line weight = angle + v = m && -w / m; // area weight multiplier + X2$1.add(v * cx); + Y2$1.add(v * cy); + Z2$1.add(v * cz); + W1 += w; + X1$1 += w * (x0$4 + (x0$4 = x)); + Y1$1 += w * (y0$4 + (y0$4 = y)); + Z1$1 += w * (z0 + (z0 = z)); + centroidPointCartesian(x0$4, y0$4, z0); +} + +function centroid$1(object) { + W0 = W1 = + X0$1 = Y0$1 = Z0$1 = + X1$1 = Y1$1 = Z1$1 = 0; + X2$1 = new Adder(); + Y2$1 = new Adder(); + Z2$1 = new Adder(); + geoStream(object, centroidStream$1); + + var x = +X2$1, + y = +Y2$1, + z = +Z2$1, + m = hypot(x, y, z); + + // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid. + if (m < epsilon2) { + x = X1$1, y = Y1$1, z = Z1$1; + // If the feature has zero length, fall back to arithmetic mean of point vectors. + if (W1 < epsilon$1) x = X0$1, y = Y0$1, z = Z0$1; + m = hypot(x, y, z); + // If the feature still has an undefined ccentroid, then return. + if (m < epsilon2) return [NaN, NaN]; + } + + return [atan2$1(y, x) * degrees, asin$1(z / m) * degrees]; +} + +function constant$3(x) { + return function() { + return x; + }; +} + +function compose(a, b) { + + function compose(x, y) { + return x = a(x, y), b(x[0], x[1]); + } + + if (a.invert && b.invert) compose.invert = function(x, y) { + return x = b.invert(x, y), x && a.invert(x[0], x[1]); + }; + + return compose; +} + +function rotationIdentity(lambda, phi) { + if (abs$1(lambda) > pi$1) lambda -= Math.round(lambda / tau$1) * tau$1; + return [lambda, phi]; +} + +rotationIdentity.invert = rotationIdentity; + +function rotateRadians(deltaLambda, deltaPhi, deltaGamma) { + return (deltaLambda %= tau$1) ? (deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) + : rotationLambda(deltaLambda)) + : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) + : rotationIdentity); +} + +function forwardRotationLambda(deltaLambda) { + return function(lambda, phi) { + lambda += deltaLambda; + if (abs$1(lambda) > pi$1) lambda -= Math.round(lambda / tau$1) * tau$1; + return [lambda, phi]; + }; +} + +function rotationLambda(deltaLambda) { + var rotation = forwardRotationLambda(deltaLambda); + rotation.invert = forwardRotationLambda(-deltaLambda); + return rotation; +} + +function rotationPhiGamma(deltaPhi, deltaGamma) { + var cosDeltaPhi = cos$1(deltaPhi), + sinDeltaPhi = sin$1(deltaPhi), + cosDeltaGamma = cos$1(deltaGamma), + sinDeltaGamma = sin$1(deltaGamma); + + function rotation(lambda, phi) { + var cosPhi = cos$1(phi), + x = cos$1(lambda) * cosPhi, + y = sin$1(lambda) * cosPhi, + z = sin$1(phi), + k = z * cosDeltaPhi + x * sinDeltaPhi; + return [ + atan2$1(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi), + asin$1(k * cosDeltaGamma + y * sinDeltaGamma) + ]; + } + + rotation.invert = function(lambda, phi) { + var cosPhi = cos$1(phi), + x = cos$1(lambda) * cosPhi, + y = sin$1(lambda) * cosPhi, + z = sin$1(phi), + k = z * cosDeltaGamma - y * sinDeltaGamma; + return [ + atan2$1(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi), + asin$1(k * cosDeltaPhi - x * sinDeltaPhi) + ]; + }; + + return rotation; +} + +function rotation(rotate) { + rotate = rotateRadians(rotate[0] * radians, rotate[1] * radians, rotate.length > 2 ? rotate[2] * radians : 0); + + function forward(coordinates) { + coordinates = rotate(coordinates[0] * radians, coordinates[1] * radians); + return coordinates[0] *= degrees, coordinates[1] *= degrees, coordinates; + } + + forward.invert = function(coordinates) { + coordinates = rotate.invert(coordinates[0] * radians, coordinates[1] * radians); + return coordinates[0] *= degrees, coordinates[1] *= degrees, coordinates; + }; + + return forward; +} + +// Generates a circle centered at [0°, 0°], with a given radius and precision. +function circleStream(stream, radius, delta, direction, t0, t1) { + if (!delta) return; + var cosRadius = cos$1(radius), + sinRadius = sin$1(radius), + step = direction * delta; + if (t0 == null) { + t0 = radius + direction * tau$1; + t1 = radius - step / 2; + } else { + t0 = circleRadius(cosRadius, t0); + t1 = circleRadius(cosRadius, t1); + if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * tau$1; + } + for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) { + point = spherical([cosRadius, -sinRadius * cos$1(t), -sinRadius * sin$1(t)]); + stream.point(point[0], point[1]); + } +} + +// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0]. +function circleRadius(cosRadius, point) { + point = cartesian(point), point[0] -= cosRadius; + cartesianNormalizeInPlace(point); + var radius = acos$1(-point[1]); + return ((-point[2] < 0 ? -radius : radius) + tau$1 - epsilon$1) % tau$1; +} + +function circle$1() { + var center = constant$3([0, 0]), + radius = constant$3(90), + precision = constant$3(2), + ring, + rotate, + stream = {point: point}; + + function point(x, y) { + ring.push(x = rotate(x, y)); + x[0] *= degrees, x[1] *= degrees; + } + + function circle() { + var c = center.apply(this, arguments), + r = radius.apply(this, arguments) * radians, + p = precision.apply(this, arguments) * radians; + ring = []; + rotate = rotateRadians(-c[0] * radians, -c[1] * radians, 0).invert; + circleStream(stream, r, p, 1); + c = {type: "Polygon", coordinates: [ring]}; + ring = rotate = null; + return c; + } + + circle.center = function(_) { + return arguments.length ? (center = typeof _ === "function" ? _ : constant$3([+_[0], +_[1]]), circle) : center; + }; + + circle.radius = function(_) { + return arguments.length ? (radius = typeof _ === "function" ? _ : constant$3(+_), circle) : radius; + }; + + circle.precision = function(_) { + return arguments.length ? (precision = typeof _ === "function" ? _ : constant$3(+_), circle) : precision; + }; + + return circle; +} + +function clipBuffer() { + var lines = [], + line; + return { + point: function(x, y, m) { + line.push([x, y, m]); + }, + lineStart: function() { + lines.push(line = []); + }, + lineEnd: noop$1, + rejoin: function() { + if (lines.length > 1) lines.push(lines.pop().concat(lines.shift())); + }, + result: function() { + var result = lines; + lines = []; + line = null; + return result; + } + }; +} + +function pointEqual(a, b) { + return abs$1(a[0] - b[0]) < epsilon$1 && abs$1(a[1] - b[1]) < epsilon$1; +} + +function Intersection(point, points, other, entry) { + this.x = point; + this.z = points; + this.o = other; // another intersection + this.e = entry; // is an entry? + this.v = false; // visited + this.n = this.p = null; // next & previous +} + +// A generalized polygon clipping algorithm: given a polygon that has been cut +// into its visible line segments, and rejoins the segments by interpolating +// along the clip edge. +function clipRejoin(segments, compareIntersection, startInside, interpolate, stream) { + var subject = [], + clip = [], + i, + n; + + segments.forEach(function(segment) { + if ((n = segment.length - 1) <= 0) return; + var n, p0 = segment[0], p1 = segment[n], x; + + if (pointEqual(p0, p1)) { + if (!p0[2] && !p1[2]) { + stream.lineStart(); + for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]); + stream.lineEnd(); + return; + } + // handle degenerate cases by moving the point + p1[0] += 2 * epsilon$1; + } + + subject.push(x = new Intersection(p0, segment, null, true)); + clip.push(x.o = new Intersection(p0, null, x, false)); + subject.push(x = new Intersection(p1, segment, null, false)); + clip.push(x.o = new Intersection(p1, null, x, true)); + }); + + if (!subject.length) return; + + clip.sort(compareIntersection); + link$1(subject); + link$1(clip); + + for (i = 0, n = clip.length; i < n; ++i) { + clip[i].e = startInside = !startInside; + } + + var start = subject[0], + points, + point; + + while (1) { + // Find first unvisited intersection. + var current = start, + isSubject = true; + while (current.v) if ((current = current.n) === start) return; + points = current.z; + stream.lineStart(); + do { + current.v = current.o.v = true; + if (current.e) { + if (isSubject) { + for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]); + } else { + interpolate(current.x, current.n.x, 1, stream); + } + current = current.n; + } else { + if (isSubject) { + points = current.p.z; + for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]); + } else { + interpolate(current.x, current.p.x, -1, stream); + } + current = current.p; + } + current = current.o; + points = current.z; + isSubject = !isSubject; + } while (!current.v); + stream.lineEnd(); + } +} + +function link$1(array) { + if (!(n = array.length)) return; + var n, + i = 0, + a = array[0], + b; + while (++i < n) { + a.n = b = array[i]; + b.p = a; + a = b; + } + a.n = b = array[0]; + b.p = a; +} + +function longitude(point) { + return abs$1(point[0]) <= pi$1 ? point[0] : sign$1(point[0]) * ((abs$1(point[0]) + pi$1) % tau$1 - pi$1); +} + +function polygonContains(polygon, point) { + var lambda = longitude(point), + phi = point[1], + sinPhi = sin$1(phi), + normal = [sin$1(lambda), -cos$1(lambda), 0], + angle = 0, + winding = 0; + + var sum = new Adder(); + + if (sinPhi === 1) phi = halfPi$1 + epsilon$1; + else if (sinPhi === -1) phi = -halfPi$1 - epsilon$1; + + for (var i = 0, n = polygon.length; i < n; ++i) { + if (!(m = (ring = polygon[i]).length)) continue; + var ring, + m, + point0 = ring[m - 1], + lambda0 = longitude(point0), + phi0 = point0[1] / 2 + quarterPi, + sinPhi0 = sin$1(phi0), + cosPhi0 = cos$1(phi0); + + for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) { + var point1 = ring[j], + lambda1 = longitude(point1), + phi1 = point1[1] / 2 + quarterPi, + sinPhi1 = sin$1(phi1), + cosPhi1 = cos$1(phi1), + delta = lambda1 - lambda0, + sign = delta >= 0 ? 1 : -1, + absDelta = sign * delta, + antimeridian = absDelta > pi$1, + k = sinPhi0 * sinPhi1; + + sum.add(atan2$1(k * sign * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta))); + angle += antimeridian ? delta + sign * tau$1 : delta; + + // Are the longitudes either side of the point’s meridian (lambda), + // and are the latitudes smaller than the parallel (phi)? + if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) { + var arc = cartesianCross(cartesian(point0), cartesian(point1)); + cartesianNormalizeInPlace(arc); + var intersection = cartesianCross(normal, arc); + cartesianNormalizeInPlace(intersection); + var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin$1(intersection[2]); + if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) { + winding += antimeridian ^ delta >= 0 ? 1 : -1; + } + } + } + } + + // First, determine whether the South pole is inside or outside: + // + // It is inside if: + // * the polygon winds around it in a clockwise direction. + // * the polygon does not (cumulatively) wind around it, but has a negative + // (counter-clockwise) area. + // + // Second, count the (signed) number of times a segment crosses a lambda + // from the point to the South pole. If it is zero, then the point is the + // same side as the South pole. + + return (angle < -epsilon$1 || angle < epsilon$1 && sum < -epsilon2) ^ (winding & 1); +} + +function clip(pointVisible, clipLine, interpolate, start) { + return function(sink) { + var line = clipLine(sink), + ringBuffer = clipBuffer(), + ringSink = clipLine(ringBuffer), + polygonStarted = false, + polygon, + segments, + ring; + + var clip = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function() { + clip.point = pointRing; + clip.lineStart = ringStart; + clip.lineEnd = ringEnd; + segments = []; + polygon = []; + }, + polygonEnd: function() { + clip.point = point; + clip.lineStart = lineStart; + clip.lineEnd = lineEnd; + segments = merge(segments); + var startInside = polygonContains(polygon, start); + if (segments.length) { + if (!polygonStarted) sink.polygonStart(), polygonStarted = true; + clipRejoin(segments, compareIntersection, startInside, interpolate, sink); + } else if (startInside) { + if (!polygonStarted) sink.polygonStart(), polygonStarted = true; + sink.lineStart(); + interpolate(null, null, 1, sink); + sink.lineEnd(); + } + if (polygonStarted) sink.polygonEnd(), polygonStarted = false; + segments = polygon = null; + }, + sphere: function() { + sink.polygonStart(); + sink.lineStart(); + interpolate(null, null, 1, sink); + sink.lineEnd(); + sink.polygonEnd(); + } + }; + + function point(lambda, phi) { + if (pointVisible(lambda, phi)) sink.point(lambda, phi); + } + + function pointLine(lambda, phi) { + line.point(lambda, phi); + } + + function lineStart() { + clip.point = pointLine; + line.lineStart(); + } + + function lineEnd() { + clip.point = point; + line.lineEnd(); + } + + function pointRing(lambda, phi) { + ring.push([lambda, phi]); + ringSink.point(lambda, phi); + } + + function ringStart() { + ringSink.lineStart(); + ring = []; + } + + function ringEnd() { + pointRing(ring[0][0], ring[0][1]); + ringSink.lineEnd(); + + var clean = ringSink.clean(), + ringSegments = ringBuffer.result(), + i, n = ringSegments.length, m, + segment, + point; + + ring.pop(); + polygon.push(ring); + ring = null; + + if (!n) return; + + // No intersections. + if (clean & 1) { + segment = ringSegments[0]; + if ((m = segment.length - 1) > 0) { + if (!polygonStarted) sink.polygonStart(), polygonStarted = true; + sink.lineStart(); + for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]); + sink.lineEnd(); + } + return; + } + + // Rejoin connected segments. + // TODO reuse ringBuffer.rejoin()? + if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift())); + + segments.push(ringSegments.filter(validSegment)); + } + + return clip; + }; +} + +function validSegment(segment) { + return segment.length > 1; +} + +// Intersections are sorted along the clip edge. For both antimeridian cutting +// and circle clipping, the same comparison is used. +function compareIntersection(a, b) { + return ((a = a.x)[0] < 0 ? a[1] - halfPi$1 - epsilon$1 : halfPi$1 - a[1]) + - ((b = b.x)[0] < 0 ? b[1] - halfPi$1 - epsilon$1 : halfPi$1 - b[1]); +} + +var clipAntimeridian = clip( + function() { return true; }, + clipAntimeridianLine, + clipAntimeridianInterpolate, + [-pi$1, -halfPi$1] +); + +// Takes a line and cuts into visible segments. Return values: 0 - there were +// intersections or the line was empty; 1 - no intersections; 2 - there were +// intersections, and the first and last segments should be rejoined. +function clipAntimeridianLine(stream) { + var lambda0 = NaN, + phi0 = NaN, + sign0 = NaN, + clean; // no intersections + + return { + lineStart: function() { + stream.lineStart(); + clean = 1; + }, + point: function(lambda1, phi1) { + var sign1 = lambda1 > 0 ? pi$1 : -pi$1, + delta = abs$1(lambda1 - lambda0); + if (abs$1(delta - pi$1) < epsilon$1) { // line crosses a pole + stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$1 : -halfPi$1); + stream.point(sign0, phi0); + stream.lineEnd(); + stream.lineStart(); + stream.point(sign1, phi0); + stream.point(lambda1, phi0); + clean = 0; + } else if (sign0 !== sign1 && delta >= pi$1) { // line crosses antimeridian + if (abs$1(lambda0 - sign0) < epsilon$1) lambda0 -= sign0 * epsilon$1; // handle degeneracies + if (abs$1(lambda1 - sign1) < epsilon$1) lambda1 -= sign1 * epsilon$1; + phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1); + stream.point(sign0, phi0); + stream.lineEnd(); + stream.lineStart(); + stream.point(sign1, phi0); + clean = 0; + } + stream.point(lambda0 = lambda1, phi0 = phi1); + sign0 = sign1; + }, + lineEnd: function() { + stream.lineEnd(); + lambda0 = phi0 = NaN; + }, + clean: function() { + return 2 - clean; // if intersections, rejoin first and last segments + } + }; +} + +function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) { + var cosPhi0, + cosPhi1, + sinLambda0Lambda1 = sin$1(lambda0 - lambda1); + return abs$1(sinLambda0Lambda1) > epsilon$1 + ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1) + - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0)) + / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) + : (phi0 + phi1) / 2; +} + +function clipAntimeridianInterpolate(from, to, direction, stream) { + var phi; + if (from == null) { + phi = direction * halfPi$1; + stream.point(-pi$1, phi); + stream.point(0, phi); + stream.point(pi$1, phi); + stream.point(pi$1, 0); + stream.point(pi$1, -phi); + stream.point(0, -phi); + stream.point(-pi$1, -phi); + stream.point(-pi$1, 0); + stream.point(-pi$1, phi); + } else if (abs$1(from[0] - to[0]) > epsilon$1) { + var lambda = from[0] < to[0] ? pi$1 : -pi$1; + phi = direction * lambda / 2; + stream.point(-lambda, phi); + stream.point(0, phi); + stream.point(lambda, phi); + } else { + stream.point(to[0], to[1]); + } +} + +function clipCircle(radius) { + var cr = cos$1(radius), + delta = 2 * radians, + smallRadius = cr > 0, + notHemisphere = abs$1(cr) > epsilon$1; // TODO optimise for this common case + + function interpolate(from, to, direction, stream) { + circleStream(stream, radius, delta, direction, from, to); + } + + function visible(lambda, phi) { + return cos$1(lambda) * cos$1(phi) > cr; + } + + // Takes a line and cuts into visible segments. Return values used for polygon + // clipping: 0 - there were intersections or the line was empty; 1 - no + // intersections 2 - there were intersections, and the first and last segments + // should be rejoined. + function clipLine(stream) { + var point0, // previous point + c0, // code for previous point + v0, // visibility of previous point + v00, // visibility of first point + clean; // no intersections + return { + lineStart: function() { + v00 = v0 = false; + clean = 1; + }, + point: function(lambda, phi) { + var point1 = [lambda, phi], + point2, + v = visible(lambda, phi), + c = smallRadius + ? v ? 0 : code(lambda, phi) + : v ? code(lambda + (lambda < 0 ? pi$1 : -pi$1), phi) : 0; + if (!point0 && (v00 = v0 = v)) stream.lineStart(); + if (v !== v0) { + point2 = intersect(point0, point1); + if (!point2 || pointEqual(point0, point2) || pointEqual(point1, point2)) + point1[2] = 1; + } + if (v !== v0) { + clean = 0; + if (v) { + // outside going in + stream.lineStart(); + point2 = intersect(point1, point0); + stream.point(point2[0], point2[1]); + } else { + // inside going out + point2 = intersect(point0, point1); + stream.point(point2[0], point2[1], 2); + stream.lineEnd(); + } + point0 = point2; + } else if (notHemisphere && point0 && smallRadius ^ v) { + var t; + // If the codes for two points are different, or are both zero, + // and there this segment intersects with the small circle. + if (!(c & c0) && (t = intersect(point1, point0, true))) { + clean = 0; + if (smallRadius) { + stream.lineStart(); + stream.point(t[0][0], t[0][1]); + stream.point(t[1][0], t[1][1]); + stream.lineEnd(); + } else { + stream.point(t[1][0], t[1][1]); + stream.lineEnd(); + stream.lineStart(); + stream.point(t[0][0], t[0][1], 3); + } + } + } + if (v && (!point0 || !pointEqual(point0, point1))) { + stream.point(point1[0], point1[1]); + } + point0 = point1, v0 = v, c0 = c; + }, + lineEnd: function() { + if (v0) stream.lineEnd(); + point0 = null; + }, + // Rejoin first and last segments if there were intersections and the first + // and last points were visible. + clean: function() { + return clean | ((v00 && v0) << 1); + } + }; + } + + // Intersects the great circle between a and b with the clip circle. + function intersect(a, b, two) { + var pa = cartesian(a), + pb = cartesian(b); + + // We have two planes, n1.p = d1 and n2.p = d2. + // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2). + var n1 = [1, 0, 0], // normal + n2 = cartesianCross(pa, pb), + n2n2 = cartesianDot(n2, n2), + n1n2 = n2[0], // cartesianDot(n1, n2), + determinant = n2n2 - n1n2 * n1n2; + + // Two polar points. + if (!determinant) return !two && a; + + var c1 = cr * n2n2 / determinant, + c2 = -cr * n1n2 / determinant, + n1xn2 = cartesianCross(n1, n2), + A = cartesianScale(n1, c1), + B = cartesianScale(n2, c2); + cartesianAddInPlace(A, B); + + // Solve |p(t)|^2 = 1. + var u = n1xn2, + w = cartesianDot(A, u), + uu = cartesianDot(u, u), + t2 = w * w - uu * (cartesianDot(A, A) - 1); + + if (t2 < 0) return; + + var t = sqrt$2(t2), + q = cartesianScale(u, (-w - t) / uu); + cartesianAddInPlace(q, A); + q = spherical(q); + + if (!two) return q; + + // Two intersection points. + var lambda0 = a[0], + lambda1 = b[0], + phi0 = a[1], + phi1 = b[1], + z; + + if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z; + + var delta = lambda1 - lambda0, + polar = abs$1(delta - pi$1) < epsilon$1, + meridian = polar || delta < epsilon$1; + + if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z; + + // Check that the first point is between a and b. + if (meridian + ? polar + ? phi0 + phi1 > 0 ^ q[1] < (abs$1(q[0] - lambda0) < epsilon$1 ? phi0 : phi1) + : phi0 <= q[1] && q[1] <= phi1 + : delta > pi$1 ^ (lambda0 <= q[0] && q[0] <= lambda1)) { + var q1 = cartesianScale(u, (-w + t) / uu); + cartesianAddInPlace(q1, A); + return [q, spherical(q1)]; + } + } + + // Generates a 4-bit vector representing the location of a point relative to + // the small circle's bounding box. + function code(lambda, phi) { + var r = smallRadius ? radius : pi$1 - radius, + code = 0; + if (lambda < -r) code |= 1; // left + else if (lambda > r) code |= 2; // right + if (phi < -r) code |= 4; // below + else if (phi > r) code |= 8; // above + return code; + } + + return clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi$1, radius - pi$1]); +} + +function clipLine(a, b, x0, y0, x1, y1) { + var ax = a[0], + ay = a[1], + bx = b[0], + by = b[1], + t0 = 0, + t1 = 1, + dx = bx - ax, + dy = by - ay, + r; + + r = x0 - ax; + if (!dx && r > 0) return; + r /= dx; + if (dx < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dx > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = x1 - ax; + if (!dx && r < 0) return; + r /= dx; + if (dx < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dx > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + r = y0 - ay; + if (!dy && r > 0) return; + r /= dy; + if (dy < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dy > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = y1 - ay; + if (!dy && r < 0) return; + r /= dy; + if (dy < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dy > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy; + if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy; + return true; +} + +var clipMax = 1e9, clipMin = -clipMax; + +// TODO Use d3-polygon’s polygonContains here for the ring check? +// TODO Eliminate duplicate buffering in clipBuffer and polygon.push? + +function clipRectangle(x0, y0, x1, y1) { + + function visible(x, y) { + return x0 <= x && x <= x1 && y0 <= y && y <= y1; + } + + function interpolate(from, to, direction, stream) { + var a = 0, a1 = 0; + if (from == null + || (a = corner(from, direction)) !== (a1 = corner(to, direction)) + || comparePoint(from, to) < 0 ^ direction > 0) { + do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0); + while ((a = (a + direction + 4) % 4) !== a1); + } else { + stream.point(to[0], to[1]); + } + } + + function corner(p, direction) { + return abs$1(p[0] - x0) < epsilon$1 ? direction > 0 ? 0 : 3 + : abs$1(p[0] - x1) < epsilon$1 ? direction > 0 ? 2 : 1 + : abs$1(p[1] - y0) < epsilon$1 ? direction > 0 ? 1 : 0 + : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon + } + + function compareIntersection(a, b) { + return comparePoint(a.x, b.x); + } + + function comparePoint(a, b) { + var ca = corner(a, 1), + cb = corner(b, 1); + return ca !== cb ? ca - cb + : ca === 0 ? b[1] - a[1] + : ca === 1 ? a[0] - b[0] + : ca === 2 ? a[1] - b[1] + : b[0] - a[0]; + } + + return function(stream) { + var activeStream = stream, + bufferStream = clipBuffer(), + segments, + polygon, + ring, + x__, y__, v__, // first point + x_, y_, v_, // previous point + first, + clean; + + var clipStream = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: polygonStart, + polygonEnd: polygonEnd + }; + + function point(x, y) { + if (visible(x, y)) activeStream.point(x, y); + } + + function polygonInside() { + var winding = 0; + + for (var i = 0, n = polygon.length; i < n; ++i) { + for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) { + a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1]; + if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; } + else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; } + } + } + + return winding; + } + + // Buffer geometry within a polygon and then clip it en masse. + function polygonStart() { + activeStream = bufferStream, segments = [], polygon = [], clean = true; + } + + function polygonEnd() { + var startInside = polygonInside(), + cleanInside = clean && startInside, + visible = (segments = merge(segments)).length; + if (cleanInside || visible) { + stream.polygonStart(); + if (cleanInside) { + stream.lineStart(); + interpolate(null, null, 1, stream); + stream.lineEnd(); + } + if (visible) { + clipRejoin(segments, compareIntersection, startInside, interpolate, stream); + } + stream.polygonEnd(); + } + activeStream = stream, segments = polygon = ring = null; + } + + function lineStart() { + clipStream.point = linePoint; + if (polygon) polygon.push(ring = []); + first = true; + v_ = false; + x_ = y_ = NaN; + } + + // TODO rather than special-case polygons, simply handle them separately. + // Ideally, coincident intersection points should be jittered to avoid + // clipping issues. + function lineEnd() { + if (segments) { + linePoint(x__, y__); + if (v__ && v_) bufferStream.rejoin(); + segments.push(bufferStream.result()); + } + clipStream.point = point; + if (v_) activeStream.lineEnd(); + } + + function linePoint(x, y) { + var v = visible(x, y); + if (polygon) ring.push([x, y]); + if (first) { + x__ = x, y__ = y, v__ = v; + first = false; + if (v) { + activeStream.lineStart(); + activeStream.point(x, y); + } + } else { + if (v && v_) activeStream.point(x, y); + else { + var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))], + b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))]; + if (clipLine(a, b, x0, y0, x1, y1)) { + if (!v_) { + activeStream.lineStart(); + activeStream.point(a[0], a[1]); + } + activeStream.point(b[0], b[1]); + if (!v) activeStream.lineEnd(); + clean = false; + } else if (v) { + activeStream.lineStart(); + activeStream.point(x, y); + clean = false; + } + } + } + x_ = x, y_ = y, v_ = v; + } + + return clipStream; + }; +} + +function extent() { + var x0 = 0, + y0 = 0, + x1 = 960, + y1 = 500, + cache, + cacheStream, + clip; + + return clip = { + stream: function(stream) { + return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream); + }, + extent: function(_) { + return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]]; + } + }; +} + +var lengthSum$1, + lambda0, + sinPhi0, + cosPhi0; + +var lengthStream$1 = { + sphere: noop$1, + point: noop$1, + lineStart: lengthLineStart, + lineEnd: noop$1, + polygonStart: noop$1, + polygonEnd: noop$1 +}; + +function lengthLineStart() { + lengthStream$1.point = lengthPointFirst$1; + lengthStream$1.lineEnd = lengthLineEnd; +} + +function lengthLineEnd() { + lengthStream$1.point = lengthStream$1.lineEnd = noop$1; +} + +function lengthPointFirst$1(lambda, phi) { + lambda *= radians, phi *= radians; + lambda0 = lambda, sinPhi0 = sin$1(phi), cosPhi0 = cos$1(phi); + lengthStream$1.point = lengthPoint$1; +} + +function lengthPoint$1(lambda, phi) { + lambda *= radians, phi *= radians; + var sinPhi = sin$1(phi), + cosPhi = cos$1(phi), + delta = abs$1(lambda - lambda0), + cosDelta = cos$1(delta), + sinDelta = sin$1(delta), + x = cosPhi * sinDelta, + y = cosPhi0 * sinPhi - sinPhi0 * cosPhi * cosDelta, + z = sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosDelta; + lengthSum$1.add(atan2$1(sqrt$2(x * x + y * y), z)); + lambda0 = lambda, sinPhi0 = sinPhi, cosPhi0 = cosPhi; +} + +function length$1(object) { + lengthSum$1 = new Adder(); + geoStream(object, lengthStream$1); + return +lengthSum$1; +} + +var coordinates = [null, null], + object = {type: "LineString", coordinates: coordinates}; + +function distance(a, b) { + coordinates[0] = a; + coordinates[1] = b; + return length$1(object); +} + +var containsObjectType = { + Feature: function(object, point) { + return containsGeometry(object.geometry, point); + }, + FeatureCollection: function(object, point) { + var features = object.features, i = -1, n = features.length; + while (++i < n) if (containsGeometry(features[i].geometry, point)) return true; + return false; + } +}; + +var containsGeometryType = { + Sphere: function() { + return true; + }, + Point: function(object, point) { + return containsPoint(object.coordinates, point); + }, + MultiPoint: function(object, point) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) if (containsPoint(coordinates[i], point)) return true; + return false; + }, + LineString: function(object, point) { + return containsLine(object.coordinates, point); + }, + MultiLineString: function(object, point) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) if (containsLine(coordinates[i], point)) return true; + return false; + }, + Polygon: function(object, point) { + return containsPolygon(object.coordinates, point); + }, + MultiPolygon: function(object, point) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) if (containsPolygon(coordinates[i], point)) return true; + return false; + }, + GeometryCollection: function(object, point) { + var geometries = object.geometries, i = -1, n = geometries.length; + while (++i < n) if (containsGeometry(geometries[i], point)) return true; + return false; + } +}; + +function containsGeometry(geometry, point) { + return geometry && containsGeometryType.hasOwnProperty(geometry.type) + ? containsGeometryType[geometry.type](geometry, point) + : false; +} + +function containsPoint(coordinates, point) { + return distance(coordinates, point) === 0; +} + +function containsLine(coordinates, point) { + var ao, bo, ab; + for (var i = 0, n = coordinates.length; i < n; i++) { + bo = distance(coordinates[i], point); + if (bo === 0) return true; + if (i > 0) { + ab = distance(coordinates[i], coordinates[i - 1]); + if ( + ab > 0 && + ao <= ab && + bo <= ab && + (ao + bo - ab) * (1 - Math.pow((ao - bo) / ab, 2)) < epsilon2 * ab + ) + return true; + } + ao = bo; + } + return false; +} + +function containsPolygon(coordinates, point) { + return !!polygonContains(coordinates.map(ringRadians), pointRadians(point)); +} + +function ringRadians(ring) { + return ring = ring.map(pointRadians), ring.pop(), ring; +} + +function pointRadians(point) { + return [point[0] * radians, point[1] * radians]; +} + +function contains$1(object, point) { + return (object && containsObjectType.hasOwnProperty(object.type) + ? containsObjectType[object.type] + : containsGeometry)(object, point); +} + +function graticuleX(y0, y1, dy) { + var y = range$2(y0, y1 - epsilon$1, dy).concat(y1); + return function(x) { return y.map(function(y) { return [x, y]; }); }; +} + +function graticuleY(x0, x1, dx) { + var x = range$2(x0, x1 - epsilon$1, dx).concat(x1); + return function(y) { return x.map(function(x) { return [x, y]; }); }; +} + +function graticule() { + var x1, x0, X1, X0, + y1, y0, Y1, Y0, + dx = 10, dy = dx, DX = 90, DY = 360, + x, y, X, Y, + precision = 2.5; + + function graticule() { + return {type: "MultiLineString", coordinates: lines()}; + } + + function lines() { + return range$2(ceil(X0 / DX) * DX, X1, DX).map(X) + .concat(range$2(ceil(Y0 / DY) * DY, Y1, DY).map(Y)) + .concat(range$2(ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return abs$1(x % DX) > epsilon$1; }).map(x)) + .concat(range$2(ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return abs$1(y % DY) > epsilon$1; }).map(y)); + } + + graticule.lines = function() { + return lines().map(function(coordinates) { return {type: "LineString", coordinates: coordinates}; }); + }; + + graticule.outline = function() { + return { + type: "Polygon", + coordinates: [ + X(X0).concat( + Y(Y1).slice(1), + X(X1).reverse().slice(1), + Y(Y0).reverse().slice(1)) + ] + }; + }; + + graticule.extent = function(_) { + if (!arguments.length) return graticule.extentMinor(); + return graticule.extentMajor(_).extentMinor(_); + }; + + graticule.extentMajor = function(_) { + if (!arguments.length) return [[X0, Y0], [X1, Y1]]; + X0 = +_[0][0], X1 = +_[1][0]; + Y0 = +_[0][1], Y1 = +_[1][1]; + if (X0 > X1) _ = X0, X0 = X1, X1 = _; + if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _; + return graticule.precision(precision); + }; + + graticule.extentMinor = function(_) { + if (!arguments.length) return [[x0, y0], [x1, y1]]; + x0 = +_[0][0], x1 = +_[1][0]; + y0 = +_[0][1], y1 = +_[1][1]; + if (x0 > x1) _ = x0, x0 = x1, x1 = _; + if (y0 > y1) _ = y0, y0 = y1, y1 = _; + return graticule.precision(precision); + }; + + graticule.step = function(_) { + if (!arguments.length) return graticule.stepMinor(); + return graticule.stepMajor(_).stepMinor(_); + }; + + graticule.stepMajor = function(_) { + if (!arguments.length) return [DX, DY]; + DX = +_[0], DY = +_[1]; + return graticule; + }; + + graticule.stepMinor = function(_) { + if (!arguments.length) return [dx, dy]; + dx = +_[0], dy = +_[1]; + return graticule; + }; + + graticule.precision = function(_) { + if (!arguments.length) return precision; + precision = +_; + x = graticuleX(y0, y1, 90); + y = graticuleY(x0, x1, precision); + X = graticuleX(Y0, Y1, 90); + Y = graticuleY(X0, X1, precision); + return graticule; + }; + + return graticule + .extentMajor([[-180, -90 + epsilon$1], [180, 90 - epsilon$1]]) + .extentMinor([[-180, -80 - epsilon$1], [180, 80 + epsilon$1]]); +} + +function graticule10() { + return graticule()(); +} + +function interpolate(a, b) { + var x0 = a[0] * radians, + y0 = a[1] * radians, + x1 = b[0] * radians, + y1 = b[1] * radians, + cy0 = cos$1(y0), + sy0 = sin$1(y0), + cy1 = cos$1(y1), + sy1 = sin$1(y1), + kx0 = cy0 * cos$1(x0), + ky0 = cy0 * sin$1(x0), + kx1 = cy1 * cos$1(x1), + ky1 = cy1 * sin$1(x1), + d = 2 * asin$1(sqrt$2(haversin(y1 - y0) + cy0 * cy1 * haversin(x1 - x0))), + k = sin$1(d); + + var interpolate = d ? function(t) { + var B = sin$1(t *= d) / k, + A = sin$1(d - t) / k, + x = A * kx0 + B * kx1, + y = A * ky0 + B * ky1, + z = A * sy0 + B * sy1; + return [ + atan2$1(y, x) * degrees, + atan2$1(z, sqrt$2(x * x + y * y)) * degrees + ]; + } : function() { + return [x0 * degrees, y0 * degrees]; + }; + + interpolate.distance = d; + + return interpolate; +} + +var identity$5 = x => x; + +var areaSum = new Adder(), + areaRingSum = new Adder(), + x00$2, + y00$2, + x0$3, + y0$3; + +var areaStream = { + point: noop$1, + lineStart: noop$1, + lineEnd: noop$1, + polygonStart: function() { + areaStream.lineStart = areaRingStart; + areaStream.lineEnd = areaRingEnd; + }, + polygonEnd: function() { + areaStream.lineStart = areaStream.lineEnd = areaStream.point = noop$1; + areaSum.add(abs$1(areaRingSum)); + areaRingSum = new Adder(); + }, + result: function() { + var area = areaSum / 2; + areaSum = new Adder(); + return area; + } +}; + +function areaRingStart() { + areaStream.point = areaPointFirst; +} + +function areaPointFirst(x, y) { + areaStream.point = areaPoint; + x00$2 = x0$3 = x, y00$2 = y0$3 = y; +} + +function areaPoint(x, y) { + areaRingSum.add(y0$3 * x - x0$3 * y); + x0$3 = x, y0$3 = y; +} + +function areaRingEnd() { + areaPoint(x00$2, y00$2); +} + +var pathArea = areaStream; + +var x0$2 = Infinity, + y0$2 = x0$2, + x1 = -x0$2, + y1 = x1; + +var boundsStream = { + point: boundsPoint, + lineStart: noop$1, + lineEnd: noop$1, + polygonStart: noop$1, + polygonEnd: noop$1, + result: function() { + var bounds = [[x0$2, y0$2], [x1, y1]]; + x1 = y1 = -(y0$2 = x0$2 = Infinity); + return bounds; + } +}; + +function boundsPoint(x, y) { + if (x < x0$2) x0$2 = x; + if (x > x1) x1 = x; + if (y < y0$2) y0$2 = y; + if (y > y1) y1 = y; +} + +var boundsStream$1 = boundsStream; + +// TODO Enforce positive area for exterior, negative area for interior? + +var X0 = 0, + Y0 = 0, + Z0 = 0, + X1 = 0, + Y1 = 0, + Z1 = 0, + X2 = 0, + Y2 = 0, + Z2 = 0, + x00$1, + y00$1, + x0$1, + y0$1; + +var centroidStream = { + point: centroidPoint, + lineStart: centroidLineStart, + lineEnd: centroidLineEnd, + polygonStart: function() { + centroidStream.lineStart = centroidRingStart; + centroidStream.lineEnd = centroidRingEnd; + }, + polygonEnd: function() { + centroidStream.point = centroidPoint; + centroidStream.lineStart = centroidLineStart; + centroidStream.lineEnd = centroidLineEnd; + }, + result: function() { + var centroid = Z2 ? [X2 / Z2, Y2 / Z2] + : Z1 ? [X1 / Z1, Y1 / Z1] + : Z0 ? [X0 / Z0, Y0 / Z0] + : [NaN, NaN]; + X0 = Y0 = Z0 = + X1 = Y1 = Z1 = + X2 = Y2 = Z2 = 0; + return centroid; + } +}; + +function centroidPoint(x, y) { + X0 += x; + Y0 += y; + ++Z0; +} + +function centroidLineStart() { + centroidStream.point = centroidPointFirstLine; +} + +function centroidPointFirstLine(x, y) { + centroidStream.point = centroidPointLine; + centroidPoint(x0$1 = x, y0$1 = y); +} + +function centroidPointLine(x, y) { + var dx = x - x0$1, dy = y - y0$1, z = sqrt$2(dx * dx + dy * dy); + X1 += z * (x0$1 + x) / 2; + Y1 += z * (y0$1 + y) / 2; + Z1 += z; + centroidPoint(x0$1 = x, y0$1 = y); +} + +function centroidLineEnd() { + centroidStream.point = centroidPoint; +} + +function centroidRingStart() { + centroidStream.point = centroidPointFirstRing; +} + +function centroidRingEnd() { + centroidPointRing(x00$1, y00$1); +} + +function centroidPointFirstRing(x, y) { + centroidStream.point = centroidPointRing; + centroidPoint(x00$1 = x0$1 = x, y00$1 = y0$1 = y); +} + +function centroidPointRing(x, y) { + var dx = x - x0$1, + dy = y - y0$1, + z = sqrt$2(dx * dx + dy * dy); + + X1 += z * (x0$1 + x) / 2; + Y1 += z * (y0$1 + y) / 2; + Z1 += z; + + z = y0$1 * x - x0$1 * y; + X2 += z * (x0$1 + x); + Y2 += z * (y0$1 + y); + Z2 += z * 3; + centroidPoint(x0$1 = x, y0$1 = y); +} + +var pathCentroid = centroidStream; + +function PathContext(context) { + this._context = context; +} + +PathContext.prototype = { + _radius: 4.5, + pointRadius: function(_) { + return this._radius = _, this; + }, + polygonStart: function() { + this._line = 0; + }, + polygonEnd: function() { + this._line = NaN; + }, + lineStart: function() { + this._point = 0; + }, + lineEnd: function() { + if (this._line === 0) this._context.closePath(); + this._point = NaN; + }, + point: function(x, y) { + switch (this._point) { + case 0: { + this._context.moveTo(x, y); + this._point = 1; + break; + } + case 1: { + this._context.lineTo(x, y); + break; + } + default: { + this._context.moveTo(x + this._radius, y); + this._context.arc(x, y, this._radius, 0, tau$1); + break; + } + } + }, + result: noop$1 +}; + +var lengthSum = new Adder(), + lengthRing, + x00, + y00, + x0, + y0; + +var lengthStream = { + point: noop$1, + lineStart: function() { + lengthStream.point = lengthPointFirst; + }, + lineEnd: function() { + if (lengthRing) lengthPoint(x00, y00); + lengthStream.point = noop$1; + }, + polygonStart: function() { + lengthRing = true; + }, + polygonEnd: function() { + lengthRing = null; + }, + result: function() { + var length = +lengthSum; + lengthSum = new Adder(); + return length; + } +}; + +function lengthPointFirst(x, y) { + lengthStream.point = lengthPoint; + x00 = x0 = x, y00 = y0 = y; +} + +function lengthPoint(x, y) { + x0 -= x, y0 -= y; + lengthSum.add(sqrt$2(x0 * x0 + y0 * y0)); + x0 = x, y0 = y; +} + +var pathMeasure = lengthStream; + +// Simple caching for constant-radius points. +let cacheDigits, cacheAppend, cacheRadius, cacheCircle; + +class PathString { + constructor(digits) { + this._append = digits == null ? append : appendRound(digits); + this._radius = 4.5; + this._ = ""; + } + pointRadius(_) { + this._radius = +_; + return this; + } + polygonStart() { + this._line = 0; + } + polygonEnd() { + this._line = NaN; + } + lineStart() { + this._point = 0; + } + lineEnd() { + if (this._line === 0) this._ += "Z"; + this._point = NaN; + } + point(x, y) { + switch (this._point) { + case 0: { + this._append`M${x},${y}`; + this._point = 1; + break; + } + case 1: { + this._append`L${x},${y}`; + break; + } + default: { + this._append`M${x},${y}`; + if (this._radius !== cacheRadius || this._append !== cacheAppend) { + const r = this._radius; + const s = this._; + this._ = ""; // stash the old string so we can cache the circle path fragment + this._append`m0,${r}a${r},${r} 0 1,1 0,${-2 * r}a${r},${r} 0 1,1 0,${2 * r}z`; + cacheRadius = r; + cacheAppend = this._append; + cacheCircle = this._; + this._ = s; + } + this._ += cacheCircle; + break; + } + } + } + result() { + const result = this._; + this._ = ""; + return result.length ? result : null; + } +} + +function append(strings) { + let i = 1; + this._ += strings[0]; + for (const j = strings.length; i < j; ++i) { + this._ += arguments[i] + strings[i]; + } +} + +function appendRound(digits) { + const d = Math.floor(digits); + if (!(d >= 0)) throw new RangeError(`invalid digits: ${digits}`); + if (d > 15) return append; + if (d !== cacheDigits) { + const k = 10 ** d; + cacheDigits = d; + cacheAppend = function append(strings) { + let i = 1; + this._ += strings[0]; + for (const j = strings.length; i < j; ++i) { + this._ += Math.round(arguments[i] * k) / k + strings[i]; + } + }; + } + return cacheAppend; +} + +function index$2(projection, context) { + let digits = 3, + pointRadius = 4.5, + projectionStream, + contextStream; + + function path(object) { + if (object) { + if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments)); + geoStream(object, projectionStream(contextStream)); + } + return contextStream.result(); + } + + path.area = function(object) { + geoStream(object, projectionStream(pathArea)); + return pathArea.result(); + }; + + path.measure = function(object) { + geoStream(object, projectionStream(pathMeasure)); + return pathMeasure.result(); + }; + + path.bounds = function(object) { + geoStream(object, projectionStream(boundsStream$1)); + return boundsStream$1.result(); + }; + + path.centroid = function(object) { + geoStream(object, projectionStream(pathCentroid)); + return pathCentroid.result(); + }; + + path.projection = function(_) { + if (!arguments.length) return projection; + projectionStream = _ == null ? (projection = null, identity$5) : (projection = _).stream; + return path; + }; + + path.context = function(_) { + if (!arguments.length) return context; + contextStream = _ == null ? (context = null, new PathString(digits)) : new PathContext(context = _); + if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius); + return path; + }; + + path.pointRadius = function(_) { + if (!arguments.length) return pointRadius; + pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_); + return path; + }; + + path.digits = function(_) { + if (!arguments.length) return digits; + if (_ == null) digits = null; + else { + const d = Math.floor(_); + if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`); + digits = d; + } + if (context === null) contextStream = new PathString(digits); + return path; + }; + + return path.projection(projection).digits(digits).context(context); +} + +function transform$1(methods) { + return { + stream: transformer$3(methods) + }; +} + +function transformer$3(methods) { + return function(stream) { + var s = new TransformStream; + for (var key in methods) s[key] = methods[key]; + s.stream = stream; + return s; + }; +} + +function TransformStream() {} + +TransformStream.prototype = { + constructor: TransformStream, + point: function(x, y) { this.stream.point(x, y); }, + 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(); } +}; + +function fit(projection, fitBounds, object) { + var clip = projection.clipExtent && projection.clipExtent(); + projection.scale(150).translate([0, 0]); + if (clip != null) projection.clipExtent(null); + geoStream(object, projection.stream(boundsStream$1)); + fitBounds(boundsStream$1.result()); + if (clip != null) projection.clipExtent(clip); + return projection; +} + +function fitExtent(projection, extent, object) { + return fit(projection, function(b) { + var w = extent[1][0] - extent[0][0], + h = extent[1][1] - extent[0][1], + k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])), + x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2, + y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2; + projection.scale(150 * k).translate([x, y]); + }, object); +} + +function fitSize(projection, size, object) { + return fitExtent(projection, [[0, 0], size], object); +} + +function fitWidth(projection, width, object) { + return fit(projection, function(b) { + var w = +width, + k = w / (b[1][0] - b[0][0]), + x = (w - k * (b[1][0] + b[0][0])) / 2, + y = -k * b[0][1]; + projection.scale(150 * k).translate([x, y]); + }, object); +} + +function fitHeight(projection, height, object) { + return fit(projection, function(b) { + var h = +height, + k = h / (b[1][1] - b[0][1]), + x = -k * b[0][0], + y = (h - k * (b[1][1] + b[0][1])) / 2; + projection.scale(150 * k).translate([x, y]); + }, object); +} + +var maxDepth = 16, // maximum depth of subdivision + cosMinDistance = cos$1(30 * radians); // cos(minimum angular distance) + +function resample(project, delta2) { + return +delta2 ? resample$1(project, delta2) : resampleNone(project); +} + +function resampleNone(project) { + return transformer$3({ + point: function(x, y) { + x = project(x, y); + this.stream.point(x[0], x[1]); + } + }); +} + +function resample$1(project, delta2) { + + function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) { + var dx = x1 - x0, + dy = y1 - y0, + d2 = dx * dx + dy * dy; + if (d2 > 4 * delta2 && depth--) { + var a = a0 + a1, + b = b0 + b1, + c = c0 + c1, + m = sqrt$2(a * a + b * b + c * c), + phi2 = asin$1(c /= m), + lambda2 = abs$1(abs$1(c) - 1) < epsilon$1 || abs$1(lambda0 - lambda1) < epsilon$1 ? (lambda0 + lambda1) / 2 : atan2$1(b, a), + p = project(lambda2, phi2), + x2 = p[0], + y2 = p[1], + dx2 = x2 - x0, + dy2 = y2 - y0, + dz = dy * dx2 - dx * dy2; + if (dz * dz / d2 > delta2 // perpendicular projected distance + || abs$1((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end + || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance + resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream); + stream.point(x2, y2); + resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream); + } + } + } + return function(stream) { + var lambda00, x00, y00, a00, b00, c00, // first point + lambda0, x0, y0, a0, b0, c0; // previous point + + var resampleStream = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; }, + polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; } + }; + + function point(x, y) { + x = project(x, y); + stream.point(x[0], x[1]); + } + + function lineStart() { + x0 = NaN; + resampleStream.point = linePoint; + stream.lineStart(); + } + + function linePoint(lambda, phi) { + var c = cartesian([lambda, phi]), p = project(lambda, phi); + resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream); + stream.point(x0, y0); + } + + function lineEnd() { + resampleStream.point = point; + stream.lineEnd(); + } + + function ringStart() { + lineStart(); + resampleStream.point = ringPoint; + resampleStream.lineEnd = ringEnd; + } + + function ringPoint(lambda, phi) { + linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0; + resampleStream.point = linePoint; + } + + function ringEnd() { + resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream); + resampleStream.lineEnd = lineEnd; + lineEnd(); + } + + return resampleStream; + }; +} + +var transformRadians = transformer$3({ + point: function(x, y) { + this.stream.point(x * radians, y * radians); + } +}); + +function transformRotate(rotate) { + return transformer$3({ + point: function(x, y) { + var r = rotate(x, y); + return this.stream.point(r[0], r[1]); + } + }); +} + +function scaleTranslate(k, dx, dy, sx, sy) { + function transform(x, y) { + x *= sx; y *= sy; + return [dx + k * x, dy - k * y]; + } + transform.invert = function(x, y) { + return [(x - dx) / k * sx, (dy - y) / k * sy]; + }; + return transform; +} + +function scaleTranslateRotate(k, dx, dy, sx, sy, alpha) { + if (!alpha) return scaleTranslate(k, dx, dy, sx, sy); + var cosAlpha = cos$1(alpha), + sinAlpha = sin$1(alpha), + a = cosAlpha * k, + b = sinAlpha * k, + ai = cosAlpha / k, + bi = sinAlpha / k, + ci = (sinAlpha * dy - cosAlpha * dx) / k, + fi = (sinAlpha * dx + cosAlpha * dy) / k; + function transform(x, y) { + x *= sx; y *= sy; + return [a * x - b * y + dx, dy - b * x - a * y]; + } + transform.invert = function(x, y) { + return [sx * (ai * x - bi * y + ci), sy * (fi - bi * x - ai * y)]; + }; + return transform; +} + +function projection(project) { + return projectionMutator(function() { return project; })(); +} + +function projectionMutator(projectAt) { + var project, + k = 150, // scale + x = 480, y = 250, // translate + lambda = 0, phi = 0, // center + deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, // pre-rotate + alpha = 0, // post-rotate angle + sx = 1, // reflectX + sy = 1, // reflectX + theta = null, preclip = clipAntimeridian, // pre-clip angle + x0 = null, y0, x1, y1, postclip = identity$5, // post-clip extent + delta2 = 0.5, // precision + projectResample, + projectTransform, + projectRotateTransform, + cache, + cacheStream; + + function projection(point) { + return projectRotateTransform(point[0] * radians, point[1] * radians); + } + + function invert(point) { + point = projectRotateTransform.invert(point[0], point[1]); + return point && [point[0] * degrees, point[1] * degrees]; + } + + projection.stream = function(stream) { + return cache && cacheStream === stream ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream))))); + }; + + projection.preclip = function(_) { + return arguments.length ? (preclip = _, theta = undefined, reset()) : preclip; + }; + + projection.postclip = function(_) { + return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip; + }; + + projection.clipAngle = function(_) { + return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians) : (theta = null, clipAntimeridian), reset()) : theta * degrees; + }; + + projection.clipExtent = function(_) { + return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$5) : clipRectangle(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]]; + }; + + projection.scale = function(_) { + return arguments.length ? (k = +_, recenter()) : k; + }; + + projection.translate = function(_) { + return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y]; + }; + + projection.center = function(_) { + return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees, phi * degrees]; + }; + + projection.rotate = function(_) { + return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees, deltaPhi * degrees, deltaGamma * degrees]; + }; + + projection.angle = function(_) { + return arguments.length ? (alpha = _ % 360 * radians, recenter()) : alpha * degrees; + }; + + projection.reflectX = function(_) { + return arguments.length ? (sx = _ ? -1 : 1, recenter()) : sx < 0; + }; + + projection.reflectY = function(_) { + return arguments.length ? (sy = _ ? -1 : 1, recenter()) : sy < 0; + }; + + projection.precision = function(_) { + return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt$2(delta2); + }; + + projection.fitExtent = function(extent, object) { + return fitExtent(projection, extent, object); + }; + + projection.fitSize = function(size, object) { + return fitSize(projection, size, object); + }; + + projection.fitWidth = function(width, object) { + return fitWidth(projection, width, object); + }; + + projection.fitHeight = function(height, object) { + return fitHeight(projection, height, object); + }; + + function recenter() { + var center = scaleTranslateRotate(k, 0, 0, sx, sy, alpha).apply(null, project(lambda, phi)), + transform = scaleTranslateRotate(k, x - center[0], y - center[1], sx, sy, alpha); + rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma); + projectTransform = compose(project, transform); + projectRotateTransform = compose(rotate, projectTransform); + projectResample = resample(projectTransform, delta2); + return reset(); + } + + function reset() { + cache = cacheStream = null; + return projection; + } + + return function() { + project = projectAt.apply(this, arguments); + projection.invert = project.invert && invert; + return recenter(); + }; +} + +function conicProjection(projectAt) { + var phi0 = 0, + phi1 = pi$1 / 3, + m = projectionMutator(projectAt), + p = m(phi0, phi1); + + p.parallels = function(_) { + return arguments.length ? m(phi0 = _[0] * radians, phi1 = _[1] * radians) : [phi0 * degrees, phi1 * degrees]; + }; + + return p; +} + +function cylindricalEqualAreaRaw(phi0) { + var cosPhi0 = cos$1(phi0); + + function forward(lambda, phi) { + return [lambda * cosPhi0, sin$1(phi) / cosPhi0]; + } + + forward.invert = function(x, y) { + return [x / cosPhi0, asin$1(y * cosPhi0)]; + }; + + return forward; +} + +function conicEqualAreaRaw(y0, y1) { + var sy0 = sin$1(y0), n = (sy0 + sin$1(y1)) / 2; + + // Are the parallels symmetrical around the Equator? + if (abs$1(n) < epsilon$1) return cylindricalEqualAreaRaw(y0); + + var c = 1 + sy0 * (2 * n - sy0), r0 = sqrt$2(c) / n; + + function project(x, y) { + var r = sqrt$2(c - 2 * n * sin$1(y)) / n; + return [r * sin$1(x *= n), r0 - r * cos$1(x)]; + } + + project.invert = function(x, y) { + var r0y = r0 - y, + l = atan2$1(x, abs$1(r0y)) * sign$1(r0y); + if (r0y * n < 0) + l -= pi$1 * sign$1(x) * sign$1(r0y); + return [l / n, asin$1((c - (x * x + r0y * r0y) * n * n) / (2 * n))]; + }; + + return project; +} + +function conicEqualArea() { + return conicProjection(conicEqualAreaRaw) + .scale(155.424) + .center([0, 33.6442]); +} + +function albers() { + return conicEqualArea() + .parallels([29.5, 45.5]) + .scale(1070) + .translate([480, 250]) + .rotate([96, 0]) + .center([-0.6, 38.7]); +} + +// The projections must have mutually exclusive clip regions on the sphere, +// as this will avoid emitting interleaving lines and polygons. +function multiplex(streams) { + var n = streams.length; + return { + point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); }, + sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); }, + lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); }, + lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); }, + polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); }, + polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); } + }; +} + +// A composite projection for the United States, configured by default for +// 960×500. The projection also works quite well at 960×600 if you change the +// scale to 1285 and adjust the translate accordingly. The set of standard +// parallels for each region comes from USGS, which is published here: +// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers +function albersUsa() { + var cache, + cacheStream, + lower48 = albers(), lower48Point, + alaska = conicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338 + hawaii = conicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007 + point, pointStream = {point: function(x, y) { point = [x, y]; }}; + + function albersUsa(coordinates) { + var x = coordinates[0], y = coordinates[1]; + return point = null, + (lower48Point.point(x, y), point) + || (alaskaPoint.point(x, y), point) + || (hawaiiPoint.point(x, y), point); + } + + albersUsa.invert = function(coordinates) { + var k = lower48.scale(), + t = lower48.translate(), + x = (coordinates[0] - t[0]) / k, + y = (coordinates[1] - t[1]) / k; + return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska + : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii + : lower48).invert(coordinates); + }; + + albersUsa.stream = function(stream) { + return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]); + }; + + albersUsa.precision = function(_) { + if (!arguments.length) return lower48.precision(); + lower48.precision(_), alaska.precision(_), hawaii.precision(_); + return reset(); + }; + + albersUsa.scale = function(_) { + if (!arguments.length) return lower48.scale(); + lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_); + return albersUsa.translate(lower48.translate()); + }; + + albersUsa.translate = function(_) { + if (!arguments.length) return lower48.translate(); + var k = lower48.scale(), x = +_[0], y = +_[1]; + + lower48Point = lower48 + .translate(_) + .clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]]) + .stream(pointStream); + + alaskaPoint = alaska + .translate([x - 0.307 * k, y + 0.201 * k]) + .clipExtent([[x - 0.425 * k + epsilon$1, y + 0.120 * k + epsilon$1], [x - 0.214 * k - epsilon$1, y + 0.234 * k - epsilon$1]]) + .stream(pointStream); + + hawaiiPoint = hawaii + .translate([x - 0.205 * k, y + 0.212 * k]) + .clipExtent([[x - 0.214 * k + epsilon$1, y + 0.166 * k + epsilon$1], [x - 0.115 * k - epsilon$1, y + 0.234 * k - epsilon$1]]) + .stream(pointStream); + + return reset(); + }; + + albersUsa.fitExtent = function(extent, object) { + return fitExtent(albersUsa, extent, object); + }; + + albersUsa.fitSize = function(size, object) { + return fitSize(albersUsa, size, object); + }; + + albersUsa.fitWidth = function(width, object) { + return fitWidth(albersUsa, width, object); + }; + + albersUsa.fitHeight = function(height, object) { + return fitHeight(albersUsa, height, object); + }; + + function reset() { + cache = cacheStream = null; + return albersUsa; + } + + return albersUsa.scale(1070); +} + +function azimuthalRaw(scale) { + return function(x, y) { + var cx = cos$1(x), + cy = cos$1(y), + k = scale(cx * cy); + if (k === Infinity) return [2, 0]; + return [ + k * cy * sin$1(x), + k * sin$1(y) + ]; + } +} + +function azimuthalInvert(angle) { + return function(x, y) { + var z = sqrt$2(x * x + y * y), + c = angle(z), + sc = sin$1(c), + cc = cos$1(c); + return [ + atan2$1(x * sc, z * cc), + asin$1(z && y * sc / z) + ]; + } +} + +var azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) { + return sqrt$2(2 / (1 + cxcy)); +}); + +azimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) { + return 2 * asin$1(z / 2); +}); + +function azimuthalEqualArea() { + return projection(azimuthalEqualAreaRaw) + .scale(124.75) + .clipAngle(180 - 1e-3); +} + +var azimuthalEquidistantRaw = azimuthalRaw(function(c) { + return (c = acos$1(c)) && c / sin$1(c); +}); + +azimuthalEquidistantRaw.invert = azimuthalInvert(function(z) { + return z; +}); + +function azimuthalEquidistant() { + return projection(azimuthalEquidistantRaw) + .scale(79.4188) + .clipAngle(180 - 1e-3); +} + +function mercatorRaw(lambda, phi) { + return [lambda, log$1(tan((halfPi$1 + phi) / 2))]; +} + +mercatorRaw.invert = function(x, y) { + return [x, 2 * atan(exp(y)) - halfPi$1]; +}; + +function mercator() { + return mercatorProjection(mercatorRaw) + .scale(961 / tau$1); +} + +function mercatorProjection(project) { + var m = projection(project), + center = m.center, + scale = m.scale, + translate = m.translate, + clipExtent = m.clipExtent, + x0 = null, y0, x1, y1; // clip extent + + m.scale = function(_) { + return arguments.length ? (scale(_), reclip()) : scale(); + }; + + m.translate = function(_) { + return arguments.length ? (translate(_), reclip()) : translate(); + }; + + m.center = function(_) { + return arguments.length ? (center(_), reclip()) : center(); + }; + + m.clipExtent = function(_) { + return arguments.length ? ((_ == null ? x0 = y0 = x1 = y1 = null : (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1])), reclip()) : x0 == null ? null : [[x0, y0], [x1, y1]]; + }; + + function reclip() { + var k = pi$1 * scale(), + t = m(rotation(m.rotate()).invert([0, 0])); + return clipExtent(x0 == null + ? [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]] : project === mercatorRaw + ? [[Math.max(t[0] - k, x0), y0], [Math.min(t[0] + k, x1), y1]] + : [[x0, Math.max(t[1] - k, y0)], [x1, Math.min(t[1] + k, y1)]]); + } + + return reclip(); +} + +function tany(y) { + return tan((halfPi$1 + y) / 2); +} + +function conicConformalRaw(y0, y1) { + var cy0 = cos$1(y0), + n = y0 === y1 ? sin$1(y0) : log$1(cy0 / cos$1(y1)) / log$1(tany(y1) / tany(y0)), + f = cy0 * pow$1(tany(y0), n) / n; + + if (!n) return mercatorRaw; + + function project(x, y) { + if (f > 0) { if (y < -halfPi$1 + epsilon$1) y = -halfPi$1 + epsilon$1; } + else { if (y > halfPi$1 - epsilon$1) y = halfPi$1 - epsilon$1; } + var r = f / pow$1(tany(y), n); + return [r * sin$1(n * x), f - r * cos$1(n * x)]; + } + + project.invert = function(x, y) { + var fy = f - y, r = sign$1(n) * sqrt$2(x * x + fy * fy), + l = atan2$1(x, abs$1(fy)) * sign$1(fy); + if (fy * n < 0) + l -= pi$1 * sign$1(x) * sign$1(fy); + return [l / n, 2 * atan(pow$1(f / r, 1 / n)) - halfPi$1]; + }; + + return project; +} + +function conicConformal() { + return conicProjection(conicConformalRaw) + .scale(109.5) + .parallels([30, 30]); +} + +function equirectangularRaw(lambda, phi) { + return [lambda, phi]; +} + +equirectangularRaw.invert = equirectangularRaw; + +function equirectangular() { + return projection(equirectangularRaw) + .scale(152.63); +} + +function conicEquidistantRaw(y0, y1) { + var cy0 = cos$1(y0), + n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0), + g = cy0 / n + y0; + + if (abs$1(n) < epsilon$1) return equirectangularRaw; + + function project(x, y) { + var gy = g - y, nx = n * x; + return [gy * sin$1(nx), g - gy * cos$1(nx)]; + } + + project.invert = function(x, y) { + var gy = g - y, + l = atan2$1(x, abs$1(gy)) * sign$1(gy); + if (gy * n < 0) + l -= pi$1 * sign$1(x) * sign$1(gy); + return [l / n, g - sign$1(n) * sqrt$2(x * x + gy * gy)]; + }; + + return project; +} + +function conicEquidistant() { + return conicProjection(conicEquidistantRaw) + .scale(131.154) + .center([0, 13.9389]); +} + +var A1 = 1.340264, + A2 = -0.081106, + A3 = 0.000893, + A4 = 0.003796, + M = sqrt$2(3) / 2, + iterations = 12; + +function equalEarthRaw(lambda, phi) { + var l = asin$1(M * sin$1(phi)), l2 = l * l, l6 = l2 * l2 * l2; + return [ + lambda * cos$1(l) / (M * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2))), + l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) + ]; +} + +equalEarthRaw.invert = function(x, y) { + var l = y, l2 = l * l, l6 = l2 * l2 * l2; + for (var i = 0, delta, fy, fpy; i < iterations; ++i) { + fy = l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) - y; + fpy = A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2); + l -= delta = fy / fpy, l2 = l * l, l6 = l2 * l2 * l2; + if (abs$1(delta) < epsilon2) break; + } + return [ + M * x * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2)) / cos$1(l), + asin$1(sin$1(l) / M) + ]; +}; + +function equalEarth() { + return projection(equalEarthRaw) + .scale(177.158); +} + +function gnomonicRaw(x, y) { + var cy = cos$1(y), k = cos$1(x) * cy; + return [cy * sin$1(x) / k, sin$1(y) / k]; +} + +gnomonicRaw.invert = azimuthalInvert(atan); + +function gnomonic() { + return projection(gnomonicRaw) + .scale(144.049) + .clipAngle(60); +} + +function identity$4() { + var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, // scale, translate and reflect + alpha = 0, ca, sa, // angle + x0 = null, y0, x1, y1, // clip extent + kx = 1, ky = 1, + transform = transformer$3({ + point: function(x, y) { + var p = projection([x, y]); + this.stream.point(p[0], p[1]); + } + }), + postclip = identity$5, + cache, + cacheStream; + + function reset() { + kx = k * sx; + ky = k * sy; + cache = cacheStream = null; + return projection; + } + + function projection (p) { + var x = p[0] * kx, y = p[1] * ky; + if (alpha) { + var t = y * ca - x * sa; + x = x * ca + y * sa; + y = t; + } + return [x + tx, y + ty]; + } + projection.invert = function(p) { + var x = p[0] - tx, y = p[1] - ty; + if (alpha) { + var t = y * ca + x * sa; + x = x * ca - y * sa; + y = t; + } + return [x / kx, y / ky]; + }; + projection.stream = function(stream) { + return cache && cacheStream === stream ? cache : cache = transform(postclip(cacheStream = stream)); + }; + projection.postclip = function(_) { + return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip; + }; + projection.clipExtent = function(_) { + return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$5) : clipRectangle(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]]; + }; + projection.scale = function(_) { + return arguments.length ? (k = +_, reset()) : k; + }; + projection.translate = function(_) { + return arguments.length ? (tx = +_[0], ty = +_[1], reset()) : [tx, ty]; + }; + projection.angle = function(_) { + return arguments.length ? (alpha = _ % 360 * radians, sa = sin$1(alpha), ca = cos$1(alpha), reset()) : alpha * degrees; + }; + projection.reflectX = function(_) { + return arguments.length ? (sx = _ ? -1 : 1, reset()) : sx < 0; + }; + projection.reflectY = function(_) { + return arguments.length ? (sy = _ ? -1 : 1, reset()) : sy < 0; + }; + projection.fitExtent = function(extent, object) { + return fitExtent(projection, extent, object); + }; + projection.fitSize = function(size, object) { + return fitSize(projection, size, object); + }; + projection.fitWidth = function(width, object) { + return fitWidth(projection, width, object); + }; + projection.fitHeight = function(height, object) { + return fitHeight(projection, height, object); + }; + + return projection; +} + +function naturalEarth1Raw(lambda, phi) { + var phi2 = phi * phi, phi4 = phi2 * phi2; + return [ + lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (0.003971 * phi2 - 0.001529 * phi4))), + phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) + ]; +} + +naturalEarth1Raw.invert = function(x, y) { + var phi = y, i = 25, delta; + do { + var phi2 = phi * phi, phi4 = phi2 * phi2; + phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) - y) / + (1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 0.005916 * 11 * phi4))); + } while (abs$1(delta) > epsilon$1 && --i > 0); + return [ + x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (0.003971 - 0.001529 * phi2)))), + phi + ]; +}; + +function naturalEarth1() { + return projection(naturalEarth1Raw) + .scale(175.295); +} + +function orthographicRaw(x, y) { + return [cos$1(y) * sin$1(x), sin$1(y)]; +} + +orthographicRaw.invert = azimuthalInvert(asin$1); + +function orthographic() { + return projection(orthographicRaw) + .scale(249.5) + .clipAngle(90 + epsilon$1); +} + +function stereographicRaw(x, y) { + var cy = cos$1(y), k = 1 + cos$1(x) * cy; + return [cy * sin$1(x) / k, sin$1(y) / k]; +} + +stereographicRaw.invert = azimuthalInvert(function(z) { + return 2 * atan(z); +}); + +function stereographic() { + return projection(stereographicRaw) + .scale(250) + .clipAngle(142); +} + +function transverseMercatorRaw(lambda, phi) { + return [log$1(tan((halfPi$1 + phi) / 2)), -lambda]; +} + +transverseMercatorRaw.invert = function(x, y) { + return [-y, 2 * atan(exp(x)) - halfPi$1]; +}; + +function transverseMercator() { + var m = mercatorProjection(transverseMercatorRaw), + center = m.center, + rotate = m.rotate; + + m.center = function(_) { + return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]); + }; + + m.rotate = function(_) { + return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]); + }; + + return rotate([0, 0, 90]) + .scale(159.155); +} + +function defaultSeparation$1(a, b) { + return a.parent === b.parent ? 1 : 2; +} + +function meanX(children) { + return children.reduce(meanXReduce, 0) / children.length; +} + +function meanXReduce(x, c) { + return x + c.x; +} + +function maxY(children) { + return 1 + children.reduce(maxYReduce, 0); +} + +function maxYReduce(y, c) { + return Math.max(y, c.y); +} + +function leafLeft(node) { + var children; + while (children = node.children) node = children[0]; + return node; +} + +function leafRight(node) { + var children; + while (children = node.children) node = children[children.length - 1]; + return node; +} + +function cluster() { + var separation = defaultSeparation$1, + dx = 1, + dy = 1, + nodeSize = false; + + function cluster(root) { + var previousNode, + x = 0; + + // First walk, computing the initial x & y values. + root.eachAfter(function(node) { + var children = node.children; + if (children) { + node.x = meanX(children); + node.y = maxY(children); + } else { + node.x = previousNode ? x += separation(node, previousNode) : 0; + node.y = 0; + previousNode = node; + } + }); + + var left = leafLeft(root), + right = leafRight(root), + x0 = left.x - separation(left, right) / 2, + x1 = right.x + separation(right, left) / 2; + + // Second walk, normalizing x & y to the desired size. + return root.eachAfter(nodeSize ? function(node) { + node.x = (node.x - root.x) * dx; + node.y = (root.y - node.y) * dy; + } : function(node) { + node.x = (node.x - x0) / (x1 - x0) * dx; + node.y = (1 - (root.y ? node.y / root.y : 1)) * dy; + }); + } + + cluster.separation = function(x) { + return arguments.length ? (separation = x, cluster) : separation; + }; + + cluster.size = function(x) { + return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]); + }; + + cluster.nodeSize = function(x) { + return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null); + }; + + return cluster; +} + +function count(node) { + var sum = 0, + children = node.children, + i = children && children.length; + if (!i) sum = 1; + else while (--i >= 0) sum += children[i].value; + node.value = sum; +} + +function node_count() { + return this.eachAfter(count); +} + +function node_each(callback, that) { + let index = -1; + for (const node of this) { + callback.call(that, node, ++index, this); + } + return this; +} + +function node_eachBefore(callback, that) { + var node = this, nodes = [node], children, i, index = -1; + while (node = nodes.pop()) { + callback.call(that, node, ++index, this); + if (children = node.children) { + for (i = children.length - 1; i >= 0; --i) { + nodes.push(children[i]); + } + } + } + return this; +} + +function node_eachAfter(callback, that) { + var node = this, nodes = [node], next = [], children, i, n, index = -1; + while (node = nodes.pop()) { + next.push(node); + if (children = node.children) { + for (i = 0, n = children.length; i < n; ++i) { + nodes.push(children[i]); + } + } + } + while (node = next.pop()) { + callback.call(that, node, ++index, this); + } + return this; +} + +function node_find(callback, that) { + let index = -1; + for (const node of this) { + if (callback.call(that, node, ++index, this)) { + return node; + } + } +} + +function node_sum(value) { + return this.eachAfter(function(node) { + var sum = +value(node.data) || 0, + children = node.children, + i = children && children.length; + while (--i >= 0) sum += children[i].value; + node.value = sum; + }); +} + +function node_sort(compare) { + return this.eachBefore(function(node) { + if (node.children) { + node.children.sort(compare); + } + }); +} + +function node_path(end) { + var start = this, + ancestor = leastCommonAncestor(start, end), + nodes = [start]; + while (start !== ancestor) { + start = start.parent; + nodes.push(start); + } + var k = nodes.length; + while (end !== ancestor) { + nodes.splice(k, 0, end); + end = end.parent; + } + return nodes; +} + +function leastCommonAncestor(a, b) { + if (a === b) return a; + var aNodes = a.ancestors(), + bNodes = b.ancestors(), + c = null; + a = aNodes.pop(); + b = bNodes.pop(); + while (a === b) { + c = a; + a = aNodes.pop(); + b = bNodes.pop(); + } + return c; +} + +function node_ancestors() { + var node = this, nodes = [node]; + while (node = node.parent) { + nodes.push(node); + } + return nodes; +} + +function node_descendants() { + return Array.from(this); +} + +function node_leaves() { + var leaves = []; + this.eachBefore(function(node) { + if (!node.children) { + leaves.push(node); + } + }); + return leaves; +} + +function node_links() { + var root = this, links = []; + root.each(function(node) { + if (node !== root) { // Don’t include the root’s parent, if any. + links.push({source: node.parent, target: node}); + } + }); + return links; +} + +function* node_iterator() { + var node = this, current, next = [node], children, i, n; + do { + current = next.reverse(), next = []; + while (node = current.pop()) { + yield node; + if (children = node.children) { + for (i = 0, n = children.length; i < n; ++i) { + next.push(children[i]); + } + } + } + } while (next.length); +} + +function hierarchy(data, children) { + if (data instanceof Map) { + data = [undefined, data]; + if (children === undefined) children = mapChildren; + } else if (children === undefined) { + children = objectChildren; + } + + var root = new Node$1(data), + node, + nodes = [root], + child, + childs, + i, + n; + + while (node = nodes.pop()) { + if ((childs = children(node.data)) && (n = (childs = Array.from(childs)).length)) { + node.children = childs; + for (i = n - 1; i >= 0; --i) { + nodes.push(child = childs[i] = new Node$1(childs[i])); + child.parent = node; + child.depth = node.depth + 1; + } + } + } + + return root.eachBefore(computeHeight); +} + +function node_copy() { + return hierarchy(this).eachBefore(copyData); +} + +function objectChildren(d) { + return d.children; +} + +function mapChildren(d) { + return Array.isArray(d) ? d[1] : null; +} + +function copyData(node) { + if (node.data.value !== undefined) node.value = node.data.value; + node.data = node.data.data; +} + +function computeHeight(node) { + var height = 0; + do node.height = height; + while ((node = node.parent) && (node.height < ++height)); +} + +function Node$1(data) { + this.data = data; + this.depth = + this.height = 0; + this.parent = null; +} + +Node$1.prototype = hierarchy.prototype = { + constructor: Node$1, + count: node_count, + each: node_each, + eachAfter: node_eachAfter, + eachBefore: node_eachBefore, + find: node_find, + sum: node_sum, + sort: node_sort, + path: node_path, + ancestors: node_ancestors, + descendants: node_descendants, + leaves: node_leaves, + links: node_links, + copy: node_copy, + [Symbol.iterator]: node_iterator +}; + +function optional(f) { + return f == null ? null : required(f); +} + +function required(f) { + if (typeof f !== "function") throw new Error; + return f; +} + +function constantZero() { + return 0; +} + +function constant$2(x) { + return function() { + return x; + }; +} + +// https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use +const a$1 = 1664525; +const c$3 = 1013904223; +const m = 4294967296; // 2^32 + +function lcg$1() { + let s = 1; + return () => (s = (a$1 * s + c$3) % m) / m; +} + +function array$1(x) { + return typeof x === "object" && "length" in x + ? x // Array, TypedArray, NodeList, array-like + : Array.from(x); // Map, Set, iterable, string, or anything else +} + +function shuffle(array, random) { + let m = array.length, + t, + i; + + while (m) { + i = random() * m-- | 0; + t = array[m]; + array[m] = array[i]; + array[i] = t; + } + + return array; +} + +function enclose(circles) { + return packEncloseRandom(circles, lcg$1()); +} + +function packEncloseRandom(circles, random) { + var i = 0, n = (circles = shuffle(Array.from(circles), random)).length, B = [], p, e; + + while (i < n) { + p = circles[i]; + if (e && enclosesWeak(e, p)) ++i; + else e = encloseBasis(B = extendBasis(B, p)), i = 0; + } + + return e; +} + +function extendBasis(B, p) { + var i, j; + + if (enclosesWeakAll(p, B)) return [p]; + + // If we get here then B must have at least one element. + for (i = 0; i < B.length; ++i) { + if (enclosesNot(p, B[i]) + && enclosesWeakAll(encloseBasis2(B[i], p), B)) { + return [B[i], p]; + } + } + + // If we get here then B must have at least two elements. + for (i = 0; i < B.length - 1; ++i) { + for (j = i + 1; j < B.length; ++j) { + if (enclosesNot(encloseBasis2(B[i], B[j]), p) + && enclosesNot(encloseBasis2(B[i], p), B[j]) + && enclosesNot(encloseBasis2(B[j], p), B[i]) + && enclosesWeakAll(encloseBasis3(B[i], B[j], p), B)) { + return [B[i], B[j], p]; + } + } + } + + // If we get here then something is very wrong. + throw new Error; +} + +function enclosesNot(a, b) { + var dr = a.r - b.r, dx = b.x - a.x, dy = b.y - a.y; + return dr < 0 || dr * dr < dx * dx + dy * dy; +} + +function enclosesWeak(a, b) { + var dr = a.r - b.r + Math.max(a.r, b.r, 1) * 1e-9, dx = b.x - a.x, dy = b.y - a.y; + return dr > 0 && dr * dr > dx * dx + dy * dy; +} + +function enclosesWeakAll(a, B) { + for (var i = 0; i < B.length; ++i) { + if (!enclosesWeak(a, B[i])) { + return false; + } + } + return true; +} + +function encloseBasis(B) { + switch (B.length) { + case 1: return encloseBasis1(B[0]); + case 2: return encloseBasis2(B[0], B[1]); + case 3: return encloseBasis3(B[0], B[1], B[2]); + } +} + +function encloseBasis1(a) { + return { + x: a.x, + y: a.y, + r: a.r + }; +} + +function encloseBasis2(a, b) { + var x1 = a.x, y1 = a.y, r1 = a.r, + x2 = b.x, y2 = b.y, r2 = b.r, + x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1, + l = Math.sqrt(x21 * x21 + y21 * y21); + return { + x: (x1 + x2 + x21 / l * r21) / 2, + y: (y1 + y2 + y21 / l * r21) / 2, + r: (l + r1 + r2) / 2 + }; +} + +function encloseBasis3(a, b, c) { + var x1 = a.x, y1 = a.y, r1 = a.r, + x2 = b.x, y2 = b.y, r2 = b.r, + x3 = c.x, y3 = c.y, r3 = c.r, + a2 = x1 - x2, + a3 = x1 - x3, + b2 = y1 - y2, + b3 = y1 - y3, + c2 = r2 - r1, + c3 = r3 - r1, + d1 = x1 * x1 + y1 * y1 - r1 * r1, + d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2, + d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3, + ab = a3 * b2 - a2 * b3, + xa = (b2 * d3 - b3 * d2) / (ab * 2) - x1, + xb = (b3 * c2 - b2 * c3) / ab, + ya = (a3 * d2 - a2 * d3) / (ab * 2) - y1, + yb = (a2 * c3 - a3 * c2) / ab, + A = xb * xb + yb * yb - 1, + B = 2 * (r1 + xa * xb + ya * yb), + C = xa * xa + ya * ya - r1 * r1, + r = -(Math.abs(A) > 1e-6 ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) : C / B); + return { + x: x1 + xa + xb * r, + y: y1 + ya + yb * r, + r: r + }; +} + +function place(b, a, c) { + var dx = b.x - a.x, x, a2, + dy = b.y - a.y, y, b2, + d2 = dx * dx + dy * dy; + if (d2) { + a2 = a.r + c.r, a2 *= a2; + b2 = b.r + c.r, b2 *= b2; + if (a2 > b2) { + x = (d2 + b2 - a2) / (2 * d2); + y = Math.sqrt(Math.max(0, b2 / d2 - x * x)); + c.x = b.x - x * dx - y * dy; + c.y = b.y - x * dy + y * dx; + } else { + x = (d2 + a2 - b2) / (2 * d2); + y = Math.sqrt(Math.max(0, a2 / d2 - x * x)); + c.x = a.x + x * dx - y * dy; + c.y = a.y + x * dy + y * dx; + } + } else { + c.x = a.x + c.r; + c.y = a.y; + } +} + +function intersects(a, b) { + var dr = a.r + b.r - 1e-6, dx = b.x - a.x, dy = b.y - a.y; + return dr > 0 && dr * dr > dx * dx + dy * dy; +} + +function score(node) { + var a = node._, + b = node.next._, + ab = a.r + b.r, + dx = (a.x * b.r + b.x * a.r) / ab, + dy = (a.y * b.r + b.y * a.r) / ab; + return dx * dx + dy * dy; +} + +function Node(circle) { + this._ = circle; + this.next = null; + this.previous = null; +} + +function packSiblingsRandom(circles, random) { + if (!(n = (circles = array$1(circles)).length)) return 0; + + var a, b, c, n, aa, ca, i, j, k, sj, sk; + + // Place the first circle. + a = circles[0], a.x = 0, a.y = 0; + if (!(n > 1)) return a.r; + + // Place the second circle. + b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0; + if (!(n > 2)) return a.r + b.r; + + // Place the third circle. + place(b, a, c = circles[2]); + + // Initialize the front-chain using the first three circles a, b and c. + a = new Node(a), b = new Node(b), c = new Node(c); + a.next = c.previous = b; + b.next = a.previous = c; + c.next = b.previous = a; + + // Attempt to place each remaining circle… + pack: for (i = 3; i < n; ++i) { + place(a._, b._, c = circles[i]), c = new Node(c); + + // Find the closest intersecting circle on the front-chain, if any. + // “Closeness” is determined by linear distance along the front-chain. + // “Ahead” or “behind” is likewise determined by linear distance. + j = b.next, k = a.previous, sj = b._.r, sk = a._.r; + do { + if (sj <= sk) { + if (intersects(j._, c._)) { + b = j, a.next = b, b.previous = a, --i; + continue pack; + } + sj += j._.r, j = j.next; + } else { + if (intersects(k._, c._)) { + a = k, a.next = b, b.previous = a, --i; + continue pack; + } + sk += k._.r, k = k.previous; + } + } while (j !== k.next); + + // Success! Insert the new circle c between a and b. + c.previous = a, c.next = b, a.next = b.previous = b = c; + + // Compute the new closest circle pair to the centroid. + aa = score(a); + while ((c = c.next) !== b) { + if ((ca = score(c)) < aa) { + a = c, aa = ca; + } + } + b = a.next; + } + + // Compute the enclosing circle of the front chain. + a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = packEncloseRandom(a, random); + + // Translate the circles to put the enclosing circle around the origin. + for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y; + + return c.r; +} + +function siblings(circles) { + packSiblingsRandom(circles, lcg$1()); + return circles; +} + +function defaultRadius(d) { + return Math.sqrt(d.value); +} + +function index$1() { + var radius = null, + dx = 1, + dy = 1, + padding = constantZero; + + function pack(root) { + const random = lcg$1(); + root.x = dx / 2, root.y = dy / 2; + if (radius) { + root.eachBefore(radiusLeaf(radius)) + .eachAfter(packChildrenRandom(padding, 0.5, random)) + .eachBefore(translateChild(1)); + } else { + root.eachBefore(radiusLeaf(defaultRadius)) + .eachAfter(packChildrenRandom(constantZero, 1, random)) + .eachAfter(packChildrenRandom(padding, root.r / Math.min(dx, dy), random)) + .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r))); + } + return root; + } + + pack.radius = function(x) { + return arguments.length ? (radius = optional(x), pack) : radius; + }; + + pack.size = function(x) { + return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy]; + }; + + pack.padding = function(x) { + return arguments.length ? (padding = typeof x === "function" ? x : constant$2(+x), pack) : padding; + }; + + return pack; +} + +function radiusLeaf(radius) { + return function(node) { + if (!node.children) { + node.r = Math.max(0, +radius(node) || 0); + } + }; +} + +function packChildrenRandom(padding, k, random) { + return function(node) { + if (children = node.children) { + var children, + i, + n = children.length, + r = padding(node) * k || 0, + e; + + if (r) for (i = 0; i < n; ++i) children[i].r += r; + e = packSiblingsRandom(children, random); + if (r) for (i = 0; i < n; ++i) children[i].r -= r; + node.r = e + r; + } + }; +} + +function translateChild(k) { + return function(node) { + var parent = node.parent; + node.r *= k; + if (parent) { + node.x = parent.x + k * node.x; + node.y = parent.y + k * node.y; + } + }; +} + +function roundNode(node) { + node.x0 = Math.round(node.x0); + node.y0 = Math.round(node.y0); + node.x1 = Math.round(node.x1); + node.y1 = Math.round(node.y1); +} + +function treemapDice(parent, x0, y0, x1, y1) { + var nodes = parent.children, + node, + i = -1, + n = nodes.length, + k = parent.value && (x1 - x0) / parent.value; + + while (++i < n) { + node = nodes[i], node.y0 = y0, node.y1 = y1; + node.x0 = x0, node.x1 = x0 += node.value * k; + } +} + +function partition() { + var dx = 1, + dy = 1, + padding = 0, + round = false; + + function partition(root) { + var n = root.height + 1; + root.x0 = + root.y0 = padding; + root.x1 = dx; + root.y1 = dy / n; + root.eachBefore(positionNode(dy, n)); + if (round) root.eachBefore(roundNode); + return root; + } + + function positionNode(dy, n) { + return function(node) { + if (node.children) { + treemapDice(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n); + } + var x0 = node.x0, + y0 = node.y0, + x1 = node.x1 - padding, + y1 = node.y1 - padding; + if (x1 < x0) x0 = x1 = (x0 + x1) / 2; + if (y1 < y0) y0 = y1 = (y0 + y1) / 2; + node.x0 = x0; + node.y0 = y0; + node.x1 = x1; + node.y1 = y1; + }; + } + + partition.round = function(x) { + return arguments.length ? (round = !!x, partition) : round; + }; + + partition.size = function(x) { + return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy]; + }; + + partition.padding = function(x) { + return arguments.length ? (padding = +x, partition) : padding; + }; + + return partition; +} + +var preroot = {depth: -1}, + ambiguous = {}, + imputed = {}; + +function defaultId(d) { + return d.id; +} + +function defaultParentId(d) { + return d.parentId; +} + +function stratify() { + var id = defaultId, + parentId = defaultParentId, + path; + + function stratify(data) { + var nodes = Array.from(data), + currentId = id, + currentParentId = parentId, + n, + d, + i, + root, + parent, + node, + nodeId, + nodeKey, + nodeByKey = new Map; + + if (path != null) { + const I = nodes.map((d, i) => normalize$1(path(d, i, data))); + const P = I.map(parentof); + const S = new Set(I).add(""); + for (const i of P) { + if (!S.has(i)) { + S.add(i); + I.push(i); + P.push(parentof(i)); + nodes.push(imputed); + } + } + currentId = (_, i) => I[i]; + currentParentId = (_, i) => P[i]; + } + + for (i = 0, n = nodes.length; i < n; ++i) { + d = nodes[i], node = nodes[i] = new Node$1(d); + if ((nodeId = currentId(d, i, data)) != null && (nodeId += "")) { + nodeKey = node.id = nodeId; + nodeByKey.set(nodeKey, nodeByKey.has(nodeKey) ? ambiguous : node); + } + if ((nodeId = currentParentId(d, i, data)) != null && (nodeId += "")) { + node.parent = nodeId; + } + } + + for (i = 0; i < n; ++i) { + node = nodes[i]; + if (nodeId = node.parent) { + parent = nodeByKey.get(nodeId); + if (!parent) throw new Error("missing: " + nodeId); + if (parent === ambiguous) throw new Error("ambiguous: " + nodeId); + if (parent.children) parent.children.push(node); + else parent.children = [node]; + node.parent = parent; + } else { + if (root) throw new Error("multiple roots"); + root = node; + } + } + + if (!root) throw new Error("no root"); + + // When imputing internal nodes, only introduce roots if needed. + // Then replace the imputed marker data with null. + if (path != null) { + while (root.data === imputed && root.children.length === 1) { + root = root.children[0], --n; + } + for (let i = nodes.length - 1; i >= 0; --i) { + node = nodes[i]; + if (node.data !== imputed) break; + node.data = null; + } + } + + root.parent = preroot; + root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight); + root.parent = null; + if (n > 0) throw new Error("cycle"); + + return root; + } + + stratify.id = function(x) { + return arguments.length ? (id = optional(x), stratify) : id; + }; + + stratify.parentId = function(x) { + return arguments.length ? (parentId = optional(x), stratify) : parentId; + }; + + stratify.path = function(x) { + return arguments.length ? (path = optional(x), stratify) : path; + }; + + return stratify; +} + +// To normalize a path, we coerce to a string, strip the trailing slash if any +// (as long as the trailing slash is not immediately preceded by another slash), +// and add leading slash if missing. +function normalize$1(path) { + path = `${path}`; + let i = path.length; + if (slash(path, i - 1) && !slash(path, i - 2)) path = path.slice(0, -1); + return path[0] === "/" ? path : `/${path}`; +} + +// Walk backwards to find the first slash that is not the leading slash, e.g.: +// "/foo/bar" ⇥ "/foo", "/foo" ⇥ "/", "/" ↦ "". (The root is special-cased +// because the id of the root must be a truthy value.) +function parentof(path) { + let i = path.length; + if (i < 2) return ""; + while (--i > 1) if (slash(path, i)) break; + return path.slice(0, i); +} + +// Slashes can be escaped; to determine whether a slash is a path delimiter, we +// count the number of preceding backslashes escaping the forward slash: an odd +// number indicates an escaped forward slash. +function slash(path, i) { + if (path[i] === "/") { + let k = 0; + while (i > 0 && path[--i] === "\\") ++k; + if ((k & 1) === 0) return true; + } + return false; +} + +function defaultSeparation(a, b) { + return a.parent === b.parent ? 1 : 2; +} + +// function radialSeparation(a, b) { +// return (a.parent === b.parent ? 1 : 2) / a.depth; +// } + +// This function is used to traverse the left contour of a subtree (or +// subforest). It returns the successor of v on this contour. This successor is +// either given by the leftmost child of v or by the thread of v. The function +// returns null if and only if v is on the highest level of its subtree. +function nextLeft(v) { + var children = v.children; + return children ? children[0] : v.t; +} + +// This function works analogously to nextLeft. +function nextRight(v) { + var children = v.children; + return children ? children[children.length - 1] : v.t; +} + +// Shifts the current subtree rooted at w+. This is done by increasing +// prelim(w+) and mod(w+) by shift. +function moveSubtree(wm, wp, shift) { + var change = shift / (wp.i - wm.i); + wp.c -= change; + wp.s += shift; + wm.c += change; + wp.z += shift; + wp.m += shift; +} + +// All other shifts, applied to the smaller subtrees between w- and w+, are +// performed by this function. To prepare the shifts, we have to adjust +// change(w+), shift(w+), and change(w-). +function executeShifts(v) { + var shift = 0, + change = 0, + children = v.children, + i = children.length, + w; + while (--i >= 0) { + w = children[i]; + w.z += shift; + w.m += shift; + shift += w.s + (change += w.c); + } +} + +// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise, +// returns the specified (default) ancestor. +function nextAncestor(vim, v, ancestor) { + return vim.a.parent === v.parent ? vim.a : ancestor; +} + +function TreeNode(node, i) { + this._ = node; + this.parent = null; + this.children = null; + this.A = null; // default ancestor + this.a = this; // ancestor + this.z = 0; // prelim + this.m = 0; // mod + this.c = 0; // change + this.s = 0; // shift + this.t = null; // thread + this.i = i; // number +} + +TreeNode.prototype = Object.create(Node$1.prototype); + +function treeRoot(root) { + var tree = new TreeNode(root, 0), + node, + nodes = [tree], + child, + children, + i, + n; + + while (node = nodes.pop()) { + if (children = node._.children) { + node.children = new Array(n = children.length); + for (i = n - 1; i >= 0; --i) { + nodes.push(child = node.children[i] = new TreeNode(children[i], i)); + child.parent = node; + } + } + } + + (tree.parent = new TreeNode(null, 0)).children = [tree]; + return tree; +} + +// Node-link tree diagram using the Reingold-Tilford "tidy" algorithm +function tree() { + var separation = defaultSeparation, + dx = 1, + dy = 1, + nodeSize = null; + + function tree(root) { + var t = treeRoot(root); + + // Compute the layout using Buchheim et al.’s algorithm. + t.eachAfter(firstWalk), t.parent.m = -t.z; + t.eachBefore(secondWalk); + + // If a fixed node size is specified, scale x and y. + if (nodeSize) root.eachBefore(sizeNode); + + // If a fixed tree size is specified, scale x and y based on the extent. + // Compute the left-most, right-most, and depth-most nodes for extents. + else { + var left = root, + right = root, + bottom = root; + root.eachBefore(function(node) { + if (node.x < left.x) left = node; + if (node.x > right.x) right = node; + if (node.depth > bottom.depth) bottom = node; + }); + var s = left === right ? 1 : separation(left, right) / 2, + tx = s - left.x, + kx = dx / (right.x + s + tx), + ky = dy / (bottom.depth || 1); + root.eachBefore(function(node) { + node.x = (node.x + tx) * kx; + node.y = node.depth * ky; + }); + } + + return root; + } + + // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is + // applied recursively to the children of v, as well as the function + // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the + // node v is placed to the midpoint of its outermost children. + function firstWalk(v) { + var children = v.children, + siblings = v.parent.children, + w = v.i ? siblings[v.i - 1] : null; + if (children) { + executeShifts(v); + var midpoint = (children[0].z + children[children.length - 1].z) / 2; + if (w) { + v.z = w.z + separation(v._, w._); + v.m = v.z - midpoint; + } else { + v.z = midpoint; + } + } else if (w) { + v.z = w.z + separation(v._, w._); + } + v.parent.A = apportion(v, w, v.parent.A || siblings[0]); + } + + // Computes all real x-coordinates by summing up the modifiers recursively. + function secondWalk(v) { + v._.x = v.z + v.parent.m; + v.m += v.parent.m; + } + + // The core of the algorithm. Here, a new subtree is combined with the + // previous subtrees. Threads are used to traverse the inside and outside + // contours of the left and right subtree up to the highest common level. The + // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the + // superscript o means outside and i means inside, the subscript - means left + // subtree and + means right subtree. For summing up the modifiers along the + // contour, we use respective variables si+, si-, so-, and so+. Whenever two + // nodes of the inside contours conflict, we compute the left one of the + // greatest uncommon ancestors using the function ANCESTOR and call MOVE + // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees. + // Finally, we add a new thread (if necessary). + function apportion(v, w, ancestor) { + if (w) { + var vip = v, + vop = v, + vim = w, + vom = vip.parent.children[0], + sip = vip.m, + sop = vop.m, + sim = vim.m, + som = vom.m, + shift; + while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) { + vom = nextLeft(vom); + vop = nextRight(vop); + vop.a = v; + shift = vim.z + sim - vip.z - sip + separation(vim._, vip._); + if (shift > 0) { + moveSubtree(nextAncestor(vim, v, ancestor), v, shift); + sip += shift; + sop += shift; + } + sim += vim.m; + sip += vip.m; + som += vom.m; + sop += vop.m; + } + if (vim && !nextRight(vop)) { + vop.t = vim; + vop.m += sim - sop; + } + if (vip && !nextLeft(vom)) { + vom.t = vip; + vom.m += sip - som; + ancestor = v; + } + } + return ancestor; + } + + function sizeNode(node) { + node.x *= dx; + node.y = node.depth * dy; + } + + tree.separation = function(x) { + return arguments.length ? (separation = x, tree) : separation; + }; + + tree.size = function(x) { + return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]); + }; + + tree.nodeSize = function(x) { + return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null); + }; + + return tree; +} + +function treemapSlice(parent, x0, y0, x1, y1) { + var nodes = parent.children, + node, + i = -1, + n = nodes.length, + k = parent.value && (y1 - y0) / parent.value; + + while (++i < n) { + node = nodes[i], node.x0 = x0, node.x1 = x1; + node.y0 = y0, node.y1 = y0 += node.value * k; + } +} + +var phi = (1 + Math.sqrt(5)) / 2; + +function squarifyRatio(ratio, parent, x0, y0, x1, y1) { + var rows = [], + nodes = parent.children, + row, + nodeValue, + i0 = 0, + i1 = 0, + n = nodes.length, + dx, dy, + value = parent.value, + sumValue, + minValue, + maxValue, + newRatio, + minRatio, + alpha, + beta; + + while (i0 < n) { + dx = x1 - x0, dy = y1 - y0; + + // Find the next non-empty node. + do sumValue = nodes[i1++].value; while (!sumValue && i1 < n); + minValue = maxValue = sumValue; + alpha = Math.max(dy / dx, dx / dy) / (value * ratio); + beta = sumValue * sumValue * alpha; + minRatio = Math.max(maxValue / beta, beta / minValue); + + // Keep adding nodes while the aspect ratio maintains or improves. + for (; i1 < n; ++i1) { + sumValue += nodeValue = nodes[i1].value; + if (nodeValue < minValue) minValue = nodeValue; + if (nodeValue > maxValue) maxValue = nodeValue; + beta = sumValue * sumValue * alpha; + newRatio = Math.max(maxValue / beta, beta / minValue); + if (newRatio > minRatio) { sumValue -= nodeValue; break; } + minRatio = newRatio; + } + + // Position and record the row orientation. + rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)}); + if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1); + else treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1); + value -= sumValue, i0 = i1; + } + + return rows; +} + +var squarify = (function custom(ratio) { + + function squarify(parent, x0, y0, x1, y1) { + squarifyRatio(ratio, parent, x0, y0, x1, y1); + } + + squarify.ratio = function(x) { + return custom((x = +x) > 1 ? x : 1); + }; + + return squarify; +})(phi); + +function index() { + var tile = squarify, + round = false, + dx = 1, + dy = 1, + paddingStack = [0], + paddingInner = constantZero, + paddingTop = constantZero, + paddingRight = constantZero, + paddingBottom = constantZero, + paddingLeft = constantZero; + + function treemap(root) { + root.x0 = + root.y0 = 0; + root.x1 = dx; + root.y1 = dy; + root.eachBefore(positionNode); + paddingStack = [0]; + if (round) root.eachBefore(roundNode); + return root; + } + + function positionNode(node) { + var p = paddingStack[node.depth], + x0 = node.x0 + p, + y0 = node.y0 + p, + x1 = node.x1 - p, + y1 = node.y1 - p; + if (x1 < x0) x0 = x1 = (x0 + x1) / 2; + if (y1 < y0) y0 = y1 = (y0 + y1) / 2; + node.x0 = x0; + node.y0 = y0; + node.x1 = x1; + node.y1 = y1; + if (node.children) { + p = paddingStack[node.depth + 1] = paddingInner(node) / 2; + x0 += paddingLeft(node) - p; + y0 += paddingTop(node) - p; + x1 -= paddingRight(node) - p; + y1 -= paddingBottom(node) - p; + if (x1 < x0) x0 = x1 = (x0 + x1) / 2; + if (y1 < y0) y0 = y1 = (y0 + y1) / 2; + tile(node, x0, y0, x1, y1); + } + } + + treemap.round = function(x) { + return arguments.length ? (round = !!x, treemap) : round; + }; + + treemap.size = function(x) { + return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy]; + }; + + treemap.tile = function(x) { + return arguments.length ? (tile = required(x), treemap) : tile; + }; + + treemap.padding = function(x) { + return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner(); + }; + + treemap.paddingInner = function(x) { + return arguments.length ? (paddingInner = typeof x === "function" ? x : constant$2(+x), treemap) : paddingInner; + }; + + treemap.paddingOuter = function(x) { + return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop(); + }; + + treemap.paddingTop = function(x) { + return arguments.length ? (paddingTop = typeof x === "function" ? x : constant$2(+x), treemap) : paddingTop; + }; + + treemap.paddingRight = function(x) { + return arguments.length ? (paddingRight = typeof x === "function" ? x : constant$2(+x), treemap) : paddingRight; + }; + + treemap.paddingBottom = function(x) { + return arguments.length ? (paddingBottom = typeof x === "function" ? x : constant$2(+x), treemap) : paddingBottom; + }; + + treemap.paddingLeft = function(x) { + return arguments.length ? (paddingLeft = typeof x === "function" ? x : constant$2(+x), treemap) : paddingLeft; + }; + + return treemap; +} + +function binary(parent, x0, y0, x1, y1) { + var nodes = parent.children, + i, n = nodes.length, + sum, sums = new Array(n + 1); + + for (sums[0] = sum = i = 0; i < n; ++i) { + sums[i + 1] = sum += nodes[i].value; + } + + partition(0, n, parent.value, x0, y0, x1, y1); + + function partition(i, j, value, x0, y0, x1, y1) { + if (i >= j - 1) { + var node = nodes[i]; + node.x0 = x0, node.y0 = y0; + node.x1 = x1, node.y1 = y1; + return; + } + + var valueOffset = sums[i], + valueTarget = (value / 2) + valueOffset, + k = i + 1, + hi = j - 1; + + while (k < hi) { + var mid = k + hi >>> 1; + if (sums[mid] < valueTarget) k = mid + 1; + else hi = mid; + } + + if ((valueTarget - sums[k - 1]) < (sums[k] - valueTarget) && i + 1 < k) --k; + + var valueLeft = sums[k] - valueOffset, + valueRight = value - valueLeft; + + if ((x1 - x0) > (y1 - y0)) { + var xk = value ? (x0 * valueRight + x1 * valueLeft) / value : x1; + partition(i, k, valueLeft, x0, y0, xk, y1); + partition(k, j, valueRight, xk, y0, x1, y1); + } else { + var yk = value ? (y0 * valueRight + y1 * valueLeft) / value : y1; + partition(i, k, valueLeft, x0, y0, x1, yk); + partition(k, j, valueRight, x0, yk, x1, y1); + } + } +} + +function sliceDice(parent, x0, y0, x1, y1) { + (parent.depth & 1 ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1); +} + +var resquarify = (function custom(ratio) { + + function resquarify(parent, x0, y0, x1, y1) { + if ((rows = parent._squarify) && (rows.ratio === ratio)) { + var rows, + row, + nodes, + i, + j = -1, + n, + m = rows.length, + value = parent.value; + + while (++j < m) { + row = rows[j], nodes = row.children; + for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value; + if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += (y1 - y0) * row.value / value : y1); + else treemapSlice(row, x0, y0, value ? x0 += (x1 - x0) * row.value / value : x1, y1); + value -= row.value; + } + } else { + parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1); + rows.ratio = ratio; + } + } + + resquarify.ratio = function(x) { + return custom((x = +x) > 1 ? x : 1); + }; + + return resquarify; +})(phi); + +function area$1(polygon) { + var i = -1, + n = polygon.length, + a, + b = polygon[n - 1], + area = 0; + + while (++i < n) { + a = b; + b = polygon[i]; + area += a[1] * b[0] - a[0] * b[1]; + } + + return area / 2; +} + +function centroid(polygon) { + var i = -1, + n = polygon.length, + x = 0, + y = 0, + a, + b = polygon[n - 1], + c, + k = 0; + + while (++i < n) { + a = b; + b = polygon[i]; + k += c = a[0] * b[1] - b[0] * a[1]; + x += (a[0] + b[0]) * c; + y += (a[1] + b[1]) * c; + } + + return k *= 3, [x / k, y / k]; +} + +// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of +// the 3D cross product in a quadrant I Cartesian coordinate system (+x is +// right, +y is up). Returns a positive value if ABC is counter-clockwise, +// negative if clockwise, and zero if the points are collinear. +function cross$1(a, b, c) { + return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); +} + +function lexicographicOrder(a, b) { + return a[0] - b[0] || a[1] - b[1]; +} + +// Computes the upper convex hull per the monotone chain algorithm. +// Assumes points.length >= 3, is sorted by x, unique in y. +// Returns an array of indices into points in left-to-right order. +function computeUpperHullIndexes(points) { + const n = points.length, + indexes = [0, 1]; + let size = 2, i; + + for (i = 2; i < n; ++i) { + while (size > 1 && cross$1(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size; + indexes[size++] = i; + } + + return indexes.slice(0, size); // remove popped points +} + +function hull(points) { + if ((n = points.length) < 3) return null; + + var i, + n, + sortedPoints = new Array(n), + flippedPoints = new Array(n); + + for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i]; + sortedPoints.sort(lexicographicOrder); + for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]]; + + var upperIndexes = computeUpperHullIndexes(sortedPoints), + lowerIndexes = computeUpperHullIndexes(flippedPoints); + + // Construct the hull polygon, removing possible duplicate endpoints. + var skipLeft = lowerIndexes[0] === upperIndexes[0], + skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1], + hull = []; + + // Add upper hull in right-to-l order. + // Then add lower hull in left-to-right order. + for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]); + for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]); + + return hull; +} + +function contains(polygon, point) { + var n = polygon.length, + p = polygon[n - 1], + x = point[0], y = point[1], + x0 = p[0], y0 = p[1], + x1, y1, + inside = false; + + for (var i = 0; i < n; ++i) { + p = polygon[i], x1 = p[0], y1 = p[1]; + if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside; + x0 = x1, y0 = y1; + } + + return inside; +} + +function length(polygon) { + var i = -1, + n = polygon.length, + b = polygon[n - 1], + xa, + ya, + xb = b[0], + yb = b[1], + perimeter = 0; + + while (++i < n) { + xa = xb; + ya = yb; + b = polygon[i]; + xb = b[0]; + yb = b[1]; + xa -= xb; + ya -= yb; + perimeter += Math.hypot(xa, ya); + } + + return perimeter; +} + +var defaultSource = Math.random; + +var uniform = (function sourceRandomUniform(source) { + function randomUniform(min, max) { + min = min == null ? 0 : +min; + max = max == null ? 1 : +max; + if (arguments.length === 1) max = min, min = 0; + else max -= min; + return function() { + return source() * max + min; + }; + } + + randomUniform.source = sourceRandomUniform; + + return randomUniform; +})(defaultSource); + +var int = (function sourceRandomInt(source) { + function randomInt(min, max) { + if (arguments.length < 2) max = min, min = 0; + min = Math.floor(min); + max = Math.floor(max) - min; + return function() { + return Math.floor(source() * max + min); + }; + } + + randomInt.source = sourceRandomInt; + + return randomInt; +})(defaultSource); + +var normal = (function sourceRandomNormal(source) { + function randomNormal(mu, sigma) { + var x, r; + mu = mu == null ? 0 : +mu; + sigma = sigma == null ? 1 : +sigma; + return function() { + var y; + + // If available, use the second previously-generated uniform random. + if (x != null) y = x, x = null; + + // Otherwise, generate a new x and y. + else do { + x = source() * 2 - 1; + y = source() * 2 - 1; + r = x * x + y * y; + } while (!r || r > 1); + + return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r); + }; + } + + randomNormal.source = sourceRandomNormal; + + return randomNormal; +})(defaultSource); + +var logNormal = (function sourceRandomLogNormal(source) { + var N = normal.source(source); + + function randomLogNormal() { + var randomNormal = N.apply(this, arguments); + return function() { + return Math.exp(randomNormal()); + }; + } + + randomLogNormal.source = sourceRandomLogNormal; + + return randomLogNormal; +})(defaultSource); + +var irwinHall = (function sourceRandomIrwinHall(source) { + function randomIrwinHall(n) { + if ((n = +n) <= 0) return () => 0; + return function() { + for (var sum = 0, i = n; i > 1; --i) sum += source(); + return sum + i * source(); + }; + } + + randomIrwinHall.source = sourceRandomIrwinHall; + + return randomIrwinHall; +})(defaultSource); + +var bates = (function sourceRandomBates(source) { + var I = irwinHall.source(source); + + function randomBates(n) { + // use limiting distribution at n === 0 + if ((n = +n) === 0) return source; + var randomIrwinHall = I(n); + return function() { + return randomIrwinHall() / n; + }; + } + + randomBates.source = sourceRandomBates; + + return randomBates; +})(defaultSource); + +var exponential = (function sourceRandomExponential(source) { + function randomExponential(lambda) { + return function() { + return -Math.log1p(-source()) / lambda; + }; + } + + randomExponential.source = sourceRandomExponential; + + return randomExponential; +})(defaultSource); + +var pareto = (function sourceRandomPareto(source) { + function randomPareto(alpha) { + if ((alpha = +alpha) < 0) throw new RangeError("invalid alpha"); + alpha = 1 / -alpha; + return function() { + return Math.pow(1 - source(), alpha); + }; + } + + randomPareto.source = sourceRandomPareto; + + return randomPareto; +})(defaultSource); + +var bernoulli = (function sourceRandomBernoulli(source) { + function randomBernoulli(p) { + if ((p = +p) < 0 || p > 1) throw new RangeError("invalid p"); + return function() { + return Math.floor(source() + p); + }; + } + + randomBernoulli.source = sourceRandomBernoulli; + + return randomBernoulli; +})(defaultSource); + +var geometric = (function sourceRandomGeometric(source) { + function randomGeometric(p) { + if ((p = +p) < 0 || p > 1) throw new RangeError("invalid p"); + if (p === 0) return () => Infinity; + if (p === 1) return () => 1; + p = Math.log1p(-p); + return function() { + return 1 + Math.floor(Math.log1p(-source()) / p); + }; + } + + randomGeometric.source = sourceRandomGeometric; + + return randomGeometric; +})(defaultSource); + +var gamma = (function sourceRandomGamma(source) { + var randomNormal = normal.source(source)(); + + function randomGamma(k, theta) { + if ((k = +k) < 0) throw new RangeError("invalid k"); + // degenerate distribution if k === 0 + if (k === 0) return () => 0; + theta = theta == null ? 1 : +theta; + // exponential distribution if k === 1 + if (k === 1) return () => -Math.log1p(-source()) * theta; + + var d = (k < 1 ? k + 1 : k) - 1 / 3, + c = 1 / (3 * Math.sqrt(d)), + multiplier = k < 1 ? () => Math.pow(source(), 1 / k) : () => 1; + return function() { + do { + do { + var x = randomNormal(), + v = 1 + c * x; + } while (v <= 0); + v *= v * v; + var u = 1 - source(); + } while (u >= 1 - 0.0331 * x * x * x * x && Math.log(u) >= 0.5 * x * x + d * (1 - v + Math.log(v))); + return d * v * multiplier() * theta; + }; + } + + randomGamma.source = sourceRandomGamma; + + return randomGamma; +})(defaultSource); + +var beta = (function sourceRandomBeta(source) { + var G = gamma.source(source); + + function randomBeta(alpha, beta) { + var X = G(alpha), + Y = G(beta); + return function() { + var x = X(); + return x === 0 ? 0 : x / (x + Y()); + }; + } + + randomBeta.source = sourceRandomBeta; + + return randomBeta; +})(defaultSource); + +var binomial = (function sourceRandomBinomial(source) { + var G = geometric.source(source), + B = beta.source(source); + + function randomBinomial(n, p) { + n = +n; + if ((p = +p) >= 1) return () => n; + if (p <= 0) return () => 0; + return function() { + var acc = 0, nn = n, pp = p; + while (nn * pp > 16 && nn * (1 - pp) > 16) { + var i = Math.floor((nn + 1) * pp), + y = B(i, nn - i + 1)(); + if (y <= pp) { + acc += i; + nn -= i; + pp = (pp - y) / (1 - y); + } else { + nn = i - 1; + pp /= y; + } + } + var sign = pp < 0.5, + pFinal = sign ? pp : 1 - pp, + g = G(pFinal); + for (var s = g(), k = 0; s <= nn; ++k) s += g(); + return acc + (sign ? k : nn - k); + }; + } + + randomBinomial.source = sourceRandomBinomial; + + return randomBinomial; +})(defaultSource); + +var weibull = (function sourceRandomWeibull(source) { + function randomWeibull(k, a, b) { + var outerFunc; + if ((k = +k) === 0) { + outerFunc = x => -Math.log(x); + } else { + k = 1 / k; + outerFunc = x => Math.pow(x, k); + } + a = a == null ? 0 : +a; + b = b == null ? 1 : +b; + return function() { + return a + b * outerFunc(-Math.log1p(-source())); + }; + } + + randomWeibull.source = sourceRandomWeibull; + + return randomWeibull; +})(defaultSource); + +var cauchy = (function sourceRandomCauchy(source) { + function randomCauchy(a, b) { + a = a == null ? 0 : +a; + b = b == null ? 1 : +b; + return function() { + return a + b * Math.tan(Math.PI * source()); + }; + } + + randomCauchy.source = sourceRandomCauchy; + + return randomCauchy; +})(defaultSource); + +var logistic = (function sourceRandomLogistic(source) { + function randomLogistic(a, b) { + a = a == null ? 0 : +a; + b = b == null ? 1 : +b; + return function() { + var u = source(); + return a + b * Math.log(u / (1 - u)); + }; + } + + randomLogistic.source = sourceRandomLogistic; + + return randomLogistic; +})(defaultSource); + +var poisson = (function sourceRandomPoisson(source) { + var G = gamma.source(source), + B = binomial.source(source); + + function randomPoisson(lambda) { + return function() { + var acc = 0, l = lambda; + while (l > 16) { + var n = Math.floor(0.875 * l), + t = G(n)(); + if (t > l) return acc + B(n - 1, l / t)(); + acc += n; + l -= t; + } + for (var s = -Math.log1p(-source()), k = 0; s <= l; ++k) s -= Math.log1p(-source()); + return acc + k; + }; + } + + randomPoisson.source = sourceRandomPoisson; + + return randomPoisson; +})(defaultSource); + +// https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use +const mul = 0x19660D; +const inc = 0x3C6EF35F; +const eps = 1 / 0x100000000; + +function lcg(seed = Math.random()) { + let state = (0 <= seed && seed < 1 ? seed / eps : Math.abs(seed)) | 0; + return () => (state = mul * state + inc | 0, eps * (state >>> 0)); +} + +function initRange(domain, range) { + switch (arguments.length) { + case 0: break; + case 1: this.range(domain); break; + default: this.range(range).domain(domain); break; + } + return this; +} + +function initInterpolator(domain, interpolator) { + switch (arguments.length) { + case 0: break; + case 1: { + if (typeof domain === "function") this.interpolator(domain); + else this.range(domain); + break; + } + default: { + this.domain(domain); + if (typeof interpolator === "function") this.interpolator(interpolator); + else this.range(interpolator); + break; + } + } + return this; +} + +const implicit = Symbol("implicit"); + +function ordinal() { + var index = new InternMap(), + domain = [], + range = [], + unknown = implicit; + + function scale(d) { + let i = index.get(d); + if (i === undefined) { + if (unknown !== implicit) return unknown; + index.set(d, i = domain.push(d) - 1); + } + return range[i % range.length]; + } + + scale.domain = function(_) { + if (!arguments.length) return domain.slice(); + domain = [], index = new InternMap(); + for (const value of _) { + if (index.has(value)) continue; + index.set(value, domain.push(value) - 1); + } + return scale; + }; + + scale.range = function(_) { + return arguments.length ? (range = Array.from(_), scale) : range.slice(); + }; + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + scale.copy = function() { + return ordinal(domain, range).unknown(unknown); + }; + + initRange.apply(scale, arguments); + + return scale; +} + +function band() { + var scale = ordinal().unknown(undefined), + domain = scale.domain, + ordinalRange = scale.range, + r0 = 0, + r1 = 1, + step, + bandwidth, + round = false, + paddingInner = 0, + paddingOuter = 0, + align = 0.5; + + delete scale.unknown; + + function rescale() { + var n = domain().length, + reverse = r1 < r0, + start = reverse ? r1 : r0, + stop = reverse ? r0 : r1; + step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2); + if (round) step = Math.floor(step); + start += (stop - start - step * (n - paddingInner)) * align; + bandwidth = step * (1 - paddingInner); + if (round) start = Math.round(start), bandwidth = Math.round(bandwidth); + var values = range$2(n).map(function(i) { return start + step * i; }); + return ordinalRange(reverse ? values.reverse() : values); + } + + scale.domain = function(_) { + return arguments.length ? (domain(_), rescale()) : domain(); + }; + + scale.range = function(_) { + return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [r0, r1]; + }; + + scale.rangeRound = function(_) { + return [r0, r1] = _, r0 = +r0, r1 = +r1, round = true, rescale(); + }; + + scale.bandwidth = function() { + return bandwidth; + }; + + scale.step = function() { + return step; + }; + + scale.round = function(_) { + return arguments.length ? (round = !!_, rescale()) : round; + }; + + scale.padding = function(_) { + return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner; + }; + + scale.paddingInner = function(_) { + return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner; + }; + + scale.paddingOuter = function(_) { + return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter; + }; + + scale.align = function(_) { + return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align; + }; + + scale.copy = function() { + return band(domain(), [r0, r1]) + .round(round) + .paddingInner(paddingInner) + .paddingOuter(paddingOuter) + .align(align); + }; + + return initRange.apply(rescale(), arguments); +} + +function pointish(scale) { + var copy = scale.copy; + + scale.padding = scale.paddingOuter; + delete scale.paddingInner; + delete scale.paddingOuter; + + scale.copy = function() { + return pointish(copy()); + }; + + return scale; +} + +function point$4() { + return pointish(band.apply(null, arguments).paddingInner(1)); +} + +function constants(x) { + return function() { + return x; + }; +} + +function number$1(x) { + return +x; +} + +var unit = [0, 1]; + +function identity$3(x) { + return x; +} + +function normalize(a, b) { + return (b -= (a = +a)) + ? function(x) { return (x - a) / b; } + : constants(isNaN(b) ? NaN : 0.5); +} + +function clamper(a, b) { + var t; + if (a > b) t = a, a = b, b = t; + return function(x) { return Math.max(a, Math.min(b, x)); }; +} + +// normalize(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1]. +// interpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding range value x in [a,b]. +function bimap(domain, range, interpolate) { + var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1]; + if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0); + else d0 = normalize(d0, d1), r0 = interpolate(r0, r1); + return function(x) { return r0(d0(x)); }; +} + +function polymap(domain, range, interpolate) { + var j = Math.min(domain.length, range.length) - 1, + d = new Array(j), + r = new Array(j), + i = -1; + + // Reverse descending domains. + if (domain[j] < domain[0]) { + domain = domain.slice().reverse(); + range = range.slice().reverse(); + } + + while (++i < j) { + d[i] = normalize(domain[i], domain[i + 1]); + r[i] = interpolate(range[i], range[i + 1]); + } + + return function(x) { + var i = bisect(domain, x, 1, j) - 1; + return r[i](d[i](x)); + }; +} + +function copy$1(source, target) { + return target + .domain(source.domain()) + .range(source.range()) + .interpolate(source.interpolate()) + .clamp(source.clamp()) + .unknown(source.unknown()); +} + +function transformer$2() { + var domain = unit, + range = unit, + interpolate = interpolate$2, + transform, + untransform, + unknown, + clamp = identity$3, + piecewise, + output, + input; + + function rescale() { + var n = Math.min(domain.length, range.length); + if (clamp !== identity$3) clamp = clamper(domain[0], domain[n - 1]); + piecewise = n > 2 ? polymap : bimap; + output = input = null; + return scale; + } + + function scale(x) { + return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate)))(transform(clamp(x))); + } + + scale.invert = function(y) { + return clamp(untransform((input || (input = piecewise(range, domain.map(transform), interpolateNumber)))(y))); + }; + + scale.domain = function(_) { + return arguments.length ? (domain = Array.from(_, number$1), rescale()) : domain.slice(); + }; + + scale.range = function(_) { + return arguments.length ? (range = Array.from(_), rescale()) : range.slice(); + }; + + scale.rangeRound = function(_) { + return range = Array.from(_), interpolate = interpolateRound, rescale(); + }; + + scale.clamp = function(_) { + return arguments.length ? (clamp = _ ? true : identity$3, rescale()) : clamp !== identity$3; + }; + + scale.interpolate = function(_) { + return arguments.length ? (interpolate = _, rescale()) : interpolate; + }; + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + return function(t, u) { + transform = t, untransform = u; + return rescale(); + }; +} + +function continuous() { + return transformer$2()(identity$3, identity$3); +} + +function tickFormat(start, stop, count, specifier) { + var step = tickStep(start, stop, count), + precision; + specifier = formatSpecifier(specifier == null ? ",f" : specifier); + switch (specifier.type) { + case "s": { + var value = Math.max(Math.abs(start), Math.abs(stop)); + if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision; + return exports.formatPrefix(specifier, value); + } + case "": + case "e": + case "g": + case "p": + case "r": { + if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e"); + break; + } + case "f": + case "%": { + if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === "%") * 2; + break; + } + } + return exports.format(specifier); +} + +function linearish(scale) { + var domain = scale.domain; + + scale.ticks = function(count) { + var d = domain(); + return ticks(d[0], d[d.length - 1], count == null ? 10 : count); + }; + + scale.tickFormat = function(count, specifier) { + var d = domain(); + return tickFormat(d[0], d[d.length - 1], count == null ? 10 : count, specifier); + }; + + scale.nice = function(count) { + if (count == null) count = 10; + + var d = domain(); + var i0 = 0; + var i1 = d.length - 1; + var start = d[i0]; + var stop = d[i1]; + var prestep; + var step; + var maxIter = 10; + + if (stop < start) { + step = start, start = stop, stop = step; + step = i0, i0 = i1, i1 = step; + } + + while (maxIter-- > 0) { + step = tickIncrement(start, stop, count); + if (step === prestep) { + d[i0] = start; + d[i1] = stop; + return domain(d); + } else if (step > 0) { + start = Math.floor(start / step) * step; + stop = Math.ceil(stop / step) * step; + } else if (step < 0) { + start = Math.ceil(start * step) / step; + stop = Math.floor(stop * step) / step; + } else { + break; + } + prestep = step; + } + + return scale; + }; + + return scale; +} + +function linear() { + var scale = continuous(); + + scale.copy = function() { + return copy$1(scale, linear()); + }; + + initRange.apply(scale, arguments); + + return linearish(scale); +} + +function identity$2(domain) { + var unknown; + + function scale(x) { + return x == null || isNaN(x = +x) ? unknown : x; + } + + scale.invert = scale; + + scale.domain = scale.range = function(_) { + return arguments.length ? (domain = Array.from(_, number$1), scale) : domain.slice(); + }; + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + scale.copy = function() { + return identity$2(domain).unknown(unknown); + }; + + domain = arguments.length ? Array.from(domain, number$1) : [0, 1]; + + return linearish(scale); +} + +function nice(domain, interval) { + domain = domain.slice(); + + var i0 = 0, + i1 = domain.length - 1, + x0 = domain[i0], + x1 = domain[i1], + t; + + if (x1 < x0) { + t = i0, i0 = i1, i1 = t; + t = x0, x0 = x1, x1 = t; + } + + domain[i0] = interval.floor(x0); + domain[i1] = interval.ceil(x1); + return domain; +} + +function transformLog(x) { + return Math.log(x); +} + +function transformExp(x) { + return Math.exp(x); +} + +function transformLogn(x) { + return -Math.log(-x); +} + +function transformExpn(x) { + return -Math.exp(-x); +} + +function pow10(x) { + return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x; +} + +function powp(base) { + return base === 10 ? pow10 + : base === Math.E ? Math.exp + : x => Math.pow(base, x); +} + +function logp(base) { + return base === Math.E ? Math.log + : base === 10 && Math.log10 + || base === 2 && Math.log2 + || (base = Math.log(base), x => Math.log(x) / base); +} + +function reflect(f) { + return (x, k) => -f(-x, k); +} + +function loggish(transform) { + const scale = transform(transformLog, transformExp); + const domain = scale.domain; + let base = 10; + let logs; + let pows; + + function rescale() { + logs = logp(base), pows = powp(base); + if (domain()[0] < 0) { + logs = reflect(logs), pows = reflect(pows); + transform(transformLogn, transformExpn); + } else { + transform(transformLog, transformExp); + } + return scale; + } + + scale.base = function(_) { + return arguments.length ? (base = +_, rescale()) : base; + }; + + scale.domain = function(_) { + return arguments.length ? (domain(_), rescale()) : domain(); + }; + + scale.ticks = count => { + const d = domain(); + let u = d[0]; + let v = d[d.length - 1]; + const r = v < u; + + if (r) ([u, v] = [v, u]); + + let i = logs(u); + let j = logs(v); + let k; + let t; + const n = count == null ? 10 : +count; + let z = []; + + if (!(base % 1) && j - i < n) { + i = Math.floor(i), j = Math.ceil(j); + if (u > 0) for (; i <= j; ++i) { + for (k = 1; k < base; ++k) { + t = i < 0 ? k / pows(-i) : k * pows(i); + if (t < u) continue; + if (t > v) break; + z.push(t); + } + } else for (; i <= j; ++i) { + for (k = base - 1; k >= 1; --k) { + t = i > 0 ? k / pows(-i) : k * pows(i); + if (t < u) continue; + if (t > v) break; + z.push(t); + } + } + if (z.length * 2 < n) z = ticks(u, v, n); + } else { + z = ticks(i, j, Math.min(j - i, n)).map(pows); + } + return r ? z.reverse() : z; + }; + + scale.tickFormat = (count, specifier) => { + if (count == null) count = 10; + if (specifier == null) specifier = base === 10 ? "s" : ","; + if (typeof specifier !== "function") { + if (!(base % 1) && (specifier = formatSpecifier(specifier)).precision == null) specifier.trim = true; + specifier = exports.format(specifier); + } + if (count === Infinity) return specifier; + const k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate? + return d => { + let i = d / pows(Math.round(logs(d))); + if (i * base < base - 0.5) i *= base; + return i <= k ? specifier(d) : ""; + }; + }; + + scale.nice = () => { + return domain(nice(domain(), { + floor: x => pows(Math.floor(logs(x))), + ceil: x => pows(Math.ceil(logs(x))) + })); + }; + + return scale; +} + +function log() { + const scale = loggish(transformer$2()).domain([1, 10]); + scale.copy = () => copy$1(scale, log()).base(scale.base()); + initRange.apply(scale, arguments); + return scale; +} + +function transformSymlog(c) { + return function(x) { + return Math.sign(x) * Math.log1p(Math.abs(x / c)); + }; +} + +function transformSymexp(c) { + return function(x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * c; + }; +} + +function symlogish(transform) { + var c = 1, scale = transform(transformSymlog(c), transformSymexp(c)); + + scale.constant = function(_) { + return arguments.length ? transform(transformSymlog(c = +_), transformSymexp(c)) : c; + }; + + return linearish(scale); +} + +function symlog() { + var scale = symlogish(transformer$2()); + + scale.copy = function() { + return copy$1(scale, symlog()).constant(scale.constant()); + }; + + return initRange.apply(scale, arguments); +} + +function transformPow(exponent) { + return function(x) { + return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent); + }; +} + +function transformSqrt(x) { + return x < 0 ? -Math.sqrt(-x) : Math.sqrt(x); +} + +function transformSquare(x) { + return x < 0 ? -x * x : x * x; +} + +function powish(transform) { + var scale = transform(identity$3, identity$3), + exponent = 1; + + function rescale() { + return exponent === 1 ? transform(identity$3, identity$3) + : exponent === 0.5 ? transform(transformSqrt, transformSquare) + : transform(transformPow(exponent), transformPow(1 / exponent)); + } + + scale.exponent = function(_) { + return arguments.length ? (exponent = +_, rescale()) : exponent; + }; + + return linearish(scale); +} + +function pow() { + var scale = powish(transformer$2()); + + scale.copy = function() { + return copy$1(scale, pow()).exponent(scale.exponent()); + }; + + initRange.apply(scale, arguments); + + return scale; +} + +function sqrt$1() { + return pow.apply(null, arguments).exponent(0.5); +} + +function square$1(x) { + return Math.sign(x) * x * x; +} + +function unsquare(x) { + return Math.sign(x) * Math.sqrt(Math.abs(x)); +} + +function radial() { + var squared = continuous(), + range = [0, 1], + round = false, + unknown; + + function scale(x) { + var y = unsquare(squared(x)); + return isNaN(y) ? unknown : round ? Math.round(y) : y; + } + + scale.invert = function(y) { + return squared.invert(square$1(y)); + }; + + scale.domain = function(_) { + return arguments.length ? (squared.domain(_), scale) : squared.domain(); + }; + + scale.range = function(_) { + return arguments.length ? (squared.range((range = Array.from(_, number$1)).map(square$1)), scale) : range.slice(); + }; + + scale.rangeRound = function(_) { + return scale.range(_).round(true); + }; + + scale.round = function(_) { + return arguments.length ? (round = !!_, scale) : round; + }; + + scale.clamp = function(_) { + return arguments.length ? (squared.clamp(_), scale) : squared.clamp(); + }; + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + scale.copy = function() { + return radial(squared.domain(), range) + .round(round) + .clamp(squared.clamp()) + .unknown(unknown); + }; + + initRange.apply(scale, arguments); + + return linearish(scale); +} + +function quantile() { + var domain = [], + range = [], + thresholds = [], + unknown; + + function rescale() { + var i = 0, n = Math.max(1, range.length); + thresholds = new Array(n - 1); + while (++i < n) thresholds[i - 1] = quantileSorted(domain, i / n); + return scale; + } + + function scale(x) { + return x == null || isNaN(x = +x) ? unknown : range[bisect(thresholds, x)]; + } + + scale.invertExtent = function(y) { + var i = range.indexOf(y); + return i < 0 ? [NaN, NaN] : [ + i > 0 ? thresholds[i - 1] : domain[0], + i < thresholds.length ? thresholds[i] : domain[domain.length - 1] + ]; + }; + + scale.domain = function(_) { + if (!arguments.length) return domain.slice(); + domain = []; + for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d); + domain.sort(ascending$3); + return rescale(); + }; + + scale.range = function(_) { + return arguments.length ? (range = Array.from(_), rescale()) : range.slice(); + }; + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + scale.quantiles = function() { + return thresholds.slice(); + }; + + scale.copy = function() { + return quantile() + .domain(domain) + .range(range) + .unknown(unknown); + }; + + return initRange.apply(scale, arguments); +} + +function quantize() { + var x0 = 0, + x1 = 1, + n = 1, + domain = [0.5], + range = [0, 1], + unknown; + + function scale(x) { + return x != null && x <= x ? range[bisect(domain, x, 0, n)] : unknown; + } + + function rescale() { + var i = -1; + domain = new Array(n); + while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1); + return scale; + } + + scale.domain = function(_) { + return arguments.length ? ([x0, x1] = _, x0 = +x0, x1 = +x1, rescale()) : [x0, x1]; + }; + + scale.range = function(_) { + return arguments.length ? (n = (range = Array.from(_)).length - 1, rescale()) : range.slice(); + }; + + scale.invertExtent = function(y) { + var i = range.indexOf(y); + return i < 0 ? [NaN, NaN] + : i < 1 ? [x0, domain[0]] + : i >= n ? [domain[n - 1], x1] + : [domain[i - 1], domain[i]]; + }; + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : scale; + }; + + scale.thresholds = function() { + return domain.slice(); + }; + + scale.copy = function() { + return quantize() + .domain([x0, x1]) + .range(range) + .unknown(unknown); + }; + + return initRange.apply(linearish(scale), arguments); +} + +function threshold() { + var domain = [0.5], + range = [0, 1], + unknown, + n = 1; + + function scale(x) { + return x != null && x <= x ? range[bisect(domain, x, 0, n)] : unknown; + } + + scale.domain = function(_) { + return arguments.length ? (domain = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : domain.slice(); + }; + + scale.range = function(_) { + return arguments.length ? (range = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice(); + }; + + scale.invertExtent = function(y) { + var i = range.indexOf(y); + return [domain[i - 1], domain[i]]; + }; + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + scale.copy = function() { + return threshold() + .domain(domain) + .range(range) + .unknown(unknown); + }; + + return initRange.apply(scale, arguments); +} + +const t0 = new Date, t1 = new Date; + +function timeInterval(floori, offseti, count, field) { + + function interval(date) { + return floori(date = arguments.length === 0 ? new Date : new Date(+date)), date; + } + + interval.floor = (date) => { + return floori(date = new Date(+date)), date; + }; + + interval.ceil = (date) => { + return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date; + }; + + interval.round = (date) => { + const d0 = interval(date), d1 = interval.ceil(date); + return date - d0 < d1 - date ? d0 : d1; + }; + + interval.offset = (date, step) => { + return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date; + }; + + interval.range = (start, stop, step) => { + const range = []; + start = interval.ceil(start); + step = step == null ? 1 : Math.floor(step); + if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date + let previous; + do range.push(previous = new Date(+start)), offseti(start, step), floori(start); + while (previous < start && start < stop); + return range; + }; + + interval.filter = (test) => { + return timeInterval((date) => { + if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1); + }, (date, step) => { + if (date >= date) { + if (step < 0) while (++step <= 0) { + while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty + } else while (--step >= 0) { + while (offseti(date, +1), !test(date)) {} // eslint-disable-line no-empty + } + } + }); + }; + + if (count) { + interval.count = (start, end) => { + t0.setTime(+start), t1.setTime(+end); + floori(t0), floori(t1); + return Math.floor(count(t0, t1)); + }; + + interval.every = (step) => { + step = Math.floor(step); + return !isFinite(step) || !(step > 0) ? null + : !(step > 1) ? interval + : interval.filter(field + ? (d) => field(d) % step === 0 + : (d) => interval.count(0, d) % step === 0); + }; + } + + return interval; +} + +const millisecond = timeInterval(() => { + // noop +}, (date, step) => { + date.setTime(+date + step); +}, (start, end) => { + return end - start; +}); + +// An optimized implementation for this simple case. +millisecond.every = (k) => { + k = Math.floor(k); + if (!isFinite(k) || !(k > 0)) return null; + if (!(k > 1)) return millisecond; + return timeInterval((date) => { + date.setTime(Math.floor(date / k) * k); + }, (date, step) => { + date.setTime(+date + step * k); + }, (start, end) => { + return (end - start) / k; + }); +}; + +const milliseconds = millisecond.range; + +const durationSecond = 1000; +const durationMinute = durationSecond * 60; +const durationHour = durationMinute * 60; +const durationDay = durationHour * 24; +const durationWeek = durationDay * 7; +const durationMonth = durationDay * 30; +const durationYear = durationDay * 365; + +const second = timeInterval((date) => { + date.setTime(date - date.getMilliseconds()); +}, (date, step) => { + date.setTime(+date + step * durationSecond); +}, (start, end) => { + return (end - start) / durationSecond; +}, (date) => { + return date.getUTCSeconds(); +}); + +const seconds = second.range; + +const timeMinute = timeInterval((date) => { + date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond); +}, (date, step) => { + date.setTime(+date + step * durationMinute); +}, (start, end) => { + return (end - start) / durationMinute; +}, (date) => { + return date.getMinutes(); +}); + +const timeMinutes = timeMinute.range; + +const utcMinute = timeInterval((date) => { + date.setUTCSeconds(0, 0); +}, (date, step) => { + date.setTime(+date + step * durationMinute); +}, (start, end) => { + return (end - start) / durationMinute; +}, (date) => { + return date.getUTCMinutes(); +}); + +const utcMinutes = utcMinute.range; + +const timeHour = timeInterval((date) => { + date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond - date.getMinutes() * durationMinute); +}, (date, step) => { + date.setTime(+date + step * durationHour); +}, (start, end) => { + return (end - start) / durationHour; +}, (date) => { + return date.getHours(); +}); + +const timeHours = timeHour.range; + +const utcHour = timeInterval((date) => { + date.setUTCMinutes(0, 0, 0); +}, (date, step) => { + date.setTime(+date + step * durationHour); +}, (start, end) => { + return (end - start) / durationHour; +}, (date) => { + return date.getUTCHours(); +}); + +const utcHours = utcHour.range; + +const timeDay = timeInterval( + date => date.setHours(0, 0, 0, 0), + (date, step) => date.setDate(date.getDate() + step), + (start, end) => (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay, + date => date.getDate() - 1 +); + +const timeDays = timeDay.range; + +const utcDay = timeInterval((date) => { + date.setUTCHours(0, 0, 0, 0); +}, (date, step) => { + date.setUTCDate(date.getUTCDate() + step); +}, (start, end) => { + return (end - start) / durationDay; +}, (date) => { + return date.getUTCDate() - 1; +}); + +const utcDays = utcDay.range; + +const unixDay = timeInterval((date) => { + date.setUTCHours(0, 0, 0, 0); +}, (date, step) => { + date.setUTCDate(date.getUTCDate() + step); +}, (start, end) => { + return (end - start) / durationDay; +}, (date) => { + return Math.floor(date / durationDay); +}); + +const unixDays = unixDay.range; + +function timeWeekday(i) { + return timeInterval((date) => { + date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7); + date.setHours(0, 0, 0, 0); + }, (date, step) => { + date.setDate(date.getDate() + step * 7); + }, (start, end) => { + return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek; + }); +} + +const timeSunday = timeWeekday(0); +const timeMonday = timeWeekday(1); +const timeTuesday = timeWeekday(2); +const timeWednesday = timeWeekday(3); +const timeThursday = timeWeekday(4); +const timeFriday = timeWeekday(5); +const timeSaturday = timeWeekday(6); + +const timeSundays = timeSunday.range; +const timeMondays = timeMonday.range; +const timeTuesdays = timeTuesday.range; +const timeWednesdays = timeWednesday.range; +const timeThursdays = timeThursday.range; +const timeFridays = timeFriday.range; +const timeSaturdays = timeSaturday.range; + +function utcWeekday(i) { + return timeInterval((date) => { + date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7); + date.setUTCHours(0, 0, 0, 0); + }, (date, step) => { + date.setUTCDate(date.getUTCDate() + step * 7); + }, (start, end) => { + return (end - start) / durationWeek; + }); +} + +const utcSunday = utcWeekday(0); +const utcMonday = utcWeekday(1); +const utcTuesday = utcWeekday(2); +const utcWednesday = utcWeekday(3); +const utcThursday = utcWeekday(4); +const utcFriday = utcWeekday(5); +const utcSaturday = utcWeekday(6); + +const utcSundays = utcSunday.range; +const utcMondays = utcMonday.range; +const utcTuesdays = utcTuesday.range; +const utcWednesdays = utcWednesday.range; +const utcThursdays = utcThursday.range; +const utcFridays = utcFriday.range; +const utcSaturdays = utcSaturday.range; + +const timeMonth = timeInterval((date) => { + date.setDate(1); + date.setHours(0, 0, 0, 0); +}, (date, step) => { + date.setMonth(date.getMonth() + step); +}, (start, end) => { + return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12; +}, (date) => { + return date.getMonth(); +}); + +const timeMonths = timeMonth.range; + +const utcMonth = timeInterval((date) => { + date.setUTCDate(1); + date.setUTCHours(0, 0, 0, 0); +}, (date, step) => { + date.setUTCMonth(date.getUTCMonth() + step); +}, (start, end) => { + return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12; +}, (date) => { + return date.getUTCMonth(); +}); + +const utcMonths = utcMonth.range; + +const timeYear = timeInterval((date) => { + date.setMonth(0, 1); + date.setHours(0, 0, 0, 0); +}, (date, step) => { + date.setFullYear(date.getFullYear() + step); +}, (start, end) => { + return end.getFullYear() - start.getFullYear(); +}, (date) => { + return date.getFullYear(); +}); + +// An optimized implementation for this simple case. +timeYear.every = (k) => { + return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date) => { + date.setFullYear(Math.floor(date.getFullYear() / k) * k); + date.setMonth(0, 1); + date.setHours(0, 0, 0, 0); + }, (date, step) => { + date.setFullYear(date.getFullYear() + step * k); + }); +}; + +const timeYears = timeYear.range; + +const utcYear = timeInterval((date) => { + date.setUTCMonth(0, 1); + date.setUTCHours(0, 0, 0, 0); +}, (date, step) => { + date.setUTCFullYear(date.getUTCFullYear() + step); +}, (start, end) => { + return end.getUTCFullYear() - start.getUTCFullYear(); +}, (date) => { + return date.getUTCFullYear(); +}); + +// An optimized implementation for this simple case. +utcYear.every = (k) => { + return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date) => { + date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k); + date.setUTCMonth(0, 1); + date.setUTCHours(0, 0, 0, 0); + }, (date, step) => { + date.setUTCFullYear(date.getUTCFullYear() + step * k); + }); +}; + +const utcYears = utcYear.range; + +function ticker(year, month, week, day, hour, minute) { + + const tickIntervals = [ + [second, 1, durationSecond], + [second, 5, 5 * durationSecond], + [second, 15, 15 * durationSecond], + [second, 30, 30 * durationSecond], + [minute, 1, durationMinute], + [minute, 5, 5 * durationMinute], + [minute, 15, 15 * durationMinute], + [minute, 30, 30 * durationMinute], + [ hour, 1, durationHour ], + [ hour, 3, 3 * durationHour ], + [ hour, 6, 6 * durationHour ], + [ hour, 12, 12 * durationHour ], + [ day, 1, durationDay ], + [ day, 2, 2 * durationDay ], + [ week, 1, durationWeek ], + [ month, 1, durationMonth ], + [ month, 3, 3 * durationMonth ], + [ year, 1, durationYear ] + ]; + + function ticks(start, stop, count) { + const reverse = stop < start; + if (reverse) [start, stop] = [stop, start]; + const interval = count && typeof count.range === "function" ? count : tickInterval(start, stop, count); + const ticks = interval ? interval.range(start, +stop + 1) : []; // inclusive stop + return reverse ? ticks.reverse() : ticks; + } + + function tickInterval(start, stop, count) { + const target = Math.abs(stop - start) / count; + const i = bisector(([,, step]) => step).right(tickIntervals, target); + if (i === tickIntervals.length) return year.every(tickStep(start / durationYear, stop / durationYear, count)); + if (i === 0) return millisecond.every(Math.max(tickStep(start, stop, count), 1)); + const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i]; + return t.every(step); + } + + return [ticks, tickInterval]; +} + +const [utcTicks, utcTickInterval] = ticker(utcYear, utcMonth, utcSunday, unixDay, utcHour, utcMinute); +const [timeTicks, timeTickInterval] = ticker(timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute); + +function localDate(d) { + if (0 <= d.y && d.y < 100) { + var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L); + date.setFullYear(d.y); + return date; + } + return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L); +} + +function utcDate(d) { + if (0 <= d.y && d.y < 100) { + var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L)); + date.setUTCFullYear(d.y); + return date; + } + return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L)); +} + +function newDate(y, m, d) { + return {y: y, m: m, d: d, H: 0, M: 0, S: 0, L: 0}; +} + +function formatLocale(locale) { + var locale_dateTime = locale.dateTime, + locale_date = locale.date, + locale_time = locale.time, + locale_periods = locale.periods, + locale_weekdays = locale.days, + locale_shortWeekdays = locale.shortDays, + locale_months = locale.months, + locale_shortMonths = locale.shortMonths; + + var periodRe = formatRe(locale_periods), + periodLookup = formatLookup(locale_periods), + weekdayRe = formatRe(locale_weekdays), + weekdayLookup = formatLookup(locale_weekdays), + shortWeekdayRe = formatRe(locale_shortWeekdays), + shortWeekdayLookup = formatLookup(locale_shortWeekdays), + monthRe = formatRe(locale_months), + monthLookup = formatLookup(locale_months), + shortMonthRe = formatRe(locale_shortMonths), + shortMonthLookup = formatLookup(locale_shortMonths); + + var formats = { + "a": formatShortWeekday, + "A": formatWeekday, + "b": formatShortMonth, + "B": formatMonth, + "c": null, + "d": formatDayOfMonth, + "e": formatDayOfMonth, + "f": formatMicroseconds, + "g": formatYearISO, + "G": formatFullYearISO, + "H": formatHour24, + "I": formatHour12, + "j": formatDayOfYear, + "L": formatMilliseconds, + "m": formatMonthNumber, + "M": formatMinutes, + "p": formatPeriod, + "q": formatQuarter, + "Q": formatUnixTimestamp, + "s": formatUnixTimestampSeconds, + "S": formatSeconds, + "u": formatWeekdayNumberMonday, + "U": formatWeekNumberSunday, + "V": formatWeekNumberISO, + "w": formatWeekdayNumberSunday, + "W": formatWeekNumberMonday, + "x": null, + "X": null, + "y": formatYear, + "Y": formatFullYear, + "Z": formatZone, + "%": formatLiteralPercent + }; + + var utcFormats = { + "a": formatUTCShortWeekday, + "A": formatUTCWeekday, + "b": formatUTCShortMonth, + "B": formatUTCMonth, + "c": null, + "d": formatUTCDayOfMonth, + "e": formatUTCDayOfMonth, + "f": formatUTCMicroseconds, + "g": formatUTCYearISO, + "G": formatUTCFullYearISO, + "H": formatUTCHour24, + "I": formatUTCHour12, + "j": formatUTCDayOfYear, + "L": formatUTCMilliseconds, + "m": formatUTCMonthNumber, + "M": formatUTCMinutes, + "p": formatUTCPeriod, + "q": formatUTCQuarter, + "Q": formatUnixTimestamp, + "s": formatUnixTimestampSeconds, + "S": formatUTCSeconds, + "u": formatUTCWeekdayNumberMonday, + "U": formatUTCWeekNumberSunday, + "V": formatUTCWeekNumberISO, + "w": formatUTCWeekdayNumberSunday, + "W": formatUTCWeekNumberMonday, + "x": null, + "X": null, + "y": formatUTCYear, + "Y": formatUTCFullYear, + "Z": formatUTCZone, + "%": formatLiteralPercent + }; + + var parses = { + "a": parseShortWeekday, + "A": parseWeekday, + "b": parseShortMonth, + "B": parseMonth, + "c": parseLocaleDateTime, + "d": parseDayOfMonth, + "e": parseDayOfMonth, + "f": parseMicroseconds, + "g": parseYear, + "G": parseFullYear, + "H": parseHour24, + "I": parseHour24, + "j": parseDayOfYear, + "L": parseMilliseconds, + "m": parseMonthNumber, + "M": parseMinutes, + "p": parsePeriod, + "q": parseQuarter, + "Q": parseUnixTimestamp, + "s": parseUnixTimestampSeconds, + "S": parseSeconds, + "u": parseWeekdayNumberMonday, + "U": parseWeekNumberSunday, + "V": parseWeekNumberISO, + "w": parseWeekdayNumberSunday, + "W": parseWeekNumberMonday, + "x": parseLocaleDate, + "X": parseLocaleTime, + "y": parseYear, + "Y": parseFullYear, + "Z": parseZone, + "%": parseLiteralPercent + }; + + // These recursive directive definitions must be deferred. + formats.x = newFormat(locale_date, formats); + formats.X = newFormat(locale_time, formats); + formats.c = newFormat(locale_dateTime, formats); + utcFormats.x = newFormat(locale_date, utcFormats); + utcFormats.X = newFormat(locale_time, utcFormats); + utcFormats.c = newFormat(locale_dateTime, utcFormats); + + function newFormat(specifier, formats) { + return function(date) { + var string = [], + i = -1, + j = 0, + n = specifier.length, + c, + pad, + format; + + if (!(date instanceof Date)) date = new Date(+date); + + while (++i < n) { + if (specifier.charCodeAt(i) === 37) { + string.push(specifier.slice(j, i)); + if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i); + else pad = c === "e" ? " " : "0"; + if (format = formats[c]) c = format(date, pad); + string.push(c); + j = i + 1; + } + } + + string.push(specifier.slice(j, i)); + return string.join(""); + }; + } + + function newParse(specifier, Z) { + return function(string) { + var d = newDate(1900, undefined, 1), + i = parseSpecifier(d, specifier, string += "", 0), + week, day; + if (i != string.length) return null; + + // If a UNIX timestamp is specified, return it. + if ("Q" in d) return new Date(d.Q); + if ("s" in d) return new Date(d.s * 1000 + ("L" in d ? d.L : 0)); + + // If this is utcParse, never use the local timezone. + if (Z && !("Z" in d)) d.Z = 0; + + // The am-pm flag is 0 for AM, and 1 for PM. + if ("p" in d) d.H = d.H % 12 + d.p * 12; + + // If the month was not specified, inherit from the quarter. + if (d.m === undefined) d.m = "q" in d ? d.q : 0; + + // Convert day-of-week and week-of-year to day-of-year. + if ("V" in d) { + if (d.V < 1 || d.V > 53) return null; + if (!("w" in d)) d.w = 1; + if ("Z" in d) { + week = utcDate(newDate(d.y, 0, 1)), day = week.getUTCDay(); + week = day > 4 || day === 0 ? utcMonday.ceil(week) : utcMonday(week); + week = utcDay.offset(week, (d.V - 1) * 7); + d.y = week.getUTCFullYear(); + d.m = week.getUTCMonth(); + d.d = week.getUTCDate() + (d.w + 6) % 7; + } else { + week = localDate(newDate(d.y, 0, 1)), day = week.getDay(); + week = day > 4 || day === 0 ? timeMonday.ceil(week) : timeMonday(week); + week = timeDay.offset(week, (d.V - 1) * 7); + d.y = week.getFullYear(); + d.m = week.getMonth(); + d.d = week.getDate() + (d.w + 6) % 7; + } + } else if ("W" in d || "U" in d) { + if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0; + day = "Z" in d ? utcDate(newDate(d.y, 0, 1)).getUTCDay() : localDate(newDate(d.y, 0, 1)).getDay(); + d.m = 0; + d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7; + } + + // If a time zone is specified, all fields are interpreted as UTC and then + // offset according to the specified time zone. + if ("Z" in d) { + d.H += d.Z / 100 | 0; + d.M += d.Z % 100; + return utcDate(d); + } + + // Otherwise, all fields are in local time. + return localDate(d); + }; + } + + function parseSpecifier(d, specifier, string, j) { + var i = 0, + n = specifier.length, + m = string.length, + c, + parse; + + while (i < n) { + if (j >= m) return -1; + c = specifier.charCodeAt(i++); + if (c === 37) { + c = specifier.charAt(i++); + parse = parses[c in pads ? specifier.charAt(i++) : c]; + if (!parse || ((j = parse(d, string, j)) < 0)) return -1; + } else if (c != string.charCodeAt(j++)) { + return -1; + } + } + + return j; + } + + function parsePeriod(d, string, i) { + var n = periodRe.exec(string.slice(i)); + return n ? (d.p = periodLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + + function parseShortWeekday(d, string, i) { + var n = shortWeekdayRe.exec(string.slice(i)); + return n ? (d.w = shortWeekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + + function parseWeekday(d, string, i) { + var n = weekdayRe.exec(string.slice(i)); + return n ? (d.w = weekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + + function parseShortMonth(d, string, i) { + var n = shortMonthRe.exec(string.slice(i)); + return n ? (d.m = shortMonthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + + function parseMonth(d, string, i) { + var n = monthRe.exec(string.slice(i)); + return n ? (d.m = monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + + function parseLocaleDateTime(d, string, i) { + return parseSpecifier(d, locale_dateTime, string, i); + } + + function parseLocaleDate(d, string, i) { + return parseSpecifier(d, locale_date, string, i); + } + + function parseLocaleTime(d, string, i) { + return parseSpecifier(d, locale_time, string, i); + } + + function formatShortWeekday(d) { + return locale_shortWeekdays[d.getDay()]; + } + + function formatWeekday(d) { + return locale_weekdays[d.getDay()]; + } + + function formatShortMonth(d) { + return locale_shortMonths[d.getMonth()]; + } + + function formatMonth(d) { + return locale_months[d.getMonth()]; + } + + function formatPeriod(d) { + return locale_periods[+(d.getHours() >= 12)]; + } + + function formatQuarter(d) { + return 1 + ~~(d.getMonth() / 3); + } + + function formatUTCShortWeekday(d) { + return locale_shortWeekdays[d.getUTCDay()]; + } + + function formatUTCWeekday(d) { + return locale_weekdays[d.getUTCDay()]; + } + + function formatUTCShortMonth(d) { + return locale_shortMonths[d.getUTCMonth()]; + } + + function formatUTCMonth(d) { + return locale_months[d.getUTCMonth()]; + } + + function formatUTCPeriod(d) { + return locale_periods[+(d.getUTCHours() >= 12)]; + } + + function formatUTCQuarter(d) { + return 1 + ~~(d.getUTCMonth() / 3); + } + + return { + format: function(specifier) { + var f = newFormat(specifier += "", formats); + f.toString = function() { return specifier; }; + return f; + }, + parse: function(specifier) { + var p = newParse(specifier += "", false); + p.toString = function() { return specifier; }; + return p; + }, + utcFormat: function(specifier) { + var f = newFormat(specifier += "", utcFormats); + f.toString = function() { return specifier; }; + return f; + }, + utcParse: function(specifier) { + var p = newParse(specifier += "", true); + p.toString = function() { return specifier; }; + return p; + } + }; +} + +var pads = {"-": "", "_": " ", "0": "0"}, + numberRe = /^\s*\d+/, // note: ignores next directive + percentRe = /^%/, + requoteRe = /[\\^$*+?|[\]().{}]/g; + +function pad(value, fill, width) { + var sign = value < 0 ? "-" : "", + string = (sign ? -value : value) + "", + length = string.length; + return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string); +} + +function requote(s) { + return s.replace(requoteRe, "\\$&"); +} + +function formatRe(names) { + return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i"); +} + +function formatLookup(names) { + return new Map(names.map((name, i) => [name.toLowerCase(), i])); +} + +function parseWeekdayNumberSunday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 1)); + return n ? (d.w = +n[0], i + n[0].length) : -1; +} + +function parseWeekdayNumberMonday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 1)); + return n ? (d.u = +n[0], i + n[0].length) : -1; +} + +function parseWeekNumberSunday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.U = +n[0], i + n[0].length) : -1; +} + +function parseWeekNumberISO(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.V = +n[0], i + n[0].length) : -1; +} + +function parseWeekNumberMonday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.W = +n[0], i + n[0].length) : -1; +} + +function parseFullYear(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 4)); + return n ? (d.y = +n[0], i + n[0].length) : -1; +} + +function parseYear(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1; +} + +function parseZone(d, string, i) { + var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6)); + return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1; +} + +function parseQuarter(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 1)); + return n ? (d.q = n[0] * 3 - 3, i + n[0].length) : -1; +} + +function parseMonthNumber(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.m = n[0] - 1, i + n[0].length) : -1; +} + +function parseDayOfMonth(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.d = +n[0], i + n[0].length) : -1; +} + +function parseDayOfYear(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 3)); + return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1; +} + +function parseHour24(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.H = +n[0], i + n[0].length) : -1; +} + +function parseMinutes(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.M = +n[0], i + n[0].length) : -1; +} + +function parseSeconds(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? (d.S = +n[0], i + n[0].length) : -1; +} + +function parseMilliseconds(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 3)); + return n ? (d.L = +n[0], i + n[0].length) : -1; +} + +function parseMicroseconds(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 6)); + return n ? (d.L = Math.floor(n[0] / 1000), i + n[0].length) : -1; +} + +function parseLiteralPercent(d, string, i) { + var n = percentRe.exec(string.slice(i, i + 1)); + return n ? i + n[0].length : -1; +} + +function parseUnixTimestamp(d, string, i) { + var n = numberRe.exec(string.slice(i)); + return n ? (d.Q = +n[0], i + n[0].length) : -1; +} + +function parseUnixTimestampSeconds(d, string, i) { + var n = numberRe.exec(string.slice(i)); + return n ? (d.s = +n[0], i + n[0].length) : -1; +} + +function formatDayOfMonth(d, p) { + return pad(d.getDate(), p, 2); +} + +function formatHour24(d, p) { + return pad(d.getHours(), p, 2); +} + +function formatHour12(d, p) { + return pad(d.getHours() % 12 || 12, p, 2); +} + +function formatDayOfYear(d, p) { + return pad(1 + timeDay.count(timeYear(d), d), p, 3); +} + +function formatMilliseconds(d, p) { + return pad(d.getMilliseconds(), p, 3); +} + +function formatMicroseconds(d, p) { + return formatMilliseconds(d, p) + "000"; +} + +function formatMonthNumber(d, p) { + return pad(d.getMonth() + 1, p, 2); +} + +function formatMinutes(d, p) { + return pad(d.getMinutes(), p, 2); +} + +function formatSeconds(d, p) { + return pad(d.getSeconds(), p, 2); +} + +function formatWeekdayNumberMonday(d) { + var day = d.getDay(); + return day === 0 ? 7 : day; +} + +function formatWeekNumberSunday(d, p) { + return pad(timeSunday.count(timeYear(d) - 1, d), p, 2); +} + +function dISO(d) { + var day = d.getDay(); + return (day >= 4 || day === 0) ? timeThursday(d) : timeThursday.ceil(d); +} + +function formatWeekNumberISO(d, p) { + d = dISO(d); + return pad(timeThursday.count(timeYear(d), d) + (timeYear(d).getDay() === 4), p, 2); +} + +function formatWeekdayNumberSunday(d) { + return d.getDay(); +} + +function formatWeekNumberMonday(d, p) { + return pad(timeMonday.count(timeYear(d) - 1, d), p, 2); +} + +function formatYear(d, p) { + return pad(d.getFullYear() % 100, p, 2); +} + +function formatYearISO(d, p) { + d = dISO(d); + return pad(d.getFullYear() % 100, p, 2); +} + +function formatFullYear(d, p) { + return pad(d.getFullYear() % 10000, p, 4); +} + +function formatFullYearISO(d, p) { + var day = d.getDay(); + d = (day >= 4 || day === 0) ? timeThursday(d) : timeThursday.ceil(d); + return pad(d.getFullYear() % 10000, p, 4); +} + +function formatZone(d) { + var z = d.getTimezoneOffset(); + return (z > 0 ? "-" : (z *= -1, "+")) + + pad(z / 60 | 0, "0", 2) + + pad(z % 60, "0", 2); +} + +function formatUTCDayOfMonth(d, p) { + return pad(d.getUTCDate(), p, 2); +} + +function formatUTCHour24(d, p) { + return pad(d.getUTCHours(), p, 2); +} + +function formatUTCHour12(d, p) { + return pad(d.getUTCHours() % 12 || 12, p, 2); +} + +function formatUTCDayOfYear(d, p) { + return pad(1 + utcDay.count(utcYear(d), d), p, 3); +} + +function formatUTCMilliseconds(d, p) { + return pad(d.getUTCMilliseconds(), p, 3); +} + +function formatUTCMicroseconds(d, p) { + return formatUTCMilliseconds(d, p) + "000"; +} + +function formatUTCMonthNumber(d, p) { + return pad(d.getUTCMonth() + 1, p, 2); +} + +function formatUTCMinutes(d, p) { + return pad(d.getUTCMinutes(), p, 2); +} + +function formatUTCSeconds(d, p) { + return pad(d.getUTCSeconds(), p, 2); +} + +function formatUTCWeekdayNumberMonday(d) { + var dow = d.getUTCDay(); + return dow === 0 ? 7 : dow; +} + +function formatUTCWeekNumberSunday(d, p) { + return pad(utcSunday.count(utcYear(d) - 1, d), p, 2); +} + +function UTCdISO(d) { + var day = d.getUTCDay(); + return (day >= 4 || day === 0) ? utcThursday(d) : utcThursday.ceil(d); +} + +function formatUTCWeekNumberISO(d, p) { + d = UTCdISO(d); + return pad(utcThursday.count(utcYear(d), d) + (utcYear(d).getUTCDay() === 4), p, 2); +} + +function formatUTCWeekdayNumberSunday(d) { + return d.getUTCDay(); +} + +function formatUTCWeekNumberMonday(d, p) { + return pad(utcMonday.count(utcYear(d) - 1, d), p, 2); +} + +function formatUTCYear(d, p) { + return pad(d.getUTCFullYear() % 100, p, 2); +} + +function formatUTCYearISO(d, p) { + d = UTCdISO(d); + return pad(d.getUTCFullYear() % 100, p, 2); +} + +function formatUTCFullYear(d, p) { + return pad(d.getUTCFullYear() % 10000, p, 4); +} + +function formatUTCFullYearISO(d, p) { + var day = d.getUTCDay(); + d = (day >= 4 || day === 0) ? utcThursday(d) : utcThursday.ceil(d); + return pad(d.getUTCFullYear() % 10000, p, 4); +} + +function formatUTCZone() { + return "+0000"; +} + +function formatLiteralPercent() { + return "%"; +} + +function formatUnixTimestamp(d) { + return +d; +} + +function formatUnixTimestampSeconds(d) { + return Math.floor(+d / 1000); +} + +var locale; +exports.timeFormat = void 0; +exports.timeParse = void 0; +exports.utcFormat = void 0; +exports.utcParse = void 0; + +defaultLocale({ + 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"] +}); + +function defaultLocale(definition) { + locale = formatLocale(definition); + exports.timeFormat = locale.format; + exports.timeParse = locale.parse; + exports.utcFormat = locale.utcFormat; + exports.utcParse = locale.utcParse; + return locale; +} + +var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ"; + +function formatIsoNative(date) { + return date.toISOString(); +} + +var formatIso = Date.prototype.toISOString + ? formatIsoNative + : exports.utcFormat(isoSpecifier); + +var formatIso$1 = formatIso; + +function parseIsoNative(string) { + var date = new Date(string); + return isNaN(date) ? null : date; +} + +var parseIso = +new Date("2000-01-01T00:00:00.000Z") + ? parseIsoNative + : exports.utcParse(isoSpecifier); + +var parseIso$1 = parseIso; + +function date(t) { + return new Date(t); +} + +function number(t) { + return t instanceof Date ? +t : +new Date(+t); +} + +function calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format) { + var scale = continuous(), + invert = scale.invert, + domain = scale.domain; + + var formatMillisecond = format(".%L"), + formatSecond = format(":%S"), + formatMinute = format("%I:%M"), + formatHour = format("%I %p"), + formatDay = format("%a %d"), + formatWeek = format("%b %d"), + formatMonth = format("%B"), + formatYear = format("%Y"); + + function tickFormat(date) { + return (second(date) < date ? formatMillisecond + : minute(date) < date ? formatSecond + : hour(date) < date ? formatMinute + : day(date) < date ? formatHour + : month(date) < date ? (week(date) < date ? formatDay : formatWeek) + : year(date) < date ? formatMonth + : formatYear)(date); + } + + scale.invert = function(y) { + return new Date(invert(y)); + }; + + scale.domain = function(_) { + return arguments.length ? domain(Array.from(_, number)) : domain().map(date); + }; + + scale.ticks = function(interval) { + var d = domain(); + return ticks(d[0], d[d.length - 1], interval == null ? 10 : interval); + }; + + scale.tickFormat = function(count, specifier) { + return specifier == null ? tickFormat : format(specifier); + }; + + scale.nice = function(interval) { + var d = domain(); + if (!interval || typeof interval.range !== "function") interval = tickInterval(d[0], d[d.length - 1], interval == null ? 10 : interval); + return interval ? domain(nice(d, interval)) : scale; + }; + + scale.copy = function() { + return copy$1(scale, calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format)); + }; + + return scale; +} + +function time() { + return initRange.apply(calendar(timeTicks, timeTickInterval, timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute, second, exports.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]), arguments); +} + +function utcTime() { + return initRange.apply(calendar(utcTicks, utcTickInterval, utcYear, utcMonth, utcSunday, utcDay, utcHour, utcMinute, second, exports.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]), arguments); +} + +function transformer$1() { + var x0 = 0, + x1 = 1, + t0, + t1, + k10, + transform, + interpolator = identity$3, + clamp = false, + unknown; + + function scale(x) { + return x == null || isNaN(x = +x) ? unknown : interpolator(k10 === 0 ? 0.5 : (x = (transform(x) - t0) * k10, clamp ? Math.max(0, Math.min(1, x)) : x)); + } + + scale.domain = function(_) { + return arguments.length ? ([x0, x1] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0), scale) : [x0, x1]; + }; + + scale.clamp = function(_) { + return arguments.length ? (clamp = !!_, scale) : clamp; + }; + + scale.interpolator = function(_) { + return arguments.length ? (interpolator = _, scale) : interpolator; + }; + + function range(interpolate) { + return function(_) { + var r0, r1; + return arguments.length ? ([r0, r1] = _, interpolator = interpolate(r0, r1), scale) : [interpolator(0), interpolator(1)]; + }; + } + + scale.range = range(interpolate$2); + + scale.rangeRound = range(interpolateRound); + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + return function(t) { + transform = t, t0 = t(x0), t1 = t(x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0); + return scale; + }; +} + +function copy(source, target) { + return target + .domain(source.domain()) + .interpolator(source.interpolator()) + .clamp(source.clamp()) + .unknown(source.unknown()); +} + +function sequential() { + var scale = linearish(transformer$1()(identity$3)); + + scale.copy = function() { + return copy(scale, sequential()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function sequentialLog() { + var scale = loggish(transformer$1()).domain([1, 10]); + + scale.copy = function() { + return copy(scale, sequentialLog()).base(scale.base()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function sequentialSymlog() { + var scale = symlogish(transformer$1()); + + scale.copy = function() { + return copy(scale, sequentialSymlog()).constant(scale.constant()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function sequentialPow() { + var scale = powish(transformer$1()); + + scale.copy = function() { + return copy(scale, sequentialPow()).exponent(scale.exponent()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function sequentialSqrt() { + return sequentialPow.apply(null, arguments).exponent(0.5); +} + +function sequentialQuantile() { + var domain = [], + interpolator = identity$3; + + function scale(x) { + if (x != null && !isNaN(x = +x)) return interpolator((bisect(domain, x, 1) - 1) / (domain.length - 1)); + } + + scale.domain = function(_) { + if (!arguments.length) return domain.slice(); + domain = []; + for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d); + domain.sort(ascending$3); + return scale; + }; + + scale.interpolator = function(_) { + return arguments.length ? (interpolator = _, scale) : interpolator; + }; + + scale.range = function() { + return domain.map((d, i) => interpolator(i / (domain.length - 1))); + }; + + scale.quantiles = function(n) { + return Array.from({length: n + 1}, (_, i) => quantile$1(domain, i / n)); + }; + + scale.copy = function() { + return sequentialQuantile(interpolator).domain(domain); + }; + + return initInterpolator.apply(scale, arguments); +} + +function transformer() { + var x0 = 0, + x1 = 0.5, + x2 = 1, + s = 1, + t0, + t1, + t2, + k10, + k21, + interpolator = identity$3, + transform, + clamp = false, + unknown; + + function scale(x) { + return isNaN(x = +x) ? unknown : (x = 0.5 + ((x = +transform(x)) - t1) * (s * x < s * t1 ? k10 : k21), interpolator(clamp ? Math.max(0, Math.min(1, x)) : x)); + } + + scale.domain = function(_) { + return arguments.length ? ([x0, x1, x2] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), t2 = transform(x2 = +x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1, scale) : [x0, x1, x2]; + }; + + scale.clamp = function(_) { + return arguments.length ? (clamp = !!_, scale) : clamp; + }; + + scale.interpolator = function(_) { + return arguments.length ? (interpolator = _, scale) : interpolator; + }; + + function range(interpolate) { + return function(_) { + var r0, r1, r2; + return arguments.length ? ([r0, r1, r2] = _, interpolator = piecewise(interpolate, [r0, r1, r2]), scale) : [interpolator(0), interpolator(0.5), interpolator(1)]; + }; + } + + scale.range = range(interpolate$2); + + scale.rangeRound = range(interpolateRound); + + scale.unknown = function(_) { + return arguments.length ? (unknown = _, scale) : unknown; + }; + + return function(t) { + transform = t, t0 = t(x0), t1 = t(x1), t2 = t(x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1; + return scale; + }; +} + +function diverging$1() { + var scale = linearish(transformer()(identity$3)); + + scale.copy = function() { + return copy(scale, diverging$1()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function divergingLog() { + var scale = loggish(transformer()).domain([0.1, 1, 10]); + + scale.copy = function() { + return copy(scale, divergingLog()).base(scale.base()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function divergingSymlog() { + var scale = symlogish(transformer()); + + scale.copy = function() { + return copy(scale, divergingSymlog()).constant(scale.constant()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function divergingPow() { + var scale = powish(transformer()); + + scale.copy = function() { + return copy(scale, divergingPow()).exponent(scale.exponent()); + }; + + return initInterpolator.apply(scale, arguments); +} + +function divergingSqrt() { + return divergingPow.apply(null, arguments).exponent(0.5); +} + +function colors(specifier) { + var n = specifier.length / 6 | 0, colors = new Array(n), i = 0; + while (i < n) colors[i] = "#" + specifier.slice(i * 6, ++i * 6); + return colors; +} + +var category10 = colors("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"); + +var Accent = colors("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"); + +var Dark2 = colors("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"); + +var observable10 = colors("4269d0efb118ff725c6cc5b03ca951ff8ab7a463f297bbf59c6b4e9498a0"); + +var Paired = colors("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"); + +var Pastel1 = colors("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"); + +var Pastel2 = colors("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"); + +var Set1 = colors("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"); + +var Set2 = colors("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"); + +var Set3 = colors("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f"); + +var Tableau10 = colors("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab"); + +var ramp$1 = scheme => rgbBasis(scheme[scheme.length - 1]); + +var scheme$q = new Array(3).concat( + "d8b365f5f5f55ab4ac", + "a6611adfc27d80cdc1018571", + "a6611adfc27df5f5f580cdc1018571", + "8c510ad8b365f6e8c3c7eae55ab4ac01665e", + "8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e", + "8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e", + "8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e", + "5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30", + "5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30" +).map(colors); + +var BrBG = ramp$1(scheme$q); + +var scheme$p = new Array(3).concat( + "af8dc3f7f7f77fbf7b", + "7b3294c2a5cfa6dba0008837", + "7b3294c2a5cff7f7f7a6dba0008837", + "762a83af8dc3e7d4e8d9f0d37fbf7b1b7837", + "762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837", + "762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837", + "762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837", + "40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b", + "40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b" +).map(colors); + +var PRGn = ramp$1(scheme$p); + +var scheme$o = new Array(3).concat( + "e9a3c9f7f7f7a1d76a", + "d01c8bf1b6dab8e1864dac26", + "d01c8bf1b6daf7f7f7b8e1864dac26", + "c51b7de9a3c9fde0efe6f5d0a1d76a4d9221", + "c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221", + "c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221", + "c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221", + "8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419", + "8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419" +).map(colors); + +var PiYG = ramp$1(scheme$o); + +var scheme$n = new Array(3).concat( + "998ec3f7f7f7f1a340", + "5e3c99b2abd2fdb863e66101", + "5e3c99b2abd2f7f7f7fdb863e66101", + "542788998ec3d8daebfee0b6f1a340b35806", + "542788998ec3d8daebf7f7f7fee0b6f1a340b35806", + "5427888073acb2abd2d8daebfee0b6fdb863e08214b35806", + "5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806", + "2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08", + "2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08" +).map(colors); + +var PuOr = ramp$1(scheme$n); + +var scheme$m = new Array(3).concat( + "ef8a62f7f7f767a9cf", + "ca0020f4a58292c5de0571b0", + "ca0020f4a582f7f7f792c5de0571b0", + "b2182bef8a62fddbc7d1e5f067a9cf2166ac", + "b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac", + "b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac", + "b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac", + "67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061", + "67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061" +).map(colors); + +var RdBu = ramp$1(scheme$m); + +var scheme$l = new Array(3).concat( + "ef8a62ffffff999999", + "ca0020f4a582bababa404040", + "ca0020f4a582ffffffbababa404040", + "b2182bef8a62fddbc7e0e0e09999994d4d4d", + "b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d", + "b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d", + "b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d", + "67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a", + "67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a" +).map(colors); + +var RdGy = ramp$1(scheme$l); + +var scheme$k = new Array(3).concat( + "fc8d59ffffbf91bfdb", + "d7191cfdae61abd9e92c7bb6", + "d7191cfdae61ffffbfabd9e92c7bb6", + "d73027fc8d59fee090e0f3f891bfdb4575b4", + "d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4", + "d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4", + "d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4", + "a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695", + "a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695" +).map(colors); + +var RdYlBu = ramp$1(scheme$k); + +var scheme$j = new Array(3).concat( + "fc8d59ffffbf91cf60", + "d7191cfdae61a6d96a1a9641", + "d7191cfdae61ffffbfa6d96a1a9641", + "d73027fc8d59fee08bd9ef8b91cf601a9850", + "d73027fc8d59fee08bffffbfd9ef8b91cf601a9850", + "d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850", + "d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850", + "a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837", + "a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837" +).map(colors); + +var RdYlGn = ramp$1(scheme$j); + +var scheme$i = new Array(3).concat( + "fc8d59ffffbf99d594", + "d7191cfdae61abdda42b83ba", + "d7191cfdae61ffffbfabdda42b83ba", + "d53e4ffc8d59fee08be6f59899d5943288bd", + "d53e4ffc8d59fee08bffffbfe6f59899d5943288bd", + "d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd", + "d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd", + "9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2", + "9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2" +).map(colors); + +var Spectral = ramp$1(scheme$i); + +var scheme$h = new Array(3).concat( + "e5f5f999d8c92ca25f", + "edf8fbb2e2e266c2a4238b45", + "edf8fbb2e2e266c2a42ca25f006d2c", + "edf8fbccece699d8c966c2a42ca25f006d2c", + "edf8fbccece699d8c966c2a441ae76238b45005824", + "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824", + "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b" +).map(colors); + +var BuGn = ramp$1(scheme$h); + +var scheme$g = new Array(3).concat( + "e0ecf49ebcda8856a7", + "edf8fbb3cde38c96c688419d", + "edf8fbb3cde38c96c68856a7810f7c", + "edf8fbbfd3e69ebcda8c96c68856a7810f7c", + "edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b", + "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b", + "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b" +).map(colors); + +var BuPu = ramp$1(scheme$g); + +var scheme$f = new Array(3).concat( + "e0f3dba8ddb543a2ca", + "f0f9e8bae4bc7bccc42b8cbe", + "f0f9e8bae4bc7bccc443a2ca0868ac", + "f0f9e8ccebc5a8ddb57bccc443a2ca0868ac", + "f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e", + "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e", + "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081" +).map(colors); + +var GnBu = ramp$1(scheme$f); + +var scheme$e = new Array(3).concat( + "fee8c8fdbb84e34a33", + "fef0d9fdcc8afc8d59d7301f", + "fef0d9fdcc8afc8d59e34a33b30000", + "fef0d9fdd49efdbb84fc8d59e34a33b30000", + "fef0d9fdd49efdbb84fc8d59ef6548d7301f990000", + "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000", + "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000" +).map(colors); + +var OrRd = ramp$1(scheme$e); + +var scheme$d = new Array(3).concat( + "ece2f0a6bddb1c9099", + "f6eff7bdc9e167a9cf02818a", + "f6eff7bdc9e167a9cf1c9099016c59", + "f6eff7d0d1e6a6bddb67a9cf1c9099016c59", + "f6eff7d0d1e6a6bddb67a9cf3690c002818a016450", + "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450", + "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636" +).map(colors); + +var PuBuGn = ramp$1(scheme$d); + +var scheme$c = new Array(3).concat( + "ece7f2a6bddb2b8cbe", + "f1eef6bdc9e174a9cf0570b0", + "f1eef6bdc9e174a9cf2b8cbe045a8d", + "f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d", + "f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b", + "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b", + "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858" +).map(colors); + +var PuBu = ramp$1(scheme$c); + +var scheme$b = new Array(3).concat( + "e7e1efc994c7dd1c77", + "f1eef6d7b5d8df65b0ce1256", + "f1eef6d7b5d8df65b0dd1c77980043", + "f1eef6d4b9dac994c7df65b0dd1c77980043", + "f1eef6d4b9dac994c7df65b0e7298ace125691003f", + "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f", + "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f" +).map(colors); + +var PuRd = ramp$1(scheme$b); + +var scheme$a = new Array(3).concat( + "fde0ddfa9fb5c51b8a", + "feebe2fbb4b9f768a1ae017e", + "feebe2fbb4b9f768a1c51b8a7a0177", + "feebe2fcc5c0fa9fb5f768a1c51b8a7a0177", + "feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177", + "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177", + "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a" +).map(colors); + +var RdPu = ramp$1(scheme$a); + +var scheme$9 = new Array(3).concat( + "edf8b17fcdbb2c7fb8", + "ffffcca1dab441b6c4225ea8", + "ffffcca1dab441b6c42c7fb8253494", + "ffffccc7e9b47fcdbb41b6c42c7fb8253494", + "ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84", + "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84", + "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58" +).map(colors); + +var YlGnBu = ramp$1(scheme$9); + +var scheme$8 = new Array(3).concat( + "f7fcb9addd8e31a354", + "ffffccc2e69978c679238443", + "ffffccc2e69978c67931a354006837", + "ffffccd9f0a3addd8e78c67931a354006837", + "ffffccd9f0a3addd8e78c67941ab5d238443005a32", + "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32", + "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529" +).map(colors); + +var YlGn = ramp$1(scheme$8); + +var scheme$7 = new Array(3).concat( + "fff7bcfec44fd95f0e", + "ffffd4fed98efe9929cc4c02", + "ffffd4fed98efe9929d95f0e993404", + "ffffd4fee391fec44ffe9929d95f0e993404", + "ffffd4fee391fec44ffe9929ec7014cc4c028c2d04", + "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04", + "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506" +).map(colors); + +var YlOrBr = ramp$1(scheme$7); + +var scheme$6 = new Array(3).concat( + "ffeda0feb24cf03b20", + "ffffb2fecc5cfd8d3ce31a1c", + "ffffb2fecc5cfd8d3cf03b20bd0026", + "ffffb2fed976feb24cfd8d3cf03b20bd0026", + "ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026", + "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026", + "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026" +).map(colors); + +var YlOrRd = ramp$1(scheme$6); + +var scheme$5 = new Array(3).concat( + "deebf79ecae13182bd", + "eff3ffbdd7e76baed62171b5", + "eff3ffbdd7e76baed63182bd08519c", + "eff3ffc6dbef9ecae16baed63182bd08519c", + "eff3ffc6dbef9ecae16baed64292c62171b5084594", + "f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594", + "f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b" +).map(colors); + +var Blues = ramp$1(scheme$5); + +var scheme$4 = new Array(3).concat( + "e5f5e0a1d99b31a354", + "edf8e9bae4b374c476238b45", + "edf8e9bae4b374c47631a354006d2c", + "edf8e9c7e9c0a1d99b74c47631a354006d2c", + "edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32", + "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32", + "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b" +).map(colors); + +var Greens = ramp$1(scheme$4); + +var scheme$3 = new Array(3).concat( + "f0f0f0bdbdbd636363", + "f7f7f7cccccc969696525252", + "f7f7f7cccccc969696636363252525", + "f7f7f7d9d9d9bdbdbd969696636363252525", + "f7f7f7d9d9d9bdbdbd969696737373525252252525", + "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525", + "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000" +).map(colors); + +var Greys = ramp$1(scheme$3); + +var scheme$2 = new Array(3).concat( + "efedf5bcbddc756bb1", + "f2f0f7cbc9e29e9ac86a51a3", + "f2f0f7cbc9e29e9ac8756bb154278f", + "f2f0f7dadaebbcbddc9e9ac8756bb154278f", + "f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486", + "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486", + "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d" +).map(colors); + +var Purples = ramp$1(scheme$2); + +var scheme$1 = new Array(3).concat( + "fee0d2fc9272de2d26", + "fee5d9fcae91fb6a4acb181d", + "fee5d9fcae91fb6a4ade2d26a50f15", + "fee5d9fcbba1fc9272fb6a4ade2d26a50f15", + "fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d", + "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d", + "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d" +).map(colors); + +var Reds = ramp$1(scheme$1); + +var scheme = new Array(3).concat( + "fee6cefdae6be6550d", + "feeddefdbe85fd8d3cd94701", + "feeddefdbe85fd8d3ce6550da63603", + "feeddefdd0a2fdae6bfd8d3ce6550da63603", + "feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04", + "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04", + "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704" +).map(colors); + +var Oranges = ramp$1(scheme); + +function cividis(t) { + t = Math.max(0, Math.min(1, t)); + return "rgb(" + + Math.max(0, Math.min(255, Math.round(-4.54 - t * (35.34 - t * (2381.73 - t * (6402.7 - t * (7024.72 - t * 2710.57))))))) + ", " + + Math.max(0, Math.min(255, Math.round(32.49 + t * (170.73 + t * (52.82 - t * (131.46 - t * (176.58 - t * 67.37))))))) + ", " + + Math.max(0, Math.min(255, Math.round(81.24 + t * (442.36 - t * (2482.43 - t * (6167.24 - t * (6614.94 - t * 2475.67))))))) + + ")"; +} + +var cubehelix = cubehelixLong(cubehelix$3(300, 0.5, 0.0), cubehelix$3(-240, 0.5, 1.0)); + +var warm = cubehelixLong(cubehelix$3(-100, 0.75, 0.35), cubehelix$3(80, 1.50, 0.8)); + +var cool = cubehelixLong(cubehelix$3(260, 0.75, 0.35), cubehelix$3(80, 1.50, 0.8)); + +var c$2 = cubehelix$3(); + +function rainbow(t) { + if (t < 0 || t > 1) t -= Math.floor(t); + var ts = Math.abs(t - 0.5); + c$2.h = 360 * t - 100; + c$2.s = 1.5 - 1.5 * ts; + c$2.l = 0.8 - 0.9 * ts; + return c$2 + ""; +} + +var c$1 = rgb(), + pi_1_3 = Math.PI / 3, + pi_2_3 = Math.PI * 2 / 3; + +function sinebow(t) { + var x; + t = (0.5 - t) * Math.PI; + c$1.r = 255 * (x = Math.sin(t)) * x; + c$1.g = 255 * (x = Math.sin(t + pi_1_3)) * x; + c$1.b = 255 * (x = Math.sin(t + pi_2_3)) * x; + return c$1 + ""; +} + +function turbo(t) { + t = Math.max(0, Math.min(1, t)); + return "rgb(" + + Math.max(0, Math.min(255, Math.round(34.61 + t * (1172.33 - t * (10793.56 - t * (33300.12 - t * (38394.49 - t * 14825.05))))))) + ", " + + Math.max(0, Math.min(255, Math.round(23.31 + t * (557.33 + t * (1225.33 - t * (3574.96 - t * (1073.77 + t * 707.56))))))) + ", " + + Math.max(0, Math.min(255, Math.round(27.2 + t * (3211.1 - t * (15327.97 - t * (27814 - t * (22569.18 - t * 6838.66))))))) + + ")"; +} + +function ramp(range) { + var n = range.length; + return function(t) { + return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))]; + }; +} + +var viridis = ramp(colors("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")); + +var magma = ramp(colors("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")); + +var inferno = ramp(colors("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")); + +var plasma = ramp(colors("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921")); + +function constant$1(x) { + return function constant() { + return x; + }; +} + +const abs = Math.abs; +const atan2 = Math.atan2; +const cos = Math.cos; +const max = Math.max; +const min = Math.min; +const sin = Math.sin; +const sqrt = Math.sqrt; + +const epsilon = 1e-12; +const pi = Math.PI; +const halfPi = pi / 2; +const tau = 2 * pi; + +function acos(x) { + return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); +} + +function asin(x) { + return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x); +} + +function withPath(shape) { + let digits = 3; + + shape.digits = function(_) { + if (!arguments.length) return digits; + if (_ == null) { + digits = null; + } else { + const d = Math.floor(_); + if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`); + digits = d; + } + return shape; + }; + + return () => new Path$1(digits); +} + +function arcInnerRadius(d) { + return d.innerRadius; +} + +function arcOuterRadius(d) { + return d.outerRadius; +} + +function arcStartAngle(d) { + return d.startAngle; +} + +function arcEndAngle(d) { + return d.endAngle; +} + +function arcPadAngle(d) { + return d && d.padAngle; // Note: optional! +} + +function intersect(x0, y0, x1, y1, x2, y2, x3, y3) { + var x10 = x1 - x0, y10 = y1 - y0, + x32 = x3 - x2, y32 = y3 - y2, + t = y32 * x10 - x32 * y10; + if (t * t < epsilon) return; + t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t; + return [x0 + t * x10, y0 + t * y10]; +} + +// Compute perpendicular offset line of length rc. +// http://mathworld.wolfram.com/Circle-LineIntersection.html +function cornerTangents(x0, y0, x1, y1, r1, rc, cw) { + var x01 = x0 - x1, + y01 = y0 - y1, + lo = (cw ? rc : -rc) / sqrt(x01 * x01 + y01 * y01), + ox = lo * y01, + oy = -lo * x01, + x11 = x0 + ox, + y11 = y0 + oy, + x10 = x1 + ox, + y10 = y1 + oy, + x00 = (x11 + x10) / 2, + y00 = (y11 + y10) / 2, + dx = x10 - x11, + dy = y10 - y11, + d2 = dx * dx + dy * dy, + r = r1 - rc, + D = x11 * y10 - x10 * y11, + d = (dy < 0 ? -1 : 1) * sqrt(max(0, r * r * d2 - D * D)), + cx0 = (D * dy - dx * d) / d2, + cy0 = (-D * dx - dy * d) / d2, + cx1 = (D * dy + dx * d) / d2, + cy1 = (-D * dx + dy * d) / d2, + dx0 = cx0 - x00, + dy0 = cy0 - y00, + dx1 = cx1 - x00, + dy1 = cy1 - y00; + + // Pick the closer of the two intersection points. + // TODO Is there a faster way to determine which intersection to use? + if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1; + + return { + cx: cx0, + cy: cy0, + x01: -ox, + y01: -oy, + x11: cx0 * (r1 / r - 1), + y11: cy0 * (r1 / r - 1) + }; +} + +function arc() { + var innerRadius = arcInnerRadius, + outerRadius = arcOuterRadius, + cornerRadius = constant$1(0), + padRadius = null, + startAngle = arcStartAngle, + endAngle = arcEndAngle, + padAngle = arcPadAngle, + context = null, + path = withPath(arc); + + function arc() { + var buffer, + r, + r0 = +innerRadius.apply(this, arguments), + r1 = +outerRadius.apply(this, arguments), + a0 = startAngle.apply(this, arguments) - halfPi, + a1 = endAngle.apply(this, arguments) - halfPi, + da = abs(a1 - a0), + cw = a1 > a0; + + if (!context) context = buffer = path(); + + // Ensure that the outer radius is always larger than the inner radius. + if (r1 < r0) r = r1, r1 = r0, r0 = r; + + // Is it a point? + if (!(r1 > epsilon)) context.moveTo(0, 0); + + // Or is it a circle or annulus? + else if (da > tau - epsilon) { + context.moveTo(r1 * cos(a0), r1 * sin(a0)); + context.arc(0, 0, r1, a0, a1, !cw); + if (r0 > epsilon) { + context.moveTo(r0 * cos(a1), r0 * sin(a1)); + context.arc(0, 0, r0, a1, a0, cw); + } + } + + // Or is it a circular or annular sector? + else { + var a01 = a0, + a11 = a1, + a00 = a0, + a10 = a1, + da0 = da, + da1 = da, + ap = padAngle.apply(this, arguments) / 2, + rp = (ap > epsilon) && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)), + rc = min(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), + rc0 = rc, + rc1 = rc, + t0, + t1; + + // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0. + if (rp > epsilon) { + var p0 = asin(rp / r0 * sin(ap)), + p1 = asin(rp / r1 * sin(ap)); + if ((da0 -= p0 * 2) > epsilon) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0; + else da0 = 0, a00 = a10 = (a0 + a1) / 2; + if ((da1 -= p1 * 2) > epsilon) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1; + else da1 = 0, a01 = a11 = (a0 + a1) / 2; + } + + var x01 = r1 * cos(a01), + y01 = r1 * sin(a01), + x10 = r0 * cos(a10), + y10 = r0 * sin(a10); + + // Apply rounded corners? + if (rc > epsilon) { + var x11 = r1 * cos(a11), + y11 = r1 * sin(a11), + x00 = r0 * cos(a00), + y00 = r0 * sin(a00), + oc; + + // Restrict the corner radius according to the sector angle. If this + // intersection fails, it’s probably because the arc is too small, so + // disable the corner radius entirely. + if (da < pi) { + if (oc = intersect(x01, y01, x00, y00, x11, y11, x10, y10)) { + var ax = x01 - oc[0], + ay = y01 - oc[1], + bx = x11 - oc[0], + by = y11 - oc[1], + kc = 1 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2), + lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]); + rc0 = min(rc, (r0 - lc) / (kc - 1)); + rc1 = min(rc, (r1 - lc) / (kc + 1)); + } else { + rc0 = rc1 = 0; + } + } + } + + // Is the sector collapsed to a line? + if (!(da1 > epsilon)) context.moveTo(x01, y01); + + // Does the sector’s outer ring have rounded corners? + else if (rc1 > epsilon) { + t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw); + t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw); + + context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01); + + // Have the corners merged? + if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw); + + // Otherwise, draw the two corners and the ring. + else { + context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw); + context.arc(0, 0, r1, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw); + context.arc(t1.cx, t1.cy, rc1, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw); + } + } + + // Or is the outer ring just a circular arc? + else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw); + + // Is there no inner ring, and it’s a circular sector? + // Or perhaps it’s an annular sector collapsed due to padding? + if (!(r0 > epsilon) || !(da0 > epsilon)) context.lineTo(x10, y10); + + // Does the sector’s inner ring (or point) have rounded corners? + else if (rc0 > epsilon) { + t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw); + t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw); + + context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01); + + // Have the corners merged? + if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw); + + // Otherwise, draw the two corners and the ring. + else { + context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw); + context.arc(0, 0, r0, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw); + context.arc(t1.cx, t1.cy, rc0, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw); + } + } + + // Or is the inner ring just a circular arc? + else context.arc(0, 0, r0, a10, a00, cw); + } + + context.closePath(); + + if (buffer) return context = null, buffer + "" || null; + } + + arc.centroid = function() { + var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, + a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi / 2; + return [cos(a) * r, sin(a) * r]; + }; + + arc.innerRadius = function(_) { + return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : innerRadius; + }; + + arc.outerRadius = function(_) { + return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : outerRadius; + }; + + arc.cornerRadius = function(_) { + return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : cornerRadius; + }; + + arc.padRadius = function(_) { + return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), arc) : padRadius; + }; + + arc.startAngle = function(_) { + return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : startAngle; + }; + + arc.endAngle = function(_) { + return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : endAngle; + }; + + arc.padAngle = function(_) { + return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : padAngle; + }; + + arc.context = function(_) { + return arguments.length ? ((context = _ == null ? null : _), arc) : context; + }; + + return arc; +} + +var slice = Array.prototype.slice; + +function array(x) { + return typeof x === "object" && "length" in x + ? x // Array, TypedArray, NodeList, array-like + : Array.from(x); // Map, Set, iterable, string, or anything else +} + +function Linear(context) { + this._context = context; +} + +Linear.prototype = { + areaStart: function() { + this._line = 0; + }, + areaEnd: function() { + this._line = NaN; + }, + lineStart: function() { + this._point = 0; + }, + lineEnd: function() { + if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; + case 1: this._point = 2; // falls through + default: this._context.lineTo(x, y); break; + } + } +}; + +function curveLinear(context) { + return new Linear(context); +} + +function x(p) { + return p[0]; +} + +function y(p) { + return p[1]; +} + +function line(x$1, y$1) { + var defined = constant$1(true), + context = null, + curve = curveLinear, + output = null, + path = withPath(line); + + x$1 = typeof x$1 === "function" ? x$1 : (x$1 === undefined) ? x : constant$1(x$1); + y$1 = typeof y$1 === "function" ? y$1 : (y$1 === undefined) ? y : constant$1(y$1); + + function line(data) { + var i, + n = (data = array(data)).length, + d, + defined0 = false, + buffer; + + if (context == null) output = curve(buffer = path()); + + for (i = 0; i <= n; ++i) { + if (!(i < n && defined(d = data[i], i, data)) === defined0) { + if (defined0 = !defined0) output.lineStart(); + else output.lineEnd(); + } + if (defined0) output.point(+x$1(d, i, data), +y$1(d, i, data)); + } + + if (buffer) return output = null, buffer + "" || null; + } + + line.x = function(_) { + return arguments.length ? (x$1 = typeof _ === "function" ? _ : constant$1(+_), line) : x$1; + }; + + line.y = function(_) { + return arguments.length ? (y$1 = typeof _ === "function" ? _ : constant$1(+_), line) : y$1; + }; + + line.defined = function(_) { + return arguments.length ? (defined = typeof _ === "function" ? _ : constant$1(!!_), line) : defined; + }; + + line.curve = function(_) { + return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve; + }; + + line.context = function(_) { + return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context; + }; + + return line; +} + +function area(x0, y0, y1) { + var x1 = null, + defined = constant$1(true), + context = null, + curve = curveLinear, + output = null, + path = withPath(area); + + x0 = typeof x0 === "function" ? x0 : (x0 === undefined) ? x : constant$1(+x0); + y0 = typeof y0 === "function" ? y0 : (y0 === undefined) ? constant$1(0) : constant$1(+y0); + y1 = typeof y1 === "function" ? y1 : (y1 === undefined) ? y : constant$1(+y1); + + function area(data) { + var i, + j, + k, + n = (data = array(data)).length, + d, + defined0 = false, + buffer, + x0z = new Array(n), + y0z = new Array(n); + + if (context == null) output = curve(buffer = path()); + + for (i = 0; i <= n; ++i) { + if (!(i < n && defined(d = data[i], i, data)) === defined0) { + if (defined0 = !defined0) { + j = i; + output.areaStart(); + output.lineStart(); + } else { + output.lineEnd(); + output.lineStart(); + for (k = i - 1; k >= j; --k) { + output.point(x0z[k], y0z[k]); + } + output.lineEnd(); + output.areaEnd(); + } + } + if (defined0) { + x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data); + output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]); + } + } + + if (buffer) return output = null, buffer + "" || null; + } + + function arealine() { + return line().defined(defined).curve(curve).context(context); + } + + area.x = function(_) { + return arguments.length ? (x0 = typeof _ === "function" ? _ : constant$1(+_), x1 = null, area) : x0; + }; + + area.x0 = function(_) { + return arguments.length ? (x0 = typeof _ === "function" ? _ : constant$1(+_), area) : x0; + }; + + area.x1 = function(_) { + return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), area) : x1; + }; + + area.y = function(_) { + return arguments.length ? (y0 = typeof _ === "function" ? _ : constant$1(+_), y1 = null, area) : y0; + }; + + area.y0 = function(_) { + return arguments.length ? (y0 = typeof _ === "function" ? _ : constant$1(+_), area) : y0; + }; + + area.y1 = function(_) { + return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), area) : y1; + }; + + area.lineX0 = + area.lineY0 = function() { + return arealine().x(x0).y(y0); + }; + + area.lineY1 = function() { + return arealine().x(x0).y(y1); + }; + + area.lineX1 = function() { + return arealine().x(x1).y(y0); + }; + + area.defined = function(_) { + return arguments.length ? (defined = typeof _ === "function" ? _ : constant$1(!!_), area) : defined; + }; + + area.curve = function(_) { + return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve; + }; + + area.context = function(_) { + return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context; + }; + + return area; +} + +function descending$1(a, b) { + return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; +} + +function identity$1(d) { + return d; +} + +function pie() { + var value = identity$1, + sortValues = descending$1, + sort = null, + startAngle = constant$1(0), + endAngle = constant$1(tau), + padAngle = constant$1(0); + + function pie(data) { + var i, + n = (data = array(data)).length, + j, + k, + sum = 0, + index = new Array(n), + arcs = new Array(n), + a0 = +startAngle.apply(this, arguments), + da = Math.min(tau, Math.max(-tau, endAngle.apply(this, arguments) - a0)), + a1, + p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), + pa = p * (da < 0 ? -1 : 1), + v; + + for (i = 0; i < n; ++i) { + if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) { + sum += v; + } + } + + // Optionally sort the arcs by previously-computed values or by data. + if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); }); + else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); }); + + // Compute the arcs! They are stored in the original data's order. + for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) { + j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = { + data: data[j], + index: i, + value: v, + startAngle: a0, + endAngle: a1, + padAngle: p + }; + } + + return arcs; + } + + pie.value = function(_) { + return arguments.length ? (value = typeof _ === "function" ? _ : constant$1(+_), pie) : value; + }; + + pie.sortValues = function(_) { + return arguments.length ? (sortValues = _, sort = null, pie) : sortValues; + }; + + pie.sort = function(_) { + return arguments.length ? (sort = _, sortValues = null, pie) : sort; + }; + + pie.startAngle = function(_) { + return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant$1(+_), pie) : startAngle; + }; + + pie.endAngle = function(_) { + return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$1(+_), pie) : endAngle; + }; + + pie.padAngle = function(_) { + return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant$1(+_), pie) : padAngle; + }; + + return pie; +} + +var curveRadialLinear = curveRadial(curveLinear); + +function Radial(curve) { + this._curve = curve; +} + +Radial.prototype = { + areaStart: function() { + this._curve.areaStart(); + }, + areaEnd: function() { + this._curve.areaEnd(); + }, + lineStart: function() { + this._curve.lineStart(); + }, + lineEnd: function() { + this._curve.lineEnd(); + }, + point: function(a, r) { + this._curve.point(r * Math.sin(a), r * -Math.cos(a)); + } +}; + +function curveRadial(curve) { + + function radial(context) { + return new Radial(curve(context)); + } + + radial._curve = curve; + + return radial; +} + +function lineRadial(l) { + var c = l.curve; + + l.angle = l.x, delete l.x; + l.radius = l.y, delete l.y; + + l.curve = function(_) { + return arguments.length ? c(curveRadial(_)) : c()._curve; + }; + + return l; +} + +function lineRadial$1() { + return lineRadial(line().curve(curveRadialLinear)); +} + +function areaRadial() { + var a = area().curve(curveRadialLinear), + c = a.curve, + x0 = a.lineX0, + x1 = a.lineX1, + y0 = a.lineY0, + y1 = a.lineY1; + + a.angle = a.x, delete a.x; + a.startAngle = a.x0, delete a.x0; + a.endAngle = a.x1, delete a.x1; + a.radius = a.y, delete a.y; + a.innerRadius = a.y0, delete a.y0; + a.outerRadius = a.y1, delete a.y1; + a.lineStartAngle = function() { return lineRadial(x0()); }, delete a.lineX0; + a.lineEndAngle = function() { return lineRadial(x1()); }, delete a.lineX1; + a.lineInnerRadius = function() { return lineRadial(y0()); }, delete a.lineY0; + a.lineOuterRadius = function() { return lineRadial(y1()); }, delete a.lineY1; + + a.curve = function(_) { + return arguments.length ? c(curveRadial(_)) : c()._curve; + }; + + return a; +} + +function pointRadial(x, y) { + return [(y = +y) * Math.cos(x -= Math.PI / 2), y * Math.sin(x)]; +} + +class Bump { + constructor(context, x) { + this._context = context; + this._x = x; + } + areaStart() { + this._line = 0; + } + areaEnd() { + this._line = NaN; + } + lineStart() { + this._point = 0; + } + lineEnd() { + if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); + this._line = 1 - this._line; + } + point(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: { + this._point = 1; + if (this._line) this._context.lineTo(x, y); + else this._context.moveTo(x, y); + break; + } + case 1: this._point = 2; // falls through + default: { + if (this._x) this._context.bezierCurveTo(this._x0 = (this._x0 + x) / 2, this._y0, this._x0, y, x, y); + else this._context.bezierCurveTo(this._x0, this._y0 = (this._y0 + y) / 2, x, this._y0, x, y); + break; + } + } + this._x0 = x, this._y0 = y; + } +} + +class BumpRadial { + constructor(context) { + this._context = context; + } + lineStart() { + this._point = 0; + } + lineEnd() {} + point(x, y) { + x = +x, y = +y; + if (this._point === 0) { + this._point = 1; + } else { + const p0 = pointRadial(this._x0, this._y0); + const p1 = pointRadial(this._x0, this._y0 = (this._y0 + y) / 2); + const p2 = pointRadial(x, this._y0); + const p3 = pointRadial(x, y); + this._context.moveTo(...p0); + this._context.bezierCurveTo(...p1, ...p2, ...p3); + } + this._x0 = x, this._y0 = y; + } +} + +function bumpX(context) { + return new Bump(context, true); +} + +function bumpY(context) { + return new Bump(context, false); +} + +function bumpRadial(context) { + return new BumpRadial(context); +} + +function linkSource(d) { + return d.source; +} + +function linkTarget(d) { + return d.target; +} + +function link(curve) { + let source = linkSource, + target = linkTarget, + x$1 = x, + y$1 = y, + context = null, + output = null, + path = withPath(link); + + function link() { + let buffer; + const argv = slice.call(arguments); + const s = source.apply(this, argv); + const t = target.apply(this, argv); + if (context == null) output = curve(buffer = path()); + output.lineStart(); + argv[0] = s, output.point(+x$1.apply(this, argv), +y$1.apply(this, argv)); + argv[0] = t, output.point(+x$1.apply(this, argv), +y$1.apply(this, argv)); + output.lineEnd(); + if (buffer) return output = null, buffer + "" || null; + } + + link.source = function(_) { + return arguments.length ? (source = _, link) : source; + }; + + link.target = function(_) { + return arguments.length ? (target = _, link) : target; + }; + + link.x = function(_) { + return arguments.length ? (x$1 = typeof _ === "function" ? _ : constant$1(+_), link) : x$1; + }; + + link.y = function(_) { + return arguments.length ? (y$1 = typeof _ === "function" ? _ : constant$1(+_), link) : y$1; + }; + + link.context = function(_) { + return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), link) : context; + }; + + return link; +} + +function linkHorizontal() { + return link(bumpX); +} + +function linkVertical() { + return link(bumpY); +} + +function linkRadial() { + const l = link(bumpRadial); + l.angle = l.x, delete l.x; + l.radius = l.y, delete l.y; + return l; +} + +const sqrt3$2 = sqrt(3); + +var asterisk = { + draw(context, size) { + const r = sqrt(size + min(size / 28, 0.75)) * 0.59436; + const t = r / 2; + const u = t * sqrt3$2; + context.moveTo(0, r); + context.lineTo(0, -r); + context.moveTo(-u, -t); + context.lineTo(u, t); + context.moveTo(-u, t); + context.lineTo(u, -t); + } +}; + +var circle = { + draw(context, size) { + const r = sqrt(size / pi); + context.moveTo(r, 0); + context.arc(0, 0, r, 0, tau); + } +}; + +var cross = { + draw(context, size) { + const r = sqrt(size / 5) / 2; + context.moveTo(-3 * r, -r); + context.lineTo(-r, -r); + context.lineTo(-r, -3 * r); + context.lineTo(r, -3 * r); + context.lineTo(r, -r); + context.lineTo(3 * r, -r); + context.lineTo(3 * r, r); + context.lineTo(r, r); + context.lineTo(r, 3 * r); + context.lineTo(-r, 3 * r); + context.lineTo(-r, r); + context.lineTo(-3 * r, r); + context.closePath(); + } +}; + +const tan30 = sqrt(1 / 3); +const tan30_2 = tan30 * 2; + +var diamond = { + draw(context, size) { + const y = sqrt(size / tan30_2); + const x = y * tan30; + context.moveTo(0, -y); + context.lineTo(x, 0); + context.lineTo(0, y); + context.lineTo(-x, 0); + context.closePath(); + } +}; + +var diamond2 = { + draw(context, size) { + const r = sqrt(size) * 0.62625; + context.moveTo(0, -r); + context.lineTo(r, 0); + context.lineTo(0, r); + context.lineTo(-r, 0); + context.closePath(); + } +}; + +var plus = { + draw(context, size) { + const r = sqrt(size - min(size / 7, 2)) * 0.87559; + context.moveTo(-r, 0); + context.lineTo(r, 0); + context.moveTo(0, r); + context.lineTo(0, -r); + } +}; + +var square = { + draw(context, size) { + const w = sqrt(size); + const x = -w / 2; + context.rect(x, x, w, w); + } +}; + +var square2 = { + draw(context, size) { + const r = sqrt(size) * 0.4431; + context.moveTo(r, r); + context.lineTo(r, -r); + context.lineTo(-r, -r); + context.lineTo(-r, r); + context.closePath(); + } +}; + +const ka = 0.89081309152928522810; +const kr = sin(pi / 10) / sin(7 * pi / 10); +const kx = sin(tau / 10) * kr; +const ky = -cos(tau / 10) * kr; + +var star = { + draw(context, size) { + const r = sqrt(size * ka); + const x = kx * r; + const y = ky * r; + context.moveTo(0, -r); + context.lineTo(x, y); + for (let i = 1; i < 5; ++i) { + const a = tau * i / 5; + const c = cos(a); + const s = sin(a); + context.lineTo(s * r, -c * r); + context.lineTo(c * x - s * y, s * x + c * y); + } + context.closePath(); + } +}; + +const sqrt3$1 = sqrt(3); + +var triangle = { + draw(context, size) { + const y = -sqrt(size / (sqrt3$1 * 3)); + context.moveTo(0, y * 2); + context.lineTo(-sqrt3$1 * y, -y); + context.lineTo(sqrt3$1 * y, -y); + context.closePath(); + } +}; + +const sqrt3 = sqrt(3); + +var triangle2 = { + draw(context, size) { + const s = sqrt(size) * 0.6824; + const t = s / 2; + const u = (s * sqrt3) / 2; // cos(Math.PI / 6) + context.moveTo(0, -s); + context.lineTo(u, t); + context.lineTo(-u, t); + context.closePath(); + } +}; + +const c = -0.5; +const s = sqrt(3) / 2; +const k = 1 / sqrt(12); +const a = (k / 2 + 1) * 3; + +var wye = { + draw(context, size) { + const r = sqrt(size / a); + const x0 = r / 2, y0 = r * k; + const x1 = x0, y1 = r * k + r; + const x2 = -x1, y2 = y1; + context.moveTo(x0, y0); + context.lineTo(x1, y1); + context.lineTo(x2, y2); + context.lineTo(c * x0 - s * y0, s * x0 + c * y0); + context.lineTo(c * x1 - s * y1, s * x1 + c * y1); + context.lineTo(c * x2 - s * y2, s * x2 + c * y2); + context.lineTo(c * x0 + s * y0, c * y0 - s * x0); + context.lineTo(c * x1 + s * y1, c * y1 - s * x1); + context.lineTo(c * x2 + s * y2, c * y2 - s * x2); + context.closePath(); + } +}; + +var times = { + draw(context, size) { + const r = sqrt(size - min(size / 6, 1.7)) * 0.6189; + context.moveTo(-r, -r); + context.lineTo(r, r); + context.moveTo(-r, r); + context.lineTo(r, -r); + } +}; + +// These symbols are designed to be filled. +const symbolsFill = [ + circle, + cross, + diamond, + square, + star, + triangle, + wye +]; + +// These symbols are designed to be stroked (with a width of 1.5px and round caps). +const symbolsStroke = [ + circle, + plus, + times, + triangle2, + asterisk, + square2, + diamond2 +]; + +function Symbol$1(type, size) { + let context = null, + path = withPath(symbol); + + type = typeof type === "function" ? type : constant$1(type || circle); + size = typeof size === "function" ? size : constant$1(size === undefined ? 64 : +size); + + function symbol() { + let buffer; + if (!context) context = buffer = path(); + type.apply(this, arguments).draw(context, +size.apply(this, arguments)); + if (buffer) return context = null, buffer + "" || null; + } + + symbol.type = function(_) { + return arguments.length ? (type = typeof _ === "function" ? _ : constant$1(_), symbol) : type; + }; + + symbol.size = function(_) { + return arguments.length ? (size = typeof _ === "function" ? _ : constant$1(+_), symbol) : size; + }; + + symbol.context = function(_) { + return arguments.length ? (context = _ == null ? null : _, symbol) : context; + }; + + return symbol; +} + +function noop() {} + +function point$3(that, x, y) { + that._context.bezierCurveTo( + (2 * that._x0 + that._x1) / 3, + (2 * that._y0 + that._y1) / 3, + (that._x0 + 2 * that._x1) / 3, + (that._y0 + 2 * that._y1) / 3, + (that._x0 + 4 * that._x1 + x) / 6, + (that._y0 + 4 * that._y1 + y) / 6 + ); +} + +function Basis(context) { + this._context = context; +} + +Basis.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: point$3(this, this._x1, this._y1); // falls through + case 2: this._context.lineTo(this._x1, this._y1); break; + } + if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); 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); // falls through + default: point$3(this, x, y); break; + } + this._x0 = this._x1, this._x1 = x; + this._y0 = this._y1, this._y1 = y; + } +}; + +function basis(context) { + return new Basis(context); +} + +function BasisClosed(context) { + this._context = context; +} + +BasisClosed.prototype = { + areaStart: noop, + areaEnd: noop, + 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); + break; + } + } + }, + point: function(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: this._point = 1; this._x2 = x, this._y2 = y; break; + case 1: this._point = 2; this._x3 = x, this._y3 = y; break; + case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break; + default: point$3(this, x, y); break; + } + this._x0 = this._x1, this._x1 = x; + this._y0 = this._y1, this._y1 = y; + } +}; + +function basisClosed(context) { + return new BasisClosed(context); +} + +function BasisOpen(context) { + this._context = context; +} + +BasisOpen.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() { + if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: this._point = 1; break; + case 1: this._point = 2; break; + case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break; + case 3: this._point = 4; // falls through + default: point$3(this, x, y); break; + } + this._x0 = this._x1, this._x1 = x; + this._y0 = this._y1, this._y1 = y; + } +}; + +function basisOpen(context) { + return new BasisOpen(context); +} + +function Bundle(context, beta) { + this._basis = new Basis(context); + this._beta = beta; +} + +Bundle.prototype = { + lineStart: function() { + this._x = []; + this._y = []; + this._basis.lineStart(); + }, + lineEnd: function() { + var x = this._x, + y = this._y, + j = x.length - 1; + + if (j > 0) { + var x0 = x[0], + y0 = y[0], + dx = x[j] - x0, + dy = y[j] - y0, + i = -1, + t; + + while (++i <= j) { + t = i / j; + this._basis.point( + this._beta * x[i] + (1 - this._beta) * (x0 + t * dx), + this._beta * y[i] + (1 - this._beta) * (y0 + t * dy) + ); + } + } + + this._x = this._y = null; + this._basis.lineEnd(); + }, + point: function(x, y) { + this._x.push(+x); + this._y.push(+y); + } +}; + +var bundle = (function custom(beta) { + + function bundle(context) { + return beta === 1 ? new Basis(context) : new Bundle(context, beta); + } + + bundle.beta = function(beta) { + return custom(+beta); + }; + + return bundle; +})(0.85); + +function point$2(that, x, y) { + that._context.bezierCurveTo( + that._x1 + that._k * (that._x2 - that._x0), + that._y1 + that._k * (that._y2 - that._y0), + that._x2 + that._k * (that._x1 - x), + that._y2 + that._k * (that._y1 - y), + that._x2, + that._y2 + ); +} + +function Cardinal(context, tension) { + this._context = context; + this._k = (1 - tension) / 6; +} + +Cardinal.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: point$2(this, this._x1, this._y1); break; + } + if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; + case 1: this._point = 2; this._x1 = x, this._y1 = y; break; + case 2: this._point = 3; // falls through + default: point$2(this, x, y); break; + } + this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; + this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; + } +}; + +var cardinal = (function custom(tension) { + + function cardinal(context) { + return new Cardinal(context, tension); + } + + cardinal.tension = function(tension) { + return custom(+tension); + }; + + return cardinal; +})(0); + +function CardinalClosed(context, tension) { + this._context = context; + this._k = (1 - tension) / 6; +} + +CardinalClosed.prototype = { + areaStart: noop, + areaEnd: noop, + 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); + break; + } + } + }, + point: function(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: this._point = 1; this._x3 = x, this._y3 = y; break; + case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; + case 2: this._point = 3; this._x5 = x, this._y5 = y; break; + default: point$2(this, x, y); break; + } + this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; + this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; + } +}; + +var cardinalClosed = (function custom(tension) { + + function cardinal(context) { + return new CardinalClosed(context, tension); + } + + cardinal.tension = function(tension) { + return custom(+tension); + }; + + return cardinal; +})(0); + +function CardinalOpen(context, tension) { + this._context = context; + this._k = (1 - tension) / 6; +} + +CardinalOpen.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() { + if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + 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; // falls through + default: point$2(this, x, y); break; + } + this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; + this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; + } +}; + +var cardinalOpen = (function custom(tension) { + + function cardinal(context) { + return new CardinalOpen(context, tension); + } + + cardinal.tension = function(tension) { + return custom(+tension); + }; + + return cardinal; +})(0); + +function point$1(that, x, y) { + var x1 = that._x1, + y1 = that._y1, + x2 = that._x2, + y2 = that._y2; + + if (that._l01_a > epsilon) { + var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a, + n = 3 * that._l01_a * (that._l01_a + that._l12_a); + x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n; + y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n; + } + + if (that._l23_a > epsilon) { + var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a, + m = 3 * that._l23_a * (that._l23_a + that._l12_a); + x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m; + y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m; + } + + that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2); +} + +function CatmullRom(context, alpha) { + this._context = context; + this._alpha = alpha; +} + +CatmullRom.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); break; + } + if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + + if (this._point) { + var x23 = this._x2 - x, + y23 = this._y2 - y; + this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); + } + + switch (this._point) { + case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; + case 1: this._point = 2; break; + case 2: this._point = 3; // falls through + default: point$1(this, x, y); break; + } + + 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 = x; + this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; + } +}; + +var catmullRom = (function custom(alpha) { + + function catmullRom(context) { + return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0); + } + + catmullRom.alpha = function(alpha) { + return custom(+alpha); + }; + + return catmullRom; +})(0.5); + +function CatmullRomClosed(context, alpha) { + this._context = context; + this._alpha = alpha; +} + +CatmullRomClosed.prototype = { + areaStart: noop, + areaEnd: noop, + 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); + break; + } + } + }, + point: function(x, y) { + x = +x, y = +y; + + if (this._point) { + var x23 = this._x2 - x, + y23 = this._y2 - y; + this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); + } + + switch (this._point) { + case 0: this._point = 1; this._x3 = x, this._y3 = y; break; + case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; + case 2: this._point = 3; this._x5 = x, this._y5 = y; break; + default: point$1(this, x, y); break; + } + + 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 = x; + this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; + } +}; + +var catmullRomClosed = (function custom(alpha) { + + function catmullRom(context) { + return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0); + } + + catmullRom.alpha = function(alpha) { + return custom(+alpha); + }; + + return catmullRom; +})(0.5); + +function CatmullRomOpen(context, alpha) { + this._context = context; + this._alpha = alpha; +} + +CatmullRomOpen.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() { + if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + + if (this._point) { + var x23 = this._x2 - x, + y23 = this._y2 - y; + this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, 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; // falls through + default: point$1(this, x, y); break; + } + + 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 = x; + this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; + } +}; + +var catmullRomOpen = (function custom(alpha) { + + function catmullRom(context) { + return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0); + } + + catmullRom.alpha = function(alpha) { + return custom(+alpha); + }; + + return catmullRom; +})(0.5); + +function LinearClosed(context) { + this._context = context; +} + +LinearClosed.prototype = { + areaStart: noop, + areaEnd: noop, + lineStart: function() { + this._point = 0; + }, + lineEnd: function() { + if (this._point) this._context.closePath(); + }, + point: function(x, y) { + x = +x, y = +y; + if (this._point) this._context.lineTo(x, y); + else this._point = 1, this._context.moveTo(x, y); + } +}; + +function linearClosed(context) { + return new LinearClosed(context); +} + +function sign(x) { + return x < 0 ? -1 : 1; +} + +// Calculate the slopes of the tangents (Hermite-type interpolation) based on +// the following paper: Steffen, M. 1990. A Simple Method for Monotonic +// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO. +// NOV(II), P. 443, 1990. +function slope3(that, x2, y2) { + var h0 = that._x1 - that._x0, + h1 = x2 - that._x1, + s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), + s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0), + p = (s0 * h1 + s1 * h0) / (h0 + h1); + return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0; +} + +// Calculate a one-sided slope. +function slope2(that, t) { + var h = that._x1 - that._x0; + return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t; +} + +// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations +// "you can express cubic Hermite interpolation in terms of cubic Bézier curves +// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1". +function point(that, t0, t1) { + var x0 = that._x0, + y0 = that._y0, + x1 = that._x1, + y1 = that._y1, + dx = (x1 - x0) / 3; + that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1); +} + +function MonotoneX(context) { + this._context = context; +} + +MonotoneX.prototype = { + areaStart: function() { + this._line = 0; + }, + areaEnd: function() { + this._line = NaN; + }, + lineStart: function() { + this._x0 = this._x1 = + this._y0 = this._y1 = + this._t0 = NaN; + this._point = 0; + }, + lineEnd: function() { + switch (this._point) { + case 2: this._context.lineTo(this._x1, this._y1); break; + case 3: point(this, this._t0, slope2(this, this._t0)); break; + } + if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); + this._line = 1 - this._line; + }, + point: function(x, y) { + var t1 = NaN; + + x = +x, y = +y; + if (x === this._x1 && y === this._y1) return; // Ignore coincident points. + switch (this._point) { + case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; + case 1: this._point = 2; break; + case 2: this._point = 3; point(this, slope2(this, t1 = slope3(this, x, y)), t1); break; + default: point(this, this._t0, t1 = slope3(this, x, y)); break; + } + + this._x0 = this._x1, this._x1 = x; + this._y0 = this._y1, this._y1 = y; + this._t0 = t1; + } +}; + +function MonotoneY(context) { + this._context = new ReflectContext(context); +} + +(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) { + MonotoneX.prototype.point.call(this, y, x); +}; + +function ReflectContext(context) { + this._context = context; +} + +ReflectContext.prototype = { + moveTo: function(x, y) { this._context.moveTo(y, x); }, + closePath: function() { this._context.closePath(); }, + lineTo: function(x, y) { this._context.lineTo(y, x); }, + bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); } +}; + +function monotoneX(context) { + return new MonotoneX(context); +} + +function monotoneY(context) { + return new MonotoneY(context); +} + +function Natural(context) { + this._context = context; +} + +Natural.prototype = { + areaStart: function() { + this._line = 0; + }, + areaEnd: function() { + this._line = NaN; + }, + lineStart: function() { + this._x = []; + this._y = []; + }, + lineEnd: function() { + var x = this._x, + y = this._y, + n = x.length; + + if (n) { + this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]); + if (n === 2) { + this._context.lineTo(x[1], y[1]); + } else { + var px = controlPoints(x), + py = controlPoints(y); + for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) { + this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]); + } + } + } + + if (this._line || (this._line !== 0 && n === 1)) this._context.closePath(); + this._line = 1 - this._line; + this._x = this._y = null; + }, + point: function(x, y) { + this._x.push(+x); + this._y.push(+y); + } +}; + +// See https://www.particleincell.com/2012/bezier-splines/ for derivation. +function controlPoints(x) { + var i, + n = x.length - 1, + m, + a = new Array(n), + b = new Array(n), + r = new Array(n); + a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1]; + for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1]; + a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n]; + for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1]; + a[n - 1] = r[n - 1] / b[n - 1]; + for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i]; + b[n - 1] = (x[n] + a[n - 1]) / 2; + for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1]; + return [a, b]; +} + +function natural(context) { + return new Natural(context); +} + +function Step(context, t) { + this._context = context; + this._t = t; +} + +Step.prototype = { + areaStart: function() { + this._line = 0; + }, + areaEnd: function() { + this._line = NaN; + }, + lineStart: function() { + this._x = this._y = NaN; + this._point = 0; + }, + lineEnd: function() { + if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y); + if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); + if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line; + }, + point: function(x, y) { + x = +x, y = +y; + switch (this._point) { + case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; + case 1: this._point = 2; // falls through + default: { + if (this._t <= 0) { + this._context.lineTo(this._x, y); + this._context.lineTo(x, y); + } else { + var x1 = this._x * (1 - this._t) + x * this._t; + this._context.lineTo(x1, this._y); + this._context.lineTo(x1, y); + } + break; + } + } + this._x = x, this._y = y; + } +}; + +function step(context) { + return new Step(context, 0.5); +} + +function stepBefore(context) { + return new Step(context, 0); +} + +function stepAfter(context) { + return new Step(context, 1); +} + +function none$1(series, order) { + if (!((n = series.length) > 1)) return; + for (var i = 1, j, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) { + s0 = s1, s1 = series[order[i]]; + for (j = 0; j < m; ++j) { + s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1]; + } + } +} + +function none(series) { + var n = series.length, o = new Array(n); + while (--n >= 0) o[n] = n; + return o; +} + +function stackValue(d, key) { + return d[key]; +} + +function stackSeries(key) { + const series = []; + series.key = key; + return series; +} + +function stack() { + var keys = constant$1([]), + order = none, + offset = none$1, + value = stackValue; + + function stack(data) { + var sz = Array.from(keys.apply(this, arguments), stackSeries), + i, n = sz.length, j = -1, + oz; + + for (const d of data) { + for (i = 0, ++j; i < n; ++i) { + (sz[i][j] = [0, +value(d, sz[i].key, j, data)]).data = d; + } + } + + for (i = 0, oz = array(order(sz)); i < n; ++i) { + sz[oz[i]].index = i; + } + + offset(sz, oz); + return sz; + } + + stack.keys = function(_) { + return arguments.length ? (keys = typeof _ === "function" ? _ : constant$1(Array.from(_)), stack) : keys; + }; + + stack.value = function(_) { + return arguments.length ? (value = typeof _ === "function" ? _ : constant$1(+_), stack) : value; + }; + + stack.order = function(_) { + return arguments.length ? (order = _ == null ? none : typeof _ === "function" ? _ : constant$1(Array.from(_)), stack) : order; + }; + + stack.offset = function(_) { + return arguments.length ? (offset = _ == null ? none$1 : _, stack) : offset; + }; + + return stack; +} + +function expand(series, order) { + if (!((n = series.length) > 0)) return; + for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) { + for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0; + if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y; + } + none$1(series, order); +} + +function diverging(series, order) { + if (!((n = series.length) > 0)) return; + for (var i, j = 0, d, dy, yp, yn, n, m = series[order[0]].length; j < m; ++j) { + for (yp = yn = 0, i = 0; i < n; ++i) { + if ((dy = (d = series[order[i]][j])[1] - d[0]) > 0) { + d[0] = yp, d[1] = yp += dy; + } else if (dy < 0) { + d[1] = yn, d[0] = yn += dy; + } else { + d[0] = 0, d[1] = dy; + } + } + } +} + +function silhouette(series, order) { + if (!((n = series.length) > 0)) return; + for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) { + for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0; + s0[j][1] += s0[j][0] = -y / 2; + } + none$1(series, order); +} + +function wiggle(series, order) { + if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return; + for (var y = 0, j = 1, s0, m, n; j < m; ++j) { + for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) { + var si = series[order[i]], + sij0 = si[j][1] || 0, + sij1 = si[j - 1][1] || 0, + s3 = (sij0 - sij1) / 2; + for (var k = 0; k < i; ++k) { + var sk = series[order[k]], + skj0 = sk[j][1] || 0, + skj1 = sk[j - 1][1] || 0; + s3 += skj0 - skj1; + } + s1 += sij0, s2 += s3 * sij0; + } + s0[j - 1][1] += s0[j - 1][0] = y; + if (s1) y -= s2 / s1; + } + s0[j - 1][1] += s0[j - 1][0] = y; + none$1(series, order); +} + +function appearance(series) { + var peaks = series.map(peak); + return none(series).sort(function(a, b) { return peaks[a] - peaks[b]; }); +} + +function peak(series) { + var i = -1, j = 0, n = series.length, vi, vj = -Infinity; + while (++i < n) if ((vi = +series[i][1]) > vj) vj = vi, j = i; + return j; +} + +function ascending(series) { + var sums = series.map(sum); + return none(series).sort(function(a, b) { return sums[a] - sums[b]; }); +} + +function sum(series) { + var s = 0, i = -1, n = series.length, v; + while (++i < n) if (v = +series[i][1]) s += v; + return s; +} + +function descending(series) { + return ascending(series).reverse(); +} + +function insideOut(series) { + var n = series.length, + i, + j, + sums = series.map(sum), + order = appearance(series), + top = 0, + bottom = 0, + tops = [], + bottoms = []; + + for (i = 0; i < n; ++i) { + j = order[i]; + if (top < bottom) { + top += sums[j]; + tops.push(j); + } else { + bottom += sums[j]; + bottoms.push(j); + } + } + + return bottoms.reverse().concat(tops); +} + +function reverse(series) { + return none(series).reverse(); +} + +var constant = x => () => x; + +function ZoomEvent(type, { + sourceEvent, + target, + transform, + dispatch +}) { + Object.defineProperties(this, { + type: {value: type, enumerable: true, configurable: true}, + sourceEvent: {value: sourceEvent, enumerable: true, configurable: true}, + target: {value: target, enumerable: true, configurable: true}, + transform: {value: transform, enumerable: true, configurable: true}, + _: {value: dispatch} + }); +} + +function Transform(k, x, y) { + this.k = k; + this.x = x; + this.y = y; +} + +Transform.prototype = { + constructor: Transform, + scale: function(k) { + return k === 1 ? this : new Transform(this.k * k, this.x, this.y); + }, + translate: function(x, y) { + return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y); + }, + apply: function(point) { + return [point[0] * this.k + this.x, point[1] * this.k + this.y]; + }, + applyX: function(x) { + return x * this.k + this.x; + }, + applyY: function(y) { + return y * this.k + this.y; + }, + invert: function(location) { + return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k]; + }, + invertX: function(x) { + return (x - this.x) / this.k; + }, + invertY: function(y) { + return (y - this.y) / this.k; + }, + rescaleX: function(x) { + return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x)); + }, + rescaleY: function(y) { + return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y)); + }, + toString: function() { + return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")"; + } +}; + +var identity = new Transform(1, 0, 0); + +transform.prototype = Transform.prototype; + +function transform(node) { + while (!node.__zoom) if (!(node = node.parentNode)) return identity; + return node.__zoom; +} + +function nopropagation(event) { + event.stopImmediatePropagation(); +} + +function noevent(event) { + event.preventDefault(); + event.stopImmediatePropagation(); +} + +// Ignore right-click, since that should open the context menu. +// except for pinch-to-zoom, which is sent as a wheel+ctrlKey event +function defaultFilter(event) { + return (!event.ctrlKey || event.type === 'wheel') && !event.button; +} + +function defaultExtent() { + var e = this; + if (e instanceof SVGElement) { + e = e.ownerSVGElement || e; + if (e.hasAttribute("viewBox")) { + e = e.viewBox.baseVal; + return [[e.x, e.y], [e.x + e.width, e.y + e.height]]; + } + return [[0, 0], [e.width.baseVal.value, e.height.baseVal.value]]; + } + return [[0, 0], [e.clientWidth, e.clientHeight]]; +} + +function defaultTransform() { + return this.__zoom || identity; +} + +function defaultWheelDelta(event) { + return -event.deltaY * (event.deltaMode === 1 ? 0.05 : event.deltaMode ? 1 : 0.002) * (event.ctrlKey ? 10 : 1); +} + +function defaultTouchable() { + return navigator.maxTouchPoints || ("ontouchstart" in this); +} + +function defaultConstrain(transform, extent, translateExtent) { + var dx0 = transform.invertX(extent[0][0]) - translateExtent[0][0], + dx1 = transform.invertX(extent[1][0]) - translateExtent[1][0], + dy0 = transform.invertY(extent[0][1]) - translateExtent[0][1], + dy1 = transform.invertY(extent[1][1]) - translateExtent[1][1]; + return transform.translate( + dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1), + dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1) + ); +} + +function zoom() { + var filter = defaultFilter, + extent = defaultExtent, + constrain = defaultConstrain, + wheelDelta = defaultWheelDelta, + touchable = defaultTouchable, + scaleExtent = [0, Infinity], + translateExtent = [[-Infinity, -Infinity], [Infinity, Infinity]], + duration = 250, + interpolate = interpolateZoom, + listeners = dispatch("start", "zoom", "end"), + touchstarting, + touchfirst, + touchending, + touchDelay = 500, + wheelDelay = 150, + clickDistance2 = 0, + tapDistance = 10; + + function zoom(selection) { + selection + .property("__zoom", defaultTransform) + .on("wheel.zoom", wheeled, {passive: false}) + .on("mousedown.zoom", mousedowned) + .on("dblclick.zoom", dblclicked) + .filter(touchable) + .on("touchstart.zoom", touchstarted) + .on("touchmove.zoom", touchmoved) + .on("touchend.zoom touchcancel.zoom", touchended) + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); + } + + zoom.transform = function(collection, transform, point, event) { + var selection = collection.selection ? collection.selection() : collection; + selection.property("__zoom", defaultTransform); + if (collection !== selection) { + schedule(collection, transform, point, event); + } else { + selection.interrupt().each(function() { + gesture(this, arguments) + .event(event) + .start() + .zoom(null, typeof transform === "function" ? transform.apply(this, arguments) : transform) + .end(); + }); + } + }; + + zoom.scaleBy = function(selection, k, p, event) { + zoom.scaleTo(selection, function() { + var k0 = this.__zoom.k, + k1 = typeof k === "function" ? k.apply(this, arguments) : k; + return k0 * k1; + }, p, event); + }; + + zoom.scaleTo = function(selection, k, p, event) { + zoom.transform(selection, function() { + var e = extent.apply(this, arguments), + t0 = this.__zoom, + p0 = p == null ? centroid(e) : typeof p === "function" ? p.apply(this, arguments) : p, + p1 = t0.invert(p0), + k1 = typeof k === "function" ? k.apply(this, arguments) : k; + return constrain(translate(scale(t0, k1), p0, p1), e, translateExtent); + }, p, event); + }; + + zoom.translateBy = function(selection, x, y, event) { + zoom.transform(selection, function() { + return constrain(this.__zoom.translate( + typeof x === "function" ? x.apply(this, arguments) : x, + typeof y === "function" ? y.apply(this, arguments) : y + ), extent.apply(this, arguments), translateExtent); + }, null, event); + }; + + zoom.translateTo = function(selection, x, y, p, event) { + zoom.transform(selection, function() { + var e = extent.apply(this, arguments), + t = this.__zoom, + p0 = p == null ? centroid(e) : typeof p === "function" ? p.apply(this, arguments) : p; + return constrain(identity.translate(p0[0], p0[1]).scale(t.k).translate( + typeof x === "function" ? -x.apply(this, arguments) : -x, + typeof y === "function" ? -y.apply(this, arguments) : -y + ), e, translateExtent); + }, p, event); + }; + + function scale(transform, k) { + k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], k)); + return k === transform.k ? transform : new Transform(k, transform.x, transform.y); + } + + function translate(transform, p0, p1) { + var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k; + return x === transform.x && y === transform.y ? transform : new Transform(transform.k, x, y); + } + + function centroid(extent) { + return [(+extent[0][0] + +extent[1][0]) / 2, (+extent[0][1] + +extent[1][1]) / 2]; + } + + function schedule(transition, transform, point, event) { + transition + .on("start.zoom", function() { gesture(this, arguments).event(event).start(); }) + .on("interrupt.zoom end.zoom", function() { gesture(this, arguments).event(event).end(); }) + .tween("zoom", function() { + var that = this, + args = arguments, + g = gesture(that, args).event(event), + e = extent.apply(that, args), + p = point == null ? centroid(e) : typeof point === "function" ? point.apply(that, args) : point, + w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]), + a = that.__zoom, + b = typeof transform === "function" ? transform.apply(that, args) : transform, + i = interpolate(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k)); + return function(t) { + if (t === 1) t = b; // Avoid rounding error on end. + else { var l = i(t), k = w / l[2]; t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); } + g.zoom(null, t); + }; + }); + } + + function gesture(that, args, clean) { + return (!clean && that.__zooming) || new Gesture(that, args); + } + + function Gesture(that, args) { + this.that = that; + this.args = args; + this.active = 0; + this.sourceEvent = null; + this.extent = extent.apply(that, args); + this.taps = 0; + } + + Gesture.prototype = { + event: function(event) { + if (event) this.sourceEvent = event; + return this; + }, + start: function() { + if (++this.active === 1) { + this.that.__zooming = this; + this.emit("start"); + } + return this; + }, + zoom: function(key, transform) { + if (this.mouse && key !== "mouse") this.mouse[1] = transform.invert(this.mouse[0]); + if (this.touch0 && key !== "touch") this.touch0[1] = transform.invert(this.touch0[0]); + if (this.touch1 && key !== "touch") this.touch1[1] = transform.invert(this.touch1[0]); + this.that.__zoom = transform; + this.emit("zoom"); + return this; + }, + end: function() { + if (--this.active === 0) { + delete this.that.__zooming; + this.emit("end"); + } + return this; + }, + emit: function(type) { + var d = select(this.that).datum(); + listeners.call( + type, + this.that, + new ZoomEvent(type, { + sourceEvent: this.sourceEvent, + target: zoom, + type, + transform: this.that.__zoom, + dispatch: listeners + }), + d + ); + } + }; + + function wheeled(event, ...args) { + if (!filter.apply(this, arguments)) return; + var g = gesture(this, args).event(event), + t = this.__zoom, + k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], t.k * Math.pow(2, wheelDelta.apply(this, arguments)))), + p = pointer(event); + + // If the mouse is in the same location as before, reuse it. + // If there were recent wheel events, reset the wheel idle timeout. + if (g.wheel) { + if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) { + g.mouse[1] = t.invert(g.mouse[0] = p); + } + clearTimeout(g.wheel); + } + + // If this wheel event won’t trigger a transform change, ignore it. + else if (t.k === k) return; + + // Otherwise, capture the mouse point and location at the start. + else { + g.mouse = [p, t.invert(p)]; + interrupt(this); + g.start(); + } + + noevent(event); + g.wheel = setTimeout(wheelidled, wheelDelay); + g.zoom("mouse", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent, translateExtent)); + + function wheelidled() { + g.wheel = null; + g.end(); + } + } + + function mousedowned(event, ...args) { + if (touchending || !filter.apply(this, arguments)) return; + var currentTarget = event.currentTarget, + g = gesture(this, args, true).event(event), + v = select(event.view).on("mousemove.zoom", mousemoved, true).on("mouseup.zoom", mouseupped, true), + p = pointer(event, currentTarget), + x0 = event.clientX, + y0 = event.clientY; + + dragDisable(event.view); + nopropagation(event); + g.mouse = [p, this.__zoom.invert(p)]; + interrupt(this); + g.start(); + + function mousemoved(event) { + noevent(event); + if (!g.moved) { + var dx = event.clientX - x0, dy = event.clientY - y0; + g.moved = dx * dx + dy * dy > clickDistance2; + } + g.event(event) + .zoom("mouse", constrain(translate(g.that.__zoom, g.mouse[0] = pointer(event, currentTarget), g.mouse[1]), g.extent, translateExtent)); + } + + function mouseupped(event) { + v.on("mousemove.zoom mouseup.zoom", null); + yesdrag(event.view, g.moved); + noevent(event); + g.event(event).end(); + } + } + + function dblclicked(event, ...args) { + if (!filter.apply(this, arguments)) return; + var t0 = this.__zoom, + p0 = pointer(event.changedTouches ? event.changedTouches[0] : event, this), + p1 = t0.invert(p0), + k1 = t0.k * (event.shiftKey ? 0.5 : 2), + t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, args), translateExtent); + + noevent(event); + if (duration > 0) select(this).transition().duration(duration).call(schedule, t1, p0, event); + else select(this).call(zoom.transform, t1, p0, event); + } + + function touchstarted(event, ...args) { + if (!filter.apply(this, arguments)) return; + var touches = event.touches, + n = touches.length, + g = gesture(this, args, event.changedTouches.length === n).event(event), + started, i, t, p; + + nopropagation(event); + for (i = 0; i < n; ++i) { + t = touches[i], p = pointer(t, this); + p = [p, this.__zoom.invert(p), t.identifier]; + if (!g.touch0) g.touch0 = p, started = true, g.taps = 1 + !!touchstarting; + else if (!g.touch1 && g.touch0[2] !== p[2]) g.touch1 = p, g.taps = 0; + } + + if (touchstarting) touchstarting = clearTimeout(touchstarting); + + if (started) { + if (g.taps < 2) touchfirst = p[0], touchstarting = setTimeout(function() { touchstarting = null; }, touchDelay); + interrupt(this); + g.start(); + } + } + + function touchmoved(event, ...args) { + if (!this.__zooming) return; + var g = gesture(this, args).event(event), + touches = event.changedTouches, + n = touches.length, i, t, p, l; + + noevent(event); + for (i = 0; i < n; ++i) { + t = touches[i], p = pointer(t, this); + if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p; + else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p; + } + t = g.that.__zoom; + if (g.touch1) { + var p0 = g.touch0[0], l0 = g.touch0[1], + p1 = g.touch1[0], l1 = g.touch1[1], + dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp, + dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl; + t = scale(t, Math.sqrt(dp / dl)); + p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2]; + l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2]; + } + else if (g.touch0) p = g.touch0[0], l = g.touch0[1]; + else return; + + g.zoom("touch", constrain(translate(t, p, l), g.extent, translateExtent)); + } + + function touchended(event, ...args) { + if (!this.__zooming) return; + var g = gesture(this, args).event(event), + touches = event.changedTouches, + n = touches.length, i, t; + + nopropagation(event); + if (touchending) clearTimeout(touchending); + touchending = setTimeout(function() { touchending = null; }, touchDelay); + for (i = 0; i < n; ++i) { + t = touches[i]; + if (g.touch0 && g.touch0[2] === t.identifier) delete g.touch0; + else if (g.touch1 && g.touch1[2] === t.identifier) delete g.touch1; + } + if (g.touch1 && !g.touch0) g.touch0 = g.touch1, delete g.touch1; + if (g.touch0) g.touch0[1] = this.__zoom.invert(g.touch0[0]); + else { + g.end(); + // If this was a dbltap, reroute to the (optional) dblclick.zoom handler. + if (g.taps === 2) { + t = pointer(t, this); + if (Math.hypot(touchfirst[0] - t[0], touchfirst[1] - t[1]) < tapDistance) { + var p = select(this).on("dblclick.zoom"); + if (p) p.apply(this, arguments); + } + } + } + } + + zoom.wheelDelta = function(_) { + return arguments.length ? (wheelDelta = typeof _ === "function" ? _ : constant(+_), zoom) : wheelDelta; + }; + + zoom.filter = function(_) { + return arguments.length ? (filter = typeof _ === "function" ? _ : constant(!!_), zoom) : filter; + }; + + zoom.touchable = function(_) { + return arguments.length ? (touchable = typeof _ === "function" ? _ : constant(!!_), zoom) : touchable; + }; + + zoom.extent = function(_) { + return arguments.length ? (extent = typeof _ === "function" ? _ : constant([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent; + }; + + zoom.scaleExtent = function(_) { + return arguments.length ? (scaleExtent[0] = +_[0], scaleExtent[1] = +_[1], zoom) : [scaleExtent[0], scaleExtent[1]]; + }; + + zoom.translateExtent = function(_) { + return arguments.length ? (translateExtent[0][0] = +_[0][0], translateExtent[1][0] = +_[1][0], translateExtent[0][1] = +_[0][1], translateExtent[1][1] = +_[1][1], zoom) : [[translateExtent[0][0], translateExtent[0][1]], [translateExtent[1][0], translateExtent[1][1]]]; + }; + + zoom.constrain = function(_) { + return arguments.length ? (constrain = _, zoom) : constrain; + }; + + zoom.duration = function(_) { + return arguments.length ? (duration = +_, zoom) : duration; + }; + + zoom.interpolate = function(_) { + return arguments.length ? (interpolate = _, zoom) : interpolate; + }; + + zoom.on = function() { + var value = listeners.on.apply(listeners, arguments); + return value === listeners ? zoom : value; + }; + + zoom.clickDistance = function(_) { + return arguments.length ? (clickDistance2 = (_ = +_) * _, zoom) : Math.sqrt(clickDistance2); + }; + + zoom.tapDistance = function(_) { + return arguments.length ? (tapDistance = +_, zoom) : tapDistance; + }; + + return zoom; +} + +exports.Adder = Adder; +exports.Delaunay = Delaunay; +exports.FormatSpecifier = FormatSpecifier; +exports.InternMap = InternMap; +exports.InternSet = InternSet; +exports.Node = Node$1; +exports.Path = Path$1; +exports.Voronoi = Voronoi; +exports.ZoomTransform = Transform; +exports.active = active; +exports.arc = arc; +exports.area = area; +exports.areaRadial = areaRadial; +exports.ascending = ascending$3; +exports.autoType = autoType; +exports.axisBottom = axisBottom; +exports.axisLeft = axisLeft; +exports.axisRight = axisRight; +exports.axisTop = axisTop; +exports.bin = bin; +exports.bisect = bisect; +exports.bisectCenter = bisectCenter; +exports.bisectLeft = bisectLeft; +exports.bisectRight = bisectRight; +exports.bisector = bisector; +exports.blob = blob; +exports.blur = blur; +exports.blur2 = blur2; +exports.blurImage = blurImage; +exports.brush = brush; +exports.brushSelection = brushSelection; +exports.brushX = brushX; +exports.brushY = brushY; +exports.buffer = buffer; +exports.chord = chord; +exports.chordDirected = chordDirected; +exports.chordTranspose = chordTranspose; +exports.cluster = cluster; +exports.color = color; +exports.contourDensity = density; +exports.contours = Contours; +exports.count = count$1; +exports.create = create$1; +exports.creator = creator; +exports.cross = cross$2; +exports.csv = csv; +exports.csvFormat = csvFormat; +exports.csvFormatBody = csvFormatBody; +exports.csvFormatRow = csvFormatRow; +exports.csvFormatRows = csvFormatRows; +exports.csvFormatValue = csvFormatValue; +exports.csvParse = csvParse; +exports.csvParseRows = csvParseRows; +exports.cubehelix = cubehelix$3; +exports.cumsum = cumsum; +exports.curveBasis = basis; +exports.curveBasisClosed = basisClosed; +exports.curveBasisOpen = basisOpen; +exports.curveBumpX = bumpX; +exports.curveBumpY = bumpY; +exports.curveBundle = bundle; +exports.curveCardinal = cardinal; +exports.curveCardinalClosed = cardinalClosed; +exports.curveCardinalOpen = cardinalOpen; +exports.curveCatmullRom = catmullRom; +exports.curveCatmullRomClosed = catmullRomClosed; +exports.curveCatmullRomOpen = catmullRomOpen; +exports.curveLinear = curveLinear; +exports.curveLinearClosed = linearClosed; +exports.curveMonotoneX = monotoneX; +exports.curveMonotoneY = monotoneY; +exports.curveNatural = natural; +exports.curveStep = step; +exports.curveStepAfter = stepAfter; +exports.curveStepBefore = stepBefore; +exports.descending = descending$2; +exports.deviation = deviation; +exports.difference = difference; +exports.disjoint = disjoint; +exports.dispatch = dispatch; +exports.drag = drag; +exports.dragDisable = dragDisable; +exports.dragEnable = yesdrag; +exports.dsv = dsv; +exports.dsvFormat = dsvFormat; +exports.easeBack = backInOut; +exports.easeBackIn = backIn; +exports.easeBackInOut = backInOut; +exports.easeBackOut = backOut; +exports.easeBounce = bounceOut; +exports.easeBounceIn = bounceIn; +exports.easeBounceInOut = bounceInOut; +exports.easeBounceOut = bounceOut; +exports.easeCircle = circleInOut; +exports.easeCircleIn = circleIn; +exports.easeCircleInOut = circleInOut; +exports.easeCircleOut = circleOut; +exports.easeCubic = cubicInOut; +exports.easeCubicIn = cubicIn; +exports.easeCubicInOut = cubicInOut; +exports.easeCubicOut = cubicOut; +exports.easeElastic = elasticOut; +exports.easeElasticIn = elasticIn; +exports.easeElasticInOut = elasticInOut; +exports.easeElasticOut = elasticOut; +exports.easeExp = expInOut; +exports.easeExpIn = expIn; +exports.easeExpInOut = expInOut; +exports.easeExpOut = expOut; +exports.easeLinear = linear$1; +exports.easePoly = polyInOut; +exports.easePolyIn = polyIn; +exports.easePolyInOut = polyInOut; +exports.easePolyOut = polyOut; +exports.easeQuad = quadInOut; +exports.easeQuadIn = quadIn; +exports.easeQuadInOut = quadInOut; +exports.easeQuadOut = quadOut; +exports.easeSin = sinInOut; +exports.easeSinIn = sinIn; +exports.easeSinInOut = sinInOut; +exports.easeSinOut = sinOut; +exports.every = every; +exports.extent = extent$1; +exports.fcumsum = fcumsum; +exports.filter = filter$1; +exports.flatGroup = flatGroup; +exports.flatRollup = flatRollup; +exports.forceCenter = center; +exports.forceCollide = collide; +exports.forceLink = link$2; +exports.forceManyBody = manyBody; +exports.forceRadial = radial$1; +exports.forceSimulation = simulation; +exports.forceX = x$1; +exports.forceY = y$1; +exports.formatDefaultLocale = defaultLocale$1; +exports.formatLocale = formatLocale$1; +exports.formatSpecifier = formatSpecifier; +exports.fsum = fsum; +exports.geoAlbers = albers; +exports.geoAlbersUsa = albersUsa; +exports.geoArea = area$2; +exports.geoAzimuthalEqualArea = azimuthalEqualArea; +exports.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw; +exports.geoAzimuthalEquidistant = azimuthalEquidistant; +exports.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw; +exports.geoBounds = bounds; +exports.geoCentroid = centroid$1; +exports.geoCircle = circle$1; +exports.geoClipAntimeridian = clipAntimeridian; +exports.geoClipCircle = clipCircle; +exports.geoClipExtent = extent; +exports.geoClipRectangle = clipRectangle; +exports.geoConicConformal = conicConformal; +exports.geoConicConformalRaw = conicConformalRaw; +exports.geoConicEqualArea = conicEqualArea; +exports.geoConicEqualAreaRaw = conicEqualAreaRaw; +exports.geoConicEquidistant = conicEquidistant; +exports.geoConicEquidistantRaw = conicEquidistantRaw; +exports.geoContains = contains$1; +exports.geoDistance = distance; +exports.geoEqualEarth = equalEarth; +exports.geoEqualEarthRaw = equalEarthRaw; +exports.geoEquirectangular = equirectangular; +exports.geoEquirectangularRaw = equirectangularRaw; +exports.geoGnomonic = gnomonic; +exports.geoGnomonicRaw = gnomonicRaw; +exports.geoGraticule = graticule; +exports.geoGraticule10 = graticule10; +exports.geoIdentity = identity$4; +exports.geoInterpolate = interpolate; +exports.geoLength = length$1; +exports.geoMercator = mercator; +exports.geoMercatorRaw = mercatorRaw; +exports.geoNaturalEarth1 = naturalEarth1; +exports.geoNaturalEarth1Raw = naturalEarth1Raw; +exports.geoOrthographic = orthographic; +exports.geoOrthographicRaw = orthographicRaw; +exports.geoPath = index$2; +exports.geoProjection = projection; +exports.geoProjectionMutator = projectionMutator; +exports.geoRotation = rotation; +exports.geoStereographic = stereographic; +exports.geoStereographicRaw = stereographicRaw; +exports.geoStream = geoStream; +exports.geoTransform = transform$1; +exports.geoTransverseMercator = transverseMercator; +exports.geoTransverseMercatorRaw = transverseMercatorRaw; +exports.gray = gray; +exports.greatest = greatest; +exports.greatestIndex = greatestIndex; +exports.group = group; +exports.groupSort = groupSort; +exports.groups = groups; +exports.hcl = hcl$2; +exports.hierarchy = hierarchy; +exports.histogram = bin; +exports.hsl = hsl$2; +exports.html = html; +exports.image = image; +exports.index = index$4; +exports.indexes = indexes; +exports.interpolate = interpolate$2; +exports.interpolateArray = array$3; +exports.interpolateBasis = basis$2; +exports.interpolateBasisClosed = basisClosed$1; +exports.interpolateBlues = Blues; +exports.interpolateBrBG = BrBG; +exports.interpolateBuGn = BuGn; +exports.interpolateBuPu = BuPu; +exports.interpolateCividis = cividis; +exports.interpolateCool = cool; +exports.interpolateCubehelix = cubehelix$2; +exports.interpolateCubehelixDefault = cubehelix; +exports.interpolateCubehelixLong = cubehelixLong; +exports.interpolateDate = date$1; +exports.interpolateDiscrete = discrete; +exports.interpolateGnBu = GnBu; +exports.interpolateGreens = Greens; +exports.interpolateGreys = Greys; +exports.interpolateHcl = hcl$1; +exports.interpolateHclLong = hclLong; +exports.interpolateHsl = hsl$1; +exports.interpolateHslLong = hslLong; +exports.interpolateHue = hue; +exports.interpolateInferno = inferno; +exports.interpolateLab = lab; +exports.interpolateMagma = magma; +exports.interpolateNumber = interpolateNumber; +exports.interpolateNumberArray = numberArray; +exports.interpolateObject = object$1; +exports.interpolateOrRd = OrRd; +exports.interpolateOranges = Oranges; +exports.interpolatePRGn = PRGn; +exports.interpolatePiYG = PiYG; +exports.interpolatePlasma = plasma; +exports.interpolatePuBu = PuBu; +exports.interpolatePuBuGn = PuBuGn; +exports.interpolatePuOr = PuOr; +exports.interpolatePuRd = PuRd; +exports.interpolatePurples = Purples; +exports.interpolateRainbow = rainbow; +exports.interpolateRdBu = RdBu; +exports.interpolateRdGy = RdGy; +exports.interpolateRdPu = RdPu; +exports.interpolateRdYlBu = RdYlBu; +exports.interpolateRdYlGn = RdYlGn; +exports.interpolateReds = Reds; +exports.interpolateRgb = interpolateRgb; +exports.interpolateRgbBasis = rgbBasis; +exports.interpolateRgbBasisClosed = rgbBasisClosed; +exports.interpolateRound = interpolateRound; +exports.interpolateSinebow = sinebow; +exports.interpolateSpectral = Spectral; +exports.interpolateString = interpolateString; +exports.interpolateTransformCss = interpolateTransformCss; +exports.interpolateTransformSvg = interpolateTransformSvg; +exports.interpolateTurbo = turbo; +exports.interpolateViridis = viridis; +exports.interpolateWarm = warm; +exports.interpolateYlGn = YlGn; +exports.interpolateYlGnBu = YlGnBu; +exports.interpolateYlOrBr = YlOrBr; +exports.interpolateYlOrRd = YlOrRd; +exports.interpolateZoom = interpolateZoom; +exports.interrupt = interrupt; +exports.intersection = intersection; +exports.interval = interval; +exports.isoFormat = formatIso$1; +exports.isoParse = parseIso$1; +exports.json = json; +exports.lab = lab$1; +exports.lch = lch; +exports.least = least; +exports.leastIndex = leastIndex; +exports.line = line; +exports.lineRadial = lineRadial$1; +exports.link = link; +exports.linkHorizontal = linkHorizontal; +exports.linkRadial = linkRadial; +exports.linkVertical = linkVertical; +exports.local = local$1; +exports.map = map$1; +exports.matcher = matcher; +exports.max = max$3; +exports.maxIndex = maxIndex; +exports.mean = mean; +exports.median = median; +exports.medianIndex = medianIndex; +exports.merge = merge; +exports.min = min$2; +exports.minIndex = minIndex; +exports.mode = mode; +exports.namespace = namespace; +exports.namespaces = namespaces; +exports.nice = nice$1; +exports.now = now; +exports.pack = index$1; +exports.packEnclose = enclose; +exports.packSiblings = siblings; +exports.pairs = pairs; +exports.partition = partition; +exports.path = path; +exports.pathRound = pathRound; +exports.permute = permute; +exports.pie = pie; +exports.piecewise = piecewise; +exports.pointRadial = pointRadial; +exports.pointer = pointer; +exports.pointers = pointers; +exports.polygonArea = area$1; +exports.polygonCentroid = centroid; +exports.polygonContains = contains; +exports.polygonHull = hull; +exports.polygonLength = length; +exports.precisionFixed = precisionFixed; +exports.precisionPrefix = precisionPrefix; +exports.precisionRound = precisionRound; +exports.quadtree = quadtree; +exports.quantile = quantile$1; +exports.quantileIndex = quantileIndex; +exports.quantileSorted = quantileSorted; +exports.quantize = quantize$1; +exports.quickselect = quickselect; +exports.radialArea = areaRadial; +exports.radialLine = lineRadial$1; +exports.randomBates = bates; +exports.randomBernoulli = bernoulli; +exports.randomBeta = beta; +exports.randomBinomial = binomial; +exports.randomCauchy = cauchy; +exports.randomExponential = exponential; +exports.randomGamma = gamma; +exports.randomGeometric = geometric; +exports.randomInt = int; +exports.randomIrwinHall = irwinHall; +exports.randomLcg = lcg; +exports.randomLogNormal = logNormal; +exports.randomLogistic = logistic; +exports.randomNormal = normal; +exports.randomPareto = pareto; +exports.randomPoisson = poisson; +exports.randomUniform = uniform; +exports.randomWeibull = weibull; +exports.range = range$2; +exports.rank = rank; +exports.reduce = reduce; +exports.reverse = reverse$1; +exports.rgb = rgb; +exports.ribbon = ribbon$1; +exports.ribbonArrow = ribbonArrow; +exports.rollup = rollup; +exports.rollups = rollups; +exports.scaleBand = band; +exports.scaleDiverging = diverging$1; +exports.scaleDivergingLog = divergingLog; +exports.scaleDivergingPow = divergingPow; +exports.scaleDivergingSqrt = divergingSqrt; +exports.scaleDivergingSymlog = divergingSymlog; +exports.scaleIdentity = identity$2; +exports.scaleImplicit = implicit; +exports.scaleLinear = linear; +exports.scaleLog = log; +exports.scaleOrdinal = ordinal; +exports.scalePoint = point$4; +exports.scalePow = pow; +exports.scaleQuantile = quantile; +exports.scaleQuantize = quantize; +exports.scaleRadial = radial; +exports.scaleSequential = sequential; +exports.scaleSequentialLog = sequentialLog; +exports.scaleSequentialPow = sequentialPow; +exports.scaleSequentialQuantile = sequentialQuantile; +exports.scaleSequentialSqrt = sequentialSqrt; +exports.scaleSequentialSymlog = sequentialSymlog; +exports.scaleSqrt = sqrt$1; +exports.scaleSymlog = symlog; +exports.scaleThreshold = threshold; +exports.scaleTime = time; +exports.scaleUtc = utcTime; +exports.scan = scan; +exports.schemeAccent = Accent; +exports.schemeBlues = scheme$5; +exports.schemeBrBG = scheme$q; +exports.schemeBuGn = scheme$h; +exports.schemeBuPu = scheme$g; +exports.schemeCategory10 = category10; +exports.schemeDark2 = Dark2; +exports.schemeGnBu = scheme$f; +exports.schemeGreens = scheme$4; +exports.schemeGreys = scheme$3; +exports.schemeObservable10 = observable10; +exports.schemeOrRd = scheme$e; +exports.schemeOranges = scheme; +exports.schemePRGn = scheme$p; +exports.schemePaired = Paired; +exports.schemePastel1 = Pastel1; +exports.schemePastel2 = Pastel2; +exports.schemePiYG = scheme$o; +exports.schemePuBu = scheme$c; +exports.schemePuBuGn = scheme$d; +exports.schemePuOr = scheme$n; +exports.schemePuRd = scheme$b; +exports.schemePurples = scheme$2; +exports.schemeRdBu = scheme$m; +exports.schemeRdGy = scheme$l; +exports.schemeRdPu = scheme$a; +exports.schemeRdYlBu = scheme$k; +exports.schemeRdYlGn = scheme$j; +exports.schemeReds = scheme$1; +exports.schemeSet1 = Set1; +exports.schemeSet2 = Set2; +exports.schemeSet3 = Set3; +exports.schemeSpectral = scheme$i; +exports.schemeTableau10 = Tableau10; +exports.schemeYlGn = scheme$8; +exports.schemeYlGnBu = scheme$9; +exports.schemeYlOrBr = scheme$7; +exports.schemeYlOrRd = scheme$6; +exports.select = select; +exports.selectAll = selectAll; +exports.selection = selection; +exports.selector = selector; +exports.selectorAll = selectorAll; +exports.shuffle = shuffle$1; +exports.shuffler = shuffler; +exports.some = some; +exports.sort = sort; +exports.stack = stack; +exports.stackOffsetDiverging = diverging; +exports.stackOffsetExpand = expand; +exports.stackOffsetNone = none$1; +exports.stackOffsetSilhouette = silhouette; +exports.stackOffsetWiggle = wiggle; +exports.stackOrderAppearance = appearance; +exports.stackOrderAscending = ascending; +exports.stackOrderDescending = descending; +exports.stackOrderInsideOut = insideOut; +exports.stackOrderNone = none; +exports.stackOrderReverse = reverse; +exports.stratify = stratify; +exports.style = styleValue; +exports.subset = subset; +exports.sum = sum$2; +exports.superset = superset; +exports.svg = svg; +exports.symbol = Symbol$1; +exports.symbolAsterisk = asterisk; +exports.symbolCircle = circle; +exports.symbolCross = cross; +exports.symbolDiamond = diamond; +exports.symbolDiamond2 = diamond2; +exports.symbolPlus = plus; +exports.symbolSquare = square; +exports.symbolSquare2 = square2; +exports.symbolStar = star; +exports.symbolTimes = times; +exports.symbolTriangle = triangle; +exports.symbolTriangle2 = triangle2; +exports.symbolWye = wye; +exports.symbolX = times; +exports.symbols = symbolsFill; +exports.symbolsFill = symbolsFill; +exports.symbolsStroke = symbolsStroke; +exports.text = text; +exports.thresholdFreedmanDiaconis = thresholdFreedmanDiaconis; +exports.thresholdScott = thresholdScott; +exports.thresholdSturges = thresholdSturges; +exports.tickFormat = tickFormat; +exports.tickIncrement = tickIncrement; +exports.tickStep = tickStep; +exports.ticks = ticks; +exports.timeDay = timeDay; +exports.timeDays = timeDays; +exports.timeFormatDefaultLocale = defaultLocale; +exports.timeFormatLocale = formatLocale; +exports.timeFriday = timeFriday; +exports.timeFridays = timeFridays; +exports.timeHour = timeHour; +exports.timeHours = timeHours; +exports.timeInterval = timeInterval; +exports.timeMillisecond = millisecond; +exports.timeMilliseconds = milliseconds; +exports.timeMinute = timeMinute; +exports.timeMinutes = timeMinutes; +exports.timeMonday = timeMonday; +exports.timeMondays = timeMondays; +exports.timeMonth = timeMonth; +exports.timeMonths = timeMonths; +exports.timeSaturday = timeSaturday; +exports.timeSaturdays = timeSaturdays; +exports.timeSecond = second; +exports.timeSeconds = seconds; +exports.timeSunday = timeSunday; +exports.timeSundays = timeSundays; +exports.timeThursday = timeThursday; +exports.timeThursdays = timeThursdays; +exports.timeTickInterval = timeTickInterval; +exports.timeTicks = timeTicks; +exports.timeTuesday = timeTuesday; +exports.timeTuesdays = timeTuesdays; +exports.timeWednesday = timeWednesday; +exports.timeWednesdays = timeWednesdays; +exports.timeWeek = timeSunday; +exports.timeWeeks = timeSundays; +exports.timeYear = timeYear; +exports.timeYears = timeYears; +exports.timeout = timeout; +exports.timer = timer; +exports.timerFlush = timerFlush; +exports.transition = transition; +exports.transpose = transpose; +exports.tree = tree; +exports.treemap = index; +exports.treemapBinary = binary; +exports.treemapDice = treemapDice; +exports.treemapResquarify = resquarify; +exports.treemapSlice = treemapSlice; +exports.treemapSliceDice = sliceDice; +exports.treemapSquarify = squarify; +exports.tsv = tsv; +exports.tsvFormat = tsvFormat; +exports.tsvFormatBody = tsvFormatBody; +exports.tsvFormatRow = tsvFormatRow; +exports.tsvFormatRows = tsvFormatRows; +exports.tsvFormatValue = tsvFormatValue; +exports.tsvParse = tsvParse; +exports.tsvParseRows = tsvParseRows; +exports.union = union; +exports.unixDay = unixDay; +exports.unixDays = unixDays; +exports.utcDay = utcDay; +exports.utcDays = utcDays; +exports.utcFriday = utcFriday; +exports.utcFridays = utcFridays; +exports.utcHour = utcHour; +exports.utcHours = utcHours; +exports.utcMillisecond = millisecond; +exports.utcMilliseconds = milliseconds; +exports.utcMinute = utcMinute; +exports.utcMinutes = utcMinutes; +exports.utcMonday = utcMonday; +exports.utcMondays = utcMondays; +exports.utcMonth = utcMonth; +exports.utcMonths = utcMonths; +exports.utcSaturday = utcSaturday; +exports.utcSaturdays = utcSaturdays; +exports.utcSecond = second; +exports.utcSeconds = seconds; +exports.utcSunday = utcSunday; +exports.utcSundays = utcSundays; +exports.utcThursday = utcThursday; +exports.utcThursdays = utcThursdays; +exports.utcTickInterval = utcTickInterval; +exports.utcTicks = utcTicks; +exports.utcTuesday = utcTuesday; +exports.utcTuesdays = utcTuesdays; +exports.utcWednesday = utcWednesday; +exports.utcWednesdays = utcWednesdays; +exports.utcWeek = utcSunday; +exports.utcWeeks = utcSundays; +exports.utcYear = utcYear; +exports.utcYears = utcYears; +exports.variance = variance; +exports.version = version; +exports.window = defaultView; +exports.xml = xml; +exports.zip = zip; +exports.zoom = zoom; +exports.zoomIdentity = identity; +exports.zoomTransform = transform; + +})); diff --git a/vulnerablecode/static/js/d3.js.ABOUT b/vulnerablecode/static/js/d3.js.ABOUT new file mode 100644 index 000000000..c37aa34a0 --- /dev/null +++ b/vulnerablecode/static/js/d3.js.ABOUT @@ -0,0 +1,19 @@ +about_resource: d3.js +name: d3.js +version: 7.9.0 +download_url: https://registry.npmjs.org/d3/-/d3-7.9.0.tgz +license_expression: isc +homepage_url: https://github.com/d3/d3 +owner: Mike Bostock +description: Bring data to life with SVG, Canvas and HTML. +attribute: yes +package_url: pkg:npm/d3@7.9.0 +licenses: + - key: isc + name: ISC License + file: d3.js.LICENSE + + + + + diff --git a/vulnerablecode/static/js/d3.js.LICENSE b/vulnerablecode/static/js/d3.js.LICENSE new file mode 100644 index 000000000..3594fffaf --- /dev/null +++ b/vulnerablecode/static/js/d3.js.LICENSE @@ -0,0 +1,13 @@ +Copyright 2010-2023 Mike Bostock + +Permission to use, copy, modify, and/or distribute this software for any purpose +with or without fee is hereby granted, provided that the above copyright notice +and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE.