From 524e667a5f2f5bcbefdd104ceaed9cde5a510724b363030a088b992be170f1ae Mon Sep 17 00:00:00 2001 From: Neal Gompa Date: Sun, 21 Jun 2020 13:57:24 +0000 Subject: [PATCH] - Backport fixes for STARTTLS support + Patch: 0002-starttls-support-via-SMTP_STARTTLS-provide-additiona.patch + Patch: 0001-Do-not-assume-there-is-a-SMTP_STARTTLS-configuration.patch - Backport fix for docs repo access grant + Patch: 0001-Fix-repotype-spelling.patch - Backport fix for visual bug on API docs formatting + Patch: 0001-api-fix-apidoc-format-on-api_view_issues_history_det.patch - Backport fix to changing pull mirror settings + Patch: 0001-Allow-editing-the-URL-a-project-is-mirrored-from.patch - Backport fix to add descriptions to API scopes + Patch: 0001-Show-the-ACL-name-in-addition-to-the-description-whe.patch - Backport fix to make heatmap UI functional again + Patch: 0001-Bring-back-JS-library-used-for-the-heatmap.patch - Backport fix for handling headers + Patch: 0001-Ensure-the-title-name-of-the-headers-are-strings.patch - Backport fix for burndown graph title + Patch: 0001-Fix-the-title-of-the-graph-showing-the-evolution-of-.patch - Backport fix for permissions on authorized_keys file + Patch: 0001-Make-sure-authorized_keys-file-has-mode-600.patch - Add patch to use whitenoise for rendering static assets + Patch: 0101-Use-WhiteNoise-to-serve-static-assets-for-the-Pagure.patch - Refresh default configuration patch + Patch: pagure-5.0-default-example-cfg.patch OBS-URL: https://build.opensuse.org/package/show/devel:tools:scm/pagure?expand=0&rev=39 --- ...smtp-server-requiring-starttls-to-wo.patch | 2 +- ...g-the-URL-a-project-is-mirrored-from.patch | 206 + ...back-JS-library-used-for-the-heatmap.patch | 9594 +++++++++++++++++ ...ere-is-a-SMTP_STARTTLS-configuration.patch | 30 + ...itle-name-of-the-headers-are-strings.patch | 28 + 0001-Fix-repotype-spelling.patch | 30 + ...-the-graph-showing-the-evolution-of-.patch | 27 + ...re-authorized_keys-file-has-mode-600.patch | 30 + ...e-in-addition-to-the-description-whe.patch | 33 + ...ormat-on-api_view_issues_history_det.patch | 25 + ...-via-SMTP_STARTTLS-provide-additiona.patch | 40 + ...o-serve-static-assets-for-the-Pagure.patch | 179 + pagure-5.0-default-example-cfg.patch | 39 +- pagure.changes | 27 + pagure.spec | 31 +- 15 files changed, 10295 insertions(+), 26 deletions(-) create mode 100644 0001-Allow-editing-the-URL-a-project-is-mirrored-from.patch create mode 100644 0001-Bring-back-JS-library-used-for-the-heatmap.patch create mode 100644 0001-Do-not-assume-there-is-a-SMTP_STARTTLS-configuration.patch create mode 100644 0001-Ensure-the-title-name-of-the-headers-are-strings.patch create mode 100644 0001-Fix-repotype-spelling.patch create mode 100644 0001-Fix-the-title-of-the-graph-showing-the-evolution-of-.patch create mode 100644 0001-Make-sure-authorized_keys-file-has-mode-600.patch create mode 100644 0001-Show-the-ACL-name-in-addition-to-the-description-whe.patch create mode 100644 0001-api-fix-apidoc-format-on-api_view_issues_history_det.patch create mode 100644 0002-starttls-support-via-SMTP_STARTTLS-provide-additiona.patch create mode 100644 0101-Use-WhiteNoise-to-serve-static-assets-for-the-Pagure.patch diff --git a/0001-Add-support-for-smtp-server-requiring-starttls-to-wo.patch b/0001-Add-support-for-smtp-server-requiring-starttls-to-wo.patch index 7f7c083..58e14fb 100644 --- a/0001-Add-support-for-smtp-server-requiring-starttls-to-wo.patch +++ b/0001-Add-support-for-smtp-server-requiring-starttls-to-wo.patch @@ -1,7 +1,7 @@ From 4196a3772693a79f1e5db12fa937bcee8280e248 Mon Sep 17 00:00:00 2001 From: Pierre-Yves Chibon Date: Mon, 18 May 2020 15:57:05 +0200 -Subject: [PATCH] Add support for smtp server requiring starttls to work +Subject: [PATCH 1/2] Add support for smtp server requiring starttls to work Signed-off-by: Pierre-Yves Chibon --- diff --git a/0001-Allow-editing-the-URL-a-project-is-mirrored-from.patch b/0001-Allow-editing-the-URL-a-project-is-mirrored-from.patch new file mode 100644 index 0000000..30d0014 --- /dev/null +++ b/0001-Allow-editing-the-URL-a-project-is-mirrored-from.patch @@ -0,0 +1,206 @@ +From c78ea50ecfb6cb9c2be7aa9eabedf1f5c6292e84 Mon Sep 17 00:00:00 2001 +From: Pierre-Yves Chibon +Date: Sat, 30 May 2020 22:30:54 +0200 +Subject: [PATCH] Allow editing the URL a project is mirrored from + +When a project is mirrored from a remote location to a local pagure +instance, we so far had no way to edit this url, for example for +when the upstream project changes location. +With this commit we're able to fix this. + +Fixes https://pagure.io/pagure/issue/4647 + +Signed-off-by: Pierre-Yves Chibon +--- + pagure/forms.py | 4 + + pagure/templates/settings.html | 9 ++ + pagure/ui/repo.py | 2 + + ...test_pagure_flask_ui_repo_mirrored_from.py | 128 ++++++++++++++++++ + 4 files changed, 143 insertions(+) + create mode 100644 tests/test_pagure_flask_ui_repo_mirrored_from.py + +diff --git a/pagure/forms.py b/pagure/forms.py +index 228a0206..6daa8a81 100644 +--- a/pagure/forms.py ++++ b/pagure/forms.py +@@ -159,6 +159,10 @@ class ProjectFormSimplified(PagureForm): + private = wtforms.BooleanField( + "Private", [wtforms.validators.Optional()], false_values=FALSE_VALUES + ) ++ mirrored_from = wtforms.StringField( ++ "Mirrored from", ++ [wtforms.validators.optional(), wtforms.validators.Length(max=255)], ++ ) + + + class ProjectForm(ProjectFormSimplified): +diff --git a/pagure/templates/settings.html b/pagure/templates/settings.html +index a09d722d..55df03a0 100644 +--- a/pagure/templates/settings.html ++++ b/pagure/templates/settings.html +@@ -160,6 +160,15 @@ + + + {% endif %} ++ {% if repo.mirrored_from %} ++
++ ++ ++ ++ The (public) url from which this repository is mirrored. ++ ++
++ {% endif %} + +diff --git a/pagure/ui/repo.py b/pagure/ui/repo.py +index 5b522b5a..040b2bc5 100644 +--- a/pagure/ui/repo.py ++++ b/pagure/ui/repo.py +@@ -1421,6 +1421,8 @@ def update_project(repo, username=None, namespace=None): + repo.url = form.url.data.strip() + if repo.private: + repo.private = form.private.data ++ if repo.mirrored_from: ++ repo.mirrored_from = form.mirrored_from.data + pagure.lib.query.update_tags( + flask.g.session, + repo, +diff --git a/tests/test_pagure_flask_ui_repo_mirrored_from.py b/tests/test_pagure_flask_ui_repo_mirrored_from.py +new file mode 100644 +index 00000000..2c33053a +--- /dev/null ++++ b/tests/test_pagure_flask_ui_repo_mirrored_from.py +@@ -0,0 +1,128 @@ ++# -*- coding: utf-8 -*- ++ ++""" ++ (c) 2020 - Copyright Red Hat Inc ++ ++ Authors: ++ Pierre-Yves Chibon ++ ++""" ++ ++from __future__ import unicode_literals, absolute_import ++ ++import datetime ++import os ++import shutil ++import sys ++import tempfile ++import time ++import unittest ++ ++import pygit2 ++import six ++from mock import patch, MagicMock, ANY, call ++ ++sys.path.insert( ++ 0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") ++) ++ ++import pagure.lib.git ++import tests ++ ++from pagure.lib.repo import PagureRepo ++ ++ ++class PagureUiRepoMirroredFromTests(tests.Modeltests): ++ """ Tests for pagure project that are mirrored from a remote location ++ """ ++ ++ maxDiff = None ++ ++ def setUp(self): ++ """ Set up the environnment, ran before every tests. """ ++ super(PagureUiRepoMirroredFromTests, self).setUp() ++ ++ tests.create_projects(self.session) ++ tests.create_projects_git(os.path.join(self.path, "repos"), bare=True) ++ ++ # Make the test project mirrored from elsewhere ++ self.project = pagure.lib.query.get_authorized_project( ++ self.session, "test" ++ ) ++ self.project.mirrored_from = "https://example.com/foo/bar.git" ++ self.session.add(self.project) ++ self.session.commit() ++ ++ def test_settings_shows(self): ++ """ Ensure that the box to edit the mirrored from value shows up ++ in the settings. ++ """ ++ user = tests.FakeUser(username="pingou") ++ with tests.user_set(self.app.application, user): ++ output = self.app.get("/test/settings") ++ self.assertEqual(output.status_code, 200) ++ output_text = output.get_data(as_text=True) ++ self.assertIn( ++ '', ++ output_text, ++ ) ++ self.assertIn( ++ "The (public) url from which this repository is mirrored.", ++ output_text, ++ ) ++ ++ def test_settings_not_show(self): ++ """ Ensure that the box to edit the mirrored from value does not ++ show up in the settings when it shouldn't. ++ """ ++ user = tests.FakeUser(username="pingou") ++ with tests.user_set(self.app.application, user): ++ output = self.app.get("/test2/settings") ++ self.assertEqual(output.status_code, 200) ++ output_text = output.get_data(as_text=True) ++ self.assertNotIn( ++ '', ++ output_text, ++ ) ++ ++ csrf_token = self.get_csrf(output=output) ++ ++ data = { ++ "csrf_token": csrf_token, ++ "description": "test repo", ++ "mirrored_from": "https://example2.com/bar.git", ++ } ++ output = self.app.post( ++ "/test/update", data=data, follow_redirects=True ++ ) ++ self.assertEqual(output.status_code, 200) ++ output_text = output.get_data(as_text=True) ++ self.assertIn( ++ '', ++ output_text, ++ ) ++ ++ ++if __name__ == "__main__": ++ unittest.main(verbosity=2) +-- +2.26.1 + diff --git a/0001-Bring-back-JS-library-used-for-the-heatmap.patch b/0001-Bring-back-JS-library-used-for-the-heatmap.patch new file mode 100644 index 0000000..1916d3e --- /dev/null +++ b/0001-Bring-back-JS-library-used-for-the-heatmap.patch @@ -0,0 +1,9594 @@ +From 028ad7a28255eebdee04008ee45be2fd17642542 Mon Sep 17 00:00:00 2001 +From: Nils Philippsen +Date: Wed, 3 Jun 2020 18:10:22 +0200 +Subject: [PATCH] Bring back JS library used for the heatmap + +The d3.v3.js file and its minified version where removed in commit +d42cac3 but are needed for cal-heatmap.js. + +Fixes: #4891 + +Signed-off-by: Nils Philippsen +--- + pagure/static/vendor/d3/d3.v3.js | 9554 ++++++++++++++++++++++++++ + pagure/static/vendor/d3/d3.v3.min.js | 5 + + 2 files changed, 9559 insertions(+) + create mode 100644 pagure/static/vendor/d3/d3.v3.js + create mode 100644 pagure/static/vendor/d3/d3.v3.min.js + +diff --git a/pagure/static/vendor/d3/d3.v3.js b/pagure/static/vendor/d3/d3.v3.js +new file mode 100644 +index 00000000..ec7c9830 +--- /dev/null ++++ b/pagure/static/vendor/d3/d3.v3.js +@@ -0,0 +1,9554 @@ ++!function() { ++ var d3 = { ++ version: "3.5.17" ++ }; ++ var d3_arraySlice = [].slice, d3_array = function(list) { ++ return d3_arraySlice.call(list); ++ }; ++ var d3_document = this.document; ++ function d3_documentElement(node) { ++ return node && (node.ownerDocument || node.document || node).documentElement; ++ } ++ function d3_window(node) { ++ return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView); ++ } ++ if (d3_document) { ++ try { ++ d3_array(d3_document.documentElement.childNodes)[0].nodeType; ++ } catch (e) { ++ d3_array = function(list) { ++ var i = list.length, array = new Array(i); ++ while (i--) array[i] = list[i]; ++ return array; ++ }; ++ } ++ } ++ if (!Date.now) Date.now = function() { ++ return +new Date(); ++ }; ++ if (d3_document) { ++ try { ++ d3_document.createElement("DIV").style.setProperty("opacity", 0, ""); ++ } catch (error) { ++ var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty; ++ d3_element_prototype.setAttribute = function(name, value) { ++ d3_element_setAttribute.call(this, name, value + ""); ++ }; ++ d3_element_prototype.setAttributeNS = function(space, local, value) { ++ d3_element_setAttributeNS.call(this, space, local, value + ""); ++ }; ++ d3_style_prototype.setProperty = function(name, value, priority) { ++ d3_style_setProperty.call(this, name, value + "", priority); ++ }; ++ } ++ } ++ d3.ascending = d3_ascending; ++ function d3_ascending(a, b) { ++ return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; ++ } ++ d3.descending = function(a, b) { ++ return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; ++ }; ++ d3.min = function(array, f) { ++ var i = -1, n = array.length, a, b; ++ if (arguments.length === 1) { ++ while (++i < n) if ((b = array[i]) != null && b >= b) { ++ a = b; ++ break; ++ } ++ while (++i < n) if ((b = array[i]) != null && a > b) a = b; ++ } else { ++ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) { ++ a = b; ++ break; ++ } ++ while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b; ++ } ++ return a; ++ }; ++ d3.max = function(array, f) { ++ var i = -1, n = array.length, a, b; ++ if (arguments.length === 1) { ++ while (++i < n) if ((b = array[i]) != null && b >= b) { ++ a = b; ++ break; ++ } ++ while (++i < n) if ((b = array[i]) != null && b > a) a = b; ++ } else { ++ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) { ++ a = b; ++ break; ++ } ++ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b; ++ } ++ return a; ++ }; ++ d3.extent = function(array, f) { ++ var i = -1, n = array.length, a, b, c; ++ if (arguments.length === 1) { ++ while (++i < n) if ((b = array[i]) != null && b >= b) { ++ a = c = b; ++ break; ++ } ++ while (++i < n) if ((b = array[i]) != null) { ++ if (a > b) a = b; ++ if (c < b) c = b; ++ } ++ } else { ++ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) { ++ a = c = b; ++ break; ++ } ++ while (++i < n) if ((b = f.call(array, array[i], i)) != null) { ++ if (a > b) a = b; ++ if (c < b) c = b; ++ } ++ } ++ return [ a, c ]; ++ }; ++ function d3_number(x) { ++ return x === null ? NaN : +x; ++ } ++ function d3_numeric(x) { ++ return !isNaN(x); ++ } ++ d3.sum = function(array, f) { ++ var s = 0, n = array.length, a, i = -1; ++ if (arguments.length === 1) { ++ while (++i < n) if (d3_numeric(a = +array[i])) s += a; ++ } else { ++ while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a; ++ } ++ return s; ++ }; ++ d3.mean = function(array, f) { ++ var s = 0, n = array.length, a, i = -1, j = n; ++ if (arguments.length === 1) { ++ while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j; ++ } else { ++ while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j; ++ } ++ if (j) return s / j; ++ }; ++ d3.quantile = function(values, p) { ++ var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h; ++ return e ? v + e * (values[h] - v) : v; ++ }; ++ d3.median = function(array, f) { ++ var numbers = [], n = array.length, a, i = -1; ++ if (arguments.length === 1) { ++ while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a); ++ } else { ++ while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a); ++ } ++ if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5); ++ }; ++ d3.variance = function(array, f) { ++ var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0; ++ if (arguments.length === 1) { ++ while (++i < n) { ++ if (d3_numeric(a = d3_number(array[i]))) { ++ d = a - m; ++ m += d / ++j; ++ s += d * (a - m); ++ } ++ } ++ } else { ++ while (++i < n) { ++ if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) { ++ d = a - m; ++ m += d / ++j; ++ s += d * (a - m); ++ } ++ } ++ } ++ if (j > 1) return s / (j - 1); ++ }; ++ d3.deviation = function() { ++ var v = d3.variance.apply(this, arguments); ++ return v ? Math.sqrt(v) : v; ++ }; ++ function d3_bisector(compare) { ++ return { ++ left: function(a, x, lo, hi) { ++ if (arguments.length < 3) lo = 0; ++ if (arguments.length < 4) hi = a.length; ++ while (lo < hi) { ++ var mid = lo + hi >>> 1; ++ if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid; ++ } ++ return lo; ++ }, ++ right: function(a, x, lo, hi) { ++ if (arguments.length < 3) lo = 0; ++ if (arguments.length < 4) hi = a.length; ++ while (lo < hi) { ++ var mid = lo + hi >>> 1; ++ if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1; ++ } ++ return lo; ++ } ++ }; ++ } ++ var d3_bisect = d3_bisector(d3_ascending); ++ d3.bisectLeft = d3_bisect.left; ++ d3.bisect = d3.bisectRight = d3_bisect.right; ++ d3.bisector = function(f) { ++ return d3_bisector(f.length === 1 ? function(d, x) { ++ return d3_ascending(f(d), x); ++ } : f); ++ }; ++ d3.shuffle = function(array, i0, i1) { ++ if ((m = arguments.length) < 3) { ++ i1 = array.length; ++ if (m < 2) i0 = 0; ++ } ++ var m = i1 - i0, t, i; ++ while (m) { ++ i = Math.random() * m-- | 0; ++ t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t; ++ } ++ return array; ++ }; ++ d3.permute = function(array, indexes) { ++ var i = indexes.length, permutes = new Array(i); ++ while (i--) permutes[i] = array[indexes[i]]; ++ return permutes; ++ }; ++ d3.pairs = function(array) { ++ var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n); ++ while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ]; ++ return pairs; ++ }; ++ d3.transpose = function(matrix) { ++ if (!(n = matrix.length)) return []; ++ for (var i = -1, m = d3.min(matrix, d3_transposeLength), 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 d3_transposeLength(d) { ++ return d.length; ++ } ++ d3.zip = function() { ++ return d3.transpose(arguments); ++ }; ++ d3.keys = function(map) { ++ var keys = []; ++ for (var key in map) keys.push(key); ++ return keys; ++ }; ++ d3.values = function(map) { ++ var values = []; ++ for (var key in map) values.push(map[key]); ++ return values; ++ }; ++ d3.entries = function(map) { ++ var entries = []; ++ for (var key in map) entries.push({ ++ key: key, ++ value: map[key] ++ }); ++ return entries; ++ }; ++ d3.merge = function(arrays) { ++ var n = arrays.length, m, i = -1, j = 0, merged, array; ++ while (++i < n) j += arrays[i].length; ++ merged = new Array(j); ++ while (--n >= 0) { ++ array = arrays[n]; ++ m = array.length; ++ while (--m >= 0) { ++ merged[--j] = array[m]; ++ } ++ } ++ return merged; ++ }; ++ var abs = Math.abs; ++ d3.range = function(start, stop, step) { ++ if (arguments.length < 3) { ++ step = 1; ++ if (arguments.length < 2) { ++ stop = start; ++ start = 0; ++ } ++ } ++ if ((stop - start) / step === Infinity) throw new Error("infinite range"); ++ var range = [], k = d3_range_integerScale(abs(step)), i = -1, j; ++ start *= k, stop *= k, step *= k; ++ if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k); ++ return range; ++ }; ++ function d3_range_integerScale(x) { ++ var k = 1; ++ while (x * k % 1) k *= 10; ++ return k; ++ } ++ function d3_class(ctor, properties) { ++ for (var key in properties) { ++ Object.defineProperty(ctor.prototype, key, { ++ value: properties[key], ++ enumerable: false ++ }); ++ } ++ } ++ d3.map = function(object, f) { ++ var map = new d3_Map(); ++ if (object instanceof d3_Map) { ++ object.forEach(function(key, value) { ++ map.set(key, value); ++ }); ++ } else if (Array.isArray(object)) { ++ var i = -1, n = object.length, o; ++ if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o); ++ } else { ++ for (var key in object) map.set(key, object[key]); ++ } ++ return map; ++ }; ++ function d3_Map() { ++ this._ = Object.create(null); ++ } ++ var d3_map_proto = "__proto__", d3_map_zero = "\x00"; ++ d3_class(d3_Map, { ++ has: d3_map_has, ++ get: function(key) { ++ return this._[d3_map_escape(key)]; ++ }, ++ set: function(key, value) { ++ return this._[d3_map_escape(key)] = value; ++ }, ++ remove: d3_map_remove, ++ keys: d3_map_keys, ++ values: function() { ++ var values = []; ++ for (var key in this._) values.push(this._[key]); ++ return values; ++ }, ++ entries: function() { ++ var entries = []; ++ for (var key in this._) entries.push({ ++ key: d3_map_unescape(key), ++ value: this._[key] ++ }); ++ return entries; ++ }, ++ size: d3_map_size, ++ empty: d3_map_empty, ++ forEach: function(f) { ++ for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]); ++ } ++ }); ++ function d3_map_escape(key) { ++ return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key; ++ } ++ function d3_map_unescape(key) { ++ return (key += "")[0] === d3_map_zero ? key.slice(1) : key; ++ } ++ function d3_map_has(key) { ++ return d3_map_escape(key) in this._; ++ } ++ function d3_map_remove(key) { ++ return (key = d3_map_escape(key)) in this._ && delete this._[key]; ++ } ++ function d3_map_keys() { ++ var keys = []; ++ for (var key in this._) keys.push(d3_map_unescape(key)); ++ return keys; ++ } ++ function d3_map_size() { ++ var size = 0; ++ for (var key in this._) ++size; ++ return size; ++ } ++ function d3_map_empty() { ++ for (var key in this._) return false; ++ return true; ++ } ++ d3.nest = function() { ++ var nest = {}, keys = [], sortKeys = [], sortValues, rollup; ++ function map(mapType, array, depth) { ++ if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array; ++ var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values; ++ while (++i < n) { ++ if (values = valuesByKey.get(keyValue = key(object = array[i]))) { ++ values.push(object); ++ } else { ++ valuesByKey.set(keyValue, [ object ]); ++ } ++ } ++ if (mapType) { ++ object = mapType(); ++ setter = function(keyValue, values) { ++ object.set(keyValue, map(mapType, values, depth)); ++ }; ++ } else { ++ object = {}; ++ setter = function(keyValue, values) { ++ object[keyValue] = map(mapType, values, depth); ++ }; ++ } ++ valuesByKey.forEach(setter); ++ return object; ++ } ++ function entries(map, depth) { ++ if (depth >= keys.length) return map; ++ var array = [], sortKey = sortKeys[depth++]; ++ map.forEach(function(key, keyMap) { ++ array.push({ ++ key: key, ++ values: entries(keyMap, depth) ++ }); ++ }); ++ return sortKey ? array.sort(function(a, b) { ++ return sortKey(a.key, b.key); ++ }) : array; ++ } ++ nest.map = function(array, mapType) { ++ return map(mapType, array, 0); ++ }; ++ nest.entries = function(array) { ++ return entries(map(d3.map, array, 0), 0); ++ }; ++ nest.key = function(d) { ++ keys.push(d); ++ return nest; ++ }; ++ nest.sortKeys = function(order) { ++ sortKeys[keys.length - 1] = order; ++ return nest; ++ }; ++ nest.sortValues = function(order) { ++ sortValues = order; ++ return nest; ++ }; ++ nest.rollup = function(f) { ++ rollup = f; ++ return nest; ++ }; ++ return nest; ++ }; ++ d3.set = function(array) { ++ var set = new d3_Set(); ++ if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]); ++ return set; ++ }; ++ function d3_Set() { ++ this._ = Object.create(null); ++ } ++ d3_class(d3_Set, { ++ has: d3_map_has, ++ add: function(key) { ++ this._[d3_map_escape(key += "")] = true; ++ return key; ++ }, ++ remove: d3_map_remove, ++ values: d3_map_keys, ++ size: d3_map_size, ++ empty: d3_map_empty, ++ forEach: function(f) { ++ for (var key in this._) f.call(this, d3_map_unescape(key)); ++ } ++ }); ++ d3.behavior = {}; ++ function d3_identity(d) { ++ return d; ++ } ++ d3.rebind = function(target, source) { ++ var i = 1, n = arguments.length, method; ++ while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]); ++ return target; ++ }; ++ function d3_rebind(target, source, method) { ++ return function() { ++ var value = method.apply(source, arguments); ++ return value === source ? target : value; ++ }; ++ } ++ function d3_vendorSymbol(object, name) { ++ if (name in object) return name; ++ name = name.charAt(0).toUpperCase() + name.slice(1); ++ for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) { ++ var prefixName = d3_vendorPrefixes[i] + name; ++ if (prefixName in object) return prefixName; ++ } ++ } ++ var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ]; ++ function d3_noop() {} ++ d3.dispatch = function() { ++ var dispatch = new d3_dispatch(), i = -1, n = arguments.length; ++ while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); ++ return dispatch; ++ }; ++ function d3_dispatch() {} ++ d3_dispatch.prototype.on = function(type, listener) { ++ var i = type.indexOf("."), name = ""; ++ if (i >= 0) { ++ name = type.slice(i + 1); ++ type = type.slice(0, i); ++ } ++ if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener); ++ if (arguments.length === 2) { ++ if (listener == null) for (type in this) { ++ if (this.hasOwnProperty(type)) this[type].on(name, null); ++ } ++ return this; ++ } ++ }; ++ function d3_dispatch_event(dispatch) { ++ var listeners = [], listenerByName = new d3_Map(); ++ function event() { ++ var z = listeners, i = -1, n = z.length, l; ++ while (++i < n) if (l = z[i].on) l.apply(this, arguments); ++ return dispatch; ++ } ++ event.on = function(name, listener) { ++ var l = listenerByName.get(name), i; ++ if (arguments.length < 2) return l && l.on; ++ if (l) { ++ l.on = null; ++ listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1)); ++ listenerByName.remove(name); ++ } ++ if (listener) listeners.push(listenerByName.set(name, { ++ on: listener ++ })); ++ return dispatch; ++ }; ++ return event; ++ } ++ d3.event = null; ++ function d3_eventPreventDefault() { ++ d3.event.preventDefault(); ++ } ++ function d3_eventSource() { ++ var e = d3.event, s; ++ while (s = e.sourceEvent) e = s; ++ return e; ++ } ++ function d3_eventDispatch(target) { ++ var dispatch = new d3_dispatch(), i = 0, n = arguments.length; ++ while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); ++ dispatch.of = function(thiz, argumentz) { ++ return function(e1) { ++ try { ++ var e0 = e1.sourceEvent = d3.event; ++ e1.target = target; ++ d3.event = e1; ++ dispatch[e1.type].apply(thiz, argumentz); ++ } finally { ++ d3.event = e0; ++ } ++ }; ++ }; ++ return dispatch; ++ } ++ d3.requote = function(s) { ++ return s.replace(d3_requote_re, "\\$&"); ++ }; ++ var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; ++ var d3_subclass = {}.__proto__ ? function(object, prototype) { ++ object.__proto__ = prototype; ++ } : function(object, prototype) { ++ for (var property in prototype) object[property] = prototype[property]; ++ }; ++ function d3_selection(groups) { ++ d3_subclass(groups, d3_selectionPrototype); ++ return groups; ++ } ++ var d3_select = function(s, n) { ++ return n.querySelector(s); ++ }, d3_selectAll = function(s, n) { ++ return n.querySelectorAll(s); ++ }, d3_selectMatches = function(n, s) { ++ var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")]; ++ d3_selectMatches = function(n, s) { ++ return d3_selectMatcher.call(n, s); ++ }; ++ return d3_selectMatches(n, s); ++ }; ++ if (typeof Sizzle === "function") { ++ d3_select = function(s, n) { ++ return Sizzle(s, n)[0] || null; ++ }; ++ d3_selectAll = Sizzle; ++ d3_selectMatches = Sizzle.matchesSelector; ++ } ++ d3.selection = function() { ++ return d3.select(d3_document.documentElement); ++ }; ++ var d3_selectionPrototype = d3.selection.prototype = []; ++ d3_selectionPrototype.select = function(selector) { ++ var subgroups = [], subgroup, subnode, group, node; ++ selector = d3_selection_selector(selector); ++ for (var j = -1, m = this.length; ++j < m; ) { ++ subgroups.push(subgroup = []); ++ subgroup.parentNode = (group = this[j]).parentNode; ++ for (var i = -1, n = group.length; ++i < n; ) { ++ if (node = group[i]) { ++ subgroup.push(subnode = selector.call(node, node.__data__, i, j)); ++ if (subnode && "__data__" in node) subnode.__data__ = node.__data__; ++ } else { ++ subgroup.push(null); ++ } ++ } ++ } ++ return d3_selection(subgroups); ++ }; ++ function d3_selection_selector(selector) { ++ return typeof selector === "function" ? selector : function() { ++ return d3_select(selector, this); ++ }; ++ } ++ d3_selectionPrototype.selectAll = function(selector) { ++ var subgroups = [], subgroup, node; ++ selector = d3_selection_selectorAll(selector); ++ for (var j = -1, m = this.length; ++j < m; ) { ++ for (var group = this[j], i = -1, n = group.length; ++i < n; ) { ++ if (node = group[i]) { ++ subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j))); ++ subgroup.parentNode = node; ++ } ++ } ++ } ++ return d3_selection(subgroups); ++ }; ++ function d3_selection_selectorAll(selector) { ++ return typeof selector === "function" ? selector : function() { ++ return d3_selectAll(selector, this); ++ }; ++ } ++ var d3_nsXhtml = "http://www.w3.org/1999/xhtml"; ++ var d3_nsPrefix = { ++ svg: "http://www.w3.org/2000/svg", ++ xhtml: d3_nsXhtml, ++ xlink: "http://www.w3.org/1999/xlink", ++ xml: "http://www.w3.org/XML/1998/namespace", ++ xmlns: "http://www.w3.org/2000/xmlns/" ++ }; ++ d3.ns = { ++ prefix: d3_nsPrefix, ++ qualify: function(name) { ++ var i = name.indexOf(":"), prefix = name; ++ if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); ++ return d3_nsPrefix.hasOwnProperty(prefix) ? { ++ space: d3_nsPrefix[prefix], ++ local: name ++ } : name; ++ } ++ }; ++ d3_selectionPrototype.attr = function(name, value) { ++ if (arguments.length < 2) { ++ if (typeof name === "string") { ++ var node = this.node(); ++ name = d3.ns.qualify(name); ++ return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name); ++ } ++ for (value in name) this.each(d3_selection_attr(value, name[value])); ++ return this; ++ } ++ return this.each(d3_selection_attr(name, value)); ++ }; ++ function d3_selection_attr(name, value) { ++ name = d3.ns.qualify(name); ++ function attrNull() { ++ this.removeAttribute(name); ++ } ++ function attrNullNS() { ++ this.removeAttributeNS(name.space, name.local); ++ } ++ function attrConstant() { ++ this.setAttribute(name, value); ++ } ++ function attrConstantNS() { ++ this.setAttributeNS(name.space, name.local, value); ++ } ++ function attrFunction() { ++ var x = value.apply(this, arguments); ++ if (x == null) this.removeAttribute(name); else this.setAttribute(name, x); ++ } ++ function attrFunctionNS() { ++ var x = value.apply(this, arguments); ++ if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x); ++ } ++ return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant; ++ } ++ function d3_collapse(s) { ++ return s.trim().replace(/\s+/g, " "); ++ } ++ d3_selectionPrototype.classed = function(name, value) { ++ if (arguments.length < 2) { ++ if (typeof name === "string") { ++ var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1; ++ if (value = node.classList) { ++ while (++i < n) if (!value.contains(name[i])) return false; ++ } else { ++ value = node.getAttribute("class"); ++ while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false; ++ } ++ return true; ++ } ++ for (value in name) this.each(d3_selection_classed(value, name[value])); ++ return this; ++ } ++ return this.each(d3_selection_classed(name, value)); ++ }; ++ function d3_selection_classedRe(name) { ++ return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g"); ++ } ++ function d3_selection_classes(name) { ++ return (name + "").trim().split(/^|\s+/); ++ } ++ function d3_selection_classed(name, value) { ++ name = d3_selection_classes(name).map(d3_selection_classedName); ++ var n = name.length; ++ function classedConstant() { ++ var i = -1; ++ while (++i < n) name[i](this, value); ++ } ++ function classedFunction() { ++ var i = -1, x = value.apply(this, arguments); ++ while (++i < n) name[i](this, x); ++ } ++ return typeof value === "function" ? classedFunction : classedConstant; ++ } ++ function d3_selection_classedName(name) { ++ var re = d3_selection_classedRe(name); ++ return function(node, value) { ++ if (c = node.classList) return value ? c.add(name) : c.remove(name); ++ var c = node.getAttribute("class") || ""; ++ if (value) { ++ re.lastIndex = 0; ++ if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name)); ++ } else { ++ node.setAttribute("class", d3_collapse(c.replace(re, " "))); ++ } ++ }; ++ } ++ d3_selectionPrototype.style = function(name, value, priority) { ++ var n = arguments.length; ++ if (n < 3) { ++ if (typeof name !== "string") { ++ if (n < 2) value = ""; ++ for (priority in name) this.each(d3_selection_style(priority, name[priority], value)); ++ return this; ++ } ++ if (n < 2) { ++ var node = this.node(); ++ return d3_window(node).getComputedStyle(node, null).getPropertyValue(name); ++ } ++ priority = ""; ++ } ++ return this.each(d3_selection_style(name, value, priority)); ++ }; ++ function d3_selection_style(name, value, priority) { ++ function styleNull() { ++ this.style.removeProperty(name); ++ } ++ function styleConstant() { ++ this.style.setProperty(name, value, priority); ++ } ++ function styleFunction() { ++ var x = value.apply(this, arguments); ++ if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority); ++ } ++ return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant; ++ } ++ d3_selectionPrototype.property = function(name, value) { ++ if (arguments.length < 2) { ++ if (typeof name === "string") return this.node()[name]; ++ for (value in name) this.each(d3_selection_property(value, name[value])); ++ return this; ++ } ++ return this.each(d3_selection_property(name, value)); ++ }; ++ function d3_selection_property(name, value) { ++ function propertyNull() { ++ delete this[name]; ++ } ++ function propertyConstant() { ++ this[name] = value; ++ } ++ function propertyFunction() { ++ var x = value.apply(this, arguments); ++ if (x == null) delete this[name]; else this[name] = x; ++ } ++ return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant; ++ } ++ d3_selectionPrototype.text = function(value) { ++ return arguments.length ? this.each(typeof value === "function" ? function() { ++ var v = value.apply(this, arguments); ++ this.textContent = v == null ? "" : v; ++ } : value == null ? function() { ++ this.textContent = ""; ++ } : function() { ++ this.textContent = value; ++ }) : this.node().textContent; ++ }; ++ d3_selectionPrototype.html = function(value) { ++ return arguments.length ? this.each(typeof value === "function" ? function() { ++ var v = value.apply(this, arguments); ++ this.innerHTML = v == null ? "" : v; ++ } : value == null ? function() { ++ this.innerHTML = ""; ++ } : function() { ++ this.innerHTML = value; ++ }) : this.node().innerHTML; ++ }; ++ d3_selectionPrototype.append = function(name) { ++ name = d3_selection_creator(name); ++ return this.select(function() { ++ return this.appendChild(name.apply(this, arguments)); ++ }); ++ }; ++ function d3_selection_creator(name) { ++ function create() { ++ var document = this.ownerDocument, namespace = this.namespaceURI; ++ return namespace === d3_nsXhtml && document.documentElement.namespaceURI === d3_nsXhtml ? document.createElement(name) : document.createElementNS(namespace, name); ++ } ++ function createNS() { ++ return this.ownerDocument.createElementNS(name.space, name.local); ++ } ++ return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? createNS : create; ++ } ++ d3_selectionPrototype.insert = function(name, before) { ++ name = d3_selection_creator(name); ++ before = d3_selection_selector(before); ++ return this.select(function() { ++ return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null); ++ }); ++ }; ++ d3_selectionPrototype.remove = function() { ++ return this.each(d3_selectionRemove); ++ }; ++ function d3_selectionRemove() { ++ var parent = this.parentNode; ++ if (parent) parent.removeChild(this); ++ } ++ d3_selectionPrototype.data = function(value, key) { ++ var i = -1, n = this.length, group, node; ++ if (!arguments.length) { ++ value = new Array(n = (group = this[0]).length); ++ while (++i < n) { ++ if (node = group[i]) { ++ value[i] = node.__data__; ++ } ++ } ++ return value; ++ } ++ function bind(group, groupData) { ++ var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData; ++ if (key) { ++ var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue; ++ for (i = -1; ++i < n; ) { ++ if (node = group[i]) { ++ if (nodeByKeyValue.has(keyValue = key.call(node, node.__data__, i))) { ++ exitNodes[i] = node; ++ } else { ++ nodeByKeyValue.set(keyValue, node); ++ } ++ keyValues[i] = keyValue; ++ } ++ } ++ for (i = -1; ++i < m; ) { ++ if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) { ++ enterNodes[i] = d3_selection_dataNode(nodeData); ++ } else if (node !== true) { ++ updateNodes[i] = node; ++ node.__data__ = nodeData; ++ } ++ nodeByKeyValue.set(keyValue, true); ++ } ++ for (i = -1; ++i < n; ) { ++ if (i in keyValues && nodeByKeyValue.get(keyValues[i]) !== true) { ++ exitNodes[i] = group[i]; ++ } ++ } ++ } else { ++ for (i = -1; ++i < n0; ) { ++ node = group[i]; ++ nodeData = groupData[i]; ++ if (node) { ++ node.__data__ = nodeData; ++ updateNodes[i] = node; ++ } else { ++ enterNodes[i] = d3_selection_dataNode(nodeData); ++ } ++ } ++ for (;i < m; ++i) { ++ enterNodes[i] = d3_selection_dataNode(groupData[i]); ++ } ++ for (;i < n; ++i) { ++ exitNodes[i] = group[i]; ++ } ++ } ++ enterNodes.update = updateNodes; ++ enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode; ++ enter.push(enterNodes); ++ update.push(updateNodes); ++ exit.push(exitNodes); ++ } ++ var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]); ++ if (typeof value === "function") { ++ while (++i < n) { ++ bind(group = this[i], value.call(group, group.parentNode.__data__, i)); ++ } ++ } else { ++ while (++i < n) { ++ bind(group = this[i], value); ++ } ++ } ++ update.enter = function() { ++ return enter; ++ }; ++ update.exit = function() { ++ return exit; ++ }; ++ return update; ++ }; ++ function d3_selection_dataNode(data) { ++ return { ++ __data__: data ++ }; ++ } ++ d3_selectionPrototype.datum = function(value) { ++ return arguments.length ? this.property("__data__", value) : this.property("__data__"); ++ }; ++ d3_selectionPrototype.filter = function(filter) { ++ var subgroups = [], subgroup, group, node; ++ if (typeof filter !== "function") filter = d3_selection_filter(filter); ++ for (var j = 0, m = this.length; j < m; j++) { ++ subgroups.push(subgroup = []); ++ subgroup.parentNode = (group = this[j]).parentNode; ++ for (var i = 0, n = group.length; i < n; i++) { ++ if ((node = group[i]) && filter.call(node, node.__data__, i, j)) { ++ subgroup.push(node); ++ } ++ } ++ } ++ return d3_selection(subgroups); ++ }; ++ function d3_selection_filter(selector) { ++ return function() { ++ return d3_selectMatches(this, selector); ++ }; ++ } ++ d3_selectionPrototype.order = function() { ++ for (var j = -1, m = this.length; ++j < m; ) { ++ for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) { ++ if (node = group[i]) { ++ if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); ++ next = node; ++ } ++ } ++ } ++ return this; ++ }; ++ d3_selectionPrototype.sort = function(comparator) { ++ comparator = d3_selection_sortComparator.apply(this, arguments); ++ for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator); ++ return this.order(); ++ }; ++ function d3_selection_sortComparator(comparator) { ++ if (!arguments.length) comparator = d3_ascending; ++ return function(a, b) { ++ return a && b ? comparator(a.__data__, b.__data__) : !a - !b; ++ }; ++ } ++ d3_selectionPrototype.each = function(callback) { ++ return d3_selection_each(this, function(node, i, j) { ++ callback.call(node, node.__data__, i, j); ++ }); ++ }; ++ function d3_selection_each(groups, callback) { ++ for (var 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(node, i, j); ++ } ++ } ++ return groups; ++ } ++ d3_selectionPrototype.call = function(callback) { ++ var args = d3_array(arguments); ++ callback.apply(args[0] = this, args); ++ return this; ++ }; ++ d3_selectionPrototype.empty = function() { ++ return !this.node(); ++ }; ++ d3_selectionPrototype.node = function() { ++ for (var j = 0, m = this.length; j < m; j++) { ++ for (var group = this[j], i = 0, n = group.length; i < n; i++) { ++ var node = group[i]; ++ if (node) return node; ++ } ++ } ++ return null; ++ }; ++ d3_selectionPrototype.size = function() { ++ var n = 0; ++ d3_selection_each(this, function() { ++ ++n; ++ }); ++ return n; ++ }; ++ function d3_selection_enter(selection) { ++ d3_subclass(selection, d3_selection_enterPrototype); ++ return selection; ++ } ++ var d3_selection_enterPrototype = []; ++ d3.selection.enter = d3_selection_enter; ++ d3.selection.enter.prototype = d3_selection_enterPrototype; ++ d3_selection_enterPrototype.append = d3_selectionPrototype.append; ++ d3_selection_enterPrototype.empty = d3_selectionPrototype.empty; ++ d3_selection_enterPrototype.node = d3_selectionPrototype.node; ++ d3_selection_enterPrototype.call = d3_selectionPrototype.call; ++ d3_selection_enterPrototype.size = d3_selectionPrototype.size; ++ d3_selection_enterPrototype.select = function(selector) { ++ var subgroups = [], subgroup, subnode, upgroup, group, node; ++ for (var j = -1, m = this.length; ++j < m; ) { ++ upgroup = (group = this[j]).update; ++ subgroups.push(subgroup = []); ++ subgroup.parentNode = group.parentNode; ++ for (var i = -1, n = group.length; ++i < n; ) { ++ if (node = group[i]) { ++ subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j)); ++ subnode.__data__ = node.__data__; ++ } else { ++ subgroup.push(null); ++ } ++ } ++ } ++ return d3_selection(subgroups); ++ }; ++ d3_selection_enterPrototype.insert = function(name, before) { ++ if (arguments.length < 2) before = d3_selection_enterInsertBefore(this); ++ return d3_selectionPrototype.insert.call(this, name, before); ++ }; ++ function d3_selection_enterInsertBefore(enter) { ++ var i0, j0; ++ return function(d, i, j) { ++ var group = enter[j].update, n = group.length, node; ++ if (j != j0) j0 = j, i0 = 0; ++ if (i >= i0) i0 = i + 1; ++ while (!(node = group[i0]) && ++i0 < n) ; ++ return node; ++ }; ++ } ++ d3.select = function(node) { ++ var group; ++ if (typeof node === "string") { ++ group = [ d3_select(node, d3_document) ]; ++ group.parentNode = d3_document.documentElement; ++ } else { ++ group = [ node ]; ++ group.parentNode = d3_documentElement(node); ++ } ++ return d3_selection([ group ]); ++ }; ++ d3.selectAll = function(nodes) { ++ var group; ++ if (typeof nodes === "string") { ++ group = d3_array(d3_selectAll(nodes, d3_document)); ++ group.parentNode = d3_document.documentElement; ++ } else { ++ group = d3_array(nodes); ++ group.parentNode = null; ++ } ++ return d3_selection([ group ]); ++ }; ++ d3_selectionPrototype.on = function(type, listener, capture) { ++ var n = arguments.length; ++ if (n < 3) { ++ if (typeof type !== "string") { ++ if (n < 2) listener = false; ++ for (capture in type) this.each(d3_selection_on(capture, type[capture], listener)); ++ return this; ++ } ++ if (n < 2) return (n = this.node()["__on" + type]) && n._; ++ capture = false; ++ } ++ return this.each(d3_selection_on(type, listener, capture)); ++ }; ++ function d3_selection_on(type, listener, capture) { ++ var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener; ++ if (i > 0) type = type.slice(0, i); ++ var filter = d3_selection_onFilters.get(type); ++ if (filter) type = filter, wrap = d3_selection_onFilter; ++ function onRemove() { ++ var l = this[name]; ++ if (l) { ++ this.removeEventListener(type, l, l.$); ++ delete this[name]; ++ } ++ } ++ function onAdd() { ++ var l = wrap(listener, d3_array(arguments)); ++ onRemove.call(this); ++ this.addEventListener(type, this[name] = l, l.$ = capture); ++ l._ = listener; ++ } ++ function removeAll() { ++ var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match; ++ for (var name in this) { ++ if (match = name.match(re)) { ++ var l = this[name]; ++ this.removeEventListener(match[1], l, l.$); ++ delete this[name]; ++ } ++ } ++ } ++ return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll; ++ } ++ var d3_selection_onFilters = d3.map({ ++ mouseenter: "mouseover", ++ mouseleave: "mouseout" ++ }); ++ if (d3_document) { ++ d3_selection_onFilters.forEach(function(k) { ++ if ("on" + k in d3_document) d3_selection_onFilters.remove(k); ++ }); ++ } ++ function d3_selection_onListener(listener, argumentz) { ++ return function(e) { ++ var o = d3.event; ++ d3.event = e; ++ argumentz[0] = this.__data__; ++ try { ++ listener.apply(this, argumentz); ++ } finally { ++ d3.event = o; ++ } ++ }; ++ } ++ function d3_selection_onFilter(listener, argumentz) { ++ var l = d3_selection_onListener(listener, argumentz); ++ return function(e) { ++ var target = this, related = e.relatedTarget; ++ if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) { ++ l.call(target, e); ++ } ++ }; ++ } ++ var d3_event_dragSelect, d3_event_dragId = 0; ++ function d3_event_dragSuppress(node) { ++ var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window(node)).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault); ++ if (d3_event_dragSelect == null) { ++ d3_event_dragSelect = "onselectstart" in node ? false : d3_vendorSymbol(node.style, "userSelect"); ++ } ++ if (d3_event_dragSelect) { ++ var style = d3_documentElement(node).style, select = style[d3_event_dragSelect]; ++ style[d3_event_dragSelect] = "none"; ++ } ++ return function(suppressClick) { ++ w.on(name, null); ++ if (d3_event_dragSelect) style[d3_event_dragSelect] = select; ++ if (suppressClick) { ++ var off = function() { ++ w.on(click, null); ++ }; ++ w.on(click, function() { ++ d3_eventPreventDefault(); ++ off(); ++ }, true); ++ setTimeout(off, 0); ++ } ++ }; ++ } ++ d3.mouse = function(container) { ++ return d3_mousePoint(container, d3_eventSource()); ++ }; ++ var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0; ++ function d3_mousePoint(container, e) { ++ if (e.changedTouches) e = e.changedTouches[0]; ++ var svg = container.ownerSVGElement || container; ++ if (svg.createSVGPoint) { ++ var point = svg.createSVGPoint(); ++ if (d3_mouse_bug44083 < 0) { ++ var window = d3_window(container); ++ if (window.scrollX || window.scrollY) { ++ svg = d3.select("body").append("svg").style({ ++ position: "absolute", ++ top: 0, ++ left: 0, ++ margin: 0, ++ padding: 0, ++ border: "none" ++ }, "important"); ++ var ctm = svg[0][0].getScreenCTM(); ++ d3_mouse_bug44083 = !(ctm.f || ctm.e); ++ svg.remove(); ++ } ++ } ++ if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX, ++ point.y = e.clientY; ++ point = point.matrixTransform(container.getScreenCTM().inverse()); ++ return [ point.x, point.y ]; ++ } ++ var rect = container.getBoundingClientRect(); ++ return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ]; ++ } ++ d3.touch = function(container, touches, identifier) { ++ if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches; ++ if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) { ++ if ((touch = touches[i]).identifier === identifier) { ++ return d3_mousePoint(container, touch); ++ } ++ } ++ }; ++ d3.behavior.drag = function() { ++ var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend"); ++ function drag() { ++ this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart); ++ } ++ function dragstart(id, position, subject, move, end) { ++ return function() { ++ var that = this, target = d3.event.target.correspondingElement || d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject(target)).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(target), position0 = position(parent, dragId); ++ if (origin) { ++ dragOffset = origin.apply(that, arguments); ++ dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ]; ++ } else { ++ dragOffset = [ 0, 0 ]; ++ } ++ dispatch({ ++ type: "dragstart" ++ }); ++ function moved() { ++ var position1 = position(parent, dragId), dx, dy; ++ if (!position1) return; ++ dx = position1[0] - position0[0]; ++ dy = position1[1] - position0[1]; ++ dragged |= dx | dy; ++ position0 = position1; ++ dispatch({ ++ type: "drag", ++ x: position1[0] + dragOffset[0], ++ y: position1[1] + dragOffset[1], ++ dx: dx, ++ dy: dy ++ }); ++ } ++ function ended() { ++ if (!position(parent, dragId)) return; ++ dragSubject.on(move + dragName, null).on(end + dragName, null); ++ dragRestore(dragged); ++ dispatch({ ++ type: "dragend" ++ }); ++ } ++ }; ++ } ++ drag.origin = function(x) { ++ if (!arguments.length) return origin; ++ origin = x; ++ return drag; ++ }; ++ return d3.rebind(drag, event, "on"); ++ }; ++ function d3_behavior_dragTouchId() { ++ return d3.event.changedTouches[0].identifier; ++ } ++ d3.touches = function(container, touches) { ++ if (arguments.length < 2) touches = d3_eventSource().touches; ++ return touches ? d3_array(touches).map(function(touch) { ++ var point = d3_mousePoint(container, touch); ++ point.identifier = touch.identifier; ++ return point; ++ }) : []; ++ }; ++ var ε = 1e-6, ε2 = ε * ε, π = Math.PI, τ = 2 * π, τε = τ - ε, halfπ = π / 2, d3_radians = π / 180, d3_degrees = 180 / π; ++ function d3_sgn(x) { ++ return x > 0 ? 1 : x < 0 ? -1 : 0; ++ } ++ function d3_cross2d(a, b, c) { ++ return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); ++ } ++ function d3_acos(x) { ++ return x > 1 ? 0 : x < -1 ? π : Math.acos(x); ++ } ++ function d3_asin(x) { ++ return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x); ++ } ++ function d3_sinh(x) { ++ return ((x = Math.exp(x)) - 1 / x) / 2; ++ } ++ function d3_cosh(x) { ++ return ((x = Math.exp(x)) + 1 / x) / 2; ++ } ++ function d3_tanh(x) { ++ return ((x = Math.exp(2 * x)) - 1) / (x + 1); ++ } ++ function d3_haversin(x) { ++ return (x = Math.sin(x / 2)) * x; ++ } ++ var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4; ++ d3.interpolateZoom = function(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; ++ if (d2 < ε2) { ++ S = Math.log(w1 / w0) / ρ; ++ i = function(t) { ++ return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * t * S) ]; ++ }; ++ } else { ++ var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); ++ S = (r1 - r0) / ρ; ++ i = function(t) { ++ var s = t * S, coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0)); ++ return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ]; ++ }; ++ } ++ i.duration = S * 1e3; ++ return i; ++ }; ++ d3.behavior.zoom = function() { ++ var view = { ++ x: 0, ++ y: 0, ++ k: 1 ++ }, translate0, center0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, duration = 250, zooming = 0, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1; ++ if (!d3_behavior_zoomWheel) { ++ d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() { ++ return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1); ++ }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() { ++ return d3.event.wheelDelta; ++ }, "mousewheel") : (d3_behavior_zoomDelta = function() { ++ return -d3.event.detail; ++ }, "MozMousePixelScroll"); ++ } ++ function zoom(g) { ++ g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted); ++ } ++ zoom.event = function(g) { ++ g.each(function() { ++ var dispatch = event.of(this, arguments), view1 = view; ++ if (d3_transitionInheritId) { ++ d3.select(this).transition().each("start.zoom", function() { ++ view = this.__chart__ || { ++ x: 0, ++ y: 0, ++ k: 1 ++ }; ++ zoomstarted(dispatch); ++ }).tween("zoom:zoom", function() { ++ var dx = size[0], dy = size[1], cx = center0 ? center0[0] : dx / 2, cy = center0 ? center0[1] : dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]); ++ return function(t) { ++ var l = i(t), k = dx / l[2]; ++ this.__chart__ = view = { ++ x: cx - l[0] * k, ++ y: cy - l[1] * k, ++ k: k ++ }; ++ zoomed(dispatch); ++ }; ++ }).each("interrupt.zoom", function() { ++ zoomended(dispatch); ++ }).each("end.zoom", function() { ++ zoomended(dispatch); ++ }); ++ } else { ++ this.__chart__ = view; ++ zoomstarted(dispatch); ++ zoomed(dispatch); ++ zoomended(dispatch); ++ } ++ }); ++ }; ++ zoom.translate = function(_) { ++ if (!arguments.length) return [ view.x, view.y ]; ++ view = { ++ x: +_[0], ++ y: +_[1], ++ k: view.k ++ }; ++ rescale(); ++ return zoom; ++ }; ++ zoom.scale = function(_) { ++ if (!arguments.length) return view.k; ++ view = { ++ x: view.x, ++ y: view.y, ++ k: null ++ }; ++ scaleTo(+_); ++ rescale(); ++ return zoom; ++ }; ++ zoom.scaleExtent = function(_) { ++ if (!arguments.length) return scaleExtent; ++ scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ]; ++ return zoom; ++ }; ++ zoom.center = function(_) { ++ if (!arguments.length) return center; ++ center = _ && [ +_[0], +_[1] ]; ++ return zoom; ++ }; ++ zoom.size = function(_) { ++ if (!arguments.length) return size; ++ size = _ && [ +_[0], +_[1] ]; ++ return zoom; ++ }; ++ zoom.duration = function(_) { ++ if (!arguments.length) return duration; ++ duration = +_; ++ return zoom; ++ }; ++ zoom.x = function(z) { ++ if (!arguments.length) return x1; ++ x1 = z; ++ x0 = z.copy(); ++ view = { ++ x: 0, ++ y: 0, ++ k: 1 ++ }; ++ return zoom; ++ }; ++ zoom.y = function(z) { ++ if (!arguments.length) return y1; ++ y1 = z; ++ y0 = z.copy(); ++ view = { ++ x: 0, ++ y: 0, ++ k: 1 ++ }; ++ return zoom; ++ }; ++ function location(p) { ++ return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ]; ++ } ++ function point(l) { ++ return [ l[0] * view.k + view.x, l[1] * view.k + view.y ]; ++ } ++ function scaleTo(s) { ++ view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s)); ++ } ++ function translateTo(p, l) { ++ l = point(l); ++ view.x += p[0] - l[0]; ++ view.y += p[1] - l[1]; ++ } ++ function zoomTo(that, p, l, k) { ++ that.__chart__ = { ++ x: view.x, ++ y: view.y, ++ k: view.k ++ }; ++ scaleTo(Math.pow(2, k)); ++ translateTo(center0 = p, l); ++ that = d3.select(that); ++ if (duration > 0) that = that.transition().duration(duration); ++ that.call(zoom.event); ++ } ++ function rescale() { ++ if (x1) x1.domain(x0.range().map(function(x) { ++ return (x - view.x) / view.k; ++ }).map(x0.invert)); ++ if (y1) y1.domain(y0.range().map(function(y) { ++ return (y - view.y) / view.k; ++ }).map(y0.invert)); ++ } ++ function zoomstarted(dispatch) { ++ if (!zooming++) dispatch({ ++ type: "zoomstart" ++ }); ++ } ++ function zoomed(dispatch) { ++ rescale(); ++ dispatch({ ++ type: "zoom", ++ scale: view.k, ++ translate: [ view.x, view.y ] ++ }); ++ } ++ function zoomended(dispatch) { ++ if (!--zooming) dispatch({ ++ type: "zoomend" ++ }), center0 = null; ++ } ++ function mousedowned() { ++ var that = this, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress(that); ++ d3_selection_interrupt.call(that); ++ zoomstarted(dispatch); ++ function moved() { ++ dragged = 1; ++ translateTo(d3.mouse(that), location0); ++ zoomed(dispatch); ++ } ++ function ended() { ++ subject.on(mousemove, null).on(mouseup, null); ++ dragRestore(dragged); ++ zoomended(dispatch); ++ } ++ } ++ function touchstarted() { ++ var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that); ++ started(); ++ zoomstarted(dispatch); ++ subject.on(mousedown, null).on(touchstart, started); ++ function relocate() { ++ var touches = d3.touches(that); ++ scale0 = view.k; ++ touches.forEach(function(t) { ++ if (t.identifier in locations0) locations0[t.identifier] = location(t); ++ }); ++ return touches; ++ } ++ function started() { ++ var target = d3.event.target; ++ d3.select(target).on(touchmove, moved).on(touchend, ended); ++ targets.push(target); ++ var changed = d3.event.changedTouches; ++ for (var i = 0, n = changed.length; i < n; ++i) { ++ locations0[changed[i].identifier] = null; ++ } ++ var touches = relocate(), now = Date.now(); ++ if (touches.length === 1) { ++ if (now - touchtime < 500) { ++ var p = touches[0]; ++ zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1); ++ d3_eventPreventDefault(); ++ } ++ touchtime = now; ++ } else if (touches.length > 1) { ++ var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1]; ++ distance0 = dx * dx + dy * dy; ++ } ++ } ++ function moved() { ++ var touches = d3.touches(that), p0, l0, p1, l1; ++ d3_selection_interrupt.call(that); ++ for (var i = 0, n = touches.length; i < n; ++i, l1 = null) { ++ p1 = touches[i]; ++ if (l1 = locations0[p1.identifier]) { ++ if (l0) break; ++ p0 = p1, l0 = l1; ++ } ++ } ++ if (l1) { ++ var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0); ++ p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ]; ++ l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ]; ++ scaleTo(scale1 * scale0); ++ } ++ touchtime = null; ++ translateTo(p0, l0); ++ zoomed(dispatch); ++ } ++ function ended() { ++ if (d3.event.touches.length) { ++ var changed = d3.event.changedTouches; ++ for (var i = 0, n = changed.length; i < n; ++i) { ++ delete locations0[changed[i].identifier]; ++ } ++ for (var identifier in locations0) { ++ return void relocate(); ++ } ++ } ++ d3.selectAll(targets).on(zoomName, null); ++ subject.on(mousedown, mousedowned).on(touchstart, touchstarted); ++ dragRestore(); ++ zoomended(dispatch); ++ } ++ } ++ function mousewheeled() { ++ var dispatch = event.of(this, arguments); ++ if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this), ++ translate0 = location(center0 = center || d3.mouse(this)), zoomstarted(dispatch); ++ mousewheelTimer = setTimeout(function() { ++ mousewheelTimer = null; ++ zoomended(dispatch); ++ }, 50); ++ d3_eventPreventDefault(); ++ scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k); ++ translateTo(center0, translate0); ++ zoomed(dispatch); ++ } ++ function dblclicked() { ++ var p = d3.mouse(this), k = Math.log(view.k) / Math.LN2; ++ zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1); ++ } ++ return d3.rebind(zoom, event, "on"); ++ }; ++ var d3_behavior_zoomInfinity = [ 0, Infinity ], d3_behavior_zoomDelta, d3_behavior_zoomWheel; ++ d3.color = d3_color; ++ function d3_color() {} ++ d3_color.prototype.toString = function() { ++ return this.rgb() + ""; ++ }; ++ d3.hsl = d3_hsl; ++ function d3_hsl(h, s, l) { ++ return this instanceof d3_hsl ? void (this.h = +h, this.s = +s, this.l = +l) : arguments.length < 2 ? h instanceof d3_hsl ? new d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : new d3_hsl(h, s, l); ++ } ++ var d3_hslPrototype = d3_hsl.prototype = new d3_color(); ++ d3_hslPrototype.brighter = function(k) { ++ k = Math.pow(.7, arguments.length ? k : 1); ++ return new d3_hsl(this.h, this.s, this.l / k); ++ }; ++ d3_hslPrototype.darker = function(k) { ++ k = Math.pow(.7, arguments.length ? k : 1); ++ return new d3_hsl(this.h, this.s, k * this.l); ++ }; ++ d3_hslPrototype.rgb = function() { ++ return d3_hsl_rgb(this.h, this.s, this.l); ++ }; ++ function d3_hsl_rgb(h, s, l) { ++ var m1, m2; ++ h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h; ++ s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s; ++ l = l < 0 ? 0 : l > 1 ? 1 : l; ++ m2 = l <= .5 ? l * (1 + s) : l + s - l * s; ++ m1 = 2 * l - m2; ++ function v(h) { ++ if (h > 360) h -= 360; else if (h < 0) h += 360; ++ if (h < 60) return m1 + (m2 - m1) * h / 60; ++ if (h < 180) return m2; ++ if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60; ++ return m1; ++ } ++ function vv(h) { ++ return Math.round(v(h) * 255); ++ } ++ return new d3_rgb(vv(h + 120), vv(h), vv(h - 120)); ++ } ++ d3.hcl = d3_hcl; ++ function d3_hcl(h, c, l) { ++ return this instanceof d3_hcl ? void (this.h = +h, this.c = +c, this.l = +l) : arguments.length < 2 ? h instanceof d3_hcl ? new d3_hcl(h.h, h.c, h.l) : h instanceof d3_lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : new d3_hcl(h, c, l); ++ } ++ var d3_hclPrototype = d3_hcl.prototype = new d3_color(); ++ d3_hclPrototype.brighter = function(k) { ++ return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1))); ++ }; ++ d3_hclPrototype.darker = function(k) { ++ return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1))); ++ }; ++ d3_hclPrototype.rgb = function() { ++ return d3_hcl_lab(this.h, this.c, this.l).rgb(); ++ }; ++ function d3_hcl_lab(h, c, l) { ++ if (isNaN(h)) h = 0; ++ if (isNaN(c)) c = 0; ++ return new d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c); ++ } ++ d3.lab = d3_lab; ++ function d3_lab(l, a, b) { ++ return this instanceof d3_lab ? void (this.l = +l, this.a = +a, this.b = +b) : arguments.length < 2 ? l instanceof d3_lab ? new d3_lab(l.l, l.a, l.b) : l instanceof d3_hcl ? d3_hcl_lab(l.h, l.c, l.l) : d3_rgb_lab((l = d3_rgb(l)).r, l.g, l.b) : new d3_lab(l, a, b); ++ } ++ var d3_lab_K = 18; ++ var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883; ++ var d3_labPrototype = d3_lab.prototype = new d3_color(); ++ d3_labPrototype.brighter = function(k) { ++ return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); ++ }; ++ d3_labPrototype.darker = function(k) { ++ return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); ++ }; ++ d3_labPrototype.rgb = function() { ++ return d3_lab_rgb(this.l, this.a, this.b); ++ }; ++ function d3_lab_rgb(l, a, b) { ++ var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200; ++ x = d3_lab_xyz(x) * d3_lab_X; ++ y = d3_lab_xyz(y) * d3_lab_Y; ++ z = d3_lab_xyz(z) * d3_lab_Z; ++ return new d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z)); ++ } ++ function d3_lab_hcl(l, a, b) { ++ return l > 0 ? new d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : new d3_hcl(NaN, NaN, l); ++ } ++ function d3_lab_xyz(x) { ++ return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037; ++ } ++ function d3_xyz_lab(x) { ++ return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29; ++ } ++ function d3_xyz_rgb(r) { ++ return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055)); ++ } ++ d3.rgb = d3_rgb; ++ function d3_rgb(r, g, b) { ++ return this instanceof d3_rgb ? void (this.r = ~~r, this.g = ~~g, this.b = ~~b) : arguments.length < 2 ? r instanceof d3_rgb ? new d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : new d3_rgb(r, g, b); ++ } ++ function d3_rgbNumber(value) { ++ return new d3_rgb(value >> 16, value >> 8 & 255, value & 255); ++ } ++ function d3_rgbString(value) { ++ return d3_rgbNumber(value) + ""; ++ } ++ var d3_rgbPrototype = d3_rgb.prototype = new d3_color(); ++ d3_rgbPrototype.brighter = function(k) { ++ k = Math.pow(.7, arguments.length ? k : 1); ++ var r = this.r, g = this.g, b = this.b, i = 30; ++ if (!r && !g && !b) return new d3_rgb(i, i, i); ++ if (r && r < i) r = i; ++ if (g && g < i) g = i; ++ if (b && b < i) b = i; ++ return new d3_rgb(Math.min(255, r / k), Math.min(255, g / k), Math.min(255, b / k)); ++ }; ++ d3_rgbPrototype.darker = function(k) { ++ k = Math.pow(.7, arguments.length ? k : 1); ++ return new d3_rgb(k * this.r, k * this.g, k * this.b); ++ }; ++ d3_rgbPrototype.hsl = function() { ++ return d3_rgb_hsl(this.r, this.g, this.b); ++ }; ++ d3_rgbPrototype.toString = function() { ++ return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b); ++ }; ++ function d3_rgb_hex(v) { ++ return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16); ++ } ++ function d3_rgb_parse(format, rgb, hsl) { ++ var r = 0, g = 0, b = 0, m1, m2, color; ++ m1 = /([a-z]+)\((.*)\)/.exec(format = format.toLowerCase()); ++ if (m1) { ++ m2 = m1[2].split(","); ++ switch (m1[1]) { ++ case "hsl": ++ { ++ return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100); ++ } ++ ++ case "rgb": ++ { ++ return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2])); ++ } ++ } ++ } ++ if (color = d3_rgb_names.get(format)) { ++ return rgb(color.r, color.g, color.b); ++ } ++ if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.slice(1), 16))) { ++ if (format.length === 4) { ++ r = (color & 3840) >> 4; ++ r = r >> 4 | r; ++ g = color & 240; ++ g = g >> 4 | g; ++ b = color & 15; ++ b = b << 4 | b; ++ } else if (format.length === 7) { ++ r = (color & 16711680) >> 16; ++ g = (color & 65280) >> 8; ++ b = color & 255; ++ } ++ } ++ return rgb(r, g, b); ++ } ++ function d3_rgb_hsl(r, g, b) { ++ var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2; ++ if (d) { ++ s = l < .5 ? d / (max + min) : d / (2 - max - min); ++ if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4; ++ h *= 60; ++ } else { ++ h = NaN; ++ s = l > 0 && l < 1 ? 0 : h; ++ } ++ return new d3_hsl(h, s, l); ++ } ++ function d3_rgb_lab(r, g, b) { ++ r = d3_rgb_xyz(r); ++ g = d3_rgb_xyz(g); ++ b = d3_rgb_xyz(b); ++ var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z); ++ return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z)); ++ } ++ function d3_rgb_xyz(r) { ++ return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4); ++ } ++ function d3_rgb_parseNumber(c) { ++ var f = parseFloat(c); ++ return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f; ++ } ++ var d3_rgb_names = d3.map({ ++ aliceblue: 15792383, ++ antiquewhite: 16444375, ++ aqua: 65535, ++ aquamarine: 8388564, ++ azure: 15794175, ++ beige: 16119260, ++ bisque: 16770244, ++ black: 0, ++ blanchedalmond: 16772045, ++ blue: 255, ++ blueviolet: 9055202, ++ brown: 10824234, ++ burlywood: 14596231, ++ cadetblue: 6266528, ++ chartreuse: 8388352, ++ chocolate: 13789470, ++ coral: 16744272, ++ cornflowerblue: 6591981, ++ cornsilk: 16775388, ++ crimson: 14423100, ++ cyan: 65535, ++ darkblue: 139, ++ darkcyan: 35723, ++ darkgoldenrod: 12092939, ++ darkgray: 11119017, ++ darkgreen: 25600, ++ darkgrey: 11119017, ++ darkkhaki: 12433259, ++ darkmagenta: 9109643, ++ darkolivegreen: 5597999, ++ darkorange: 16747520, ++ darkorchid: 10040012, ++ darkred: 9109504, ++ darksalmon: 15308410, ++ darkseagreen: 9419919, ++ darkslateblue: 4734347, ++ darkslategray: 3100495, ++ darkslategrey: 3100495, ++ darkturquoise: 52945, ++ darkviolet: 9699539, ++ deeppink: 16716947, ++ deepskyblue: 49151, ++ dimgray: 6908265, ++ dimgrey: 6908265, ++ dodgerblue: 2003199, ++ firebrick: 11674146, ++ floralwhite: 16775920, ++ forestgreen: 2263842, ++ fuchsia: 16711935, ++ gainsboro: 14474460, ++ ghostwhite: 16316671, ++ gold: 16766720, ++ goldenrod: 14329120, ++ gray: 8421504, ++ green: 32768, ++ greenyellow: 11403055, ++ grey: 8421504, ++ honeydew: 15794160, ++ hotpink: 16738740, ++ indianred: 13458524, ++ indigo: 4915330, ++ ivory: 16777200, ++ khaki: 15787660, ++ lavender: 15132410, ++ lavenderblush: 16773365, ++ lawngreen: 8190976, ++ lemonchiffon: 16775885, ++ lightblue: 11393254, ++ lightcoral: 15761536, ++ lightcyan: 14745599, ++ lightgoldenrodyellow: 16448210, ++ lightgray: 13882323, ++ lightgreen: 9498256, ++ lightgrey: 13882323, ++ lightpink: 16758465, ++ lightsalmon: 16752762, ++ lightseagreen: 2142890, ++ lightskyblue: 8900346, ++ lightslategray: 7833753, ++ lightslategrey: 7833753, ++ lightsteelblue: 11584734, ++ lightyellow: 16777184, ++ lime: 65280, ++ limegreen: 3329330, ++ linen: 16445670, ++ magenta: 16711935, ++ maroon: 8388608, ++ mediumaquamarine: 6737322, ++ mediumblue: 205, ++ mediumorchid: 12211667, ++ mediumpurple: 9662683, ++ mediumseagreen: 3978097, ++ mediumslateblue: 8087790, ++ mediumspringgreen: 64154, ++ mediumturquoise: 4772300, ++ mediumvioletred: 13047173, ++ midnightblue: 1644912, ++ mintcream: 16121850, ++ mistyrose: 16770273, ++ moccasin: 16770229, ++ navajowhite: 16768685, ++ navy: 128, ++ oldlace: 16643558, ++ olive: 8421376, ++ olivedrab: 7048739, ++ orange: 16753920, ++ orangered: 16729344, ++ orchid: 14315734, ++ palegoldenrod: 15657130, ++ palegreen: 10025880, ++ paleturquoise: 11529966, ++ palevioletred: 14381203, ++ papayawhip: 16773077, ++ peachpuff: 16767673, ++ peru: 13468991, ++ pink: 16761035, ++ plum: 14524637, ++ powderblue: 11591910, ++ purple: 8388736, ++ rebeccapurple: 6697881, ++ red: 16711680, ++ rosybrown: 12357519, ++ royalblue: 4286945, ++ saddlebrown: 9127187, ++ salmon: 16416882, ++ sandybrown: 16032864, ++ seagreen: 3050327, ++ seashell: 16774638, ++ sienna: 10506797, ++ silver: 12632256, ++ skyblue: 8900331, ++ slateblue: 6970061, ++ slategray: 7372944, ++ slategrey: 7372944, ++ snow: 16775930, ++ springgreen: 65407, ++ steelblue: 4620980, ++ tan: 13808780, ++ teal: 32896, ++ thistle: 14204888, ++ tomato: 16737095, ++ turquoise: 4251856, ++ violet: 15631086, ++ wheat: 16113331, ++ white: 16777215, ++ whitesmoke: 16119285, ++ yellow: 16776960, ++ yellowgreen: 10145074 ++ }); ++ d3_rgb_names.forEach(function(key, value) { ++ d3_rgb_names.set(key, d3_rgbNumber(value)); ++ }); ++ function d3_functor(v) { ++ return typeof v === "function" ? v : function() { ++ return v; ++ }; ++ } ++ d3.functor = d3_functor; ++ d3.xhr = d3_xhrType(d3_identity); ++ function d3_xhrType(response) { ++ return function(url, mimeType, callback) { ++ if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, ++ mimeType = null; ++ return d3_xhr(url, mimeType, response, callback); ++ }; ++ } ++ function d3_xhr(url, mimeType, response, callback) { ++ var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null; ++ if (this.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest(); ++ "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() { ++ request.readyState > 3 && respond(); ++ }; ++ function respond() { ++ var status = request.status, result; ++ if (!status && d3_xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) { ++ try { ++ result = response.call(xhr, request); ++ } catch (e) { ++ dispatch.error.call(xhr, e); ++ return; ++ } ++ dispatch.load.call(xhr, result); ++ } else { ++ dispatch.error.call(xhr, request); ++ } ++ } ++ request.onprogress = function(event) { ++ var o = d3.event; ++ d3.event = event; ++ try { ++ dispatch.progress.call(xhr, request); ++ } finally { ++ d3.event = o; ++ } ++ }; ++ xhr.header = function(name, value) { ++ name = (name + "").toLowerCase(); ++ if (arguments.length < 2) return headers[name]; ++ if (value == null) delete headers[name]; else headers[name] = value + ""; ++ return xhr; ++ }; ++ xhr.mimeType = function(value) { ++ if (!arguments.length) return mimeType; ++ mimeType = value == null ? null : value + ""; ++ return xhr; ++ }; ++ xhr.responseType = function(value) { ++ if (!arguments.length) return responseType; ++ responseType = value; ++ return xhr; ++ }; ++ xhr.response = function(value) { ++ response = value; ++ return xhr; ++ }; ++ [ "get", "post" ].forEach(function(method) { ++ xhr[method] = function() { ++ return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments))); ++ }; ++ }); ++ xhr.send = function(method, data, callback) { ++ if (arguments.length === 2 && typeof data === "function") callback = data, data = null; ++ request.open(method, url, true); ++ if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*"; ++ if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]); ++ if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType); ++ if (responseType != null) request.responseType = responseType; ++ if (callback != null) xhr.on("error", callback).on("load", function(request) { ++ callback(null, request); ++ }); ++ dispatch.beforesend.call(xhr, request); ++ request.send(data == null ? null : data); ++ return xhr; ++ }; ++ xhr.abort = function() { ++ request.abort(); ++ return xhr; ++ }; ++ d3.rebind(xhr, dispatch, "on"); ++ return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback)); ++ } ++ function d3_xhr_fixCallback(callback) { ++ return callback.length === 1 ? function(error, request) { ++ callback(error == null ? request : null); ++ } : callback; ++ } ++ function d3_xhrHasResponse(request) { ++ var type = request.responseType; ++ return type && type !== "text" ? request.response : request.responseText; ++ } ++ d3.dsv = function(delimiter, mimeType) { ++ var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0); ++ function dsv(url, row, callback) { ++ if (arguments.length < 3) callback = row, row = null; ++ var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback); ++ xhr.row = function(_) { ++ return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row; ++ }; ++ return xhr; ++ } ++ function response(request) { ++ return dsv.parse(request.responseText); ++ } ++ function typedResponse(f) { ++ return function(request) { ++ return dsv.parse(request.responseText, f); ++ }; ++ } ++ dsv.parse = function(text, f) { ++ var o; ++ return dsv.parseRows(text, function(row, i) { ++ if (o) return o(row, i - 1); ++ var a = new Function("d", "return {" + row.map(function(name, i) { ++ return JSON.stringify(name) + ": d[" + i + "]"; ++ }).join(",") + "}"); ++ o = f ? function(row, i) { ++ return f(a(row), i); ++ } : a; ++ }); ++ }; ++ dsv.parseRows = function(text, f) { ++ var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol; ++ function token() { ++ if (I >= N) return EOF; ++ if (eol) return eol = false, EOL; ++ var j = I; ++ if (text.charCodeAt(j) === 34) { ++ var i = j; ++ while (i++ < N) { ++ if (text.charCodeAt(i) === 34) { ++ if (text.charCodeAt(i + 1) !== 34) break; ++ ++i; ++ } ++ } ++ I = i + 2; ++ var c = text.charCodeAt(i + 1); ++ if (c === 13) { ++ eol = true; ++ if (text.charCodeAt(i + 2) === 10) ++I; ++ } else if (c === 10) { ++ eol = true; ++ } ++ return text.slice(j + 1, i).replace(/""/g, '"'); ++ } ++ while (I < N) { ++ var c = text.charCodeAt(I++), k = 1; ++ if (c === 10) eol = true; else if (c === 13) { ++ eol = true; ++ if (text.charCodeAt(I) === 10) ++I, ++k; ++ } else if (c !== delimiterCode) continue; ++ return text.slice(j, I - k); ++ } ++ return text.slice(j); ++ } ++ while ((t = token()) !== EOF) { ++ var a = []; ++ while (t !== EOL && t !== EOF) { ++ a.push(t); ++ t = token(); ++ } ++ if (f && (a = f(a, n++)) == null) continue; ++ rows.push(a); ++ } ++ return rows; ++ }; ++ dsv.format = function(rows) { ++ if (Array.isArray(rows[0])) return dsv.formatRows(rows); ++ var fieldSet = new d3_Set(), fields = []; ++ rows.forEach(function(row) { ++ for (var field in row) { ++ if (!fieldSet.has(field)) { ++ fields.push(fieldSet.add(field)); ++ } ++ } ++ }); ++ return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) { ++ return fields.map(function(field) { ++ return formatValue(row[field]); ++ }).join(delimiter); ++ })).join("\n"); ++ }; ++ dsv.formatRows = function(rows) { ++ return rows.map(formatRow).join("\n"); ++ }; ++ function formatRow(row) { ++ return row.map(formatValue).join(delimiter); ++ } ++ function formatValue(text) { ++ return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text; ++ } ++ return dsv; ++ }; ++ d3.csv = d3.dsv(",", "text/csv"); ++ d3.tsv = d3.dsv(" ", "text/tab-separated-values"); ++ var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) { ++ setTimeout(callback, 17); ++ }; ++ d3.timer = function() { ++ d3_timer.apply(this, arguments); ++ }; ++ function d3_timer(callback, delay, then) { ++ var n = arguments.length; ++ if (n < 2) delay = 0; ++ if (n < 3) then = Date.now(); ++ var time = then + delay, timer = { ++ c: callback, ++ t: time, ++ n: null ++ }; ++ if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer; ++ d3_timer_queueTail = timer; ++ if (!d3_timer_interval) { ++ d3_timer_timeout = clearTimeout(d3_timer_timeout); ++ d3_timer_interval = 1; ++ d3_timer_frame(d3_timer_step); ++ } ++ return timer; ++ } ++ function d3_timer_step() { ++ var now = d3_timer_mark(), delay = d3_timer_sweep() - now; ++ if (delay > 24) { ++ if (isFinite(delay)) { ++ clearTimeout(d3_timer_timeout); ++ d3_timer_timeout = setTimeout(d3_timer_step, delay); ++ } ++ d3_timer_interval = 0; ++ } else { ++ d3_timer_interval = 1; ++ d3_timer_frame(d3_timer_step); ++ } ++ } ++ d3.timer.flush = function() { ++ d3_timer_mark(); ++ d3_timer_sweep(); ++ }; ++ function d3_timer_mark() { ++ var now = Date.now(), timer = d3_timer_queueHead; ++ while (timer) { ++ if (now >= timer.t && timer.c(now - timer.t)) timer.c = null; ++ timer = timer.n; ++ } ++ return now; ++ } ++ function d3_timer_sweep() { ++ var t0, t1 = d3_timer_queueHead, time = Infinity; ++ while (t1) { ++ if (t1.c) { ++ if (t1.t < time) time = t1.t; ++ t1 = (t0 = t1).n; ++ } else { ++ t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n; ++ } ++ } ++ d3_timer_queueTail = t0; ++ return time; ++ } ++ function d3_format_precision(x, p) { ++ return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1); ++ } ++ d3.round = function(x, n) { ++ return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x); ++ }; ++ var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix); ++ d3.formatPrefix = function(value, precision) { ++ var i = 0; ++ if (value = +value) { ++ if (value < 0) value *= -1; ++ if (precision) value = d3.round(value, d3_format_precision(value, precision)); ++ i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10); ++ i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3)); ++ } ++ return d3_formatPrefixes[8 + i / 3]; ++ }; ++ function d3_formatPrefix(d, i) { ++ var k = Math.pow(10, abs(8 - i) * 3); ++ return { ++ scale: i > 8 ? function(d) { ++ return d / k; ++ } : function(d) { ++ return d * k; ++ }, ++ symbol: d ++ }; ++ } ++ function d3_locale_numberFormat(locale) { ++ var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping && locale_thousands ? function(value, width) { ++ var i = value.length, t = [], j = 0, g = locale_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 = locale_grouping[j = (j + 1) % locale_grouping.length]; ++ } ++ return t.reverse().join(locale_thousands); ++ } : d3_identity; ++ return function(specifier) { ++ var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "-", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false, exponent = true; ++ if (precision) precision = +precision.substring(1); ++ if (zfill || fill === "0" && align === "=") { ++ zfill = fill = "0"; ++ align = "="; ++ } ++ switch (type) { ++ case "n": ++ comma = true; ++ type = "g"; ++ break; ++ ++ case "%": ++ scale = 100; ++ suffix = "%"; ++ type = "f"; ++ break; ++ ++ case "p": ++ scale = 100; ++ suffix = "%"; ++ type = "r"; ++ break; ++ ++ case "b": ++ case "o": ++ case "x": ++ case "X": ++ if (symbol === "#") prefix = "0" + type.toLowerCase(); ++ ++ case "c": ++ exponent = false; ++ ++ case "d": ++ integer = true; ++ precision = 0; ++ break; ++ ++ case "s": ++ scale = -1; ++ type = "r"; ++ break; ++ } ++ if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1]; ++ if (type == "r" && !precision) type = "g"; ++ if (precision != null) { ++ if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision)); ++ } ++ type = d3_format_types.get(type) || d3_format_typeDefault; ++ var zcomma = zfill && comma; ++ return function(value) { ++ var fullSuffix = suffix; ++ if (integer && value % 1) return ""; ++ var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign === "-" ? "" : sign; ++ if (scale < 0) { ++ var unit = d3.formatPrefix(value, precision); ++ value = unit.scale(value); ++ fullSuffix = unit.symbol + suffix; ++ } else { ++ value *= scale; ++ } ++ value = type(value, precision); ++ var i = value.lastIndexOf("."), before, after; ++ if (i < 0) { ++ var j = exponent ? value.lastIndexOf("e") : -1; ++ if (j < 0) before = value, after = ""; else before = value.substring(0, j), after = value.substring(j); ++ } else { ++ before = value.substring(0, i); ++ after = locale_decimal + value.substring(i + 1); ++ } ++ if (!zfill && comma) before = formatGroup(before, Infinity); ++ var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : ""; ++ if (zcomma) before = formatGroup(padding + before, padding.length ? width - after.length : Infinity); ++ negative += prefix; ++ value = before + after; ++ return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix; ++ }; ++ }; ++ } ++ var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i; ++ var d3_format_types = d3.map({ ++ b: function(x) { ++ return x.toString(2); ++ }, ++ c: function(x) { ++ return String.fromCharCode(x); ++ }, ++ o: function(x) { ++ return x.toString(8); ++ }, ++ x: function(x) { ++ return x.toString(16); ++ }, ++ X: function(x) { ++ return x.toString(16).toUpperCase(); ++ }, ++ g: function(x, p) { ++ return x.toPrecision(p); ++ }, ++ e: function(x, p) { ++ return x.toExponential(p); ++ }, ++ f: function(x, p) { ++ return x.toFixed(p); ++ }, ++ r: function(x, p) { ++ return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p)))); ++ } ++ }); ++ function d3_format_typeDefault(x) { ++ return x + ""; ++ } ++ var d3_time = d3.time = {}, d3_date = Date; ++ function d3_date_utc() { ++ this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]); ++ } ++ d3_date_utc.prototype = { ++ getDate: function() { ++ return this._.getUTCDate(); ++ }, ++ getDay: function() { ++ return this._.getUTCDay(); ++ }, ++ getFullYear: function() { ++ return this._.getUTCFullYear(); ++ }, ++ getHours: function() { ++ return this._.getUTCHours(); ++ }, ++ getMilliseconds: function() { ++ return this._.getUTCMilliseconds(); ++ }, ++ getMinutes: function() { ++ return this._.getUTCMinutes(); ++ }, ++ getMonth: function() { ++ return this._.getUTCMonth(); ++ }, ++ getSeconds: function() { ++ return this._.getUTCSeconds(); ++ }, ++ getTime: function() { ++ return this._.getTime(); ++ }, ++ getTimezoneOffset: function() { ++ return 0; ++ }, ++ valueOf: function() { ++ return this._.valueOf(); ++ }, ++ setDate: function() { ++ d3_time_prototype.setUTCDate.apply(this._, arguments); ++ }, ++ setDay: function() { ++ d3_time_prototype.setUTCDay.apply(this._, arguments); ++ }, ++ setFullYear: function() { ++ d3_time_prototype.setUTCFullYear.apply(this._, arguments); ++ }, ++ setHours: function() { ++ d3_time_prototype.setUTCHours.apply(this._, arguments); ++ }, ++ setMilliseconds: function() { ++ d3_time_prototype.setUTCMilliseconds.apply(this._, arguments); ++ }, ++ setMinutes: function() { ++ d3_time_prototype.setUTCMinutes.apply(this._, arguments); ++ }, ++ setMonth: function() { ++ d3_time_prototype.setUTCMonth.apply(this._, arguments); ++ }, ++ setSeconds: function() { ++ d3_time_prototype.setUTCSeconds.apply(this._, arguments); ++ }, ++ setTime: function() { ++ d3_time_prototype.setTime.apply(this._, arguments); ++ } ++ }; ++ var d3_time_prototype = Date.prototype; ++ function d3_time_interval(local, step, number) { ++ function round(date) { ++ var d0 = local(date), d1 = offset(d0, 1); ++ return date - d0 < d1 - date ? d0 : d1; ++ } ++ function ceil(date) { ++ step(date = local(new d3_date(date - 1)), 1); ++ return date; ++ } ++ function offset(date, k) { ++ step(date = new d3_date(+date), k); ++ return date; ++ } ++ function range(t0, t1, dt) { ++ var time = ceil(t0), times = []; ++ if (dt > 1) { ++ while (time < t1) { ++ if (!(number(time) % dt)) times.push(new Date(+time)); ++ step(time, 1); ++ } ++ } else { ++ while (time < t1) times.push(new Date(+time)), step(time, 1); ++ } ++ return times; ++ } ++ function range_utc(t0, t1, dt) { ++ try { ++ d3_date = d3_date_utc; ++ var utc = new d3_date_utc(); ++ utc._ = t0; ++ return range(utc, t1, dt); ++ } finally { ++ d3_date = Date; ++ } ++ } ++ local.floor = local; ++ local.round = round; ++ local.ceil = ceil; ++ local.offset = offset; ++ local.range = range; ++ var utc = local.utc = d3_time_interval_utc(local); ++ utc.floor = utc; ++ utc.round = d3_time_interval_utc(round); ++ utc.ceil = d3_time_interval_utc(ceil); ++ utc.offset = d3_time_interval_utc(offset); ++ utc.range = range_utc; ++ return local; ++ } ++ function d3_time_interval_utc(method) { ++ return function(date, k) { ++ try { ++ d3_date = d3_date_utc; ++ var utc = new d3_date_utc(); ++ utc._ = date; ++ return method(utc, k)._; ++ } finally { ++ d3_date = Date; ++ } ++ }; ++ } ++ d3_time.year = d3_time_interval(function(date) { ++ date = d3_time.day(date); ++ date.setMonth(0, 1); ++ return date; ++ }, function(date, offset) { ++ date.setFullYear(date.getFullYear() + offset); ++ }, function(date) { ++ return date.getFullYear(); ++ }); ++ d3_time.years = d3_time.year.range; ++ d3_time.years.utc = d3_time.year.utc.range; ++ d3_time.day = d3_time_interval(function(date) { ++ var day = new d3_date(2e3, 0); ++ day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate()); ++ return day; ++ }, function(date, offset) { ++ date.setDate(date.getDate() + offset); ++ }, function(date) { ++ return date.getDate() - 1; ++ }); ++ d3_time.days = d3_time.day.range; ++ d3_time.days.utc = d3_time.day.utc.range; ++ d3_time.dayOfYear = function(date) { ++ var year = d3_time.year(date); ++ return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5); ++ }; ++ [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) { ++ i = 7 - i; ++ var interval = d3_time[day] = d3_time_interval(function(date) { ++ (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7); ++ return date; ++ }, function(date, offset) { ++ date.setDate(date.getDate() + Math.floor(offset) * 7); ++ }, function(date) { ++ var day = d3_time.year(date).getDay(); ++ return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i); ++ }); ++ d3_time[day + "s"] = interval.range; ++ d3_time[day + "s"].utc = interval.utc.range; ++ d3_time[day + "OfYear"] = function(date) { ++ var day = d3_time.year(date).getDay(); ++ return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7); ++ }; ++ }); ++ d3_time.week = d3_time.sunday; ++ d3_time.weeks = d3_time.sunday.range; ++ d3_time.weeks.utc = d3_time.sunday.utc.range; ++ d3_time.weekOfYear = d3_time.sundayOfYear; ++ function d3_locale_timeFormat(locale) { ++ var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths; ++ function d3_time_format(template) { ++ var n = template.length; ++ function format(date) { ++ var string = [], i = -1, j = 0, c, p, f; ++ while (++i < n) { ++ if (template.charCodeAt(i) === 37) { ++ string.push(template.slice(j, i)); ++ if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i); ++ if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p); ++ string.push(c); ++ j = i + 1; ++ } ++ } ++ string.push(template.slice(j, i)); ++ return string.join(""); ++ } ++ format.parse = function(string) { ++ var d = { ++ y: 1900, ++ m: 0, ++ d: 1, ++ H: 0, ++ M: 0, ++ S: 0, ++ L: 0, ++ Z: null ++ }, i = d3_time_parse(d, template, string, 0); ++ if (i != string.length) return null; ++ if ("p" in d) d.H = d.H % 12 + d.p * 12; ++ var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)(); ++ if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("W" in d || "U" in d) { ++ if (!("w" in d)) d.w = "W" in d ? 1 : 0; ++ date.setFullYear(d.y, 0, 1); ++ date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7); ++ } else date.setFullYear(d.y, d.m, d.d); ++ date.setHours(d.H + (d.Z / 100 | 0), d.M + d.Z % 100, d.S, d.L); ++ return localZ ? date._ : date; ++ }; ++ format.toString = function() { ++ return template; ++ }; ++ return format; ++ } ++ function d3_time_parse(date, template, string, j) { ++ var c, p, t, i = 0, n = template.length, m = string.length; ++ while (i < n) { ++ if (j >= m) return -1; ++ c = template.charCodeAt(i++); ++ if (c === 37) { ++ t = template.charAt(i++); ++ p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t]; ++ if (!p || (j = p(date, string, j)) < 0) return -1; ++ } else if (c != string.charCodeAt(j++)) { ++ return -1; ++ } ++ } ++ return j; ++ } ++ d3_time_format.utc = function(template) { ++ var local = d3_time_format(template); ++ function format(date) { ++ try { ++ d3_date = d3_date_utc; ++ var utc = new d3_date(); ++ utc._ = date; ++ return local(utc); ++ } finally { ++ d3_date = Date; ++ } ++ } ++ format.parse = function(string) { ++ try { ++ d3_date = d3_date_utc; ++ var date = local.parse(string); ++ return date && date._; ++ } finally { ++ d3_date = Date; ++ } ++ }; ++ format.toString = local.toString; ++ return format; ++ }; ++ d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti; ++ var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(locale_shortMonths); ++ locale_periods.forEach(function(p, i) { ++ d3_time_periodLookup.set(p.toLowerCase(), i); ++ }); ++ var d3_time_formats = { ++ a: function(d) { ++ return locale_shortDays[d.getDay()]; ++ }, ++ A: function(d) { ++ return locale_days[d.getDay()]; ++ }, ++ b: function(d) { ++ return locale_shortMonths[d.getMonth()]; ++ }, ++ B: function(d) { ++ return locale_months[d.getMonth()]; ++ }, ++ c: d3_time_format(locale_dateTime), ++ d: function(d, p) { ++ return d3_time_formatPad(d.getDate(), p, 2); ++ }, ++ e: function(d, p) { ++ return d3_time_formatPad(d.getDate(), p, 2); ++ }, ++ H: function(d, p) { ++ return d3_time_formatPad(d.getHours(), p, 2); ++ }, ++ I: function(d, p) { ++ return d3_time_formatPad(d.getHours() % 12 || 12, p, 2); ++ }, ++ j: function(d, p) { ++ return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3); ++ }, ++ L: function(d, p) { ++ return d3_time_formatPad(d.getMilliseconds(), p, 3); ++ }, ++ m: function(d, p) { ++ return d3_time_formatPad(d.getMonth() + 1, p, 2); ++ }, ++ M: function(d, p) { ++ return d3_time_formatPad(d.getMinutes(), p, 2); ++ }, ++ p: function(d) { ++ return locale_periods[+(d.getHours() >= 12)]; ++ }, ++ S: function(d, p) { ++ return d3_time_formatPad(d.getSeconds(), p, 2); ++ }, ++ U: function(d, p) { ++ return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2); ++ }, ++ w: function(d) { ++ return d.getDay(); ++ }, ++ W: function(d, p) { ++ return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2); ++ }, ++ x: d3_time_format(locale_date), ++ X: d3_time_format(locale_time), ++ y: function(d, p) { ++ return d3_time_formatPad(d.getFullYear() % 100, p, 2); ++ }, ++ Y: function(d, p) { ++ return d3_time_formatPad(d.getFullYear() % 1e4, p, 4); ++ }, ++ Z: d3_time_zone, ++ "%": function() { ++ return "%"; ++ } ++ }; ++ var d3_time_parsers = { ++ a: d3_time_parseWeekdayAbbrev, ++ A: d3_time_parseWeekday, ++ b: d3_time_parseMonthAbbrev, ++ B: d3_time_parseMonth, ++ c: d3_time_parseLocaleFull, ++ d: d3_time_parseDay, ++ e: d3_time_parseDay, ++ H: d3_time_parseHour24, ++ I: d3_time_parseHour24, ++ j: d3_time_parseDayOfYear, ++ L: d3_time_parseMilliseconds, ++ m: d3_time_parseMonthNumber, ++ M: d3_time_parseMinutes, ++ p: d3_time_parseAmPm, ++ S: d3_time_parseSeconds, ++ U: d3_time_parseWeekNumberSunday, ++ w: d3_time_parseWeekdayNumber, ++ W: d3_time_parseWeekNumberMonday, ++ x: d3_time_parseLocaleDate, ++ X: d3_time_parseLocaleTime, ++ y: d3_time_parseYear, ++ Y: d3_time_parseFullYear, ++ Z: d3_time_parseZone, ++ "%": d3_time_parseLiteralPercent ++ }; ++ function d3_time_parseWeekdayAbbrev(date, string, i) { ++ d3_time_dayAbbrevRe.lastIndex = 0; ++ var n = d3_time_dayAbbrevRe.exec(string.slice(i)); ++ return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; ++ } ++ function d3_time_parseWeekday(date, string, i) { ++ d3_time_dayRe.lastIndex = 0; ++ var n = d3_time_dayRe.exec(string.slice(i)); ++ return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; ++ } ++ function d3_time_parseMonthAbbrev(date, string, i) { ++ d3_time_monthAbbrevRe.lastIndex = 0; ++ var n = d3_time_monthAbbrevRe.exec(string.slice(i)); ++ return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; ++ } ++ function d3_time_parseMonth(date, string, i) { ++ d3_time_monthRe.lastIndex = 0; ++ var n = d3_time_monthRe.exec(string.slice(i)); ++ return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; ++ } ++ function d3_time_parseLocaleFull(date, string, i) { ++ return d3_time_parse(date, d3_time_formats.c.toString(), string, i); ++ } ++ function d3_time_parseLocaleDate(date, string, i) { ++ return d3_time_parse(date, d3_time_formats.x.toString(), string, i); ++ } ++ function d3_time_parseLocaleTime(date, string, i) { ++ return d3_time_parse(date, d3_time_formats.X.toString(), string, i); ++ } ++ function d3_time_parseAmPm(date, string, i) { ++ var n = d3_time_periodLookup.get(string.slice(i, i += 2).toLowerCase()); ++ return n == null ? -1 : (date.p = n, i); ++ } ++ return d3_time_format; ++ } ++ var d3_time_formatPads = { ++ "-": "", ++ _: " ", ++ "0": "0" ++ }, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/; ++ function d3_time_formatPad(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 d3_time_formatRe(names) { ++ return new RegExp("^(?:" + names.map(d3.requote).join("|") + ")", "i"); ++ } ++ function d3_time_formatLookup(names) { ++ var map = new d3_Map(), i = -1, n = names.length; ++ while (++i < n) map.set(names[i].toLowerCase(), i); ++ return map; ++ } ++ function d3_time_parseWeekdayNumber(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 1)); ++ return n ? (date.w = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseWeekNumberSunday(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i)); ++ return n ? (date.U = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseWeekNumberMonday(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i)); ++ return n ? (date.W = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseFullYear(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 4)); ++ return n ? (date.y = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseYear(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 2)); ++ return n ? (date.y = d3_time_expandYear(+n[0]), i + n[0].length) : -1; ++ } ++ function d3_time_parseZone(date, string, i) { ++ return /^[+-]\d{4}$/.test(string = string.slice(i, i + 5)) ? (date.Z = -string, ++ i + 5) : -1; ++ } ++ function d3_time_expandYear(d) { ++ return d + (d > 68 ? 1900 : 2e3); ++ } ++ function d3_time_parseMonthNumber(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 2)); ++ return n ? (date.m = n[0] - 1, i + n[0].length) : -1; ++ } ++ function d3_time_parseDay(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 2)); ++ return n ? (date.d = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseDayOfYear(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 3)); ++ return n ? (date.j = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseHour24(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 2)); ++ return n ? (date.H = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseMinutes(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 2)); ++ return n ? (date.M = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseSeconds(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 2)); ++ return n ? (date.S = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_parseMilliseconds(date, string, i) { ++ d3_time_numberRe.lastIndex = 0; ++ var n = d3_time_numberRe.exec(string.slice(i, i + 3)); ++ return n ? (date.L = +n[0], i + n[0].length) : -1; ++ } ++ function d3_time_zone(d) { ++ var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = abs(z) / 60 | 0, zm = abs(z) % 60; ++ return zs + d3_time_formatPad(zh, "0", 2) + d3_time_formatPad(zm, "0", 2); ++ } ++ function d3_time_parseLiteralPercent(date, string, i) { ++ d3_time_percentRe.lastIndex = 0; ++ var n = d3_time_percentRe.exec(string.slice(i, i + 1)); ++ return n ? i + n[0].length : -1; ++ } ++ function d3_time_formatMulti(formats) { ++ var n = formats.length, i = -1; ++ while (++i < n) formats[i][0] = this(formats[i][0]); ++ return function(date) { ++ var i = 0, f = formats[i]; ++ while (!f[1](date)) f = formats[++i]; ++ return f[0](date); ++ }; ++ } ++ d3.locale = function(locale) { ++ return { ++ numberFormat: d3_locale_numberFormat(locale), ++ timeFormat: d3_locale_timeFormat(locale) ++ }; ++ }; ++ var d3_locale_enUS = d3.locale({ ++ decimal: ".", ++ thousands: ",", ++ grouping: [ 3 ], ++ currency: [ "$", "" ], ++ dateTime: "%a %b %e %X %Y", ++ date: "%m/%d/%Y", ++ time: "%H:%M:%S", ++ 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" ] ++ }); ++ d3.format = d3_locale_enUS.numberFormat; ++ d3.geo = {}; ++ function d3_adder() {} ++ d3_adder.prototype = { ++ s: 0, ++ t: 0, ++ add: function(y) { ++ d3_adderSum(y, this.t, d3_adderTemp); ++ d3_adderSum(d3_adderTemp.s, this.s, this); ++ if (this.s) this.t += d3_adderTemp.t; else this.s = d3_adderTemp.t; ++ }, ++ reset: function() { ++ this.s = this.t = 0; ++ }, ++ valueOf: function() { ++ return this.s; ++ } ++ }; ++ var d3_adderTemp = new d3_adder(); ++ function d3_adderSum(a, b, o) { ++ var x = o.s = a + b, bv = x - a, av = x - bv; ++ o.t = a - av + (b - bv); ++ } ++ d3.geo.stream = function(object, listener) { ++ if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) { ++ d3_geo_streamObjectType[object.type](object, listener); ++ } else { ++ d3_geo_streamGeometry(object, listener); ++ } ++ }; ++ function d3_geo_streamGeometry(geometry, listener) { ++ if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) { ++ d3_geo_streamGeometryType[geometry.type](geometry, listener); ++ } ++ } ++ var d3_geo_streamObjectType = { ++ Feature: function(feature, listener) { ++ d3_geo_streamGeometry(feature.geometry, listener); ++ }, ++ FeatureCollection: function(object, listener) { ++ var features = object.features, i = -1, n = features.length; ++ while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener); ++ } ++ }; ++ var d3_geo_streamGeometryType = { ++ Sphere: function(object, listener) { ++ listener.sphere(); ++ }, ++ Point: function(object, listener) { ++ object = object.coordinates; ++ listener.point(object[0], object[1], object[2]); ++ }, ++ MultiPoint: function(object, listener) { ++ var coordinates = object.coordinates, i = -1, n = coordinates.length; ++ while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]); ++ }, ++ LineString: function(object, listener) { ++ d3_geo_streamLine(object.coordinates, listener, 0); ++ }, ++ MultiLineString: function(object, listener) { ++ var coordinates = object.coordinates, i = -1, n = coordinates.length; ++ while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0); ++ }, ++ Polygon: function(object, listener) { ++ d3_geo_streamPolygon(object.coordinates, listener); ++ }, ++ MultiPolygon: function(object, listener) { ++ var coordinates = object.coordinates, i = -1, n = coordinates.length; ++ while (++i < n) d3_geo_streamPolygon(coordinates[i], listener); ++ }, ++ GeometryCollection: function(object, listener) { ++ var geometries = object.geometries, i = -1, n = geometries.length; ++ while (++i < n) d3_geo_streamGeometry(geometries[i], listener); ++ } ++ }; ++ function d3_geo_streamLine(coordinates, listener, closed) { ++ var i = -1, n = coordinates.length - closed, coordinate; ++ listener.lineStart(); ++ while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]); ++ listener.lineEnd(); ++ } ++ function d3_geo_streamPolygon(coordinates, listener) { ++ var i = -1, n = coordinates.length; ++ listener.polygonStart(); ++ while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1); ++ listener.polygonEnd(); ++ } ++ d3.geo.area = function(object) { ++ d3_geo_areaSum = 0; ++ d3.geo.stream(object, d3_geo_area); ++ return d3_geo_areaSum; ++ }; ++ var d3_geo_areaSum, d3_geo_areaRingSum = new d3_adder(); ++ var d3_geo_area = { ++ sphere: function() { ++ d3_geo_areaSum += 4 * π; ++ }, ++ point: d3_noop, ++ lineStart: d3_noop, ++ lineEnd: d3_noop, ++ polygonStart: function() { ++ d3_geo_areaRingSum.reset(); ++ d3_geo_area.lineStart = d3_geo_areaRingStart; ++ }, ++ polygonEnd: function() { ++ var area = 2 * d3_geo_areaRingSum; ++ d3_geo_areaSum += area < 0 ? 4 * π + area : area; ++ d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop; ++ } ++ }; ++ function d3_geo_areaRingStart() { ++ var λ00, φ00, λ0, cosφ0, sinφ0; ++ d3_geo_area.point = function(λ, φ) { ++ d3_geo_area.point = nextPoint; ++ λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), ++ sinφ0 = Math.sin(φ); ++ }; ++ function nextPoint(λ, φ) { ++ λ *= d3_radians; ++ φ = φ * d3_radians / 2 + π / 4; ++ var dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u = cosφ0 * cosφ + k * Math.cos(adλ), v = k * sdλ * Math.sin(adλ); ++ d3_geo_areaRingSum.add(Math.atan2(v, u)); ++ λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ; ++ } ++ d3_geo_area.lineEnd = function() { ++ nextPoint(λ00, φ00); ++ }; ++ } ++ function d3_geo_cartesian(spherical) { ++ var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ); ++ return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ]; ++ } ++ function d3_geo_cartesianDot(a, b) { ++ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; ++ } ++ function d3_geo_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] ]; ++ } ++ function d3_geo_cartesianAdd(a, b) { ++ a[0] += b[0]; ++ a[1] += b[1]; ++ a[2] += b[2]; ++ } ++ function d3_geo_cartesianScale(vector, k) { ++ return [ vector[0] * k, vector[1] * k, vector[2] * k ]; ++ } ++ function d3_geo_cartesianNormalize(d) { ++ var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]); ++ d[0] /= l; ++ d[1] /= l; ++ d[2] /= l; ++ } ++ function d3_geo_spherical(cartesian) { ++ return [ Math.atan2(cartesian[1], cartesian[0]), d3_asin(cartesian[2]) ]; ++ } ++ function d3_geo_sphericalEqual(a, b) { ++ return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε; ++ } ++ d3.geo.bounds = function() { ++ var λ0, φ0, λ1, φ1, λ_, λ__, φ__, p0, dλSum, ranges, range; ++ var bound = { ++ point: point, ++ lineStart: lineStart, ++ lineEnd: lineEnd, ++ polygonStart: function() { ++ bound.point = ringPoint; ++ bound.lineStart = ringStart; ++ bound.lineEnd = ringEnd; ++ dλSum = 0; ++ d3_geo_area.polygonStart(); ++ }, ++ polygonEnd: function() { ++ d3_geo_area.polygonEnd(); ++ bound.point = point; ++ bound.lineStart = lineStart; ++ bound.lineEnd = lineEnd; ++ if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90); else if (dλSum > ε) φ1 = 90; else if (dλSum < -ε) φ0 = -90; ++ range[0] = λ0, range[1] = λ1; ++ } ++ }; ++ function point(λ, φ) { ++ ranges.push(range = [ λ0 = λ, λ1 = λ ]); ++ if (φ < φ0) φ0 = φ; ++ if (φ > φ1) φ1 = φ; ++ } ++ function linePoint(λ, φ) { ++ var p = d3_geo_cartesian([ λ * d3_radians, φ * d3_radians ]); ++ if (p0) { ++ var normal = d3_geo_cartesianCross(p0, p), equatorial = [ normal[1], -normal[0], 0 ], inflection = d3_geo_cartesianCross(equatorial, normal); ++ d3_geo_cartesianNormalize(inflection); ++ inflection = d3_geo_spherical(inflection); ++ var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, antimeridian = abs(dλ) > 180; ++ if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) { ++ var φi = inflection[1] * d3_degrees; ++ if (φi > φ1) φ1 = φi; ++ } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) { ++ var φi = -inflection[1] * d3_degrees; ++ if (φi < φ0) φ0 = φi; ++ } else { ++ if (φ < φ0) φ0 = φ; ++ if (φ > φ1) φ1 = φ; ++ } ++ if (antimeridian) { ++ if (λ < λ_) { ++ if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ; ++ } else { ++ if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ; ++ } ++ } else { ++ if (λ1 >= λ0) { ++ if (λ < λ0) λ0 = λ; ++ if (λ > λ1) λ1 = λ; ++ } else { ++ if (λ > λ_) { ++ if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ; ++ } else { ++ if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ; ++ } ++ } ++ } ++ } else { ++ point(λ, φ); ++ } ++ p0 = p, λ_ = λ; ++ } ++ function lineStart() { ++ bound.point = linePoint; ++ } ++ function lineEnd() { ++ range[0] = λ0, range[1] = λ1; ++ bound.point = point; ++ p0 = null; ++ } ++ function ringPoint(λ, φ) { ++ if (p0) { ++ var dλ = λ - λ_; ++ dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ; ++ } else λ__ = λ, φ__ = φ; ++ d3_geo_area.point(λ, φ); ++ linePoint(λ, φ); ++ } ++ function ringStart() { ++ d3_geo_area.lineStart(); ++ } ++ function ringEnd() { ++ ringPoint(λ__, φ__); ++ d3_geo_area.lineEnd(); ++ if (abs(dλSum) > ε) λ0 = -(λ1 = 180); ++ range[0] = λ0, range[1] = λ1; ++ p0 = null; ++ } ++ function angle(λ0, λ1) { ++ return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1; ++ } ++ function compareRanges(a, b) { ++ return a[0] - b[0]; ++ } ++ function withinRange(x, range) { ++ return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x; ++ } ++ return function(feature) { ++ φ1 = λ1 = -(λ0 = φ0 = Infinity); ++ ranges = []; ++ d3.geo.stream(feature, bound); ++ var n = ranges.length; ++ if (n) { ++ ranges.sort(compareRanges); ++ for (var i = 1, a = ranges[0], b, merged = [ a ]; i < n; ++i) { ++ b = ranges[i]; ++ if (withinRange(b[0], a) || withinRange(b[1], a)) { ++ 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); ++ } ++ } ++ var best = -Infinity, dλ; ++ for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) { ++ b = merged[i]; ++ if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1]; ++ } ++ } ++ ranges = range = null; ++ return λ0 === Infinity || φ0 === Infinity ? [ [ NaN, NaN ], [ NaN, NaN ] ] : [ [ λ0, φ0 ], [ λ1, φ1 ] ]; ++ }; ++ }(); ++ d3.geo.centroid = function(object) { ++ d3_geo_centroidW0 = d3_geo_centroidW1 = d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0; ++ d3.geo.stream(object, d3_geo_centroid); ++ var x = d3_geo_centroidX2, y = d3_geo_centroidY2, z = d3_geo_centroidZ2, m = x * x + y * y + z * z; ++ if (m < ε2) { ++ x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1; ++ if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0; ++ m = x * x + y * y + z * z; ++ if (m < ε2) return [ NaN, NaN ]; ++ } ++ return [ Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees ]; ++ }; ++ var d3_geo_centroidW0, d3_geo_centroidW1, d3_geo_centroidX0, d3_geo_centroidY0, d3_geo_centroidZ0, d3_geo_centroidX1, d3_geo_centroidY1, d3_geo_centroidZ1, d3_geo_centroidX2, d3_geo_centroidY2, d3_geo_centroidZ2; ++ var d3_geo_centroid = { ++ sphere: d3_noop, ++ point: d3_geo_centroidPoint, ++ lineStart: d3_geo_centroidLineStart, ++ lineEnd: d3_geo_centroidLineEnd, ++ polygonStart: function() { ++ d3_geo_centroid.lineStart = d3_geo_centroidRingStart; ++ }, ++ polygonEnd: function() { ++ d3_geo_centroid.lineStart = d3_geo_centroidLineStart; ++ } ++ }; ++ function d3_geo_centroidPoint(λ, φ) { ++ λ *= d3_radians; ++ var cosφ = Math.cos(φ *= d3_radians); ++ d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ)); ++ } ++ function d3_geo_centroidPointXYZ(x, y, z) { ++ ++d3_geo_centroidW0; ++ d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0; ++ d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0; ++ d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0; ++ } ++ function d3_geo_centroidLineStart() { ++ var x0, y0, z0; ++ d3_geo_centroid.point = function(λ, φ) { ++ λ *= d3_radians; ++ var cosφ = Math.cos(φ *= d3_radians); ++ x0 = cosφ * Math.cos(λ); ++ y0 = cosφ * Math.sin(λ); ++ z0 = Math.sin(φ); ++ d3_geo_centroid.point = nextPoint; ++ d3_geo_centroidPointXYZ(x0, y0, z0); ++ }; ++ function nextPoint(λ, φ) { ++ λ *= d3_radians; ++ var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z); ++ d3_geo_centroidW1 += w; ++ d3_geo_centroidX1 += w * (x0 + (x0 = x)); ++ d3_geo_centroidY1 += w * (y0 + (y0 = y)); ++ d3_geo_centroidZ1 += w * (z0 + (z0 = z)); ++ d3_geo_centroidPointXYZ(x0, y0, z0); ++ } ++ } ++ function d3_geo_centroidLineEnd() { ++ d3_geo_centroid.point = d3_geo_centroidPoint; ++ } ++ function d3_geo_centroidRingStart() { ++ var λ00, φ00, x0, y0, z0; ++ d3_geo_centroid.point = function(λ, φ) { ++ λ00 = λ, φ00 = φ; ++ d3_geo_centroid.point = nextPoint; ++ λ *= d3_radians; ++ var cosφ = Math.cos(φ *= d3_radians); ++ x0 = cosφ * Math.cos(λ); ++ y0 = cosφ * Math.sin(λ); ++ z0 = Math.sin(φ); ++ d3_geo_centroidPointXYZ(x0, y0, z0); ++ }; ++ d3_geo_centroid.lineEnd = function() { ++ nextPoint(λ00, φ00); ++ d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd; ++ d3_geo_centroid.point = d3_geo_centroidPoint; ++ }; ++ function nextPoint(λ, φ) { ++ λ *= d3_radians; ++ var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = Math.sqrt(cx * cx + cy * cy + cz * cz), u = x0 * x + y0 * y + z0 * z, v = m && -d3_acos(u) / m, w = Math.atan2(m, u); ++ d3_geo_centroidX2 += v * cx; ++ d3_geo_centroidY2 += v * cy; ++ d3_geo_centroidZ2 += v * cz; ++ d3_geo_centroidW1 += w; ++ d3_geo_centroidX1 += w * (x0 + (x0 = x)); ++ d3_geo_centroidY1 += w * (y0 + (y0 = y)); ++ d3_geo_centroidZ1 += w * (z0 + (z0 = z)); ++ d3_geo_centroidPointXYZ(x0, y0, z0); ++ } ++ } ++ function d3_geo_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 d3_true() { ++ return true; ++ } ++ function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) { ++ var subject = [], clip = []; ++ segments.forEach(function(segment) { ++ if ((n = segment.length - 1) <= 0) return; ++ var n, p0 = segment[0], p1 = segment[n]; ++ if (d3_geo_sphericalEqual(p0, p1)) { ++ listener.lineStart(); ++ for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]); ++ listener.lineEnd(); ++ return; ++ } ++ var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), b = new d3_geo_clipPolygonIntersection(p0, null, a, false); ++ a.o = b; ++ subject.push(a); ++ clip.push(b); ++ a = new d3_geo_clipPolygonIntersection(p1, segment, null, false); ++ b = new d3_geo_clipPolygonIntersection(p1, null, a, true); ++ a.o = b; ++ subject.push(a); ++ clip.push(b); ++ }); ++ clip.sort(compare); ++ d3_geo_clipPolygonLinkCircular(subject); ++ d3_geo_clipPolygonLinkCircular(clip); ++ if (!subject.length) return; ++ for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) { ++ clip[i].e = entry = !entry; ++ } ++ var start = subject[0], points, point; ++ while (1) { ++ var current = start, isSubject = true; ++ while (current.v) if ((current = current.n) === start) return; ++ points = current.z; ++ listener.lineStart(); ++ do { ++ current.v = current.o.v = true; ++ if (current.e) { ++ if (isSubject) { ++ for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]); ++ } else { ++ interpolate(current.x, current.n.x, 1, listener); ++ } ++ current = current.n; ++ } else { ++ if (isSubject) { ++ points = current.p.z; ++ for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]); ++ } else { ++ interpolate(current.x, current.p.x, -1, listener); ++ } ++ current = current.p; ++ } ++ current = current.o; ++ points = current.z; ++ isSubject = !isSubject; ++ } while (!current.v); ++ listener.lineEnd(); ++ } ++ } ++ function d3_geo_clipPolygonLinkCircular(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 d3_geo_clipPolygonIntersection(point, points, other, entry) { ++ this.x = point; ++ this.z = points; ++ this.o = other; ++ this.e = entry; ++ this.v = false; ++ this.n = this.p = null; ++ } ++ function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) { ++ return function(rotate, listener) { ++ var line = clipLine(listener), rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]); ++ 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 = d3.merge(segments); ++ var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon); ++ if (segments.length) { ++ if (!polygonStarted) listener.polygonStart(), polygonStarted = true; ++ d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener); ++ } else if (clipStartInside) { ++ if (!polygonStarted) listener.polygonStart(), polygonStarted = true; ++ listener.lineStart(); ++ interpolate(null, null, 1, listener); ++ listener.lineEnd(); ++ } ++ if (polygonStarted) listener.polygonEnd(), polygonStarted = false; ++ segments = polygon = null; ++ }, ++ sphere: function() { ++ listener.polygonStart(); ++ listener.lineStart(); ++ interpolate(null, null, 1, listener); ++ listener.lineEnd(); ++ listener.polygonEnd(); ++ } ++ }; ++ function point(λ, φ) { ++ var point = rotate(λ, φ); ++ if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ); ++ } ++ function pointLine(λ, φ) { ++ var point = rotate(λ, φ); ++ line.point(point[0], point[1]); ++ } ++ function lineStart() { ++ clip.point = pointLine; ++ line.lineStart(); ++ } ++ function lineEnd() { ++ clip.point = point; ++ line.lineEnd(); ++ } ++ var segments; ++ var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), polygonStarted = false, polygon, ring; ++ function pointRing(λ, φ) { ++ ring.push([ λ, φ ]); ++ var point = rotate(λ, φ); ++ ringListener.point(point[0], point[1]); ++ } ++ function ringStart() { ++ ringListener.lineStart(); ++ ring = []; ++ } ++ function ringEnd() { ++ pointRing(ring[0][0], ring[0][1]); ++ ringListener.lineEnd(); ++ var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length; ++ ring.pop(); ++ polygon.push(ring); ++ ring = null; ++ if (!n) return; ++ if (clean & 1) { ++ segment = ringSegments[0]; ++ var n = segment.length - 1, i = -1, point; ++ if (n > 0) { ++ if (!polygonStarted) listener.polygonStart(), polygonStarted = true; ++ listener.lineStart(); ++ while (++i < n) listener.point((point = segment[i])[0], point[1]); ++ listener.lineEnd(); ++ } ++ return; ++ } ++ if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift())); ++ segments.push(ringSegments.filter(d3_geo_clipSegmentLength1)); ++ } ++ return clip; ++ }; ++ } ++ function d3_geo_clipSegmentLength1(segment) { ++ return segment.length > 1; ++ } ++ function d3_geo_clipBufferListener() { ++ var lines = [], line; ++ return { ++ lineStart: function() { ++ lines.push(line = []); ++ }, ++ point: function(λ, φ) { ++ line.push([ λ, φ ]); ++ }, ++ lineEnd: d3_noop, ++ buffer: function() { ++ var buffer = lines; ++ lines = []; ++ line = null; ++ return buffer; ++ }, ++ rejoin: function() { ++ if (lines.length > 1) lines.push(lines.pop().concat(lines.shift())); ++ } ++ }; ++ } ++ function d3_geo_clipSort(a, b) { ++ return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]); ++ } ++ var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate, [ -π, -π / 2 ]); ++ function d3_geo_clipAntimeridianLine(listener) { ++ var λ0 = NaN, φ0 = NaN, sλ0 = NaN, clean; ++ return { ++ lineStart: function() { ++ listener.lineStart(); ++ clean = 1; ++ }, ++ point: function(λ1, φ1) { ++ var sλ1 = λ1 > 0 ? π : -π, dλ = abs(λ1 - λ0); ++ if (abs(dλ - π) < ε) { ++ listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ); ++ listener.point(sλ0, φ0); ++ listener.lineEnd(); ++ listener.lineStart(); ++ listener.point(sλ1, φ0); ++ listener.point(λ1, φ0); ++ clean = 0; ++ } else if (sλ0 !== sλ1 && dλ >= π) { ++ if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε; ++ if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε; ++ φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1); ++ listener.point(sλ0, φ0); ++ listener.lineEnd(); ++ listener.lineStart(); ++ listener.point(sλ1, φ0); ++ clean = 0; ++ } ++ listener.point(λ0 = λ1, φ0 = φ1); ++ sλ0 = sλ1; ++ }, ++ lineEnd: function() { ++ listener.lineEnd(); ++ λ0 = φ0 = NaN; ++ }, ++ clean: function() { ++ return 2 - clean; ++ } ++ }; ++ } ++ function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) { ++ var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1); ++ return abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) : (φ0 + φ1) / 2; ++ } ++ function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) { ++ var φ; ++ if (from == null) { ++ φ = direction * halfπ; ++ listener.point(-π, φ); ++ listener.point(0, φ); ++ listener.point(π, φ); ++ listener.point(π, 0); ++ listener.point(π, -φ); ++ listener.point(0, -φ); ++ listener.point(-π, -φ); ++ listener.point(-π, 0); ++ listener.point(-π, φ); ++ } else if (abs(from[0] - to[0]) > ε) { ++ var s = from[0] < to[0] ? π : -π; ++ φ = direction * s / 2; ++ listener.point(-s, φ); ++ listener.point(0, φ); ++ listener.point(s, φ); ++ } else { ++ listener.point(to[0], to[1]); ++ } ++ } ++ function d3_geo_pointInPolygon(point, polygon) { ++ var meridian = point[0], parallel = point[1], meridianNormal = [ Math.sin(meridian), -Math.cos(meridian), 0 ], polarAngle = 0, winding = 0; ++ d3_geo_areaRingSum.reset(); ++ for (var i = 0, n = polygon.length; i < n; ++i) { ++ var ring = polygon[i], m = ring.length; ++ if (!m) continue; ++ var point0 = ring[0], λ0 = point0[0], φ0 = point0[1] / 2 + π / 4, sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), j = 1; ++ while (true) { ++ if (j === m) j = 0; ++ point = ring[j]; ++ var λ = point[0], φ = point[1] / 2 + π / 4, sinφ = Math.sin(φ), cosφ = Math.cos(φ), dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, antimeridian = adλ > π, k = sinφ0 * sinφ; ++ d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ))); ++ polarAngle += antimeridian ? dλ + sdλ * τ : dλ; ++ if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) { ++ var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point)); ++ d3_geo_cartesianNormalize(arc); ++ var intersection = d3_geo_cartesianCross(meridianNormal, arc); ++ d3_geo_cartesianNormalize(intersection); ++ var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]); ++ if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) { ++ winding += antimeridian ^ dλ >= 0 ? 1 : -1; ++ } ++ } ++ if (!j++) break; ++ λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point; ++ } ++ } ++ return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < -ε) ^ winding & 1; ++ } ++ function d3_geo_clipCircle(radius) { ++ var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians); ++ return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [ 0, -radius ] : [ -π, radius - π ]); ++ function visible(λ, φ) { ++ return Math.cos(λ) * Math.cos(φ) > cr; ++ } ++ function clipLine(listener) { ++ var point0, c0, v0, v00, clean; ++ return { ++ lineStart: function() { ++ v00 = v0 = false; ++ clean = 1; ++ }, ++ point: function(λ, φ) { ++ var point1 = [ λ, φ ], point2, v = visible(λ, φ), c = smallRadius ? v ? 0 : code(λ, φ) : v ? code(λ + (λ < 0 ? π : -π), φ) : 0; ++ if (!point0 && (v00 = v0 = v)) listener.lineStart(); ++ if (v !== v0) { ++ point2 = intersect(point0, point1); ++ if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) { ++ point1[0] += ε; ++ point1[1] += ε; ++ v = visible(point1[0], point1[1]); ++ } ++ } ++ if (v !== v0) { ++ clean = 0; ++ if (v) { ++ listener.lineStart(); ++ point2 = intersect(point1, point0); ++ listener.point(point2[0], point2[1]); ++ } else { ++ point2 = intersect(point0, point1); ++ listener.point(point2[0], point2[1]); ++ listener.lineEnd(); ++ } ++ point0 = point2; ++ } else if (notHemisphere && point0 && smallRadius ^ v) { ++ var t; ++ if (!(c & c0) && (t = intersect(point1, point0, true))) { ++ clean = 0; ++ if (smallRadius) { ++ listener.lineStart(); ++ listener.point(t[0][0], t[0][1]); ++ listener.point(t[1][0], t[1][1]); ++ listener.lineEnd(); ++ } else { ++ listener.point(t[1][0], t[1][1]); ++ listener.lineEnd(); ++ listener.lineStart(); ++ listener.point(t[0][0], t[0][1]); ++ } ++ } ++ } ++ if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) { ++ listener.point(point1[0], point1[1]); ++ } ++ point0 = point1, v0 = v, c0 = c; ++ }, ++ lineEnd: function() { ++ if (v0) listener.lineEnd(); ++ point0 = null; ++ }, ++ clean: function() { ++ return clean | (v00 && v0) << 1; ++ } ++ }; ++ } ++ function intersect(a, b, two) { ++ var pa = d3_geo_cartesian(a), pb = d3_geo_cartesian(b); ++ var n1 = [ 1, 0, 0 ], n2 = d3_geo_cartesianCross(pa, pb), n2n2 = d3_geo_cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2; ++ if (!determinant) return !two && a; ++ var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = d3_geo_cartesianCross(n1, n2), A = d3_geo_cartesianScale(n1, c1), B = d3_geo_cartesianScale(n2, c2); ++ d3_geo_cartesianAdd(A, B); ++ var u = n1xn2, w = d3_geo_cartesianDot(A, u), uu = d3_geo_cartesianDot(u, u), t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1); ++ if (t2 < 0) return; ++ var t = Math.sqrt(t2), q = d3_geo_cartesianScale(u, (-w - t) / uu); ++ d3_geo_cartesianAdd(q, A); ++ q = d3_geo_spherical(q); ++ if (!two) return q; ++ var λ0 = a[0], λ1 = b[0], φ0 = a[1], φ1 = b[1], z; ++ if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z; ++ var δλ = λ1 - λ0, polar = abs(δλ - π) < ε, meridian = polar || δλ < ε; ++ if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z; ++ if (meridian ? polar ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) { ++ var q1 = d3_geo_cartesianScale(u, (-w + t) / uu); ++ d3_geo_cartesianAdd(q1, A); ++ return [ q, d3_geo_spherical(q1) ]; ++ } ++ } ++ function code(λ, φ) { ++ var r = smallRadius ? radius : π - radius, code = 0; ++ if (λ < -r) code |= 1; else if (λ > r) code |= 2; ++ if (φ < -r) code |= 4; else if (φ > r) code |= 8; ++ return code; ++ } ++ } ++ function d3_geom_clipLine(x0, y0, x1, y1) { ++ return function(line) { ++ var a = line.a, b = line.b, ax = a.x, ay = a.y, bx = b.x, by = b.y, 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) line.a = { ++ x: ax + t0 * dx, ++ y: ay + t0 * dy ++ }; ++ if (t1 < 1) line.b = { ++ x: ax + t1 * dx, ++ y: ay + t1 * dy ++ }; ++ return line; ++ }; ++ } ++ var d3_geo_clipExtentMAX = 1e9; ++ d3.geo.clipExtent = function() { ++ var x0, y0, x1, y1, stream, clip, clipExtent = { ++ stream: function(output) { ++ if (stream) stream.valid = false; ++ stream = clip(output); ++ stream.valid = true; ++ return stream; ++ }, ++ extent: function(_) { ++ if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ]; ++ clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]); ++ if (stream) stream.valid = false, stream = null; ++ return clipExtent; ++ } ++ }; ++ return clipExtent.extent([ [ 0, 0 ], [ 960, 500 ] ]); ++ }; ++ function d3_geo_clipExtent(x0, y0, x1, y1) { ++ return function(listener) { ++ var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), clipLine = d3_geom_clipLine(x0, y0, x1, y1), segments, polygon, ring; ++ var clip = { ++ point: point, ++ lineStart: lineStart, ++ lineEnd: lineEnd, ++ polygonStart: function() { ++ listener = bufferListener; ++ segments = []; ++ polygon = []; ++ clean = true; ++ }, ++ polygonEnd: function() { ++ listener = listener_; ++ segments = d3.merge(segments); ++ var clipStartInside = insidePolygon([ x0, y1 ]), inside = clean && clipStartInside, visible = segments.length; ++ if (inside || visible) { ++ listener.polygonStart(); ++ if (inside) { ++ listener.lineStart(); ++ interpolate(null, null, 1, listener); ++ listener.lineEnd(); ++ } ++ if (visible) { ++ d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener); ++ } ++ listener.polygonEnd(); ++ } ++ segments = polygon = ring = null; ++ } ++ }; ++ function insidePolygon(p) { ++ var wn = 0, n = polygon.length, y = p[1]; ++ for (var i = 0; i < n; ++i) { ++ for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) { ++ b = v[j]; ++ if (a[1] <= y) { ++ if (b[1] > y && d3_cross2d(a, b, p) > 0) ++wn; ++ } else { ++ if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn; ++ } ++ a = b; ++ } ++ } ++ return wn !== 0; ++ } ++ function interpolate(from, to, direction, listener) { ++ var a = 0, a1 = 0; ++ if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoints(from, to) < 0 ^ direction > 0) { ++ do { ++ listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0); ++ } while ((a = (a + direction + 4) % 4) !== a1); ++ } else { ++ listener.point(to[0], to[1]); ++ } ++ } ++ function pointVisible(x, y) { ++ return x0 <= x && x <= x1 && y0 <= y && y <= y1; ++ } ++ function point(x, y) { ++ if (pointVisible(x, y)) listener.point(x, y); ++ } ++ var x__, y__, v__, x_, y_, v_, first, clean; ++ function lineStart() { ++ clip.point = linePoint; ++ if (polygon) polygon.push(ring = []); ++ first = true; ++ v_ = false; ++ x_ = y_ = NaN; ++ } ++ function lineEnd() { ++ if (segments) { ++ linePoint(x__, y__); ++ if (v__ && v_) bufferListener.rejoin(); ++ segments.push(bufferListener.buffer()); ++ } ++ clip.point = point; ++ if (v_) listener.lineEnd(); ++ } ++ function linePoint(x, y) { ++ x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x)); ++ y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y)); ++ var v = pointVisible(x, y); ++ if (polygon) ring.push([ x, y ]); ++ if (first) { ++ x__ = x, y__ = y, v__ = v; ++ first = false; ++ if (v) { ++ listener.lineStart(); ++ listener.point(x, y); ++ } ++ } else { ++ if (v && v_) listener.point(x, y); else { ++ var l = { ++ a: { ++ x: x_, ++ y: y_ ++ }, ++ b: { ++ x: x, ++ y: y ++ } ++ }; ++ if (clipLine(l)) { ++ if (!v_) { ++ listener.lineStart(); ++ listener.point(l.a.x, l.a.y); ++ } ++ listener.point(l.b.x, l.b.y); ++ if (!v) listener.lineEnd(); ++ clean = false; ++ } else if (v) { ++ listener.lineStart(); ++ listener.point(x, y); ++ clean = false; ++ } ++ } ++ } ++ x_ = x, y_ = y, v_ = v; ++ } ++ return clip; ++ }; ++ function corner(p, direction) { ++ return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2; ++ } ++ function compare(a, b) { ++ return comparePoints(a.x, b.x); ++ } ++ function comparePoints(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]; ++ } ++ } ++ function d3_geo_conic(projectAt) { ++ var φ0 = 0, φ1 = π / 3, m = d3_geo_projectionMutator(projectAt), p = m(φ0, φ1); ++ p.parallels = function(_) { ++ if (!arguments.length) return [ φ0 / π * 180, φ1 / π * 180 ]; ++ return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180); ++ }; ++ return p; ++ } ++ function d3_geo_conicEqualArea(φ0, φ1) { ++ var sinφ0 = Math.sin(φ0), n = (sinφ0 + Math.sin(φ1)) / 2, C = 1 + sinφ0 * (2 * n - sinφ0), ρ0 = Math.sqrt(C) / n; ++ function forward(λ, φ) { ++ var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n; ++ return [ ρ * Math.sin(λ *= n), ρ0 - ρ * Math.cos(λ) ]; ++ } ++ forward.invert = function(x, y) { ++ var ρ0_y = ρ0 - y; ++ return [ Math.atan2(x, ρ0_y) / n, d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n)) ]; ++ }; ++ return forward; ++ } ++ (d3.geo.conicEqualArea = function() { ++ return d3_geo_conic(d3_geo_conicEqualArea); ++ }).raw = d3_geo_conicEqualArea; ++ d3.geo.albers = function() { ++ return d3.geo.conicEqualArea().rotate([ 96, 0 ]).center([ -.6, 38.7 ]).parallels([ 29.5, 45.5 ]).scale(1070); ++ }; ++ d3.geo.albersUsa = function() { ++ var lower48 = d3.geo.albers(); ++ var alaska = d3.geo.conicEqualArea().rotate([ 154, 0 ]).center([ -2, 58.5 ]).parallels([ 55, 65 ]); ++ var hawaii = d3.geo.conicEqualArea().rotate([ 157, 0 ]).center([ -3, 19.9 ]).parallels([ 8, 18 ]); ++ var point, pointStream = { ++ point: function(x, y) { ++ point = [ x, y ]; ++ } ++ }, lower48Point, alaskaPoint, hawaiiPoint; ++ function albersUsa(coordinates) { ++ var x = coordinates[0], y = coordinates[1]; ++ point = null; ++ (lower48Point(x, y), point) || (alaskaPoint(x, y), point) || hawaiiPoint(x, y); ++ return 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 >= .12 && y < .234 && x >= -.425 && x < -.214 ? alaska : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii : lower48).invert(coordinates); ++ }; ++ albersUsa.stream = function(stream) { ++ var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream); ++ return { ++ point: function(x, y) { ++ lower48Stream.point(x, y); ++ alaskaStream.point(x, y); ++ hawaiiStream.point(x, y); ++ }, ++ sphere: function() { ++ lower48Stream.sphere(); ++ alaskaStream.sphere(); ++ hawaiiStream.sphere(); ++ }, ++ lineStart: function() { ++ lower48Stream.lineStart(); ++ alaskaStream.lineStart(); ++ hawaiiStream.lineStart(); ++ }, ++ lineEnd: function() { ++ lower48Stream.lineEnd(); ++ alaskaStream.lineEnd(); ++ hawaiiStream.lineEnd(); ++ }, ++ polygonStart: function() { ++ lower48Stream.polygonStart(); ++ alaskaStream.polygonStart(); ++ hawaiiStream.polygonStart(); ++ }, ++ polygonEnd: function() { ++ lower48Stream.polygonEnd(); ++ alaskaStream.polygonEnd(); ++ hawaiiStream.polygonEnd(); ++ } ++ }; ++ }; ++ albersUsa.precision = function(_) { ++ if (!arguments.length) return lower48.precision(); ++ lower48.precision(_); ++ alaska.precision(_); ++ hawaii.precision(_); ++ return albersUsa; ++ }; ++ albersUsa.scale = function(_) { ++ if (!arguments.length) return lower48.scale(); ++ lower48.scale(_); ++ alaska.scale(_ * .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 - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point; ++ alaskaPoint = alaska.translate([ x - .307 * k, y + .201 * k ]).clipExtent([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point; ++ hawaiiPoint = hawaii.translate([ x - .205 * k, y + .212 * k ]).clipExtent([ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point; ++ return albersUsa; ++ }; ++ return albersUsa.scale(1070); ++ }; ++ var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = { ++ point: d3_noop, ++ lineStart: d3_noop, ++ lineEnd: d3_noop, ++ polygonStart: function() { ++ d3_geo_pathAreaPolygon = 0; ++ d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart; ++ }, ++ polygonEnd: function() { ++ d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop; ++ d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2); ++ } ++ }; ++ function d3_geo_pathAreaRingStart() { ++ var x00, y00, x0, y0; ++ d3_geo_pathArea.point = function(x, y) { ++ d3_geo_pathArea.point = nextPoint; ++ x00 = x0 = x, y00 = y0 = y; ++ }; ++ function nextPoint(x, y) { ++ d3_geo_pathAreaPolygon += y0 * x - x0 * y; ++ x0 = x, y0 = y; ++ } ++ d3_geo_pathArea.lineEnd = function() { ++ nextPoint(x00, y00); ++ }; ++ } ++ var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1; ++ var d3_geo_pathBounds = { ++ point: d3_geo_pathBoundsPoint, ++ lineStart: d3_noop, ++ lineEnd: d3_noop, ++ polygonStart: d3_noop, ++ polygonEnd: d3_noop ++ }; ++ function d3_geo_pathBoundsPoint(x, y) { ++ if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x; ++ if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x; ++ if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y; ++ if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y; ++ } ++ function d3_geo_pathBuffer() { ++ var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = []; ++ var stream = { ++ point: point, ++ lineStart: function() { ++ stream.point = pointLineStart; ++ }, ++ lineEnd: lineEnd, ++ polygonStart: function() { ++ stream.lineEnd = lineEndPolygon; ++ }, ++ polygonEnd: function() { ++ stream.lineEnd = lineEnd; ++ stream.point = point; ++ }, ++ pointRadius: function(_) { ++ pointCircle = d3_geo_pathBufferCircle(_); ++ return stream; ++ }, ++ result: function() { ++ if (buffer.length) { ++ var result = buffer.join(""); ++ buffer = []; ++ return result; ++ } ++ } ++ }; ++ function point(x, y) { ++ buffer.push("M", x, ",", y, pointCircle); ++ } ++ function pointLineStart(x, y) { ++ buffer.push("M", x, ",", y); ++ stream.point = pointLine; ++ } ++ function pointLine(x, y) { ++ buffer.push("L", x, ",", y); ++ } ++ function lineEnd() { ++ stream.point = point; ++ } ++ function lineEndPolygon() { ++ buffer.push("Z"); ++ } ++ return stream; ++ } ++ function d3_geo_pathBufferCircle(radius) { ++ return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z"; ++ } ++ var d3_geo_pathCentroid = { ++ point: d3_geo_pathCentroidPoint, ++ lineStart: d3_geo_pathCentroidLineStart, ++ lineEnd: d3_geo_pathCentroidLineEnd, ++ polygonStart: function() { ++ d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart; ++ }, ++ polygonEnd: function() { ++ d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint; ++ d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart; ++ d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd; ++ } ++ }; ++ function d3_geo_pathCentroidPoint(x, y) { ++ d3_geo_centroidX0 += x; ++ d3_geo_centroidY0 += y; ++ ++d3_geo_centroidZ0; ++ } ++ function d3_geo_pathCentroidLineStart() { ++ var x0, y0; ++ d3_geo_pathCentroid.point = function(x, y) { ++ d3_geo_pathCentroid.point = nextPoint; ++ d3_geo_pathCentroidPoint(x0 = x, y0 = y); ++ }; ++ function nextPoint(x, y) { ++ var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy); ++ d3_geo_centroidX1 += z * (x0 + x) / 2; ++ d3_geo_centroidY1 += z * (y0 + y) / 2; ++ d3_geo_centroidZ1 += z; ++ d3_geo_pathCentroidPoint(x0 = x, y0 = y); ++ } ++ } ++ function d3_geo_pathCentroidLineEnd() { ++ d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint; ++ } ++ function d3_geo_pathCentroidRingStart() { ++ var x00, y00, x0, y0; ++ d3_geo_pathCentroid.point = function(x, y) { ++ d3_geo_pathCentroid.point = nextPoint; ++ d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y); ++ }; ++ function nextPoint(x, y) { ++ var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy); ++ d3_geo_centroidX1 += z * (x0 + x) / 2; ++ d3_geo_centroidY1 += z * (y0 + y) / 2; ++ d3_geo_centroidZ1 += z; ++ z = y0 * x - x0 * y; ++ d3_geo_centroidX2 += z * (x0 + x); ++ d3_geo_centroidY2 += z * (y0 + y); ++ d3_geo_centroidZ2 += z * 3; ++ d3_geo_pathCentroidPoint(x0 = x, y0 = y); ++ } ++ d3_geo_pathCentroid.lineEnd = function() { ++ nextPoint(x00, y00); ++ }; ++ } ++ function d3_geo_pathContext(context) { ++ var pointRadius = 4.5; ++ var stream = { ++ point: point, ++ lineStart: function() { ++ stream.point = pointLineStart; ++ }, ++ lineEnd: lineEnd, ++ polygonStart: function() { ++ stream.lineEnd = lineEndPolygon; ++ }, ++ polygonEnd: function() { ++ stream.lineEnd = lineEnd; ++ stream.point = point; ++ }, ++ pointRadius: function(_) { ++ pointRadius = _; ++ return stream; ++ }, ++ result: d3_noop ++ }; ++ function point(x, y) { ++ context.moveTo(x + pointRadius, y); ++ context.arc(x, y, pointRadius, 0, τ); ++ } ++ function pointLineStart(x, y) { ++ context.moveTo(x, y); ++ stream.point = pointLine; ++ } ++ function pointLine(x, y) { ++ context.lineTo(x, y); ++ } ++ function lineEnd() { ++ stream.point = point; ++ } ++ function lineEndPolygon() { ++ context.closePath(); ++ } ++ return stream; ++ } ++ function d3_geo_resample(project) { ++ var δ2 = .5, cosMinDistance = Math.cos(30 * d3_radians), maxDepth = 16; ++ function resample(stream) { ++ return (maxDepth ? resampleRecursive : resampleNone)(stream); ++ } ++ function resampleNone(stream) { ++ return d3_geo_transformPoint(stream, function(x, y) { ++ x = project(x, y); ++ stream.point(x[0], x[1]); ++ }); ++ } ++ function resampleRecursive(stream) { ++ var λ00, φ00, x00, y00, a00, b00, c00, λ0, x0, y0, a0, b0, c0; ++ var resample = { ++ point: point, ++ lineStart: lineStart, ++ lineEnd: lineEnd, ++ polygonStart: function() { ++ stream.polygonStart(); ++ resample.lineStart = ringStart; ++ }, ++ polygonEnd: function() { ++ stream.polygonEnd(); ++ resample.lineStart = lineStart; ++ } ++ }; ++ function point(x, y) { ++ x = project(x, y); ++ stream.point(x[0], x[1]); ++ } ++ function lineStart() { ++ x0 = NaN; ++ resample.point = linePoint; ++ stream.lineStart(); ++ } ++ function linePoint(λ, φ) { ++ var c = d3_geo_cartesian([ λ, φ ]), p = project(λ, φ); ++ resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream); ++ stream.point(x0, y0); ++ } ++ function lineEnd() { ++ resample.point = point; ++ stream.lineEnd(); ++ } ++ function ringStart() { ++ lineStart(); ++ resample.point = ringPoint; ++ resample.lineEnd = ringEnd; ++ } ++ function ringPoint(λ, φ) { ++ linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0; ++ resample.point = linePoint; ++ } ++ function ringEnd() { ++ resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream); ++ resample.lineEnd = lineEnd; ++ lineEnd(); ++ } ++ return resample; ++ } ++ function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) { ++ var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy; ++ if (d2 > 4 * δ2 && depth--) { ++ var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = Math.sqrt(a * a + b * b + c * c), φ2 = Math.asin(c /= m), λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), p = project(λ2, φ2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2; ++ if (dz * dz / d2 > δ2 || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { ++ resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream); ++ stream.point(x2, y2); ++ resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream); ++ } ++ } ++ } ++ resample.precision = function(_) { ++ if (!arguments.length) return Math.sqrt(δ2); ++ maxDepth = (δ2 = _ * _) > 0 && 16; ++ return resample; ++ }; ++ return resample; ++ } ++ d3.geo.path = function() { ++ var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream; ++ function path(object) { ++ if (object) { ++ if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments)); ++ if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream); ++ d3.geo.stream(object, cacheStream); ++ } ++ return contextStream.result(); ++ } ++ path.area = function(object) { ++ d3_geo_pathAreaSum = 0; ++ d3.geo.stream(object, projectStream(d3_geo_pathArea)); ++ return d3_geo_pathAreaSum; ++ }; ++ path.centroid = function(object) { ++ d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0; ++ d3.geo.stream(object, projectStream(d3_geo_pathCentroid)); ++ return d3_geo_centroidZ2 ? [ d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2 ] : d3_geo_centroidZ1 ? [ d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1 ] : d3_geo_centroidZ0 ? [ d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0 ] : [ NaN, NaN ]; ++ }; ++ path.bounds = function(object) { ++ d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity); ++ d3.geo.stream(object, projectStream(d3_geo_pathBounds)); ++ return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ]; ++ }; ++ path.projection = function(_) { ++ if (!arguments.length) return projection; ++ projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity; ++ return reset(); ++ }; ++ path.context = function(_) { ++ if (!arguments.length) return context; ++ contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_); ++ if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius); ++ return reset(); ++ }; ++ path.pointRadius = function(_) { ++ if (!arguments.length) return pointRadius; ++ pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_); ++ return path; ++ }; ++ function reset() { ++ cacheStream = null; ++ return path; ++ } ++ return path.projection(d3.geo.albersUsa()).context(null); ++ }; ++ function d3_geo_pathProjectStream(project) { ++ var resample = d3_geo_resample(function(x, y) { ++ return project([ x * d3_degrees, y * d3_degrees ]); ++ }); ++ return function(stream) { ++ return d3_geo_projectionRadians(resample(stream)); ++ }; ++ } ++ d3.geo.transform = function(methods) { ++ return { ++ stream: function(stream) { ++ var transform = new d3_geo_transform(stream); ++ for (var k in methods) transform[k] = methods[k]; ++ return transform; ++ } ++ }; ++ }; ++ function d3_geo_transform(stream) { ++ this.stream = stream; ++ } ++ d3_geo_transform.prototype = { ++ 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 d3_geo_transformPoint(stream, point) { ++ return { ++ point: point, ++ sphere: function() { ++ stream.sphere(); ++ }, ++ lineStart: function() { ++ stream.lineStart(); ++ }, ++ lineEnd: function() { ++ stream.lineEnd(); ++ }, ++ polygonStart: function() { ++ stream.polygonStart(); ++ }, ++ polygonEnd: function() { ++ stream.polygonEnd(); ++ } ++ }; ++ } ++ d3.geo.projection = d3_geo_projection; ++ d3.geo.projectionMutator = d3_geo_projectionMutator; ++ function d3_geo_projection(project) { ++ return d3_geo_projectionMutator(function() { ++ return project; ++ })(); ++ } ++ function d3_geo_projectionMutator(projectAt) { ++ var project, rotate, projectRotate, projectResample = d3_geo_resample(function(x, y) { ++ x = project(x, y); ++ return [ x[0] * k + δx, δy - x[1] * k ]; ++ }), k = 150, x = 480, y = 250, λ = 0, φ = 0, δλ = 0, δφ = 0, δγ = 0, δx, δy, preclip = d3_geo_clipAntimeridian, postclip = d3_identity, clipAngle = null, clipExtent = null, stream; ++ function projection(point) { ++ point = projectRotate(point[0] * d3_radians, point[1] * d3_radians); ++ return [ point[0] * k + δx, δy - point[1] * k ]; ++ } ++ function invert(point) { ++ point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k); ++ return point && [ point[0] * d3_degrees, point[1] * d3_degrees ]; ++ } ++ projection.stream = function(output) { ++ if (stream) stream.valid = false; ++ stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output)))); ++ stream.valid = true; ++ return stream; ++ }; ++ projection.clipAngle = function(_) { ++ if (!arguments.length) return clipAngle; ++ preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians); ++ return invalidate(); ++ }; ++ projection.clipExtent = function(_) { ++ if (!arguments.length) return clipExtent; ++ clipExtent = _; ++ postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity; ++ return invalidate(); ++ }; ++ projection.scale = function(_) { ++ if (!arguments.length) return k; ++ k = +_; ++ return reset(); ++ }; ++ projection.translate = function(_) { ++ if (!arguments.length) return [ x, y ]; ++ x = +_[0]; ++ y = +_[1]; ++ return reset(); ++ }; ++ projection.center = function(_) { ++ if (!arguments.length) return [ λ * d3_degrees, φ * d3_degrees ]; ++ λ = _[0] % 360 * d3_radians; ++ φ = _[1] % 360 * d3_radians; ++ return reset(); ++ }; ++ projection.rotate = function(_) { ++ if (!arguments.length) return [ δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees ]; ++ δλ = _[0] % 360 * d3_radians; ++ δφ = _[1] % 360 * d3_radians; ++ δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0; ++ return reset(); ++ }; ++ d3.rebind(projection, projectResample, "precision"); ++ function reset() { ++ projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project); ++ var center = project(λ, φ); ++ δx = x - center[0] * k; ++ δy = y + center[1] * k; ++ return invalidate(); ++ } ++ function invalidate() { ++ if (stream) stream.valid = false, stream = null; ++ return projection; ++ } ++ return function() { ++ project = projectAt.apply(this, arguments); ++ projection.invert = project.invert && invert; ++ return reset(); ++ }; ++ } ++ function d3_geo_projectionRadians(stream) { ++ return d3_geo_transformPoint(stream, function(x, y) { ++ stream.point(x * d3_radians, y * d3_radians); ++ }); ++ } ++ function d3_geo_equirectangular(λ, φ) { ++ return [ λ, φ ]; ++ } ++ (d3.geo.equirectangular = function() { ++ return d3_geo_projection(d3_geo_equirectangular); ++ }).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular; ++ d3.geo.rotation = function(rotate) { ++ rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0); ++ function forward(coordinates) { ++ coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians); ++ return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates; ++ } ++ forward.invert = function(coordinates) { ++ coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians); ++ return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates; ++ }; ++ return forward; ++ }; ++ function d3_geo_identityRotation(λ, φ) { ++ return [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ]; ++ } ++ d3_geo_identityRotation.invert = d3_geo_equirectangular; ++ function d3_geo_rotation(δλ, δφ, δγ) { ++ return δλ ? δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) : d3_geo_rotationλ(δλ) : δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) : d3_geo_identityRotation; ++ } ++ function d3_geo_forwardRotationλ(δλ) { ++ return function(λ, φ) { ++ return λ += δλ, [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ]; ++ }; ++ } ++ function d3_geo_rotationλ(δλ) { ++ var rotation = d3_geo_forwardRotationλ(δλ); ++ rotation.invert = d3_geo_forwardRotationλ(-δλ); ++ return rotation; ++ } ++ function d3_geo_rotationφγ(δφ, δγ) { ++ var cosδφ = Math.cos(δφ), sinδφ = Math.sin(δφ), cosδγ = Math.cos(δγ), sinδγ = Math.sin(δγ); ++ function rotation(λ, φ) { ++ var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδφ + x * sinδφ; ++ return [ Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ), d3_asin(k * cosδγ + y * sinδγ) ]; ++ } ++ rotation.invert = function(λ, φ) { ++ var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδγ - y * sinδγ; ++ return [ Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ), d3_asin(k * cosδφ - x * sinδφ) ]; ++ }; ++ return rotation; ++ } ++ d3.geo.circle = function() { ++ var origin = [ 0, 0 ], angle, precision = 6, interpolate; ++ function circle() { ++ var center = typeof origin === "function" ? origin.apply(this, arguments) : origin, rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert, ring = []; ++ interpolate(null, null, 1, { ++ point: function(x, y) { ++ ring.push(x = rotate(x, y)); ++ x[0] *= d3_degrees, x[1] *= d3_degrees; ++ } ++ }); ++ return { ++ type: "Polygon", ++ coordinates: [ ring ] ++ }; ++ } ++ circle.origin = function(x) { ++ if (!arguments.length) return origin; ++ origin = x; ++ return circle; ++ }; ++ circle.angle = function(x) { ++ if (!arguments.length) return angle; ++ interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians); ++ return circle; ++ }; ++ circle.precision = function(_) { ++ if (!arguments.length) return precision; ++ interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians); ++ return circle; ++ }; ++ return circle.angle(90); ++ }; ++ function d3_geo_circleInterpolate(radius, precision) { ++ var cr = Math.cos(radius), sr = Math.sin(radius); ++ return function(from, to, direction, listener) { ++ var step = direction * precision; ++ if (from != null) { ++ from = d3_geo_circleAngle(cr, from); ++ to = d3_geo_circleAngle(cr, to); ++ if (direction > 0 ? from < to : from > to) from += direction * τ; ++ } else { ++ from = radius + direction * τ; ++ to = radius - .5 * step; ++ } ++ for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) { ++ listener.point((point = d3_geo_spherical([ cr, -sr * Math.cos(t), -sr * Math.sin(t) ]))[0], point[1]); ++ } ++ }; ++ } ++ function d3_geo_circleAngle(cr, point) { ++ var a = d3_geo_cartesian(point); ++ a[0] -= cr; ++ d3_geo_cartesianNormalize(a); ++ var angle = d3_acos(-a[1]); ++ return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI); ++ } ++ d3.geo.distance = function(a, b) { ++ var Δλ = (b[0] - a[0]) * d3_radians, φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians, sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ), sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1), t; ++ return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ); ++ }; ++ d3.geo.graticule = function() { ++ 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 d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X).concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) { ++ return abs(x % DX) > ε; ++ }).map(x)).concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) { ++ return abs(y % DY) > ε; ++ }).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.minorExtent(); ++ return graticule.majorExtent(_).minorExtent(_); ++ }; ++ graticule.majorExtent = 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.minorExtent = 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.minorStep(); ++ return graticule.majorStep(_).minorStep(_); ++ }; ++ graticule.majorStep = function(_) { ++ if (!arguments.length) return [ DX, DY ]; ++ DX = +_[0], DY = +_[1]; ++ return graticule; ++ }; ++ graticule.minorStep = function(_) { ++ if (!arguments.length) return [ dx, dy ]; ++ dx = +_[0], dy = +_[1]; ++ return graticule; ++ }; ++ graticule.precision = function(_) { ++ if (!arguments.length) return precision; ++ precision = +_; ++ x = d3_geo_graticuleX(y0, y1, 90); ++ y = d3_geo_graticuleY(x0, x1, precision); ++ X = d3_geo_graticuleX(Y0, Y1, 90); ++ Y = d3_geo_graticuleY(X0, X1, precision); ++ return graticule; ++ }; ++ return graticule.majorExtent([ [ -180, -90 + ε ], [ 180, 90 - ε ] ]).minorExtent([ [ -180, -80 - ε ], [ 180, 80 + ε ] ]); ++ }; ++ function d3_geo_graticuleX(y0, y1, dy) { ++ var y = d3.range(y0, y1 - ε, dy).concat(y1); ++ return function(x) { ++ return y.map(function(y) { ++ return [ x, y ]; ++ }); ++ }; ++ } ++ function d3_geo_graticuleY(x0, x1, dx) { ++ var x = d3.range(x0, x1 - ε, dx).concat(x1); ++ return function(y) { ++ return x.map(function(x) { ++ return [ x, y ]; ++ }); ++ }; ++ } ++ function d3_source(d) { ++ return d.source; ++ } ++ function d3_target(d) { ++ return d.target; ++ } ++ d3.geo.greatArc = function() { ++ var source = d3_source, source_, target = d3_target, target_; ++ function greatArc() { ++ return { ++ type: "LineString", ++ coordinates: [ source_ || source.apply(this, arguments), target_ || target.apply(this, arguments) ] ++ }; ++ } ++ greatArc.distance = function() { ++ return d3.geo.distance(source_ || source.apply(this, arguments), target_ || target.apply(this, arguments)); ++ }; ++ greatArc.source = function(_) { ++ if (!arguments.length) return source; ++ source = _, source_ = typeof _ === "function" ? null : _; ++ return greatArc; ++ }; ++ greatArc.target = function(_) { ++ if (!arguments.length) return target; ++ target = _, target_ = typeof _ === "function" ? null : _; ++ return greatArc; ++ }; ++ greatArc.precision = function() { ++ return arguments.length ? greatArc : 0; ++ }; ++ return greatArc; ++ }; ++ d3.geo.interpolate = function(source, target) { ++ return d3_geo_interpolate(source[0] * d3_radians, source[1] * d3_radians, target[0] * d3_radians, target[1] * d3_radians); ++ }; ++ function d3_geo_interpolate(x0, y0, x1, y1) { ++ var cy0 = Math.cos(y0), sy0 = Math.sin(y0), cy1 = Math.cos(y1), sy1 = Math.sin(y1), kx0 = cy0 * Math.cos(x0), ky0 = cy0 * Math.sin(x0), kx1 = cy1 * Math.cos(x1), ky1 = cy1 * Math.sin(x1), d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))), k = 1 / Math.sin(d); ++ var interpolate = d ? function(t) { ++ var B = Math.sin(t *= d) * k, A = Math.sin(d - t) * k, x = A * kx0 + B * kx1, y = A * ky0 + B * ky1, z = A * sy0 + B * sy1; ++ return [ Math.atan2(y, x) * d3_degrees, Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees ]; ++ } : function() { ++ return [ x0 * d3_degrees, y0 * d3_degrees ]; ++ }; ++ interpolate.distance = d; ++ return interpolate; ++ } ++ d3.geo.length = function(object) { ++ d3_geo_lengthSum = 0; ++ d3.geo.stream(object, d3_geo_length); ++ return d3_geo_lengthSum; ++ }; ++ var d3_geo_lengthSum; ++ var d3_geo_length = { ++ sphere: d3_noop, ++ point: d3_noop, ++ lineStart: d3_geo_lengthLineStart, ++ lineEnd: d3_noop, ++ polygonStart: d3_noop, ++ polygonEnd: d3_noop ++ }; ++ function d3_geo_lengthLineStart() { ++ var λ0, sinφ0, cosφ0; ++ d3_geo_length.point = function(λ, φ) { ++ λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ); ++ d3_geo_length.point = nextPoint; ++ }; ++ d3_geo_length.lineEnd = function() { ++ d3_geo_length.point = d3_geo_length.lineEnd = d3_noop; ++ }; ++ function nextPoint(λ, φ) { ++ var sinφ = Math.sin(φ *= d3_radians), cosφ = Math.cos(φ), t = abs((λ *= d3_radians) - λ0), cosΔλ = Math.cos(t); ++ d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ); ++ λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ; ++ } ++ } ++ function d3_geo_azimuthal(scale, angle) { ++ function azimuthal(λ, φ) { ++ var cosλ = Math.cos(λ), cosφ = Math.cos(φ), k = scale(cosλ * cosφ); ++ return [ k * cosφ * Math.sin(λ), k * Math.sin(φ) ]; ++ } ++ azimuthal.invert = function(x, y) { ++ var ρ = Math.sqrt(x * x + y * y), c = angle(ρ), sinc = Math.sin(c), cosc = Math.cos(c); ++ return [ Math.atan2(x * sinc, ρ * cosc), Math.asin(ρ && y * sinc / ρ) ]; ++ }; ++ return azimuthal; ++ } ++ var d3_geo_azimuthalEqualArea = d3_geo_azimuthal(function(cosλcosφ) { ++ return Math.sqrt(2 / (1 + cosλcosφ)); ++ }, function(ρ) { ++ return 2 * Math.asin(ρ / 2); ++ }); ++ (d3.geo.azimuthalEqualArea = function() { ++ return d3_geo_projection(d3_geo_azimuthalEqualArea); ++ }).raw = d3_geo_azimuthalEqualArea; ++ var d3_geo_azimuthalEquidistant = d3_geo_azimuthal(function(cosλcosφ) { ++ var c = Math.acos(cosλcosφ); ++ return c && c / Math.sin(c); ++ }, d3_identity); ++ (d3.geo.azimuthalEquidistant = function() { ++ return d3_geo_projection(d3_geo_azimuthalEquidistant); ++ }).raw = d3_geo_azimuthalEquidistant; ++ function d3_geo_conicConformal(φ0, φ1) { ++ var cosφ0 = Math.cos(φ0), t = function(φ) { ++ return Math.tan(π / 4 + φ / 2); ++ }, n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)), F = cosφ0 * Math.pow(t(φ0), n) / n; ++ if (!n) return d3_geo_mercator; ++ function forward(λ, φ) { ++ if (F > 0) { ++ if (φ < -halfπ + ε) φ = -halfπ + ε; ++ } else { ++ if (φ > halfπ - ε) φ = halfπ - ε; ++ } ++ var ρ = F / Math.pow(t(φ), n); ++ return [ ρ * Math.sin(n * λ), F - ρ * Math.cos(n * λ) ]; ++ } ++ forward.invert = function(x, y) { ++ var ρ0_y = F - y, ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y); ++ return [ Math.atan2(x, ρ0_y) / n, 2 * Math.atan(Math.pow(F / ρ, 1 / n)) - halfπ ]; ++ }; ++ return forward; ++ } ++ (d3.geo.conicConformal = function() { ++ return d3_geo_conic(d3_geo_conicConformal); ++ }).raw = d3_geo_conicConformal; ++ function d3_geo_conicEquidistant(φ0, φ1) { ++ var cosφ0 = Math.cos(φ0), n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0), G = cosφ0 / n + φ0; ++ if (abs(n) < ε) return d3_geo_equirectangular; ++ function forward(λ, φ) { ++ var ρ = G - φ; ++ return [ ρ * Math.sin(n * λ), G - ρ * Math.cos(n * λ) ]; ++ } ++ forward.invert = function(x, y) { ++ var ρ0_y = G - y; ++ return [ Math.atan2(x, ρ0_y) / n, G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y) ]; ++ }; ++ return forward; ++ } ++ (d3.geo.conicEquidistant = function() { ++ return d3_geo_conic(d3_geo_conicEquidistant); ++ }).raw = d3_geo_conicEquidistant; ++ var d3_geo_gnomonic = d3_geo_azimuthal(function(cosλcosφ) { ++ return 1 / cosλcosφ; ++ }, Math.atan); ++ (d3.geo.gnomonic = function() { ++ return d3_geo_projection(d3_geo_gnomonic); ++ }).raw = d3_geo_gnomonic; ++ function d3_geo_mercator(λ, φ) { ++ return [ λ, Math.log(Math.tan(π / 4 + φ / 2)) ]; ++ } ++ d3_geo_mercator.invert = function(x, y) { ++ return [ x, 2 * Math.atan(Math.exp(y)) - halfπ ]; ++ }; ++ function d3_geo_mercatorProjection(project) { ++ var m = d3_geo_projection(project), scale = m.scale, translate = m.translate, clipExtent = m.clipExtent, clipAuto; ++ m.scale = function() { ++ var v = scale.apply(m, arguments); ++ return v === m ? clipAuto ? m.clipExtent(null) : m : v; ++ }; ++ m.translate = function() { ++ var v = translate.apply(m, arguments); ++ return v === m ? clipAuto ? m.clipExtent(null) : m : v; ++ }; ++ m.clipExtent = function(_) { ++ var v = clipExtent.apply(m, arguments); ++ if (v === m) { ++ if (clipAuto = _ == null) { ++ var k = π * scale(), t = translate(); ++ clipExtent([ [ t[0] - k, t[1] - k ], [ t[0] + k, t[1] + k ] ]); ++ } ++ } else if (clipAuto) { ++ v = null; ++ } ++ return v; ++ }; ++ return m.clipExtent(null); ++ } ++ (d3.geo.mercator = function() { ++ return d3_geo_mercatorProjection(d3_geo_mercator); ++ }).raw = d3_geo_mercator; ++ var d3_geo_orthographic = d3_geo_azimuthal(function() { ++ return 1; ++ }, Math.asin); ++ (d3.geo.orthographic = function() { ++ return d3_geo_projection(d3_geo_orthographic); ++ }).raw = d3_geo_orthographic; ++ var d3_geo_stereographic = d3_geo_azimuthal(function(cosλcosφ) { ++ return 1 / (1 + cosλcosφ); ++ }, function(ρ) { ++ return 2 * Math.atan(ρ); ++ }); ++ (d3.geo.stereographic = function() { ++ return d3_geo_projection(d3_geo_stereographic); ++ }).raw = d3_geo_stereographic; ++ function d3_geo_transverseMercator(λ, φ) { ++ return [ Math.log(Math.tan(π / 4 + φ / 2)), -λ ]; ++ } ++ d3_geo_transverseMercator.invert = function(x, y) { ++ return [ -y, 2 * Math.atan(Math.exp(x)) - halfπ ]; ++ }; ++ (d3.geo.transverseMercator = function() { ++ var projection = d3_geo_mercatorProjection(d3_geo_transverseMercator), center = projection.center, rotate = projection.rotate; ++ projection.center = function(_) { ++ return _ ? center([ -_[1], _[0] ]) : (_ = center(), [ _[1], -_[0] ]); ++ }; ++ projection.rotate = function(_) { ++ return _ ? rotate([ _[0], _[1], _.length > 2 ? _[2] + 90 : 90 ]) : (_ = rotate(), ++ [ _[0], _[1], _[2] - 90 ]); ++ }; ++ return rotate([ 0, 0, 90 ]); ++ }).raw = d3_geo_transverseMercator; ++ d3.geom = {}; ++ function d3_geom_pointX(d) { ++ return d[0]; ++ } ++ function d3_geom_pointY(d) { ++ return d[1]; ++ } ++ d3.geom.hull = function(vertices) { ++ var x = d3_geom_pointX, y = d3_geom_pointY; ++ if (arguments.length) return hull(vertices); ++ function hull(data) { ++ if (data.length < 3) return []; ++ var fx = d3_functor(x), fy = d3_functor(y), i, n = data.length, points = [], flippedPoints = []; ++ for (i = 0; i < n; i++) { ++ points.push([ +fx.call(this, data[i], i), +fy.call(this, data[i], i), i ]); ++ } ++ points.sort(d3_geom_hullOrder); ++ for (i = 0; i < n; i++) flippedPoints.push([ points[i][0], -points[i][1] ]); ++ var upper = d3_geom_hullUpper(points), lower = d3_geom_hullUpper(flippedPoints); ++ var skipLeft = lower[0] === upper[0], skipRight = lower[lower.length - 1] === upper[upper.length - 1], polygon = []; ++ for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]); ++ for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]); ++ return polygon; ++ } ++ hull.x = function(_) { ++ return arguments.length ? (x = _, hull) : x; ++ }; ++ hull.y = function(_) { ++ return arguments.length ? (y = _, hull) : y; ++ }; ++ return hull; ++ }; ++ function d3_geom_hullUpper(points) { ++ var n = points.length, hull = [ 0, 1 ], hs = 2; ++ for (var i = 2; i < n; i++) { ++ while (hs > 1 && d3_cross2d(points[hull[hs - 2]], points[hull[hs - 1]], points[i]) <= 0) --hs; ++ hull[hs++] = i; ++ } ++ return hull.slice(0, hs); ++ } ++ function d3_geom_hullOrder(a, b) { ++ return a[0] - b[0] || a[1] - b[1]; ++ } ++ d3.geom.polygon = function(coordinates) { ++ d3_subclass(coordinates, d3_geom_polygonPrototype); ++ return coordinates; ++ }; ++ var d3_geom_polygonPrototype = d3.geom.polygon.prototype = []; ++ d3_geom_polygonPrototype.area = function() { ++ var i = -1, n = this.length, a, b = this[n - 1], area = 0; ++ while (++i < n) { ++ a = b; ++ b = this[i]; ++ area += a[1] * b[0] - a[0] * b[1]; ++ } ++ return area * .5; ++ }; ++ d3_geom_polygonPrototype.centroid = function(k) { ++ var i = -1, n = this.length, x = 0, y = 0, a, b = this[n - 1], c; ++ if (!arguments.length) k = -1 / (6 * this.area()); ++ while (++i < n) { ++ a = b; ++ b = this[i]; ++ c = a[0] * b[1] - b[0] * a[1]; ++ x += (a[0] + b[0]) * c; ++ y += (a[1] + b[1]) * c; ++ } ++ return [ x * k, y * k ]; ++ }; ++ d3_geom_polygonPrototype.clip = function(subject) { ++ var input, closed = d3_geom_polygonClosed(subject), i = -1, n = this.length - d3_geom_polygonClosed(this), j, m, a = this[n - 1], b, c, d; ++ while (++i < n) { ++ input = subject.slice(); ++ subject.length = 0; ++ b = this[i]; ++ c = input[(m = input.length - closed) - 1]; ++ j = -1; ++ while (++j < m) { ++ d = input[j]; ++ if (d3_geom_polygonInside(d, a, b)) { ++ if (!d3_geom_polygonInside(c, a, b)) { ++ subject.push(d3_geom_polygonIntersect(c, d, a, b)); ++ } ++ subject.push(d); ++ } else if (d3_geom_polygonInside(c, a, b)) { ++ subject.push(d3_geom_polygonIntersect(c, d, a, b)); ++ } ++ c = d; ++ } ++ if (closed) subject.push(subject[0]); ++ a = b; ++ } ++ return subject; ++ }; ++ function d3_geom_polygonInside(p, a, b) { ++ return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]); ++ } ++ function d3_geom_polygonIntersect(c, d, a, b) { ++ var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3, y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3, ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21); ++ return [ x1 + ua * x21, y1 + ua * y21 ]; ++ } ++ function d3_geom_polygonClosed(coordinates) { ++ var a = coordinates[0], b = coordinates[coordinates.length - 1]; ++ return !(a[0] - b[0] || a[1] - b[1]); ++ } ++ var d3_geom_voronoiEdges, d3_geom_voronoiCells, d3_geom_voronoiBeaches, d3_geom_voronoiBeachPool = [], d3_geom_voronoiFirstCircle, d3_geom_voronoiCircles, d3_geom_voronoiCirclePool = []; ++ function d3_geom_voronoiBeach() { ++ d3_geom_voronoiRedBlackNode(this); ++ this.edge = this.site = this.circle = null; ++ } ++ function d3_geom_voronoiCreateBeach(site) { ++ var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach(); ++ beach.site = site; ++ return beach; ++ } ++ function d3_geom_voronoiDetachBeach(beach) { ++ d3_geom_voronoiDetachCircle(beach); ++ d3_geom_voronoiBeaches.remove(beach); ++ d3_geom_voronoiBeachPool.push(beach); ++ d3_geom_voronoiRedBlackNode(beach); ++ } ++ function d3_geom_voronoiRemoveBeach(beach) { ++ var circle = beach.circle, x = circle.x, y = circle.cy, vertex = { ++ x: x, ++ y: y ++ }, previous = beach.P, next = beach.N, disappearing = [ beach ]; ++ d3_geom_voronoiDetachBeach(beach); ++ var lArc = previous; ++ while (lArc.circle && abs(x - lArc.circle.x) < ε && abs(y - lArc.circle.cy) < ε) { ++ previous = lArc.P; ++ disappearing.unshift(lArc); ++ d3_geom_voronoiDetachBeach(lArc); ++ lArc = previous; ++ } ++ disappearing.unshift(lArc); ++ d3_geom_voronoiDetachCircle(lArc); ++ var rArc = next; ++ while (rArc.circle && abs(x - rArc.circle.x) < ε && abs(y - rArc.circle.cy) < ε) { ++ next = rArc.N; ++ disappearing.push(rArc); ++ d3_geom_voronoiDetachBeach(rArc); ++ rArc = next; ++ } ++ disappearing.push(rArc); ++ d3_geom_voronoiDetachCircle(rArc); ++ var nArcs = disappearing.length, iArc; ++ for (iArc = 1; iArc < nArcs; ++iArc) { ++ rArc = disappearing[iArc]; ++ lArc = disappearing[iArc - 1]; ++ d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex); ++ } ++ lArc = disappearing[0]; ++ rArc = disappearing[nArcs - 1]; ++ rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex); ++ d3_geom_voronoiAttachCircle(lArc); ++ d3_geom_voronoiAttachCircle(rArc); ++ } ++ function d3_geom_voronoiAddBeach(site) { ++ var x = site.x, directrix = site.y, lArc, rArc, dxl, dxr, node = d3_geom_voronoiBeaches._; ++ while (node) { ++ dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x; ++ if (dxl > ε) node = node.L; else { ++ dxr = x - d3_geom_voronoiRightBreakPoint(node, directrix); ++ if (dxr > ε) { ++ if (!node.R) { ++ lArc = node; ++ break; ++ } ++ node = node.R; ++ } else { ++ if (dxl > -ε) { ++ lArc = node.P; ++ rArc = node; ++ } else if (dxr > -ε) { ++ lArc = node; ++ rArc = node.N; ++ } else { ++ lArc = rArc = node; ++ } ++ break; ++ } ++ } ++ } ++ var newArc = d3_geom_voronoiCreateBeach(site); ++ d3_geom_voronoiBeaches.insert(lArc, newArc); ++ if (!lArc && !rArc) return; ++ if (lArc === rArc) { ++ d3_geom_voronoiDetachCircle(lArc); ++ rArc = d3_geom_voronoiCreateBeach(lArc.site); ++ d3_geom_voronoiBeaches.insert(newArc, rArc); ++ newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site); ++ d3_geom_voronoiAttachCircle(lArc); ++ d3_geom_voronoiAttachCircle(rArc); ++ return; ++ } ++ if (!rArc) { ++ newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site); ++ return; ++ } ++ d3_geom_voronoiDetachCircle(lArc); ++ d3_geom_voronoiDetachCircle(rArc); ++ var lSite = lArc.site, ax = lSite.x, ay = lSite.y, bx = site.x - ax, by = site.y - ay, rSite = rArc.site, cx = rSite.x - ax, cy = rSite.y - ay, d = 2 * (bx * cy - by * cx), hb = bx * bx + by * by, hc = cx * cx + cy * cy, vertex = { ++ x: (cy * hb - by * hc) / d + ax, ++ y: (bx * hc - cx * hb) / d + ay ++ }; ++ d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex); ++ newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex); ++ rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex); ++ d3_geom_voronoiAttachCircle(lArc); ++ d3_geom_voronoiAttachCircle(rArc); ++ } ++ function d3_geom_voronoiLeftBreakPoint(arc, directrix) { ++ var site = arc.site, rfocx = site.x, rfocy = site.y, pby2 = rfocy - directrix; ++ if (!pby2) return rfocx; ++ var lArc = arc.P; ++ if (!lArc) return -Infinity; ++ site = lArc.site; ++ var lfocx = site.x, lfocy = site.y, plby2 = lfocy - directrix; ++ if (!plby2) return lfocx; ++ var hl = lfocx - rfocx, aby2 = 1 / pby2 - 1 / plby2, b = hl / plby2; ++ if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx; ++ return (rfocx + lfocx) / 2; ++ } ++ function d3_geom_voronoiRightBreakPoint(arc, directrix) { ++ var rArc = arc.N; ++ if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix); ++ var site = arc.site; ++ return site.y === directrix ? site.x : Infinity; ++ } ++ function d3_geom_voronoiCell(site) { ++ this.site = site; ++ this.edges = []; ++ } ++ d3_geom_voronoiCell.prototype.prepare = function() { ++ var halfEdges = this.edges, iHalfEdge = halfEdges.length, edge; ++ while (iHalfEdge--) { ++ edge = halfEdges[iHalfEdge].edge; ++ if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1); ++ } ++ halfEdges.sort(d3_geom_voronoiHalfEdgeOrder); ++ return halfEdges.length; ++ }; ++ function d3_geom_voronoiCloseCells(extent) { ++ var x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], x2, y2, x3, y3, cells = d3_geom_voronoiCells, iCell = cells.length, cell, iHalfEdge, halfEdges, nHalfEdges, start, end; ++ while (iCell--) { ++ cell = cells[iCell]; ++ if (!cell || !cell.prepare()) continue; ++ halfEdges = cell.edges; ++ nHalfEdges = halfEdges.length; ++ iHalfEdge = 0; ++ while (iHalfEdge < nHalfEdges) { ++ end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y; ++ start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y; ++ if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) { ++ halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end, abs(x3 - x0) < ε && y1 - y3 > ε ? { ++ x: x0, ++ y: abs(x2 - x0) < ε ? y2 : y1 ++ } : abs(y3 - y1) < ε && x1 - x3 > ε ? { ++ x: abs(y2 - y1) < ε ? x2 : x1, ++ y: y1 ++ } : abs(x3 - x1) < ε && y3 - y0 > ε ? { ++ x: x1, ++ y: abs(x2 - x1) < ε ? y2 : y0 ++ } : abs(y3 - y0) < ε && x3 - x0 > ε ? { ++ x: abs(y2 - y0) < ε ? x2 : x0, ++ y: y0 ++ } : null), cell.site, null)); ++ ++nHalfEdges; ++ } ++ } ++ } ++ } ++ function d3_geom_voronoiHalfEdgeOrder(a, b) { ++ return b.angle - a.angle; ++ } ++ function d3_geom_voronoiCircle() { ++ d3_geom_voronoiRedBlackNode(this); ++ this.x = this.y = this.arc = this.site = this.cy = null; ++ } ++ function d3_geom_voronoiAttachCircle(arc) { ++ var lArc = arc.P, rArc = arc.N; ++ if (!lArc || !rArc) return; ++ var lSite = lArc.site, cSite = arc.site, rSite = rArc.site; ++ if (lSite === rSite) return; ++ var bx = cSite.x, by = cSite.y, ax = lSite.x - bx, ay = lSite.y - by, cx = rSite.x - bx, cy = rSite.y - by; ++ var d = 2 * (ax * cy - ay * cx); ++ if (d >= -ε2) return; ++ var ha = ax * ax + ay * ay, hc = cx * cx + cy * cy, x = (cy * ha - ay * hc) / d, y = (ax * hc - cx * ha) / d, cy = y + by; ++ var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle(); ++ circle.arc = arc; ++ circle.site = cSite; ++ circle.x = x + bx; ++ circle.y = cy + Math.sqrt(x * x + y * y); ++ circle.cy = cy; ++ arc.circle = circle; ++ var before = null, node = d3_geom_voronoiCircles._; ++ while (node) { ++ if (circle.y < node.y || circle.y === node.y && circle.x <= node.x) { ++ if (node.L) node = node.L; else { ++ before = node.P; ++ break; ++ } ++ } else { ++ if (node.R) node = node.R; else { ++ before = node; ++ break; ++ } ++ } ++ } ++ d3_geom_voronoiCircles.insert(before, circle); ++ if (!before) d3_geom_voronoiFirstCircle = circle; ++ } ++ function d3_geom_voronoiDetachCircle(arc) { ++ var circle = arc.circle; ++ if (circle) { ++ if (!circle.P) d3_geom_voronoiFirstCircle = circle.N; ++ d3_geom_voronoiCircles.remove(circle); ++ d3_geom_voronoiCirclePool.push(circle); ++ d3_geom_voronoiRedBlackNode(circle); ++ arc.circle = null; ++ } ++ } ++ function d3_geom_voronoiClipEdges(extent) { ++ var edges = d3_geom_voronoiEdges, clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]), i = edges.length, e; ++ while (i--) { ++ e = edges[i]; ++ if (!d3_geom_voronoiConnectEdge(e, extent) || !clip(e) || abs(e.a.x - e.b.x) < ε && abs(e.a.y - e.b.y) < ε) { ++ e.a = e.b = null; ++ edges.splice(i, 1); ++ } ++ } ++ } ++ function d3_geom_voronoiConnectEdge(edge, extent) { ++ var vb = edge.b; ++ if (vb) return true; ++ var va = edge.a, x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], lSite = edge.l, rSite = edge.r, lx = lSite.x, ly = lSite.y, rx = rSite.x, ry = rSite.y, fx = (lx + rx) / 2, fy = (ly + ry) / 2, fm, fb; ++ if (ry === ly) { ++ if (fx < x0 || fx >= x1) return; ++ if (lx > rx) { ++ if (!va) va = { ++ x: fx, ++ y: y0 ++ }; else if (va.y >= y1) return; ++ vb = { ++ x: fx, ++ y: y1 ++ }; ++ } else { ++ if (!va) va = { ++ x: fx, ++ y: y1 ++ }; else if (va.y < y0) return; ++ vb = { ++ x: fx, ++ y: y0 ++ }; ++ } ++ } else { ++ fm = (lx - rx) / (ry - ly); ++ fb = fy - fm * fx; ++ if (fm < -1 || fm > 1) { ++ if (lx > rx) { ++ if (!va) va = { ++ x: (y0 - fb) / fm, ++ y: y0 ++ }; else if (va.y >= y1) return; ++ vb = { ++ x: (y1 - fb) / fm, ++ y: y1 ++ }; ++ } else { ++ if (!va) va = { ++ x: (y1 - fb) / fm, ++ y: y1 ++ }; else if (va.y < y0) return; ++ vb = { ++ x: (y0 - fb) / fm, ++ y: y0 ++ }; ++ } ++ } else { ++ if (ly < ry) { ++ if (!va) va = { ++ x: x0, ++ y: fm * x0 + fb ++ }; else if (va.x >= x1) return; ++ vb = { ++ x: x1, ++ y: fm * x1 + fb ++ }; ++ } else { ++ if (!va) va = { ++ x: x1, ++ y: fm * x1 + fb ++ }; else if (va.x < x0) return; ++ vb = { ++ x: x0, ++ y: fm * x0 + fb ++ }; ++ } ++ } ++ } ++ edge.a = va; ++ edge.b = vb; ++ return true; ++ } ++ function d3_geom_voronoiEdge(lSite, rSite) { ++ this.l = lSite; ++ this.r = rSite; ++ this.a = this.b = null; ++ } ++ function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) { ++ var edge = new d3_geom_voronoiEdge(lSite, rSite); ++ d3_geom_voronoiEdges.push(edge); ++ if (va) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va); ++ if (vb) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb); ++ d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite)); ++ d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite)); ++ return edge; ++ } ++ function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) { ++ var edge = new d3_geom_voronoiEdge(lSite, null); ++ edge.a = va; ++ edge.b = vb; ++ d3_geom_voronoiEdges.push(edge); ++ return edge; ++ } ++ function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) { ++ if (!edge.a && !edge.b) { ++ edge.a = vertex; ++ edge.l = lSite; ++ edge.r = rSite; ++ } else if (edge.l === rSite) { ++ edge.b = vertex; ++ } else { ++ edge.a = vertex; ++ } ++ } ++ function d3_geom_voronoiHalfEdge(edge, lSite, rSite) { ++ var va = edge.a, vb = edge.b; ++ this.edge = edge; ++ this.site = lSite; ++ this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x) : edge.l === lSite ? Math.atan2(vb.x - va.x, va.y - vb.y) : Math.atan2(va.x - vb.x, vb.y - va.y); ++ } ++ d3_geom_voronoiHalfEdge.prototype = { ++ start: function() { ++ return this.edge.l === this.site ? this.edge.a : this.edge.b; ++ }, ++ end: function() { ++ return this.edge.l === this.site ? this.edge.b : this.edge.a; ++ } ++ }; ++ function d3_geom_voronoiRedBlackTree() { ++ this._ = null; ++ } ++ function d3_geom_voronoiRedBlackNode(node) { ++ node.U = node.C = node.L = node.R = node.P = node.N = null; ++ } ++ d3_geom_voronoiRedBlackTree.prototype = { ++ insert: function(after, node) { ++ var parent, grandpa, uncle; ++ if (after) { ++ node.P = after; ++ node.N = after.N; ++ if (after.N) after.N.P = node; ++ after.N = node; ++ if (after.R) { ++ after = after.R; ++ while (after.L) after = after.L; ++ after.L = node; ++ } else { ++ after.R = node; ++ } ++ parent = after; ++ } else if (this._) { ++ after = d3_geom_voronoiRedBlackFirst(this._); ++ node.P = null; ++ node.N = after; ++ after.P = after.L = node; ++ parent = after; ++ } else { ++ node.P = node.N = null; ++ this._ = node; ++ parent = null; ++ } ++ node.L = node.R = null; ++ node.U = parent; ++ node.C = true; ++ after = node; ++ while (parent && parent.C) { ++ grandpa = parent.U; ++ if (parent === grandpa.L) { ++ uncle = grandpa.R; ++ if (uncle && uncle.C) { ++ parent.C = uncle.C = false; ++ grandpa.C = true; ++ after = grandpa; ++ } else { ++ if (after === parent.R) { ++ d3_geom_voronoiRedBlackRotateLeft(this, parent); ++ after = parent; ++ parent = after.U; ++ } ++ parent.C = false; ++ grandpa.C = true; ++ d3_geom_voronoiRedBlackRotateRight(this, grandpa); ++ } ++ } else { ++ uncle = grandpa.L; ++ if (uncle && uncle.C) { ++ parent.C = uncle.C = false; ++ grandpa.C = true; ++ after = grandpa; ++ } else { ++ if (after === parent.L) { ++ d3_geom_voronoiRedBlackRotateRight(this, parent); ++ after = parent; ++ parent = after.U; ++ } ++ parent.C = false; ++ grandpa.C = true; ++ d3_geom_voronoiRedBlackRotateLeft(this, grandpa); ++ } ++ } ++ parent = after.U; ++ } ++ this._.C = false; ++ }, ++ remove: function(node) { ++ if (node.N) node.N.P = node.P; ++ if (node.P) node.P.N = node.N; ++ node.N = node.P = null; ++ var parent = node.U, sibling, left = node.L, right = node.R, next, red; ++ if (!left) next = right; else if (!right) next = left; else next = d3_geom_voronoiRedBlackFirst(right); ++ if (parent) { ++ if (parent.L === node) parent.L = next; else parent.R = next; ++ } else { ++ this._ = next; ++ } ++ if (left && right) { ++ red = next.C; ++ next.C = node.C; ++ next.L = left; ++ left.U = next; ++ if (next !== right) { ++ parent = next.U; ++ next.U = node.U; ++ node = next.R; ++ parent.L = node; ++ next.R = right; ++ right.U = next; ++ } else { ++ next.U = parent; ++ parent = next; ++ node = next.R; ++ } ++ } else { ++ red = node.C; ++ node = next; ++ } ++ if (node) node.U = parent; ++ if (red) return; ++ if (node && node.C) { ++ node.C = false; ++ return; ++ } ++ do { ++ if (node === this._) break; ++ if (node === parent.L) { ++ sibling = parent.R; ++ if (sibling.C) { ++ sibling.C = false; ++ parent.C = true; ++ d3_geom_voronoiRedBlackRotateLeft(this, parent); ++ sibling = parent.R; ++ } ++ if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) { ++ if (!sibling.R || !sibling.R.C) { ++ sibling.L.C = false; ++ sibling.C = true; ++ d3_geom_voronoiRedBlackRotateRight(this, sibling); ++ sibling = parent.R; ++ } ++ sibling.C = parent.C; ++ parent.C = sibling.R.C = false; ++ d3_geom_voronoiRedBlackRotateLeft(this, parent); ++ node = this._; ++ break; ++ } ++ } else { ++ sibling = parent.L; ++ if (sibling.C) { ++ sibling.C = false; ++ parent.C = true; ++ d3_geom_voronoiRedBlackRotateRight(this, parent); ++ sibling = parent.L; ++ } ++ if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) { ++ if (!sibling.L || !sibling.L.C) { ++ sibling.R.C = false; ++ sibling.C = true; ++ d3_geom_voronoiRedBlackRotateLeft(this, sibling); ++ sibling = parent.L; ++ } ++ sibling.C = parent.C; ++ parent.C = sibling.L.C = false; ++ d3_geom_voronoiRedBlackRotateRight(this, parent); ++ node = this._; ++ break; ++ } ++ } ++ sibling.C = true; ++ node = parent; ++ parent = parent.U; ++ } while (!node.C); ++ if (node) node.C = false; ++ } ++ }; ++ function d3_geom_voronoiRedBlackRotateLeft(tree, node) { ++ var p = node, q = node.R, parent = p.U; ++ if (parent) { ++ if (parent.L === p) parent.L = q; else parent.R = q; ++ } else { ++ tree._ = q; ++ } ++ q.U = parent; ++ p.U = q; ++ p.R = q.L; ++ if (p.R) p.R.U = p; ++ q.L = p; ++ } ++ function d3_geom_voronoiRedBlackRotateRight(tree, node) { ++ var p = node, q = node.L, parent = p.U; ++ if (parent) { ++ if (parent.L === p) parent.L = q; else parent.R = q; ++ } else { ++ tree._ = q; ++ } ++ q.U = parent; ++ p.U = q; ++ p.L = q.R; ++ if (p.L) p.L.U = p; ++ q.R = p; ++ } ++ function d3_geom_voronoiRedBlackFirst(node) { ++ while (node.L) node = node.L; ++ return node; ++ } ++ function d3_geom_voronoi(sites, bbox) { ++ var site = sites.sort(d3_geom_voronoiVertexOrder).pop(), x0, y0, circle; ++ d3_geom_voronoiEdges = []; ++ d3_geom_voronoiCells = new Array(sites.length); ++ d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree(); ++ d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree(); ++ while (true) { ++ circle = d3_geom_voronoiFirstCircle; ++ if (site && (!circle || site.y < circle.y || site.y === circle.y && site.x < circle.x)) { ++ if (site.x !== x0 || site.y !== y0) { ++ d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site); ++ d3_geom_voronoiAddBeach(site); ++ x0 = site.x, y0 = site.y; ++ } ++ site = sites.pop(); ++ } else if (circle) { ++ d3_geom_voronoiRemoveBeach(circle.arc); ++ } else { ++ break; ++ } ++ } ++ if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox); ++ var diagram = { ++ cells: d3_geom_voronoiCells, ++ edges: d3_geom_voronoiEdges ++ }; ++ d3_geom_voronoiBeaches = d3_geom_voronoiCircles = d3_geom_voronoiEdges = d3_geom_voronoiCells = null; ++ return diagram; ++ } ++ function d3_geom_voronoiVertexOrder(a, b) { ++ return b.y - a.y || b.x - a.x; ++ } ++ d3.geom.voronoi = function(points) { ++ var x = d3_geom_pointX, y = d3_geom_pointY, fx = x, fy = y, clipExtent = d3_geom_voronoiClipExtent; ++ if (points) return voronoi(points); ++ function voronoi(data) { ++ var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[1][1]; ++ d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i) { ++ var edges = cell.edges, site = cell.site, polygon = polygons[i] = edges.length ? edges.map(function(e) { ++ var s = e.start(); ++ return [ s.x, s.y ]; ++ }) : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [ [ x0, y1 ], [ x1, y1 ], [ x1, y0 ], [ x0, y0 ] ] : []; ++ polygon.point = data[i]; ++ }); ++ return polygons; ++ } ++ function sites(data) { ++ return data.map(function(d, i) { ++ return { ++ x: Math.round(fx(d, i) / ε) * ε, ++ y: Math.round(fy(d, i) / ε) * ε, ++ i: i ++ }; ++ }); ++ } ++ voronoi.links = function(data) { ++ return d3_geom_voronoi(sites(data)).edges.filter(function(edge) { ++ return edge.l && edge.r; ++ }).map(function(edge) { ++ return { ++ source: data[edge.l.i], ++ target: data[edge.r.i] ++ }; ++ }); ++ }; ++ voronoi.triangles = function(data) { ++ var triangles = []; ++ d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i) { ++ var site = cell.site, edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder), j = -1, m = edges.length, e0, s0, e1 = edges[m - 1].edge, s1 = e1.l === site ? e1.r : e1.l; ++ while (++j < m) { ++ e0 = e1; ++ s0 = s1; ++ e1 = edges[j].edge; ++ s1 = e1.l === site ? e1.r : e1.l; ++ if (i < s0.i && i < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) { ++ triangles.push([ data[i], data[s0.i], data[s1.i] ]); ++ } ++ } ++ }); ++ return triangles; ++ }; ++ voronoi.x = function(_) { ++ return arguments.length ? (fx = d3_functor(x = _), voronoi) : x; ++ }; ++ voronoi.y = function(_) { ++ return arguments.length ? (fy = d3_functor(y = _), voronoi) : y; ++ }; ++ voronoi.clipExtent = function(_) { ++ if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent; ++ clipExtent = _ == null ? d3_geom_voronoiClipExtent : _; ++ return voronoi; ++ }; ++ voronoi.size = function(_) { ++ if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1]; ++ return voronoi.clipExtent(_ && [ [ 0, 0 ], _ ]); ++ }; ++ return voronoi; ++ }; ++ var d3_geom_voronoiClipExtent = [ [ -1e6, -1e6 ], [ 1e6, 1e6 ] ]; ++ function d3_geom_voronoiTriangleArea(a, b, c) { ++ return (a.x - c.x) * (b.y - a.y) - (a.x - b.x) * (c.y - a.y); ++ } ++ d3.geom.delaunay = function(vertices) { ++ return d3.geom.voronoi().triangles(vertices); ++ }; ++ d3.geom.quadtree = function(points, x1, y1, x2, y2) { ++ var x = d3_geom_pointX, y = d3_geom_pointY, compat; ++ if (compat = arguments.length) { ++ x = d3_geom_quadtreeCompatX; ++ y = d3_geom_quadtreeCompatY; ++ if (compat === 3) { ++ y2 = y1; ++ x2 = x1; ++ y1 = x1 = 0; ++ } ++ return quadtree(points); ++ } ++ function quadtree(data) { ++ var d, fx = d3_functor(x), fy = d3_functor(y), xs, ys, i, n, x1_, y1_, x2_, y2_; ++ if (x1 != null) { ++ x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2; ++ } else { ++ x2_ = y2_ = -(x1_ = y1_ = Infinity); ++ xs = [], ys = []; ++ n = data.length; ++ if (compat) for (i = 0; i < n; ++i) { ++ d = data[i]; ++ if (d.x < x1_) x1_ = d.x; ++ if (d.y < y1_) y1_ = d.y; ++ if (d.x > x2_) x2_ = d.x; ++ if (d.y > y2_) y2_ = d.y; ++ xs.push(d.x); ++ ys.push(d.y); ++ } else for (i = 0; i < n; ++i) { ++ var x_ = +fx(d = data[i], i), y_ = +fy(d, i); ++ if (x_ < x1_) x1_ = x_; ++ if (y_ < y1_) y1_ = y_; ++ if (x_ > x2_) x2_ = x_; ++ if (y_ > y2_) y2_ = y_; ++ xs.push(x_); ++ ys.push(y_); ++ } ++ } ++ var dx = x2_ - x1_, dy = y2_ - y1_; ++ if (dx > dy) y2_ = y1_ + dx; else x2_ = x1_ + dy; ++ function insert(n, d, x, y, x1, y1, x2, y2) { ++ if (isNaN(x) || isNaN(y)) return; ++ if (n.leaf) { ++ var nx = n.x, ny = n.y; ++ if (nx != null) { ++ if (abs(nx - x) + abs(ny - y) < .01) { ++ insertChild(n, d, x, y, x1, y1, x2, y2); ++ } else { ++ var nPoint = n.point; ++ n.x = n.y = n.point = null; ++ insertChild(n, nPoint, nx, ny, x1, y1, x2, y2); ++ insertChild(n, d, x, y, x1, y1, x2, y2); ++ } ++ } else { ++ n.x = x, n.y = y, n.point = d; ++ } ++ } else { ++ insertChild(n, d, x, y, x1, y1, x2, y2); ++ } ++ } ++ function insertChild(n, d, x, y, x1, y1, x2, y2) { ++ var xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym, i = below << 1 | right; ++ n.leaf = false; ++ n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode()); ++ if (right) x1 = xm; else x2 = xm; ++ if (below) y1 = ym; else y2 = ym; ++ insert(n, d, x, y, x1, y1, x2, y2); ++ } ++ var root = d3_geom_quadtreeNode(); ++ root.add = function(d) { ++ insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_); ++ }; ++ root.visit = function(f) { ++ d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_); ++ }; ++ root.find = function(point) { ++ return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_); ++ }; ++ i = -1; ++ if (x1 == null) { ++ while (++i < n) { ++ insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_); ++ } ++ --i; ++ } else data.forEach(root.add); ++ xs = ys = data = d = null; ++ return root; ++ } ++ quadtree.x = function(_) { ++ return arguments.length ? (x = _, quadtree) : x; ++ }; ++ quadtree.y = function(_) { ++ return arguments.length ? (y = _, quadtree) : y; ++ }; ++ quadtree.extent = function(_) { ++ if (!arguments.length) return x1 == null ? null : [ [ x1, y1 ], [ x2, y2 ] ]; ++ if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0], ++ y2 = +_[1][1]; ++ return quadtree; ++ }; ++ quadtree.size = function(_) { ++ if (!arguments.length) return x1 == null ? null : [ x2 - x1, y2 - y1 ]; ++ if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = y1 = 0, x2 = +_[0], y2 = +_[1]; ++ return quadtree; ++ }; ++ return quadtree; ++ }; ++ function d3_geom_quadtreeCompatX(d) { ++ return d.x; ++ } ++ function d3_geom_quadtreeCompatY(d) { ++ return d.y; ++ } ++ function d3_geom_quadtreeNode() { ++ return { ++ leaf: true, ++ nodes: [], ++ point: null, ++ x: null, ++ y: null ++ }; ++ } ++ function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) { ++ if (!f(node, x1, y1, x2, y2)) { ++ var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, children = node.nodes; ++ if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy); ++ if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy); ++ if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2); ++ if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2); ++ } ++ } ++ function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) { ++ var minDistance2 = Infinity, closestPoint; ++ (function find(node, x1, y1, x2, y2) { ++ if (x1 > x3 || y1 > y3 || x2 < x0 || y2 < y0) return; ++ if (point = node.point) { ++ var point, dx = x - node.x, dy = y - node.y, distance2 = dx * dx + dy * dy; ++ if (distance2 < minDistance2) { ++ var distance = Math.sqrt(minDistance2 = distance2); ++ x0 = x - distance, y0 = y - distance; ++ x3 = x + distance, y3 = y + distance; ++ closestPoint = point; ++ } ++ } ++ var children = node.nodes, xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym; ++ for (var i = below << 1 | right, j = i + 4; i < j; ++i) { ++ if (node = children[i & 3]) switch (i & 3) { ++ case 0: ++ find(node, x1, y1, xm, ym); ++ break; ++ ++ case 1: ++ find(node, xm, y1, x2, ym); ++ break; ++ ++ case 2: ++ find(node, x1, ym, xm, y2); ++ break; ++ ++ case 3: ++ find(node, xm, ym, x2, y2); ++ break; ++ } ++ } ++ })(root, x0, y0, x3, y3); ++ return closestPoint; ++ } ++ d3.interpolateRgb = d3_interpolateRgb; ++ function d3_interpolateRgb(a, b) { ++ a = d3.rgb(a); ++ b = d3.rgb(b); ++ var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab; ++ return function(t) { ++ return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t)); ++ }; ++ } ++ d3.interpolateObject = d3_interpolateObject; ++ function d3_interpolateObject(a, b) { ++ var i = {}, c = {}, k; ++ for (k in a) { ++ if (k in b) { ++ i[k] = d3_interpolate(a[k], b[k]); ++ } else { ++ c[k] = a[k]; ++ } ++ } ++ for (k in b) { ++ if (!(k in a)) { ++ c[k] = b[k]; ++ } ++ } ++ return function(t) { ++ for (k in i) c[k] = i[k](t); ++ return c; ++ }; ++ } ++ d3.interpolateNumber = d3_interpolateNumber; ++ function d3_interpolateNumber(a, b) { ++ a = +a, b = +b; ++ return function(t) { ++ return a * (1 - t) + b * t; ++ }; ++ } ++ d3.interpolateString = d3_interpolateString; ++ function d3_interpolateString(a, b) { ++ var bi = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = []; ++ a = a + "", b = b + ""; ++ while ((am = d3_interpolate_numberA.exec(a)) && (bm = d3_interpolate_numberB.exec(b))) { ++ if ((bs = bm.index) > bi) { ++ bs = b.slice(bi, bs); ++ if (s[i]) s[i] += bs; else s[++i] = bs; ++ } ++ if ((am = am[0]) === (bm = bm[0])) { ++ if (s[i]) s[i] += bm; else s[++i] = bm; ++ } else { ++ s[++i] = null; ++ q.push({ ++ i: i, ++ x: d3_interpolateNumber(am, bm) ++ }); ++ } ++ bi = d3_interpolate_numberB.lastIndex; ++ } ++ if (bi < b.length) { ++ bs = b.slice(bi); ++ if (s[i]) s[i] += bs; else s[++i] = bs; ++ } ++ return s.length < 2 ? q[0] ? (b = q[0].x, function(t) { ++ return b(t) + ""; ++ }) : function() { ++ return 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(""); ++ }); ++ } ++ var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g"); ++ d3.interpolate = d3_interpolate; ++ function d3_interpolate(a, b) { ++ var i = d3.interpolators.length, f; ++ while (--i >= 0 && !(f = d3.interpolators[i](a, b))) ; ++ return f; ++ } ++ d3.interpolators = [ function(a, b) { ++ var t = typeof b; ++ return (t === "string" ? d3_rgb_names.has(b.toLowerCase()) || /^(#|rgb\(|hsl\()/i.test(b) ? d3_interpolateRgb : d3_interpolateString : b instanceof d3_color ? d3_interpolateRgb : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b); ++ } ]; ++ d3.interpolateArray = d3_interpolateArray; ++ function d3_interpolateArray(a, b) { ++ var x = [], c = [], na = a.length, nb = b.length, n0 = Math.min(a.length, b.length), i; ++ for (i = 0; i < n0; ++i) x.push(d3_interpolate(a[i], b[i])); ++ for (;i < na; ++i) c[i] = a[i]; ++ for (;i < nb; ++i) c[i] = b[i]; ++ return function(t) { ++ for (i = 0; i < n0; ++i) c[i] = x[i](t); ++ return c; ++ }; ++ } ++ var d3_ease_default = function() { ++ return d3_identity; ++ }; ++ var d3_ease = d3.map({ ++ linear: d3_ease_default, ++ poly: d3_ease_poly, ++ quad: function() { ++ return d3_ease_quad; ++ }, ++ cubic: function() { ++ return d3_ease_cubic; ++ }, ++ sin: function() { ++ return d3_ease_sin; ++ }, ++ exp: function() { ++ return d3_ease_exp; ++ }, ++ circle: function() { ++ return d3_ease_circle; ++ }, ++ elastic: d3_ease_elastic, ++ back: d3_ease_back, ++ bounce: function() { ++ return d3_ease_bounce; ++ } ++ }); ++ var d3_ease_mode = d3.map({ ++ "in": d3_identity, ++ out: d3_ease_reverse, ++ "in-out": d3_ease_reflect, ++ "out-in": function(f) { ++ return d3_ease_reflect(d3_ease_reverse(f)); ++ } ++ }); ++ d3.ease = function(name) { ++ var i = name.indexOf("-"), t = i >= 0 ? name.slice(0, i) : name, m = i >= 0 ? name.slice(i + 1) : "in"; ++ t = d3_ease.get(t) || d3_ease_default; ++ m = d3_ease_mode.get(m) || d3_identity; ++ return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1)))); ++ }; ++ function d3_ease_clamp(f) { ++ return function(t) { ++ return t <= 0 ? 0 : t >= 1 ? 1 : f(t); ++ }; ++ } ++ function d3_ease_reverse(f) { ++ return function(t) { ++ return 1 - f(1 - t); ++ }; ++ } ++ function d3_ease_reflect(f) { ++ return function(t) { ++ return .5 * (t < .5 ? f(2 * t) : 2 - f(2 - 2 * t)); ++ }; ++ } ++ function d3_ease_quad(t) { ++ return t * t; ++ } ++ function d3_ease_cubic(t) { ++ return t * t * t; ++ } ++ function d3_ease_cubicInOut(t) { ++ if (t <= 0) return 0; ++ if (t >= 1) return 1; ++ var t2 = t * t, t3 = t2 * t; ++ return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75); ++ } ++ function d3_ease_poly(e) { ++ return function(t) { ++ return Math.pow(t, e); ++ }; ++ } ++ function d3_ease_sin(t) { ++ return 1 - Math.cos(t * halfπ); ++ } ++ function d3_ease_exp(t) { ++ return Math.pow(2, 10 * (t - 1)); ++ } ++ function d3_ease_circle(t) { ++ return 1 - Math.sqrt(1 - t * t); ++ } ++ function d3_ease_elastic(a, p) { ++ var s; ++ if (arguments.length < 2) p = .45; ++ if (arguments.length) s = p / τ * Math.asin(1 / a); else a = 1, s = p / 4; ++ return function(t) { ++ return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * τ / p); ++ }; ++ } ++ function d3_ease_back(s) { ++ if (!s) s = 1.70158; ++ return function(t) { ++ return t * t * ((s + 1) * t - s); ++ }; ++ } ++ function d3_ease_bounce(t) { ++ return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375; ++ } ++ d3.interpolateHcl = d3_interpolateHcl; ++ function d3_interpolateHcl(a, b) { ++ a = d3.hcl(a); ++ b = d3.hcl(b); ++ var ah = a.h, ac = a.c, al = a.l, bh = b.h - ah, bc = b.c - ac, bl = b.l - al; ++ if (isNaN(bc)) bc = 0, ac = isNaN(ac) ? b.c : ac; ++ if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360; ++ return function(t) { ++ return d3_hcl_lab(ah + bh * t, ac + bc * t, al + bl * t) + ""; ++ }; ++ } ++ d3.interpolateHsl = d3_interpolateHsl; ++ function d3_interpolateHsl(a, b) { ++ a = d3.hsl(a); ++ b = d3.hsl(b); ++ var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al; ++ if (isNaN(bs)) bs = 0, as = isNaN(as) ? b.s : as; ++ if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360; ++ return function(t) { ++ return d3_hsl_rgb(ah + bh * t, as + bs * t, al + bl * t) + ""; ++ }; ++ } ++ d3.interpolateLab = d3_interpolateLab; ++ function d3_interpolateLab(a, b) { ++ a = d3.lab(a); ++ b = d3.lab(b); ++ var al = a.l, aa = a.a, ab = a.b, bl = b.l - al, ba = b.a - aa, bb = b.b - ab; ++ return function(t) { ++ return d3_lab_rgb(al + bl * t, aa + ba * t, ab + bb * t) + ""; ++ }; ++ } ++ d3.interpolateRound = d3_interpolateRound; ++ function d3_interpolateRound(a, b) { ++ b -= a; ++ return function(t) { ++ return Math.round(a + b * t); ++ }; ++ } ++ d3.transform = function(string) { ++ var g = d3_document.createElementNS(d3.ns.prefix.svg, "g"); ++ return (d3.transform = function(string) { ++ if (string != null) { ++ g.setAttribute("transform", string); ++ var t = g.transform.baseVal.consolidate(); ++ } ++ return new d3_transform(t ? t.matrix : d3_transformIdentity); ++ })(string); ++ }; ++ function d3_transform(m) { ++ var r0 = [ m.a, m.b ], r1 = [ m.c, m.d ], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0; ++ if (r0[0] * r1[1] < r1[0] * r0[1]) { ++ r0[0] *= -1; ++ r0[1] *= -1; ++ kx *= -1; ++ kz *= -1; ++ } ++ this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees; ++ this.translate = [ m.e, m.f ]; ++ this.scale = [ kx, ky ]; ++ this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0; ++ } ++ d3_transform.prototype.toString = function() { ++ return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")"; ++ }; ++ function d3_transformDot(a, b) { ++ return a[0] * b[0] + a[1] * b[1]; ++ } ++ function d3_transformNormalize(a) { ++ var k = Math.sqrt(d3_transformDot(a, a)); ++ if (k) { ++ a[0] /= k; ++ a[1] /= k; ++ } ++ return k; ++ } ++ function d3_transformCombine(a, b, k) { ++ a[0] += k * b[0]; ++ a[1] += k * b[1]; ++ return a; ++ } ++ var d3_transformIdentity = { ++ a: 1, ++ b: 0, ++ c: 0, ++ d: 1, ++ e: 0, ++ f: 0 ++ }; ++ d3.interpolateTransform = d3_interpolateTransform; ++ function d3_interpolateTransformPop(s) { ++ return s.length ? s.pop() + "," : ""; ++ } ++ function d3_interpolateTranslate(ta, tb, s, q) { ++ if (ta[0] !== tb[0] || ta[1] !== tb[1]) { ++ var i = s.push("translate(", null, ",", null, ")"); ++ q.push({ ++ i: i - 4, ++ x: d3_interpolateNumber(ta[0], tb[0]) ++ }, { ++ i: i - 2, ++ x: d3_interpolateNumber(ta[1], tb[1]) ++ }); ++ } else if (tb[0] || tb[1]) { ++ s.push("translate(" + tb + ")"); ++ } ++ } ++ function d3_interpolateRotate(ra, rb, s, q) { ++ if (ra !== rb) { ++ if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360; ++ q.push({ ++ i: s.push(d3_interpolateTransformPop(s) + "rotate(", null, ")") - 2, ++ x: d3_interpolateNumber(ra, rb) ++ }); ++ } else if (rb) { ++ s.push(d3_interpolateTransformPop(s) + "rotate(" + rb + ")"); ++ } ++ } ++ function d3_interpolateSkew(wa, wb, s, q) { ++ if (wa !== wb) { ++ q.push({ ++ i: s.push(d3_interpolateTransformPop(s) + "skewX(", null, ")") - 2, ++ x: d3_interpolateNumber(wa, wb) ++ }); ++ } else if (wb) { ++ s.push(d3_interpolateTransformPop(s) + "skewX(" + wb + ")"); ++ } ++ } ++ function d3_interpolateScale(ka, kb, s, q) { ++ if (ka[0] !== kb[0] || ka[1] !== kb[1]) { ++ var i = s.push(d3_interpolateTransformPop(s) + "scale(", null, ",", null, ")"); ++ q.push({ ++ i: i - 4, ++ x: d3_interpolateNumber(ka[0], kb[0]) ++ }, { ++ i: i - 2, ++ x: d3_interpolateNumber(ka[1], kb[1]) ++ }); ++ } else if (kb[0] !== 1 || kb[1] !== 1) { ++ s.push(d3_interpolateTransformPop(s) + "scale(" + kb + ")"); ++ } ++ } ++ function d3_interpolateTransform(a, b) { ++ var s = [], q = []; ++ a = d3.transform(a), b = d3.transform(b); ++ d3_interpolateTranslate(a.translate, b.translate, s, q); ++ d3_interpolateRotate(a.rotate, b.rotate, s, q); ++ d3_interpolateSkew(a.skew, b.skew, s, q); ++ d3_interpolateScale(a.scale, b.scale, s, q); ++ a = b = null; ++ return function(t) { ++ var i = -1, n = q.length, o; ++ while (++i < n) s[(o = q[i]).i] = o.x(t); ++ return s.join(""); ++ }; ++ } ++ function d3_uninterpolateNumber(a, b) { ++ b = (b -= a = +a) || 1 / b; ++ return function(x) { ++ return (x - a) / b; ++ }; ++ } ++ function d3_uninterpolateClamp(a, b) { ++ b = (b -= a = +a) || 1 / b; ++ return function(x) { ++ return Math.max(0, Math.min(1, (x - a) / b)); ++ }; ++ } ++ d3.layout = {}; ++ d3.layout.bundle = function() { ++ return function(links) { ++ var paths = [], i = -1, n = links.length; ++ while (++i < n) paths.push(d3_layout_bundlePath(links[i])); ++ return paths; ++ }; ++ }; ++ function d3_layout_bundlePath(link) { ++ var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [ start ]; ++ while (start !== lca) { ++ start = start.parent; ++ points.push(start); ++ } ++ var k = points.length; ++ while (end !== lca) { ++ points.splice(k, 0, end); ++ end = end.parent; ++ } ++ return points; ++ } ++ function d3_layout_bundleAncestors(node) { ++ var ancestors = [], parent = node.parent; ++ while (parent != null) { ++ ancestors.push(node); ++ node = parent; ++ parent = parent.parent; ++ } ++ ancestors.push(node); ++ return ancestors; ++ } ++ function d3_layout_bundleLeastCommonAncestor(a, b) { ++ if (a === b) return a; ++ var aNodes = d3_layout_bundleAncestors(a), bNodes = d3_layout_bundleAncestors(b), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null; ++ while (aNode === bNode) { ++ sharedNode = aNode; ++ aNode = aNodes.pop(); ++ bNode = bNodes.pop(); ++ } ++ return sharedNode; ++ } ++ d3.layout.chord = function() { ++ var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords; ++ function relayout() { ++ var subgroups = {}, groupSums = [], groupIndex = d3.range(n), subgroupIndex = [], k, x, x0, i, j; ++ chords = []; ++ groups = []; ++ k = 0, i = -1; ++ while (++i < n) { ++ x = 0, j = -1; ++ while (++j < n) { ++ x += matrix[i][j]; ++ } ++ groupSums.push(x); ++ subgroupIndex.push(d3.range(n)); ++ k += x; ++ } ++ if (sortGroups) { ++ groupIndex.sort(function(a, b) { ++ return sortGroups(groupSums[a], groupSums[b]); ++ }); ++ } ++ if (sortSubgroups) { ++ subgroupIndex.forEach(function(d, i) { ++ d.sort(function(a, b) { ++ return sortSubgroups(matrix[i][a], matrix[i][b]); ++ }); ++ }); ++ } ++ k = (τ - padding * n) / k; ++ x = 0, i = -1; ++ while (++i < n) { ++ x0 = x, j = -1; ++ while (++j < n) { ++ var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k; ++ subgroups[di + "-" + dj] = { ++ index: di, ++ subindex: dj, ++ startAngle: a0, ++ endAngle: a1, ++ value: v ++ }; ++ } ++ groups[di] = { ++ index: di, ++ startAngle: x0, ++ endAngle: x, ++ value: groupSums[di] ++ }; ++ x += padding; ++ } ++ i = -1; ++ while (++i < n) { ++ j = i - 1; ++ while (++j < n) { ++ var source = subgroups[i + "-" + j], target = subgroups[j + "-" + i]; ++ if (source.value || target.value) { ++ chords.push(source.value < target.value ? { ++ source: target, ++ target: source ++ } : { ++ source: source, ++ target: target ++ }); ++ } ++ } ++ } ++ if (sortChords) resort(); ++ } ++ function resort() { ++ chords.sort(function(a, b) { ++ return sortChords((a.source.value + a.target.value) / 2, (b.source.value + b.target.value) / 2); ++ }); ++ } ++ chord.matrix = function(x) { ++ if (!arguments.length) return matrix; ++ n = (matrix = x) && matrix.length; ++ chords = groups = null; ++ return chord; ++ }; ++ chord.padding = function(x) { ++ if (!arguments.length) return padding; ++ padding = x; ++ chords = groups = null; ++ return chord; ++ }; ++ chord.sortGroups = function(x) { ++ if (!arguments.length) return sortGroups; ++ sortGroups = x; ++ chords = groups = null; ++ return chord; ++ }; ++ chord.sortSubgroups = function(x) { ++ if (!arguments.length) return sortSubgroups; ++ sortSubgroups = x; ++ chords = null; ++ return chord; ++ }; ++ chord.sortChords = function(x) { ++ if (!arguments.length) return sortChords; ++ sortChords = x; ++ if (chords) resort(); ++ return chord; ++ }; ++ chord.chords = function() { ++ if (!chords) relayout(); ++ return chords; ++ }; ++ chord.groups = function() { ++ if (!groups) relayout(); ++ return groups; ++ }; ++ return chord; ++ }; ++ d3.layout.force = function() { ++ var force = {}, event = d3.dispatch("start", "tick", "end"), timer, size = [ 1, 1 ], drag, alpha, friction = .9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, chargeDistance2 = d3_layout_forceChargeDistance2, gravity = .1, theta2 = .64, nodes = [], links = [], distances, strengths, charges; ++ function repulse(node) { ++ return function(quad, x1, _, x2) { ++ if (quad.point !== node) { ++ var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy; ++ if (dw * dw / theta2 < dn) { ++ if (dn < chargeDistance2) { ++ var k = quad.charge / dn; ++ node.px -= dx * k; ++ node.py -= dy * k; ++ } ++ return true; ++ } ++ if (quad.point && dn && dn < chargeDistance2) { ++ var k = quad.pointCharge / dn; ++ node.px -= dx * k; ++ node.py -= dy * k; ++ } ++ } ++ return !quad.charge; ++ }; ++ } ++ force.tick = function() { ++ if ((alpha *= .99) < .005) { ++ timer = null; ++ event.end({ ++ type: "end", ++ alpha: alpha = 0 ++ }); ++ return true; ++ } ++ var n = nodes.length, m = links.length, q, i, o, s, t, l, k, x, y; ++ for (i = 0; i < m; ++i) { ++ o = links[i]; ++ s = o.source; ++ t = o.target; ++ x = t.x - s.x; ++ y = t.y - s.y; ++ if (l = x * x + y * y) { ++ l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l; ++ x *= l; ++ y *= l; ++ t.x -= x * (k = s.weight + t.weight ? s.weight / (s.weight + t.weight) : .5); ++ t.y -= y * k; ++ s.x += x * (k = 1 - k); ++ s.y += y * k; ++ } ++ } ++ if (k = alpha * gravity) { ++ x = size[0] / 2; ++ y = size[1] / 2; ++ i = -1; ++ if (k) while (++i < n) { ++ o = nodes[i]; ++ o.x += (x - o.x) * k; ++ o.y += (y - o.y) * k; ++ } ++ } ++ if (charge) { ++ d3_layout_forceAccumulate(q = d3.geom.quadtree(nodes), alpha, charges); ++ i = -1; ++ while (++i < n) { ++ if (!(o = nodes[i]).fixed) { ++ q.visit(repulse(o)); ++ } ++ } ++ } ++ i = -1; ++ while (++i < n) { ++ o = nodes[i]; ++ if (o.fixed) { ++ o.x = o.px; ++ o.y = o.py; ++ } else { ++ o.x -= (o.px - (o.px = o.x)) * friction; ++ o.y -= (o.py - (o.py = o.y)) * friction; ++ } ++ } ++ event.tick({ ++ type: "tick", ++ alpha: alpha ++ }); ++ }; ++ force.nodes = function(x) { ++ if (!arguments.length) return nodes; ++ nodes = x; ++ return force; ++ }; ++ force.links = function(x) { ++ if (!arguments.length) return links; ++ links = x; ++ return force; ++ }; ++ force.size = function(x) { ++ if (!arguments.length) return size; ++ size = x; ++ return force; ++ }; ++ force.linkDistance = function(x) { ++ if (!arguments.length) return linkDistance; ++ linkDistance = typeof x === "function" ? x : +x; ++ return force; ++ }; ++ force.distance = force.linkDistance; ++ force.linkStrength = function(x) { ++ if (!arguments.length) return linkStrength; ++ linkStrength = typeof x === "function" ? x : +x; ++ return force; ++ }; ++ force.friction = function(x) { ++ if (!arguments.length) return friction; ++ friction = +x; ++ return force; ++ }; ++ force.charge = function(x) { ++ if (!arguments.length) return charge; ++ charge = typeof x === "function" ? x : +x; ++ return force; ++ }; ++ force.chargeDistance = function(x) { ++ if (!arguments.length) return Math.sqrt(chargeDistance2); ++ chargeDistance2 = x * x; ++ return force; ++ }; ++ force.gravity = function(x) { ++ if (!arguments.length) return gravity; ++ gravity = +x; ++ return force; ++ }; ++ force.theta = function(x) { ++ if (!arguments.length) return Math.sqrt(theta2); ++ theta2 = x * x; ++ return force; ++ }; ++ force.alpha = function(x) { ++ if (!arguments.length) return alpha; ++ x = +x; ++ if (alpha) { ++ if (x > 0) { ++ alpha = x; ++ } else { ++ timer.c = null, timer.t = NaN, timer = null; ++ event.end({ ++ type: "end", ++ alpha: alpha = 0 ++ }); ++ } ++ } else if (x > 0) { ++ event.start({ ++ type: "start", ++ alpha: alpha = x ++ }); ++ timer = d3_timer(force.tick); ++ } ++ return force; ++ }; ++ force.start = function() { ++ var i, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o; ++ for (i = 0; i < n; ++i) { ++ (o = nodes[i]).index = i; ++ o.weight = 0; ++ } ++ for (i = 0; i < m; ++i) { ++ o = links[i]; ++ if (typeof o.source == "number") o.source = nodes[o.source]; ++ if (typeof o.target == "number") o.target = nodes[o.target]; ++ ++o.source.weight; ++ ++o.target.weight; ++ } ++ for (i = 0; i < n; ++i) { ++ o = nodes[i]; ++ if (isNaN(o.x)) o.x = position("x", w); ++ if (isNaN(o.y)) o.y = position("y", h); ++ if (isNaN(o.px)) o.px = o.x; ++ if (isNaN(o.py)) o.py = o.y; ++ } ++ distances = []; ++ if (typeof linkDistance === "function") for (i = 0; i < m; ++i) distances[i] = +linkDistance.call(this, links[i], i); else for (i = 0; i < m; ++i) distances[i] = linkDistance; ++ strengths = []; ++ if (typeof linkStrength === "function") for (i = 0; i < m; ++i) strengths[i] = +linkStrength.call(this, links[i], i); else for (i = 0; i < m; ++i) strengths[i] = linkStrength; ++ charges = []; ++ if (typeof charge === "function") for (i = 0; i < n; ++i) charges[i] = +charge.call(this, nodes[i], i); else for (i = 0; i < n; ++i) charges[i] = charge; ++ function position(dimension, size) { ++ if (!neighbors) { ++ neighbors = new Array(n); ++ for (j = 0; j < n; ++j) { ++ neighbors[j] = []; ++ } ++ for (j = 0; j < m; ++j) { ++ var o = links[j]; ++ neighbors[o.source.index].push(o.target); ++ neighbors[o.target.index].push(o.source); ++ } ++ } ++ var candidates = neighbors[i], j = -1, l = candidates.length, x; ++ while (++j < l) if (!isNaN(x = candidates[j][dimension])) return x; ++ return Math.random() * size; ++ } ++ return force.resume(); ++ }; ++ force.resume = function() { ++ return force.alpha(.1); ++ }; ++ force.stop = function() { ++ return force.alpha(0); ++ }; ++ force.drag = function() { ++ if (!drag) drag = d3.behavior.drag().origin(d3_identity).on("dragstart.force", d3_layout_forceDragstart).on("drag.force", dragmove).on("dragend.force", d3_layout_forceDragend); ++ if (!arguments.length) return drag; ++ this.on("mouseover.force", d3_layout_forceMouseover).on("mouseout.force", d3_layout_forceMouseout).call(drag); ++ }; ++ function dragmove(d) { ++ d.px = d3.event.x, d.py = d3.event.y; ++ force.resume(); ++ } ++ return d3.rebind(force, event, "on"); ++ }; ++ function d3_layout_forceDragstart(d) { ++ d.fixed |= 2; ++ } ++ function d3_layout_forceDragend(d) { ++ d.fixed &= ~6; ++ } ++ function d3_layout_forceMouseover(d) { ++ d.fixed |= 4; ++ d.px = d.x, d.py = d.y; ++ } ++ function d3_layout_forceMouseout(d) { ++ d.fixed &= ~4; ++ } ++ function d3_layout_forceAccumulate(quad, alpha, charges) { ++ var cx = 0, cy = 0; ++ quad.charge = 0; ++ if (!quad.leaf) { ++ var nodes = quad.nodes, n = nodes.length, i = -1, c; ++ while (++i < n) { ++ c = nodes[i]; ++ if (c == null) continue; ++ d3_layout_forceAccumulate(c, alpha, charges); ++ quad.charge += c.charge; ++ cx += c.charge * c.cx; ++ cy += c.charge * c.cy; ++ } ++ } ++ if (quad.point) { ++ if (!quad.leaf) { ++ quad.point.x += Math.random() - .5; ++ quad.point.y += Math.random() - .5; ++ } ++ var k = alpha * charges[quad.point.index]; ++ quad.charge += quad.pointCharge = k; ++ cx += k * quad.point.x; ++ cy += k * quad.point.y; ++ } ++ quad.cx = cx / quad.charge; ++ quad.cy = cy / quad.charge; ++ } ++ var d3_layout_forceLinkDistance = 20, d3_layout_forceLinkStrength = 1, d3_layout_forceChargeDistance2 = Infinity; ++ d3.layout.hierarchy = function() { ++ var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue; ++ function hierarchy(root) { ++ var stack = [ root ], nodes = [], node; ++ root.depth = 0; ++ while ((node = stack.pop()) != null) { ++ nodes.push(node); ++ if ((childs = children.call(hierarchy, node, node.depth)) && (n = childs.length)) { ++ var n, childs, child; ++ while (--n >= 0) { ++ stack.push(child = childs[n]); ++ child.parent = node; ++ child.depth = node.depth + 1; ++ } ++ if (value) node.value = 0; ++ node.children = childs; ++ } else { ++ if (value) node.value = +value.call(hierarchy, node, node.depth) || 0; ++ delete node.children; ++ } ++ } ++ d3_layout_hierarchyVisitAfter(root, function(node) { ++ var childs, parent; ++ if (sort && (childs = node.children)) childs.sort(sort); ++ if (value && (parent = node.parent)) parent.value += node.value; ++ }); ++ return nodes; ++ } ++ hierarchy.sort = function(x) { ++ if (!arguments.length) return sort; ++ sort = x; ++ return hierarchy; ++ }; ++ hierarchy.children = function(x) { ++ if (!arguments.length) return children; ++ children = x; ++ return hierarchy; ++ }; ++ hierarchy.value = function(x) { ++ if (!arguments.length) return value; ++ value = x; ++ return hierarchy; ++ }; ++ hierarchy.revalue = function(root) { ++ if (value) { ++ d3_layout_hierarchyVisitBefore(root, function(node) { ++ if (node.children) node.value = 0; ++ }); ++ d3_layout_hierarchyVisitAfter(root, function(node) { ++ var parent; ++ if (!node.children) node.value = +value.call(hierarchy, node, node.depth) || 0; ++ if (parent = node.parent) parent.value += node.value; ++ }); ++ } ++ return root; ++ }; ++ return hierarchy; ++ }; ++ function d3_layout_hierarchyRebind(object, hierarchy) { ++ d3.rebind(object, hierarchy, "sort", "children", "value"); ++ object.nodes = object; ++ object.links = d3_layout_hierarchyLinks; ++ return object; ++ } ++ function d3_layout_hierarchyVisitBefore(node, callback) { ++ var nodes = [ node ]; ++ while ((node = nodes.pop()) != null) { ++ callback(node); ++ if ((children = node.children) && (n = children.length)) { ++ var n, children; ++ while (--n >= 0) nodes.push(children[n]); ++ } ++ } ++ } ++ function d3_layout_hierarchyVisitAfter(node, callback) { ++ var nodes = [ node ], nodes2 = []; ++ while ((node = nodes.pop()) != null) { ++ nodes2.push(node); ++ if ((children = node.children) && (n = children.length)) { ++ var i = -1, n, children; ++ while (++i < n) nodes.push(children[i]); ++ } ++ } ++ while ((node = nodes2.pop()) != null) { ++ callback(node); ++ } ++ } ++ function d3_layout_hierarchyChildren(d) { ++ return d.children; ++ } ++ function d3_layout_hierarchyValue(d) { ++ return d.value; ++ } ++ function d3_layout_hierarchySort(a, b) { ++ return b.value - a.value; ++ } ++ function d3_layout_hierarchyLinks(nodes) { ++ return d3.merge(nodes.map(function(parent) { ++ return (parent.children || []).map(function(child) { ++ return { ++ source: parent, ++ target: child ++ }; ++ }); ++ })); ++ } ++ d3.layout.partition = function() { ++ var hierarchy = d3.layout.hierarchy(), size = [ 1, 1 ]; ++ function position(node, x, dx, dy) { ++ var children = node.children; ++ node.x = x; ++ node.y = node.depth * dy; ++ node.dx = dx; ++ node.dy = dy; ++ if (children && (n = children.length)) { ++ var i = -1, n, c, d; ++ dx = node.value ? dx / node.value : 0; ++ while (++i < n) { ++ position(c = children[i], x, d = c.value * dx, dy); ++ x += d; ++ } ++ } ++ } ++ function depth(node) { ++ var children = node.children, d = 0; ++ if (children && (n = children.length)) { ++ var i = -1, n; ++ while (++i < n) d = Math.max(d, depth(children[i])); ++ } ++ return 1 + d; ++ } ++ function partition(d, i) { ++ var nodes = hierarchy.call(this, d, i); ++ position(nodes[0], 0, size[0], size[1] / depth(nodes[0])); ++ return nodes; ++ } ++ partition.size = function(x) { ++ if (!arguments.length) return size; ++ size = x; ++ return partition; ++ }; ++ return d3_layout_hierarchyRebind(partition, hierarchy); ++ }; ++ d3.layout.pie = function() { ++ var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ, padAngle = 0; ++ function pie(data) { ++ var n = data.length, values = data.map(function(d, i) { ++ return +value.call(pie, d, i); ++ }), a = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle), da = (typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - a, p = Math.min(Math.abs(da) / n, +(typeof padAngle === "function" ? padAngle.apply(this, arguments) : padAngle)), pa = p * (da < 0 ? -1 : 1), sum = d3.sum(values), k = sum ? (da - n * pa) / sum : 0, index = d3.range(n), arcs = [], v; ++ if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) { ++ return values[j] - values[i]; ++ } : function(i, j) { ++ return sort(data[i], data[j]); ++ }); ++ index.forEach(function(i) { ++ arcs[i] = { ++ data: data[i], ++ value: v = values[i], ++ startAngle: a, ++ endAngle: a += v * k + pa, ++ padAngle: p ++ }; ++ }); ++ return arcs; ++ } ++ pie.value = function(_) { ++ if (!arguments.length) return value; ++ value = _; ++ return pie; ++ }; ++ pie.sort = function(_) { ++ if (!arguments.length) return sort; ++ sort = _; ++ return pie; ++ }; ++ pie.startAngle = function(_) { ++ if (!arguments.length) return startAngle; ++ startAngle = _; ++ return pie; ++ }; ++ pie.endAngle = function(_) { ++ if (!arguments.length) return endAngle; ++ endAngle = _; ++ return pie; ++ }; ++ pie.padAngle = function(_) { ++ if (!arguments.length) return padAngle; ++ padAngle = _; ++ return pie; ++ }; ++ return pie; ++ }; ++ var d3_layout_pieSortByValue = {}; ++ d3.layout.stack = function() { ++ var values = d3_identity, order = d3_layout_stackOrderDefault, offset = d3_layout_stackOffsetZero, out = d3_layout_stackOut, x = d3_layout_stackX, y = d3_layout_stackY; ++ function stack(data, index) { ++ if (!(n = data.length)) return data; ++ var series = data.map(function(d, i) { ++ return values.call(stack, d, i); ++ }); ++ var points = series.map(function(d) { ++ return d.map(function(v, i) { ++ return [ x.call(stack, v, i), y.call(stack, v, i) ]; ++ }); ++ }); ++ var orders = order.call(stack, points, index); ++ series = d3.permute(series, orders); ++ points = d3.permute(points, orders); ++ var offsets = offset.call(stack, points, index); ++ var m = series[0].length, n, i, j, o; ++ for (j = 0; j < m; ++j) { ++ out.call(stack, series[0][j], o = offsets[j], points[0][j][1]); ++ for (i = 1; i < n; ++i) { ++ out.call(stack, series[i][j], o += points[i - 1][j][1], points[i][j][1]); ++ } ++ } ++ return data; ++ } ++ stack.values = function(x) { ++ if (!arguments.length) return values; ++ values = x; ++ return stack; ++ }; ++ stack.order = function(x) { ++ if (!arguments.length) return order; ++ order = typeof x === "function" ? x : d3_layout_stackOrders.get(x) || d3_layout_stackOrderDefault; ++ return stack; ++ }; ++ stack.offset = function(x) { ++ if (!arguments.length) return offset; ++ offset = typeof x === "function" ? x : d3_layout_stackOffsets.get(x) || d3_layout_stackOffsetZero; ++ return stack; ++ }; ++ stack.x = function(z) { ++ if (!arguments.length) return x; ++ x = z; ++ return stack; ++ }; ++ stack.y = function(z) { ++ if (!arguments.length) return y; ++ y = z; ++ return stack; ++ }; ++ stack.out = function(z) { ++ if (!arguments.length) return out; ++ out = z; ++ return stack; ++ }; ++ return stack; ++ }; ++ function d3_layout_stackX(d) { ++ return d.x; ++ } ++ function d3_layout_stackY(d) { ++ return d.y; ++ } ++ function d3_layout_stackOut(d, y0, y) { ++ d.y0 = y0; ++ d.y = y; ++ } ++ var d3_layout_stackOrders = d3.map({ ++ "inside-out": function(data) { ++ var n = data.length, i, j, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n).sort(function(a, b) { ++ return max[a] - max[b]; ++ }), top = 0, bottom = 0, tops = [], bottoms = []; ++ for (i = 0; i < n; ++i) { ++ j = index[i]; ++ if (top < bottom) { ++ top += sums[j]; ++ tops.push(j); ++ } else { ++ bottom += sums[j]; ++ bottoms.push(j); ++ } ++ } ++ return bottoms.reverse().concat(tops); ++ }, ++ reverse: function(data) { ++ return d3.range(data.length).reverse(); ++ }, ++ "default": d3_layout_stackOrderDefault ++ }); ++ var d3_layout_stackOffsets = d3.map({ ++ silhouette: function(data) { ++ var n = data.length, m = data[0].length, sums = [], max = 0, i, j, o, y0 = []; ++ for (j = 0; j < m; ++j) { ++ for (i = 0, o = 0; i < n; i++) o += data[i][j][1]; ++ if (o > max) max = o; ++ sums.push(o); ++ } ++ for (j = 0; j < m; ++j) { ++ y0[j] = (max - sums[j]) / 2; ++ } ++ return y0; ++ }, ++ wiggle: function(data) { ++ var n = data.length, x = data[0], m = x.length, i, j, k, s1, s2, s3, dx, o, o0, y0 = []; ++ y0[0] = o = o0 = 0; ++ for (j = 1; j < m; ++j) { ++ for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j][1]; ++ for (i = 0, s2 = 0, dx = x[j][0] - x[j - 1][0]; i < n; ++i) { ++ for (k = 0, s3 = (data[i][j][1] - data[i][j - 1][1]) / (2 * dx); k < i; ++k) { ++ s3 += (data[k][j][1] - data[k][j - 1][1]) / dx; ++ } ++ s2 += s3 * data[i][j][1]; ++ } ++ y0[j] = o -= s1 ? s2 / s1 * dx : 0; ++ if (o < o0) o0 = o; ++ } ++ for (j = 0; j < m; ++j) y0[j] -= o0; ++ return y0; ++ }, ++ expand: function(data) { ++ var n = data.length, m = data[0].length, k = 1 / n, i, j, o, y0 = []; ++ for (j = 0; j < m; ++j) { ++ for (i = 0, o = 0; i < n; i++) o += data[i][j][1]; ++ if (o) for (i = 0; i < n; i++) data[i][j][1] /= o; else for (i = 0; i < n; i++) data[i][j][1] = k; ++ } ++ for (j = 0; j < m; ++j) y0[j] = 0; ++ return y0; ++ }, ++ zero: d3_layout_stackOffsetZero ++ }); ++ function d3_layout_stackOrderDefault(data) { ++ return d3.range(data.length); ++ } ++ function d3_layout_stackOffsetZero(data) { ++ var j = -1, m = data[0].length, y0 = []; ++ while (++j < m) y0[j] = 0; ++ return y0; ++ } ++ function d3_layout_stackMaxIndex(array) { ++ var i = 1, j = 0, v = array[0][1], k, n = array.length; ++ for (;i < n; ++i) { ++ if ((k = array[i][1]) > v) { ++ j = i; ++ v = k; ++ } ++ } ++ return j; ++ } ++ function d3_layout_stackReduceSum(d) { ++ return d.reduce(d3_layout_stackSum, 0); ++ } ++ function d3_layout_stackSum(p, d) { ++ return p + d[1]; ++ } ++ d3.layout.histogram = function() { ++ var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges; ++ function histogram(data, i) { ++ var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i), thresholds = binner.call(this, range, values, i), bin, i = -1, n = values.length, m = thresholds.length - 1, k = frequency ? 1 : 1 / n, x; ++ while (++i < m) { ++ bin = bins[i] = []; ++ bin.dx = thresholds[i + 1] - (bin.x = thresholds[i]); ++ bin.y = 0; ++ } ++ if (m > 0) { ++ i = -1; ++ while (++i < n) { ++ x = values[i]; ++ if (x >= range[0] && x <= range[1]) { ++ bin = bins[d3.bisect(thresholds, x, 1, m) - 1]; ++ bin.y += k; ++ bin.push(data[i]); ++ } ++ } ++ } ++ return bins; ++ } ++ histogram.value = function(x) { ++ if (!arguments.length) return valuer; ++ valuer = x; ++ return histogram; ++ }; ++ histogram.range = function(x) { ++ if (!arguments.length) return ranger; ++ ranger = d3_functor(x); ++ return histogram; ++ }; ++ histogram.bins = function(x) { ++ if (!arguments.length) return binner; ++ binner = typeof x === "number" ? function(range) { ++ return d3_layout_histogramBinFixed(range, x); ++ } : d3_functor(x); ++ return histogram; ++ }; ++ histogram.frequency = function(x) { ++ if (!arguments.length) return frequency; ++ frequency = !!x; ++ return histogram; ++ }; ++ return histogram; ++ }; ++ function d3_layout_histogramBinSturges(range, values) { ++ return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1)); ++ } ++ function d3_layout_histogramBinFixed(range, n) { ++ var x = -1, b = +range[0], m = (range[1] - b) / n, f = []; ++ while (++x <= n) f[x] = m * x + b; ++ return f; ++ } ++ function d3_layout_histogramRange(values) { ++ return [ d3.min(values), d3.max(values) ]; ++ } ++ d3.layout.pack = function() { ++ var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), padding = 0, size = [ 1, 1 ], radius; ++ function pack(d, i) { ++ var nodes = hierarchy.call(this, d, i), root = nodes[0], w = size[0], h = size[1], r = radius == null ? Math.sqrt : typeof radius === "function" ? radius : function() { ++ return radius; ++ }; ++ root.x = root.y = 0; ++ d3_layout_hierarchyVisitAfter(root, function(d) { ++ d.r = +r(d.value); ++ }); ++ d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings); ++ if (padding) { ++ var dr = padding * (radius ? 1 : Math.max(2 * root.r / w, 2 * root.r / h)) / 2; ++ d3_layout_hierarchyVisitAfter(root, function(d) { ++ d.r += dr; ++ }); ++ d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings); ++ d3_layout_hierarchyVisitAfter(root, function(d) { ++ d.r -= dr; ++ }); ++ } ++ d3_layout_packTransform(root, w / 2, h / 2, radius ? 1 : 1 / Math.max(2 * root.r / w, 2 * root.r / h)); ++ return nodes; ++ } ++ pack.size = function(_) { ++ if (!arguments.length) return size; ++ size = _; ++ return pack; ++ }; ++ pack.radius = function(_) { ++ if (!arguments.length) return radius; ++ radius = _ == null || typeof _ === "function" ? _ : +_; ++ return pack; ++ }; ++ pack.padding = function(_) { ++ if (!arguments.length) return padding; ++ padding = +_; ++ return pack; ++ }; ++ return d3_layout_hierarchyRebind(pack, hierarchy); ++ }; ++ function d3_layout_packSort(a, b) { ++ return a.value - b.value; ++ } ++ function d3_layout_packInsert(a, b) { ++ var c = a._pack_next; ++ a._pack_next = b; ++ b._pack_prev = a; ++ b._pack_next = c; ++ c._pack_prev = b; ++ } ++ function d3_layout_packSplice(a, b) { ++ a._pack_next = b; ++ b._pack_prev = a; ++ } ++ function d3_layout_packIntersects(a, b) { ++ var dx = b.x - a.x, dy = b.y - a.y, dr = a.r + b.r; ++ return .999 * dr * dr > dx * dx + dy * dy; ++ } ++ function d3_layout_packSiblings(node) { ++ if (!(nodes = node.children) || !(n = nodes.length)) return; ++ var nodes, xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, a, b, c, i, j, k, n; ++ function bound(node) { ++ xMin = Math.min(node.x - node.r, xMin); ++ xMax = Math.max(node.x + node.r, xMax); ++ yMin = Math.min(node.y - node.r, yMin); ++ yMax = Math.max(node.y + node.r, yMax); ++ } ++ nodes.forEach(d3_layout_packLink); ++ a = nodes[0]; ++ a.x = -a.r; ++ a.y = 0; ++ bound(a); ++ if (n > 1) { ++ b = nodes[1]; ++ b.x = b.r; ++ b.y = 0; ++ bound(b); ++ if (n > 2) { ++ c = nodes[2]; ++ d3_layout_packPlace(a, b, c); ++ bound(c); ++ d3_layout_packInsert(a, c); ++ a._pack_prev = c; ++ d3_layout_packInsert(c, b); ++ b = a._pack_next; ++ for (i = 3; i < n; i++) { ++ d3_layout_packPlace(a, b, c = nodes[i]); ++ var isect = 0, s1 = 1, s2 = 1; ++ for (j = b._pack_next; j !== b; j = j._pack_next, s1++) { ++ if (d3_layout_packIntersects(j, c)) { ++ isect = 1; ++ break; ++ } ++ } ++ if (isect == 1) { ++ for (k = a._pack_prev; k !== j._pack_prev; k = k._pack_prev, s2++) { ++ if (d3_layout_packIntersects(k, c)) { ++ break; ++ } ++ } ++ } ++ if (isect) { ++ if (s1 < s2 || s1 == s2 && b.r < a.r) d3_layout_packSplice(a, b = j); else d3_layout_packSplice(a = k, b); ++ i--; ++ } else { ++ d3_layout_packInsert(a, c); ++ b = c; ++ bound(c); ++ } ++ } ++ } ++ } ++ var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0; ++ for (i = 0; i < n; i++) { ++ c = nodes[i]; ++ c.x -= cx; ++ c.y -= cy; ++ cr = Math.max(cr, c.r + Math.sqrt(c.x * c.x + c.y * c.y)); ++ } ++ node.r = cr; ++ nodes.forEach(d3_layout_packUnlink); ++ } ++ function d3_layout_packLink(node) { ++ node._pack_next = node._pack_prev = node; ++ } ++ function d3_layout_packUnlink(node) { ++ delete node._pack_next; ++ delete node._pack_prev; ++ } ++ function d3_layout_packTransform(node, x, y, k) { ++ var children = node.children; ++ node.x = x += k * node.x; ++ node.y = y += k * node.y; ++ node.r *= k; ++ if (children) { ++ var i = -1, n = children.length; ++ while (++i < n) d3_layout_packTransform(children[i], x, y, k); ++ } ++ } ++ function d3_layout_packPlace(a, b, c) { ++ var db = a.r + c.r, dx = b.x - a.x, dy = b.y - a.y; ++ if (db && (dx || dy)) { ++ var da = b.r + c.r, dc = dx * dx + dy * dy; ++ da *= da; ++ db *= db; ++ var x = .5 + (db - da) / (2 * dc), y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc); ++ c.x = a.x + x * dx + y * dy; ++ c.y = a.y + x * dy - y * dx; ++ } else { ++ c.x = a.x + db; ++ c.y = a.y; ++ } ++ } ++ d3.layout.tree = function() { ++ var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = null; ++ function tree(d, i) { ++ var nodes = hierarchy.call(this, d, i), root0 = nodes[0], root1 = wrapTree(root0); ++ d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z; ++ d3_layout_hierarchyVisitBefore(root1, secondWalk); ++ if (nodeSize) d3_layout_hierarchyVisitBefore(root0, sizeNode); else { ++ var left = root0, right = root0, bottom = root0; ++ d3_layout_hierarchyVisitBefore(root0, function(node) { ++ if (node.x < left.x) left = node; ++ if (node.x > right.x) right = node; ++ if (node.depth > bottom.depth) bottom = node; ++ }); ++ var tx = separation(left, right) / 2 - left.x, kx = size[0] / (right.x + separation(right, left) / 2 + tx), ky = size[1] / (bottom.depth || 1); ++ d3_layout_hierarchyVisitBefore(root0, function(node) { ++ node.x = (node.x + tx) * kx; ++ node.y = node.depth * ky; ++ }); ++ } ++ return nodes; ++ } ++ function wrapTree(root0) { ++ var root1 = { ++ A: null, ++ children: [ root0 ] ++ }, queue = [ root1 ], node1; ++ while ((node1 = queue.pop()) != null) { ++ for (var children = node1.children, child, i = 0, n = children.length; i < n; ++i) { ++ queue.push((children[i] = child = { ++ _: children[i], ++ parent: node1, ++ children: (child = children[i].children) && child.slice() || [], ++ A: null, ++ a: null, ++ z: 0, ++ m: 0, ++ c: 0, ++ s: 0, ++ t: null, ++ i: i ++ }).a = child); ++ } ++ } ++ return root1.children[0]; ++ } ++ function firstWalk(v) { ++ var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null; ++ if (children.length) { ++ d3_layout_treeShift(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]); ++ } ++ function secondWalk(v) { ++ v._.x = v.z + v.parent.m; ++ v.m += v.parent.m; ++ } ++ 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 = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) { ++ vom = d3_layout_treeLeft(vom); ++ vop = d3_layout_treeRight(vop); ++ vop.a = v; ++ shift = vim.z + sim - vip.z - sip + separation(vim._, vip._); ++ if (shift > 0) { ++ d3_layout_treeMove(d3_layout_treeAncestor(vim, v, ancestor), v, shift); ++ sip += shift; ++ sop += shift; ++ } ++ sim += vim.m; ++ sip += vip.m; ++ som += vom.m; ++ sop += vop.m; ++ } ++ if (vim && !d3_layout_treeRight(vop)) { ++ vop.t = vim; ++ vop.m += sim - sop; ++ } ++ if (vip && !d3_layout_treeLeft(vom)) { ++ vom.t = vip; ++ vom.m += sip - som; ++ ancestor = v; ++ } ++ } ++ return ancestor; ++ } ++ function sizeNode(node) { ++ node.x *= size[0]; ++ node.y = node.depth * size[1]; ++ } ++ tree.separation = function(x) { ++ if (!arguments.length) return separation; ++ separation = x; ++ return tree; ++ }; ++ tree.size = function(x) { ++ if (!arguments.length) return nodeSize ? null : size; ++ nodeSize = (size = x) == null ? sizeNode : null; ++ return tree; ++ }; ++ tree.nodeSize = function(x) { ++ if (!arguments.length) return nodeSize ? size : null; ++ nodeSize = (size = x) == null ? null : sizeNode; ++ return tree; ++ }; ++ return d3_layout_hierarchyRebind(tree, hierarchy); ++ }; ++ function d3_layout_treeSeparation(a, b) { ++ return a.parent == b.parent ? 1 : 2; ++ } ++ function d3_layout_treeLeft(v) { ++ var children = v.children; ++ return children.length ? children[0] : v.t; ++ } ++ function d3_layout_treeRight(v) { ++ var children = v.children, n; ++ return (n = children.length) ? children[n - 1] : v.t; ++ } ++ function d3_layout_treeMove(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; ++ } ++ function d3_layout_treeShift(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); ++ } ++ } ++ function d3_layout_treeAncestor(vim, v, ancestor) { ++ return vim.a.parent === v.parent ? vim.a : ancestor; ++ } ++ d3.layout.cluster = function() { ++ var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = false; ++ function cluster(d, i) { ++ var nodes = hierarchy.call(this, d, i), root = nodes[0], previousNode, x = 0; ++ d3_layout_hierarchyVisitAfter(root, function(node) { ++ var children = node.children; ++ if (children && children.length) { ++ node.x = d3_layout_clusterX(children); ++ node.y = d3_layout_clusterY(children); ++ } else { ++ node.x = previousNode ? x += separation(node, previousNode) : 0; ++ node.y = 0; ++ previousNode = node; ++ } ++ }); ++ var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2; ++ d3_layout_hierarchyVisitAfter(root, nodeSize ? function(node) { ++ node.x = (node.x - root.x) * size[0]; ++ node.y = (root.y - node.y) * size[1]; ++ } : function(node) { ++ node.x = (node.x - x0) / (x1 - x0) * size[0]; ++ node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1]; ++ }); ++ return nodes; ++ } ++ cluster.separation = function(x) { ++ if (!arguments.length) return separation; ++ separation = x; ++ return cluster; ++ }; ++ cluster.size = function(x) { ++ if (!arguments.length) return nodeSize ? null : size; ++ nodeSize = (size = x) == null; ++ return cluster; ++ }; ++ cluster.nodeSize = function(x) { ++ if (!arguments.length) return nodeSize ? size : null; ++ nodeSize = (size = x) != null; ++ return cluster; ++ }; ++ return d3_layout_hierarchyRebind(cluster, hierarchy); ++ }; ++ function d3_layout_clusterY(children) { ++ return 1 + d3.max(children, function(child) { ++ return child.y; ++ }); ++ } ++ function d3_layout_clusterX(children) { ++ return children.reduce(function(x, child) { ++ return x + child.x; ++ }, 0) / children.length; ++ } ++ function d3_layout_clusterLeft(node) { ++ var children = node.children; ++ return children && children.length ? d3_layout_clusterLeft(children[0]) : node; ++ } ++ function d3_layout_clusterRight(node) { ++ var children = node.children, n; ++ return children && (n = children.length) ? d3_layout_clusterRight(children[n - 1]) : node; ++ } ++ d3.layout.treemap = function() { ++ var hierarchy = d3.layout.hierarchy(), round = Math.round, size = [ 1, 1 ], padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, mode = "squarify", ratio = .5 * (1 + Math.sqrt(5)); ++ function scale(children, k) { ++ var i = -1, n = children.length, child, area; ++ while (++i < n) { ++ area = (child = children[i]).value * (k < 0 ? 0 : k); ++ child.area = isNaN(area) || area <= 0 ? 0 : area; ++ } ++ } ++ function squarify(node) { ++ var children = node.children; ++ if (children && children.length) { ++ var rect = pad(node), row = [], remaining = children.slice(), child, best = Infinity, score, u = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy), n; ++ scale(remaining, rect.dx * rect.dy / node.value); ++ row.area = 0; ++ while ((n = remaining.length) > 0) { ++ row.push(child = remaining[n - 1]); ++ row.area += child.area; ++ if (mode !== "squarify" || (score = worst(row, u)) <= best) { ++ remaining.pop(); ++ best = score; ++ } else { ++ row.area -= row.pop().area; ++ position(row, u, rect, false); ++ u = Math.min(rect.dx, rect.dy); ++ row.length = row.area = 0; ++ best = Infinity; ++ } ++ } ++ if (row.length) { ++ position(row, u, rect, true); ++ row.length = row.area = 0; ++ } ++ children.forEach(squarify); ++ } ++ } ++ function stickify(node) { ++ var children = node.children; ++ if (children && children.length) { ++ var rect = pad(node), remaining = children.slice(), child, row = []; ++ scale(remaining, rect.dx * rect.dy / node.value); ++ row.area = 0; ++ while (child = remaining.pop()) { ++ row.push(child); ++ row.area += child.area; ++ if (child.z != null) { ++ position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length); ++ row.length = row.area = 0; ++ } ++ } ++ children.forEach(stickify); ++ } ++ } ++ function worst(row, u) { ++ var s = row.area, r, rmax = 0, rmin = Infinity, i = -1, n = row.length; ++ while (++i < n) { ++ if (!(r = row[i].area)) continue; ++ if (r < rmin) rmin = r; ++ if (r > rmax) rmax = r; ++ } ++ s *= s; ++ u *= u; ++ return s ? Math.max(u * rmax * ratio / s, s / (u * rmin * ratio)) : Infinity; ++ } ++ function position(row, u, rect, flush) { ++ var i = -1, n = row.length, x = rect.x, y = rect.y, v = u ? round(row.area / u) : 0, o; ++ if (u == rect.dx) { ++ if (flush || v > rect.dy) v = rect.dy; ++ while (++i < n) { ++ o = row[i]; ++ o.x = x; ++ o.y = y; ++ o.dy = v; ++ x += o.dx = Math.min(rect.x + rect.dx - x, v ? round(o.area / v) : 0); ++ } ++ o.z = true; ++ o.dx += rect.x + rect.dx - x; ++ rect.y += v; ++ rect.dy -= v; ++ } else { ++ if (flush || v > rect.dx) v = rect.dx; ++ while (++i < n) { ++ o = row[i]; ++ o.x = x; ++ o.y = y; ++ o.dx = v; ++ y += o.dy = Math.min(rect.y + rect.dy - y, v ? round(o.area / v) : 0); ++ } ++ o.z = false; ++ o.dy += rect.y + rect.dy - y; ++ rect.x += v; ++ rect.dx -= v; ++ } ++ } ++ function treemap(d) { ++ var nodes = stickies || hierarchy(d), root = nodes[0]; ++ root.x = root.y = 0; ++ if (root.value) root.dx = size[0], root.dy = size[1]; else root.dx = root.dy = 0; ++ if (stickies) hierarchy.revalue(root); ++ scale([ root ], root.dx * root.dy / root.value); ++ (stickies ? stickify : squarify)(root); ++ if (sticky) stickies = nodes; ++ return nodes; ++ } ++ treemap.size = function(x) { ++ if (!arguments.length) return size; ++ size = x; ++ return treemap; ++ }; ++ treemap.padding = function(x) { ++ if (!arguments.length) return padding; ++ function padFunction(node) { ++ var p = x.call(treemap, node, node.depth); ++ return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [ p, p, p, p ] : p); ++ } ++ function padConstant(node) { ++ return d3_layout_treemapPad(node, x); ++ } ++ var type; ++ pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [ x, x, x, x ], ++ padConstant) : padConstant; ++ return treemap; ++ }; ++ treemap.round = function(x) { ++ if (!arguments.length) return round != Number; ++ round = x ? Math.round : Number; ++ return treemap; ++ }; ++ treemap.sticky = function(x) { ++ if (!arguments.length) return sticky; ++ sticky = x; ++ stickies = null; ++ return treemap; ++ }; ++ treemap.ratio = function(x) { ++ if (!arguments.length) return ratio; ++ ratio = x; ++ return treemap; ++ }; ++ treemap.mode = function(x) { ++ if (!arguments.length) return mode; ++ mode = x + ""; ++ return treemap; ++ }; ++ return d3_layout_hierarchyRebind(treemap, hierarchy); ++ }; ++ function d3_layout_treemapPadNull(node) { ++ return { ++ x: node.x, ++ y: node.y, ++ dx: node.dx, ++ dy: node.dy ++ }; ++ } ++ function d3_layout_treemapPad(node, padding) { ++ var x = node.x + padding[3], y = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2]; ++ if (dx < 0) { ++ x += dx / 2; ++ dx = 0; ++ } ++ if (dy < 0) { ++ y += dy / 2; ++ dy = 0; ++ } ++ return { ++ x: x, ++ y: y, ++ dx: dx, ++ dy: dy ++ }; ++ } ++ d3.random = { ++ normal: function(µ, σ) { ++ var n = arguments.length; ++ if (n < 2) σ = 1; ++ if (n < 1) µ = 0; ++ return function() { ++ var x, y, r; ++ do { ++ x = Math.random() * 2 - 1; ++ y = Math.random() * 2 - 1; ++ r = x * x + y * y; ++ } while (!r || r > 1); ++ return µ + σ * x * Math.sqrt(-2 * Math.log(r) / r); ++ }; ++ }, ++ logNormal: function() { ++ var random = d3.random.normal.apply(d3, arguments); ++ return function() { ++ return Math.exp(random()); ++ }; ++ }, ++ bates: function(m) { ++ var random = d3.random.irwinHall(m); ++ return function() { ++ return random() / m; ++ }; ++ }, ++ irwinHall: function(m) { ++ return function() { ++ for (var s = 0, j = 0; j < m; j++) s += Math.random(); ++ return s; ++ }; ++ } ++ }; ++ d3.scale = {}; ++ function d3_scaleExtent(domain) { ++ var start = domain[0], stop = domain[domain.length - 1]; ++ return start < stop ? [ start, stop ] : [ stop, start ]; ++ } ++ function d3_scaleRange(scale) { ++ return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range()); ++ } ++ function d3_scale_bilinear(domain, range, uninterpolate, interpolate) { ++ var u = uninterpolate(domain[0], domain[1]), i = interpolate(range[0], range[1]); ++ return function(x) { ++ return i(u(x)); ++ }; ++ } ++ function d3_scale_nice(domain, nice) { ++ var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx; ++ if (x1 < x0) { ++ dx = i0, i0 = i1, i1 = dx; ++ dx = x0, x0 = x1, x1 = dx; ++ } ++ domain[i0] = nice.floor(x0); ++ domain[i1] = nice.ceil(x1); ++ return domain; ++ } ++ function d3_scale_niceStep(step) { ++ return step ? { ++ floor: function(x) { ++ return Math.floor(x / step) * step; ++ }, ++ ceil: function(x) { ++ return Math.ceil(x / step) * step; ++ } ++ } : d3_scale_niceIdentity; ++ } ++ var d3_scale_niceIdentity = { ++ floor: d3_identity, ++ ceil: d3_identity ++ }; ++ function d3_scale_polylinear(domain, range, uninterpolate, interpolate) { ++ var u = [], i = [], j = 0, k = Math.min(domain.length, range.length) - 1; ++ if (domain[k] < domain[0]) { ++ domain = domain.slice().reverse(); ++ range = range.slice().reverse(); ++ } ++ while (++j <= k) { ++ u.push(uninterpolate(domain[j - 1], domain[j])); ++ i.push(interpolate(range[j - 1], range[j])); ++ } ++ return function(x) { ++ var j = d3.bisect(domain, x, 1, k) - 1; ++ return i[j](u[j](x)); ++ }; ++ } ++ d3.scale.linear = function() { ++ return d3_scale_linear([ 0, 1 ], [ 0, 1 ], d3_interpolate, false); ++ }; ++ function d3_scale_linear(domain, range, interpolate, clamp) { ++ var output, input; ++ function rescale() { ++ var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear, uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber; ++ output = linear(domain, range, uninterpolate, interpolate); ++ input = linear(range, domain, uninterpolate, d3_interpolate); ++ return scale; ++ } ++ function scale(x) { ++ return output(x); ++ } ++ scale.invert = function(y) { ++ return input(y); ++ }; ++ scale.domain = function(x) { ++ if (!arguments.length) return domain; ++ domain = x.map(Number); ++ return rescale(); ++ }; ++ scale.range = function(x) { ++ if (!arguments.length) return range; ++ range = x; ++ return rescale(); ++ }; ++ scale.rangeRound = function(x) { ++ return scale.range(x).interpolate(d3_interpolateRound); ++ }; ++ scale.clamp = function(x) { ++ if (!arguments.length) return clamp; ++ clamp = x; ++ return rescale(); ++ }; ++ scale.interpolate = function(x) { ++ if (!arguments.length) return interpolate; ++ interpolate = x; ++ return rescale(); ++ }; ++ scale.ticks = function(m) { ++ return d3_scale_linearTicks(domain, m); ++ }; ++ scale.tickFormat = function(m, format) { ++ return d3_scale_linearTickFormat(domain, m, format); ++ }; ++ scale.nice = function(m) { ++ d3_scale_linearNice(domain, m); ++ return rescale(); ++ }; ++ scale.copy = function() { ++ return d3_scale_linear(domain, range, interpolate, clamp); ++ }; ++ return rescale(); ++ } ++ function d3_scale_linearRebind(scale, linear) { ++ return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp"); ++ } ++ function d3_scale_linearNice(domain, m) { ++ d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2])); ++ d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2])); ++ return domain; ++ } ++ function d3_scale_linearTickRange(domain, m) { ++ if (m == null) m = 10; ++ var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step; ++ if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2; ++ extent[0] = Math.ceil(extent[0] / step) * step; ++ extent[1] = Math.floor(extent[1] / step) * step + step * .5; ++ extent[2] = step; ++ return extent; ++ } ++ function d3_scale_linearTicks(domain, m) { ++ return d3.range.apply(d3, d3_scale_linearTickRange(domain, m)); ++ } ++ function d3_scale_linearTickFormat(domain, m, format) { ++ var range = d3_scale_linearTickRange(domain, m); ++ if (format) { ++ var match = d3_format_re.exec(format); ++ match.shift(); ++ if (match[8] === "s") { ++ var prefix = d3.formatPrefix(Math.max(abs(range[0]), abs(range[1]))); ++ if (!match[7]) match[7] = "." + d3_scale_linearPrecision(prefix.scale(range[2])); ++ match[8] = "f"; ++ format = d3.format(match.join("")); ++ return function(d) { ++ return format(prefix.scale(d)) + prefix.symbol; ++ }; ++ } ++ if (!match[7]) match[7] = "." + d3_scale_linearFormatPrecision(match[8], range); ++ format = match.join(""); ++ } else { ++ format = ",." + d3_scale_linearPrecision(range[2]) + "f"; ++ } ++ return d3.format(format); ++ } ++ var d3_scale_linearFormatSignificant = { ++ s: 1, ++ g: 1, ++ p: 1, ++ r: 1, ++ e: 1 ++ }; ++ function d3_scale_linearPrecision(value) { ++ return -Math.floor(Math.log(value) / Math.LN10 + .01); ++ } ++ function d3_scale_linearFormatPrecision(type, range) { ++ var p = d3_scale_linearPrecision(range[2]); ++ return type in d3_scale_linearFormatSignificant ? Math.abs(p - d3_scale_linearPrecision(Math.max(abs(range[0]), abs(range[1])))) + +(type !== "e") : p - (type === "%") * 2; ++ } ++ d3.scale.log = function() { ++ return d3_scale_log(d3.scale.linear().domain([ 0, 1 ]), 10, true, [ 1, 10 ]); ++ }; ++ function d3_scale_log(linear, base, positive, domain) { ++ function log(x) { ++ return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base); ++ } ++ function pow(x) { ++ return positive ? Math.pow(base, x) : -Math.pow(base, -x); ++ } ++ function scale(x) { ++ return linear(log(x)); ++ } ++ scale.invert = function(x) { ++ return pow(linear.invert(x)); ++ }; ++ scale.domain = function(x) { ++ if (!arguments.length) return domain; ++ positive = x[0] >= 0; ++ linear.domain((domain = x.map(Number)).map(log)); ++ return scale; ++ }; ++ scale.base = function(_) { ++ if (!arguments.length) return base; ++ base = +_; ++ linear.domain(domain.map(log)); ++ return scale; ++ }; ++ scale.nice = function() { ++ var niced = d3_scale_nice(domain.map(log), positive ? Math : d3_scale_logNiceNegative); ++ linear.domain(niced); ++ domain = niced.map(pow); ++ return scale; ++ }; ++ scale.ticks = function() { ++ var extent = d3_scaleExtent(domain), ticks = [], u = extent[0], v = extent[1], i = Math.floor(log(u)), j = Math.ceil(log(v)), n = base % 1 ? 2 : base; ++ if (isFinite(j - i)) { ++ if (positive) { ++ for (;i < j; i++) for (var k = 1; k < n; k++) ticks.push(pow(i) * k); ++ ticks.push(pow(i)); ++ } else { ++ ticks.push(pow(i)); ++ for (;i++ < j; ) for (var k = n - 1; k > 0; k--) ticks.push(pow(i) * k); ++ } ++ for (i = 0; ticks[i] < u; i++) {} ++ for (j = ticks.length; ticks[j - 1] > v; j--) {} ++ ticks = ticks.slice(i, j); ++ } ++ return ticks; ++ }; ++ scale.tickFormat = function(n, format) { ++ if (!arguments.length) return d3_scale_logFormat; ++ if (arguments.length < 2) format = d3_scale_logFormat; else if (typeof format !== "function") format = d3.format(format); ++ var k = Math.max(1, base * n / scale.ticks().length); ++ return function(d) { ++ var i = d / pow(Math.round(log(d))); ++ if (i * base < base - .5) i *= base; ++ return i <= k ? format(d) : ""; ++ }; ++ }; ++ scale.copy = function() { ++ return d3_scale_log(linear.copy(), base, positive, domain); ++ }; ++ return d3_scale_linearRebind(scale, linear); ++ } ++ var d3_scale_logFormat = d3.format(".0e"), d3_scale_logNiceNegative = { ++ floor: function(x) { ++ return -Math.ceil(-x); ++ }, ++ ceil: function(x) { ++ return -Math.floor(-x); ++ } ++ }; ++ d3.scale.pow = function() { ++ return d3_scale_pow(d3.scale.linear(), 1, [ 0, 1 ]); ++ }; ++ function d3_scale_pow(linear, exponent, domain) { ++ var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent); ++ function scale(x) { ++ return linear(powp(x)); ++ } ++ scale.invert = function(x) { ++ return powb(linear.invert(x)); ++ }; ++ scale.domain = function(x) { ++ if (!arguments.length) return domain; ++ linear.domain((domain = x.map(Number)).map(powp)); ++ return scale; ++ }; ++ scale.ticks = function(m) { ++ return d3_scale_linearTicks(domain, m); ++ }; ++ scale.tickFormat = function(m, format) { ++ return d3_scale_linearTickFormat(domain, m, format); ++ }; ++ scale.nice = function(m) { ++ return scale.domain(d3_scale_linearNice(domain, m)); ++ }; ++ scale.exponent = function(x) { ++ if (!arguments.length) return exponent; ++ powp = d3_scale_powPow(exponent = x); ++ powb = d3_scale_powPow(1 / exponent); ++ linear.domain(domain.map(powp)); ++ return scale; ++ }; ++ scale.copy = function() { ++ return d3_scale_pow(linear.copy(), exponent, domain); ++ }; ++ return d3_scale_linearRebind(scale, linear); ++ } ++ function d3_scale_powPow(e) { ++ return function(x) { ++ return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e); ++ }; ++ } ++ d3.scale.sqrt = function() { ++ return d3.scale.pow().exponent(.5); ++ }; ++ d3.scale.ordinal = function() { ++ return d3_scale_ordinal([], { ++ t: "range", ++ a: [ [] ] ++ }); ++ }; ++ function d3_scale_ordinal(domain, ranger) { ++ var index, range, rangeBand; ++ function scale(x) { ++ return range[((index.get(x) || (ranger.t === "range" ? index.set(x, domain.push(x)) : NaN)) - 1) % range.length]; ++ } ++ function steps(start, step) { ++ return d3.range(domain.length).map(function(i) { ++ return start + step * i; ++ }); ++ } ++ scale.domain = function(x) { ++ if (!arguments.length) return domain; ++ domain = []; ++ index = new d3_Map(); ++ var i = -1, n = x.length, xi; ++ while (++i < n) if (!index.has(xi = x[i])) index.set(xi, domain.push(xi)); ++ return scale[ranger.t].apply(scale, ranger.a); ++ }; ++ scale.range = function(x) { ++ if (!arguments.length) return range; ++ range = x; ++ rangeBand = 0; ++ ranger = { ++ t: "range", ++ a: arguments ++ }; ++ return scale; ++ }; ++ scale.rangePoints = function(x, padding) { ++ if (arguments.length < 2) padding = 0; ++ var start = x[0], stop = x[1], step = domain.length < 2 ? (start = (start + stop) / 2, ++ 0) : (stop - start) / (domain.length - 1 + padding); ++ range = steps(start + step * padding / 2, step); ++ rangeBand = 0; ++ ranger = { ++ t: "rangePoints", ++ a: arguments ++ }; ++ return scale; ++ }; ++ scale.rangeRoundPoints = function(x, padding) { ++ if (arguments.length < 2) padding = 0; ++ var start = x[0], stop = x[1], step = domain.length < 2 ? (start = stop = Math.round((start + stop) / 2), ++ 0) : (stop - start) / (domain.length - 1 + padding) | 0; ++ range = steps(start + Math.round(step * padding / 2 + (stop - start - (domain.length - 1 + padding) * step) / 2), step); ++ rangeBand = 0; ++ ranger = { ++ t: "rangeRoundPoints", ++ a: arguments ++ }; ++ return scale; ++ }; ++ scale.rangeBands = function(x, padding, outerPadding) { ++ if (arguments.length < 2) padding = 0; ++ if (arguments.length < 3) outerPadding = padding; ++ var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = (stop - start) / (domain.length - padding + 2 * outerPadding); ++ range = steps(start + step * outerPadding, step); ++ if (reverse) range.reverse(); ++ rangeBand = step * (1 - padding); ++ ranger = { ++ t: "rangeBands", ++ a: arguments ++ }; ++ return scale; ++ }; ++ scale.rangeRoundBands = function(x, padding, outerPadding) { ++ if (arguments.length < 2) padding = 0; ++ if (arguments.length < 3) outerPadding = padding; ++ var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding)); ++ range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step); ++ if (reverse) range.reverse(); ++ rangeBand = Math.round(step * (1 - padding)); ++ ranger = { ++ t: "rangeRoundBands", ++ a: arguments ++ }; ++ return scale; ++ }; ++ scale.rangeBand = function() { ++ return rangeBand; ++ }; ++ scale.rangeExtent = function() { ++ return d3_scaleExtent(ranger.a[0]); ++ }; ++ scale.copy = function() { ++ return d3_scale_ordinal(domain, ranger); ++ }; ++ return scale.domain(domain); ++ } ++ d3.scale.category10 = function() { ++ return d3.scale.ordinal().range(d3_category10); ++ }; ++ d3.scale.category20 = function() { ++ return d3.scale.ordinal().range(d3_category20); ++ }; ++ d3.scale.category20b = function() { ++ return d3.scale.ordinal().range(d3_category20b); ++ }; ++ d3.scale.category20c = function() { ++ return d3.scale.ordinal().range(d3_category20c); ++ }; ++ var d3_category10 = [ 2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175 ].map(d3_rgbString); ++ var d3_category20 = [ 2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725 ].map(d3_rgbString); ++ var d3_category20b = [ 3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654 ].map(d3_rgbString); ++ var d3_category20c = [ 3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081 ].map(d3_rgbString); ++ d3.scale.quantile = function() { ++ return d3_scale_quantile([], []); ++ }; ++ function d3_scale_quantile(domain, range) { ++ var thresholds; ++ function rescale() { ++ var k = 0, q = range.length; ++ thresholds = []; ++ while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q); ++ return scale; ++ } ++ function scale(x) { ++ if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)]; ++ } ++ scale.domain = function(x) { ++ if (!arguments.length) return domain; ++ domain = x.map(d3_number).filter(d3_numeric).sort(d3_ascending); ++ return rescale(); ++ }; ++ scale.range = function(x) { ++ if (!arguments.length) return range; ++ range = x; ++ return rescale(); ++ }; ++ scale.quantiles = function() { ++ return thresholds; ++ }; ++ scale.invertExtent = function(y) { ++ y = range.indexOf(y); ++ return y < 0 ? [ NaN, NaN ] : [ y > 0 ? thresholds[y - 1] : domain[0], y < thresholds.length ? thresholds[y] : domain[domain.length - 1] ]; ++ }; ++ scale.copy = function() { ++ return d3_scale_quantile(domain, range); ++ }; ++ return rescale(); ++ } ++ d3.scale.quantize = function() { ++ return d3_scale_quantize(0, 1, [ 0, 1 ]); ++ }; ++ function d3_scale_quantize(x0, x1, range) { ++ var kx, i; ++ function scale(x) { ++ return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))]; ++ } ++ function rescale() { ++ kx = range.length / (x1 - x0); ++ i = range.length - 1; ++ return scale; ++ } ++ scale.domain = function(x) { ++ if (!arguments.length) return [ x0, x1 ]; ++ x0 = +x[0]; ++ x1 = +x[x.length - 1]; ++ return rescale(); ++ }; ++ scale.range = function(x) { ++ if (!arguments.length) return range; ++ range = x; ++ return rescale(); ++ }; ++ scale.invertExtent = function(y) { ++ y = range.indexOf(y); ++ y = y < 0 ? NaN : y / kx + x0; ++ return [ y, y + 1 / kx ]; ++ }; ++ scale.copy = function() { ++ return d3_scale_quantize(x0, x1, range); ++ }; ++ return rescale(); ++ } ++ d3.scale.threshold = function() { ++ return d3_scale_threshold([ .5 ], [ 0, 1 ]); ++ }; ++ function d3_scale_threshold(domain, range) { ++ function scale(x) { ++ if (x <= x) return range[d3.bisect(domain, x)]; ++ } ++ scale.domain = function(_) { ++ if (!arguments.length) return domain; ++ domain = _; ++ return scale; ++ }; ++ scale.range = function(_) { ++ if (!arguments.length) return range; ++ range = _; ++ return scale; ++ }; ++ scale.invertExtent = function(y) { ++ y = range.indexOf(y); ++ return [ domain[y - 1], domain[y] ]; ++ }; ++ scale.copy = function() { ++ return d3_scale_threshold(domain, range); ++ }; ++ return scale; ++ } ++ d3.scale.identity = function() { ++ return d3_scale_identity([ 0, 1 ]); ++ }; ++ function d3_scale_identity(domain) { ++ function identity(x) { ++ return +x; ++ } ++ identity.invert = identity; ++ identity.domain = identity.range = function(x) { ++ if (!arguments.length) return domain; ++ domain = x.map(identity); ++ return identity; ++ }; ++ identity.ticks = function(m) { ++ return d3_scale_linearTicks(domain, m); ++ }; ++ identity.tickFormat = function(m, format) { ++ return d3_scale_linearTickFormat(domain, m, format); ++ }; ++ identity.copy = function() { ++ return d3_scale_identity(domain); ++ }; ++ return identity; ++ } ++ d3.svg = {}; ++ function d3_zero() { ++ return 0; ++ } ++ d3.svg.arc = function() { ++ var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, cornerRadius = d3_zero, padRadius = d3_svg_arcAuto, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle, padAngle = d3_svg_arcPadAngle; ++ function arc() { ++ var r0 = Math.max(0, +innerRadius.apply(this, arguments)), r1 = Math.max(0, +outerRadius.apply(this, arguments)), a0 = startAngle.apply(this, arguments) - halfπ, a1 = endAngle.apply(this, arguments) - halfπ, da = Math.abs(a1 - a0), cw = a0 > a1 ? 0 : 1; ++ if (r1 < r0) rc = r1, r1 = r0, r0 = rc; ++ if (da >= τε) return circleSegment(r1, cw) + (r0 ? circleSegment(r0, 1 - cw) : "") + "Z"; ++ var rc, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = []; ++ if (ap = (+padAngle.apply(this, arguments) || 0) / 2) { ++ rp = padRadius === d3_svg_arcAuto ? Math.sqrt(r0 * r0 + r1 * r1) : +padRadius.apply(this, arguments); ++ if (!cw) p1 *= -1; ++ if (r1) p1 = d3_asin(rp / r1 * Math.sin(ap)); ++ if (r0) p0 = d3_asin(rp / r0 * Math.sin(ap)); ++ } ++ if (r1) { ++ x0 = r1 * Math.cos(a0 + p1); ++ y0 = r1 * Math.sin(a0 + p1); ++ x1 = r1 * Math.cos(a1 - p1); ++ y1 = r1 * Math.sin(a1 - p1); ++ var l1 = Math.abs(a1 - a0 - 2 * p1) <= π ? 0 : 1; ++ if (p1 && d3_svg_arcSweep(x0, y0, x1, y1) === cw ^ l1) { ++ var h1 = (a0 + a1) / 2; ++ x0 = r1 * Math.cos(h1); ++ y0 = r1 * Math.sin(h1); ++ x1 = y1 = null; ++ } ++ } else { ++ x0 = y0 = 0; ++ } ++ if (r0) { ++ x2 = r0 * Math.cos(a1 - p0); ++ y2 = r0 * Math.sin(a1 - p0); ++ x3 = r0 * Math.cos(a0 + p0); ++ y3 = r0 * Math.sin(a0 + p0); ++ var l0 = Math.abs(a0 - a1 + 2 * p0) <= π ? 0 : 1; ++ if (p0 && d3_svg_arcSweep(x2, y2, x3, y3) === 1 - cw ^ l0) { ++ var h0 = (a0 + a1) / 2; ++ x2 = r0 * Math.cos(h0); ++ y2 = r0 * Math.sin(h0); ++ x3 = y3 = null; ++ } ++ } else { ++ x2 = y2 = 0; ++ } ++ if (da > ε && (rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments))) > .001) { ++ cr = r0 < r1 ^ cw ? 0 : 1; ++ var rc1 = rc, rc0 = rc; ++ if (da < π) { ++ var oc = x3 == null ? [ x2, y2 ] : x1 == null ? [ x0, y0 ] : d3_geom_polygonIntersect([ x0, y0 ], [ x3, y3 ], [ x1, y1 ], [ x2, y2 ]), ax = x0 - oc[0], ay = y0 - oc[1], bx = x1 - oc[0], by = y1 - oc[1], kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2), lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]); ++ rc0 = Math.min(rc, (r0 - lc) / (kc - 1)); ++ rc1 = Math.min(rc, (r1 - lc) / (kc + 1)); ++ } ++ if (x1 != null) { ++ var t30 = d3_svg_arcCornerTangents(x3 == null ? [ x2, y2 ] : [ x3, y3 ], [ x0, y0 ], r1, rc1, cw), t12 = d3_svg_arcCornerTangents([ x1, y1 ], [ x2, y2 ], r1, rc1, cw); ++ if (rc === rc1) { ++ path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]); ++ } else { ++ path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]); ++ } ++ } else { ++ path.push("M", x0, ",", y0); ++ } ++ if (x3 != null) { ++ var t03 = d3_svg_arcCornerTangents([ x0, y0 ], [ x3, y3 ], r0, -rc0, cw), t21 = d3_svg_arcCornerTangents([ x2, y2 ], x1 == null ? [ x0, y0 ] : [ x1, y1 ], r0, -rc0, cw); ++ if (rc === rc0) { ++ path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]); ++ } else { ++ path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]); ++ } ++ } else { ++ path.push("L", x2, ",", y2); ++ } ++ } else { ++ path.push("M", x0, ",", y0); ++ if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1); ++ path.push("L", x2, ",", y2); ++ if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3); ++ } ++ path.push("Z"); ++ return path.join(""); ++ } ++ function circleSegment(r1, cw) { ++ return "M0," + r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + -r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + r1; ++ } ++ arc.innerRadius = function(v) { ++ if (!arguments.length) return innerRadius; ++ innerRadius = d3_functor(v); ++ return arc; ++ }; ++ arc.outerRadius = function(v) { ++ if (!arguments.length) return outerRadius; ++ outerRadius = d3_functor(v); ++ return arc; ++ }; ++ arc.cornerRadius = function(v) { ++ if (!arguments.length) return cornerRadius; ++ cornerRadius = d3_functor(v); ++ return arc; ++ }; ++ arc.padRadius = function(v) { ++ if (!arguments.length) return padRadius; ++ padRadius = v == d3_svg_arcAuto ? d3_svg_arcAuto : d3_functor(v); ++ return arc; ++ }; ++ arc.startAngle = function(v) { ++ if (!arguments.length) return startAngle; ++ startAngle = d3_functor(v); ++ return arc; ++ }; ++ arc.endAngle = function(v) { ++ if (!arguments.length) return endAngle; ++ endAngle = d3_functor(v); ++ return arc; ++ }; ++ arc.padAngle = function(v) { ++ if (!arguments.length) return padAngle; ++ padAngle = d3_functor(v); ++ return arc; ++ }; ++ arc.centroid = function() { ++ var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - halfπ; ++ return [ Math.cos(a) * r, Math.sin(a) * r ]; ++ }; ++ return arc; ++ }; ++ var d3_svg_arcAuto = "auto"; ++ function d3_svg_arcInnerRadius(d) { ++ return d.innerRadius; ++ } ++ function d3_svg_arcOuterRadius(d) { ++ return d.outerRadius; ++ } ++ function d3_svg_arcStartAngle(d) { ++ return d.startAngle; ++ } ++ function d3_svg_arcEndAngle(d) { ++ return d.endAngle; ++ } ++ function d3_svg_arcPadAngle(d) { ++ return d && d.padAngle; ++ } ++ function d3_svg_arcSweep(x0, y0, x1, y1) { ++ return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1; ++ } ++ function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) { ++ var x01 = p0[0] - p1[0], y01 = p0[1] - p1[1], lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x1 = p0[0] + ox, y1 = p0[1] + oy, x2 = p1[0] + ox, y2 = p1[1] + oy, x3 = (x1 + x2) / 2, y3 = (y1 + y2) / 2, dx = x2 - x1, dy = y2 - y1, d2 = dx * dx + dy * dy, r = r1 - rc, D = x1 * y2 - x2 * y1, d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.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 - x3, dy0 = cy0 - y3, dx1 = cx1 - x3, dy1 = cy1 - y3; ++ if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1; ++ return [ [ cx0 - ox, cy0 - oy ], [ cx0 * r1 / r, cy0 * r1 / r ] ]; ++ } ++ function d3_svg_line(projection) { ++ var x = d3_geom_pointX, y = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = .7; ++ function line(data) { ++ var segments = [], points = [], i = -1, n = data.length, d, fx = d3_functor(x), fy = d3_functor(y); ++ function segment() { ++ segments.push("M", interpolate(projection(points), tension)); ++ } ++ while (++i < n) { ++ if (defined.call(this, d = data[i], i)) { ++ points.push([ +fx.call(this, d, i), +fy.call(this, d, i) ]); ++ } else if (points.length) { ++ segment(); ++ points = []; ++ } ++ } ++ if (points.length) segment(); ++ return segments.length ? segments.join("") : null; ++ } ++ line.x = function(_) { ++ if (!arguments.length) return x; ++ x = _; ++ return line; ++ }; ++ line.y = function(_) { ++ if (!arguments.length) return y; ++ y = _; ++ return line; ++ }; ++ line.defined = function(_) { ++ if (!arguments.length) return defined; ++ defined = _; ++ return line; ++ }; ++ line.interpolate = function(_) { ++ if (!arguments.length) return interpolateKey; ++ if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key; ++ return line; ++ }; ++ line.tension = function(_) { ++ if (!arguments.length) return tension; ++ tension = _; ++ return line; ++ }; ++ return line; ++ } ++ d3.svg.line = function() { ++ return d3_svg_line(d3_identity); ++ }; ++ var d3_svg_lineInterpolators = d3.map({ ++ linear: d3_svg_lineLinear, ++ "linear-closed": d3_svg_lineLinearClosed, ++ step: d3_svg_lineStep, ++ "step-before": d3_svg_lineStepBefore, ++ "step-after": d3_svg_lineStepAfter, ++ basis: d3_svg_lineBasis, ++ "basis-open": d3_svg_lineBasisOpen, ++ "basis-closed": d3_svg_lineBasisClosed, ++ bundle: d3_svg_lineBundle, ++ cardinal: d3_svg_lineCardinal, ++ "cardinal-open": d3_svg_lineCardinalOpen, ++ "cardinal-closed": d3_svg_lineCardinalClosed, ++ monotone: d3_svg_lineMonotone ++ }); ++ d3_svg_lineInterpolators.forEach(function(key, value) { ++ value.key = key; ++ value.closed = /-closed$/.test(key); ++ }); ++ function d3_svg_lineLinear(points) { ++ return points.length > 1 ? points.join("L") : points + "Z"; ++ } ++ function d3_svg_lineLinearClosed(points) { ++ return points.join("L") + "Z"; ++ } ++ function d3_svg_lineStep(points) { ++ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ]; ++ while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]); ++ if (n > 1) path.push("H", p[0]); ++ return path.join(""); ++ } ++ function d3_svg_lineStepBefore(points) { ++ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ]; ++ while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]); ++ return path.join(""); ++ } ++ function d3_svg_lineStepAfter(points) { ++ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ]; ++ while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]); ++ return path.join(""); ++ } ++ function d3_svg_lineCardinalOpen(points, tension) { ++ return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, -1), d3_svg_lineCardinalTangents(points, tension)); ++ } ++ function d3_svg_lineCardinalClosed(points, tension) { ++ return points.length < 3 ? d3_svg_lineLinearClosed(points) : points[0] + d3_svg_lineHermite((points.push(points[0]), ++ points), d3_svg_lineCardinalTangents([ points[points.length - 2] ].concat(points, [ points[1] ]), tension)); ++ } ++ function d3_svg_lineCardinal(points, tension) { ++ return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension)); ++ } ++ function d3_svg_lineHermite(points, tangents) { ++ if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) { ++ return d3_svg_lineLinear(points); ++ } ++ var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1; ++ if (quad) { ++ path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1]; ++ p0 = points[1]; ++ pi = 2; ++ } ++ if (tangents.length > 1) { ++ t = tangents[1]; ++ p = points[pi]; ++ pi++; ++ path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1]; ++ for (var i = 2; i < tangents.length; i++, pi++) { ++ p = points[pi]; ++ t = tangents[i]; ++ path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1]; ++ } ++ } ++ if (quad) { ++ var lp = points[pi]; ++ path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1]; ++ } ++ return path; ++ } ++ function d3_svg_lineCardinalTangents(points, tension) { ++ var tangents = [], a = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i = 1, n = points.length; ++ while (++i < n) { ++ p0 = p1; ++ p1 = p2; ++ p2 = points[i]; ++ tangents.push([ a * (p2[0] - p0[0]), a * (p2[1] - p0[1]) ]); ++ } ++ return tangents; ++ } ++ function d3_svg_lineBasis(points) { ++ if (points.length < 3) return d3_svg_lineLinear(points); ++ var i = 1, n = points.length, pi = points[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ]; ++ points.push(points[n - 1]); ++ while (++i <= n) { ++ pi = points[i]; ++ px.shift(); ++ px.push(pi[0]); ++ py.shift(); ++ py.push(pi[1]); ++ d3_svg_lineBasisBezier(path, px, py); ++ } ++ points.pop(); ++ path.push("L", pi); ++ return path.join(""); ++ } ++ function d3_svg_lineBasisOpen(points) { ++ if (points.length < 4) return d3_svg_lineLinear(points); ++ var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ]; ++ while (++i < 3) { ++ pi = points[i]; ++ px.push(pi[0]); ++ py.push(pi[1]); ++ } ++ path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)); ++ --i; ++ while (++i < n) { ++ pi = points[i]; ++ px.shift(); ++ px.push(pi[0]); ++ py.shift(); ++ py.push(pi[1]); ++ d3_svg_lineBasisBezier(path, px, py); ++ } ++ return path.join(""); ++ } ++ function d3_svg_lineBasisClosed(points) { ++ var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = []; ++ while (++i < 4) { ++ pi = points[i % n]; ++ px.push(pi[0]); ++ py.push(pi[1]); ++ } ++ path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ]; ++ --i; ++ while (++i < m) { ++ pi = points[i % n]; ++ px.shift(); ++ px.push(pi[0]); ++ py.shift(); ++ py.push(pi[1]); ++ d3_svg_lineBasisBezier(path, px, py); ++ } ++ return path.join(""); ++ } ++ function d3_svg_lineBundle(points, tension) { ++ var n = points.length - 1; ++ if (n) { ++ var x0 = points[0][0], y0 = points[0][1], dx = points[n][0] - x0, dy = points[n][1] - y0, i = -1, p, t; ++ while (++i <= n) { ++ p = points[i]; ++ t = i / n; ++ p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx); ++ p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy); ++ } ++ } ++ return d3_svg_lineBasis(points); ++ } ++ function d3_svg_lineDot4(a, b) { ++ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; ++ } ++ var d3_svg_lineBasisBezier1 = [ 0, 2 / 3, 1 / 3, 0 ], d3_svg_lineBasisBezier2 = [ 0, 1 / 3, 2 / 3, 0 ], d3_svg_lineBasisBezier3 = [ 0, 1 / 6, 2 / 3, 1 / 6 ]; ++ function d3_svg_lineBasisBezier(path, x, y) { ++ path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y)); ++ } ++ function d3_svg_lineSlope(p0, p1) { ++ return (p1[1] - p0[1]) / (p1[0] - p0[0]); ++ } ++ function d3_svg_lineFiniteDifferences(points) { ++ var i = 0, j = points.length - 1, m = [], p0 = points[0], p1 = points[1], d = m[0] = d3_svg_lineSlope(p0, p1); ++ while (++i < j) { ++ m[i] = (d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]))) / 2; ++ } ++ m[i] = d; ++ return m; ++ } ++ function d3_svg_lineMonotoneTangents(points) { ++ var tangents = [], d, a, b, s, m = d3_svg_lineFiniteDifferences(points), i = -1, j = points.length - 1; ++ while (++i < j) { ++ d = d3_svg_lineSlope(points[i], points[i + 1]); ++ if (abs(d) < ε) { ++ m[i] = m[i + 1] = 0; ++ } else { ++ a = m[i] / d; ++ b = m[i + 1] / d; ++ s = a * a + b * b; ++ if (s > 9) { ++ s = d * 3 / Math.sqrt(s); ++ m[i] = s * a; ++ m[i + 1] = s * b; ++ } ++ } ++ } ++ i = -1; ++ while (++i <= j) { ++ s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i])); ++ tangents.push([ s || 0, m[i] * s || 0 ]); ++ } ++ return tangents; ++ } ++ function d3_svg_lineMonotone(points) { ++ return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points)); ++ } ++ d3.svg.line.radial = function() { ++ var line = d3_svg_line(d3_svg_lineRadial); ++ line.radius = line.x, delete line.x; ++ line.angle = line.y, delete line.y; ++ return line; ++ }; ++ function d3_svg_lineRadial(points) { ++ var point, i = -1, n = points.length, r, a; ++ while (++i < n) { ++ point = points[i]; ++ r = point[0]; ++ a = point[1] - halfπ; ++ point[0] = r * Math.cos(a); ++ point[1] = r * Math.sin(a); ++ } ++ return points; ++ } ++ function d3_svg_area(projection) { ++ var x0 = d3_geom_pointX, x1 = d3_geom_pointX, y0 = 0, y1 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, interpolateReverse = interpolate, L = "L", tension = .7; ++ function area(data) { ++ var segments = [], points0 = [], points1 = [], i = -1, n = data.length, d, fx0 = d3_functor(x0), fy0 = d3_functor(y0), fx1 = x0 === x1 ? function() { ++ return x; ++ } : d3_functor(x1), fy1 = y0 === y1 ? function() { ++ return y; ++ } : d3_functor(y1), x, y; ++ function segment() { ++ segments.push("M", interpolate(projection(points1), tension), L, interpolateReverse(projection(points0.reverse()), tension), "Z"); ++ } ++ while (++i < n) { ++ if (defined.call(this, d = data[i], i)) { ++ points0.push([ x = +fx0.call(this, d, i), y = +fy0.call(this, d, i) ]); ++ points1.push([ +fx1.call(this, d, i), +fy1.call(this, d, i) ]); ++ } else if (points0.length) { ++ segment(); ++ points0 = []; ++ points1 = []; ++ } ++ } ++ if (points0.length) segment(); ++ return segments.length ? segments.join("") : null; ++ } ++ area.x = function(_) { ++ if (!arguments.length) return x1; ++ x0 = x1 = _; ++ return area; ++ }; ++ area.x0 = function(_) { ++ if (!arguments.length) return x0; ++ x0 = _; ++ return area; ++ }; ++ area.x1 = function(_) { ++ if (!arguments.length) return x1; ++ x1 = _; ++ return area; ++ }; ++ area.y = function(_) { ++ if (!arguments.length) return y1; ++ y0 = y1 = _; ++ return area; ++ }; ++ area.y0 = function(_) { ++ if (!arguments.length) return y0; ++ y0 = _; ++ return area; ++ }; ++ area.y1 = function(_) { ++ if (!arguments.length) return y1; ++ y1 = _; ++ return area; ++ }; ++ area.defined = function(_) { ++ if (!arguments.length) return defined; ++ defined = _; ++ return area; ++ }; ++ area.interpolate = function(_) { ++ if (!arguments.length) return interpolateKey; ++ if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key; ++ interpolateReverse = interpolate.reverse || interpolate; ++ L = interpolate.closed ? "M" : "L"; ++ return area; ++ }; ++ area.tension = function(_) { ++ if (!arguments.length) return tension; ++ tension = _; ++ return area; ++ }; ++ return area; ++ } ++ d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter; ++ d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore; ++ d3.svg.area = function() { ++ return d3_svg_area(d3_identity); ++ }; ++ d3.svg.area.radial = function() { ++ var area = d3_svg_area(d3_svg_lineRadial); ++ area.radius = area.x, delete area.x; ++ area.innerRadius = area.x0, delete area.x0; ++ area.outerRadius = area.x1, delete area.x1; ++ area.angle = area.y, delete area.y; ++ area.startAngle = area.y0, delete area.y0; ++ area.endAngle = area.y1, delete area.y1; ++ return area; ++ }; ++ d3.svg.chord = function() { ++ var source = d3_source, target = d3_target, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle; ++ function chord(d, i) { ++ var s = subgroup(this, source, d, i), t = subgroup(this, target, d, i); ++ return "M" + s.p0 + arc(s.r, s.p1, s.a1 - s.a0) + (equals(s, t) ? curve(s.r, s.p1, s.r, s.p0) : curve(s.r, s.p1, t.r, t.p0) + arc(t.r, t.p1, t.a1 - t.a0) + curve(t.r, t.p1, s.r, s.p0)) + "Z"; ++ } ++ function subgroup(self, f, d, i) { ++ var subgroup = f.call(self, d, i), r = radius.call(self, subgroup, i), a0 = startAngle.call(self, subgroup, i) - halfπ, a1 = endAngle.call(self, subgroup, i) - halfπ; ++ return { ++ r: r, ++ a0: a0, ++ a1: a1, ++ p0: [ r * Math.cos(a0), r * Math.sin(a0) ], ++ p1: [ r * Math.cos(a1), r * Math.sin(a1) ] ++ }; ++ } ++ function equals(a, b) { ++ return a.a0 == b.a0 && a.a1 == b.a1; ++ } ++ function arc(r, p, a) { ++ return "A" + r + "," + r + " 0 " + +(a > π) + ",1 " + p; ++ } ++ function curve(r0, p0, r1, p1) { ++ return "Q 0,0 " + p1; ++ } ++ chord.radius = function(v) { ++ if (!arguments.length) return radius; ++ radius = d3_functor(v); ++ return chord; ++ }; ++ chord.source = function(v) { ++ if (!arguments.length) return source; ++ source = d3_functor(v); ++ return chord; ++ }; ++ chord.target = function(v) { ++ if (!arguments.length) return target; ++ target = d3_functor(v); ++ return chord; ++ }; ++ chord.startAngle = function(v) { ++ if (!arguments.length) return startAngle; ++ startAngle = d3_functor(v); ++ return chord; ++ }; ++ chord.endAngle = function(v) { ++ if (!arguments.length) return endAngle; ++ endAngle = d3_functor(v); ++ return chord; ++ }; ++ return chord; ++ }; ++ function d3_svg_chordRadius(d) { ++ return d.radius; ++ } ++ d3.svg.diagonal = function() { ++ var source = d3_source, target = d3_target, projection = d3_svg_diagonalProjection; ++ function diagonal(d, i) { ++ var p0 = source.call(this, d, i), p3 = target.call(this, d, i), m = (p0.y + p3.y) / 2, p = [ p0, { ++ x: p0.x, ++ y: m ++ }, { ++ x: p3.x, ++ y: m ++ }, p3 ]; ++ p = p.map(projection); ++ return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3]; ++ } ++ diagonal.source = function(x) { ++ if (!arguments.length) return source; ++ source = d3_functor(x); ++ return diagonal; ++ }; ++ diagonal.target = function(x) { ++ if (!arguments.length) return target; ++ target = d3_functor(x); ++ return diagonal; ++ }; ++ diagonal.projection = function(x) { ++ if (!arguments.length) return projection; ++ projection = x; ++ return diagonal; ++ }; ++ return diagonal; ++ }; ++ function d3_svg_diagonalProjection(d) { ++ return [ d.x, d.y ]; ++ } ++ d3.svg.diagonal.radial = function() { ++ var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection; ++ diagonal.projection = function(x) { ++ return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x)) : projection; ++ }; ++ return diagonal; ++ }; ++ function d3_svg_diagonalRadialProjection(projection) { ++ return function() { ++ var d = projection.apply(this, arguments), r = d[0], a = d[1] - halfπ; ++ return [ r * Math.cos(a), r * Math.sin(a) ]; ++ }; ++ } ++ d3.svg.symbol = function() { ++ var type = d3_svg_symbolType, size = d3_svg_symbolSize; ++ function symbol(d, i) { ++ return (d3_svg_symbols.get(type.call(this, d, i)) || d3_svg_symbolCircle)(size.call(this, d, i)); ++ } ++ symbol.type = function(x) { ++ if (!arguments.length) return type; ++ type = d3_functor(x); ++ return symbol; ++ }; ++ symbol.size = function(x) { ++ if (!arguments.length) return size; ++ size = d3_functor(x); ++ return symbol; ++ }; ++ return symbol; ++ }; ++ function d3_svg_symbolSize() { ++ return 64; ++ } ++ function d3_svg_symbolType() { ++ return "circle"; ++ } ++ function d3_svg_symbolCircle(size) { ++ var r = Math.sqrt(size / π); ++ return "M0," + r + "A" + r + "," + r + " 0 1,1 0," + -r + "A" + r + "," + r + " 0 1,1 0," + r + "Z"; ++ } ++ var d3_svg_symbols = d3.map({ ++ circle: d3_svg_symbolCircle, ++ cross: function(size) { ++ var r = Math.sqrt(size / 5) / 2; ++ return "M" + -3 * r + "," + -r + "H" + -r + "V" + -3 * r + "H" + r + "V" + -r + "H" + 3 * r + "V" + r + "H" + r + "V" + 3 * r + "H" + -r + "V" + r + "H" + -3 * r + "Z"; ++ }, ++ diamond: function(size) { ++ var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30; ++ return "M0," + -ry + "L" + rx + ",0" + " 0," + ry + " " + -rx + ",0" + "Z"; ++ }, ++ square: function(size) { ++ var r = Math.sqrt(size) / 2; ++ return "M" + -r + "," + -r + "L" + r + "," + -r + " " + r + "," + r + " " + -r + "," + r + "Z"; ++ }, ++ "triangle-down": function(size) { ++ var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2; ++ return "M0," + ry + "L" + rx + "," + -ry + " " + -rx + "," + -ry + "Z"; ++ }, ++ "triangle-up": function(size) { ++ var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2; ++ return "M0," + -ry + "L" + rx + "," + ry + " " + -rx + "," + ry + "Z"; ++ } ++ }); ++ d3.svg.symbolTypes = d3_svg_symbols.keys(); ++ var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * d3_radians); ++ d3_selectionPrototype.transition = function(name) { ++ var id = d3_transitionInheritId || ++d3_transitionId, ns = d3_transitionNamespace(name), subgroups = [], subgroup, node, transition = d3_transitionInherit || { ++ time: Date.now(), ++ ease: d3_ease_cubicInOut, ++ delay: 0, ++ duration: 250 ++ }; ++ for (var j = -1, m = this.length; ++j < m; ) { ++ subgroups.push(subgroup = []); ++ for (var group = this[j], i = -1, n = group.length; ++i < n; ) { ++ if (node = group[i]) d3_transitionNode(node, i, ns, id, transition); ++ subgroup.push(node); ++ } ++ } ++ return d3_transition(subgroups, ns, id); ++ }; ++ d3_selectionPrototype.interrupt = function(name) { ++ return this.each(name == null ? d3_selection_interrupt : d3_selection_interruptNS(d3_transitionNamespace(name))); ++ }; ++ var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace()); ++ function d3_selection_interruptNS(ns) { ++ return function() { ++ var lock, activeId, active; ++ if ((lock = this[ns]) && (active = lock[activeId = lock.active])) { ++ active.timer.c = null; ++ active.timer.t = NaN; ++ if (--lock.count) delete lock[activeId]; else delete this[ns]; ++ lock.active += .5; ++ active.event && active.event.interrupt.call(this, this.__data__, active.index); ++ } ++ }; ++ } ++ function d3_transition(groups, ns, id) { ++ d3_subclass(groups, d3_transitionPrototype); ++ groups.namespace = ns; ++ groups.id = id; ++ return groups; ++ } ++ var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId, d3_transitionInherit; ++ d3_transitionPrototype.call = d3_selectionPrototype.call; ++ d3_transitionPrototype.empty = d3_selectionPrototype.empty; ++ d3_transitionPrototype.node = d3_selectionPrototype.node; ++ d3_transitionPrototype.size = d3_selectionPrototype.size; ++ d3.transition = function(selection, name) { ++ return selection && selection.transition ? d3_transitionInheritId ? selection.transition(name) : selection : d3.selection().transition(selection); ++ }; ++ d3.transition.prototype = d3_transitionPrototype; ++ d3_transitionPrototype.select = function(selector) { ++ var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnode, node; ++ selector = d3_selection_selector(selector); ++ for (var j = -1, m = this.length; ++j < m; ) { ++ subgroups.push(subgroup = []); ++ for (var group = this[j], i = -1, n = group.length; ++i < n; ) { ++ if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i, j))) { ++ if ("__data__" in node) subnode.__data__ = node.__data__; ++ d3_transitionNode(subnode, i, ns, id, node[ns][id]); ++ subgroup.push(subnode); ++ } else { ++ subgroup.push(null); ++ } ++ } ++ } ++ return d3_transition(subgroups, ns, id); ++ }; ++ d3_transitionPrototype.selectAll = function(selector) { ++ var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnodes, node, subnode, transition; ++ selector = d3_selection_selectorAll(selector); ++ for (var j = -1, m = this.length; ++j < m; ) { ++ for (var group = this[j], i = -1, n = group.length; ++i < n; ) { ++ if (node = group[i]) { ++ transition = node[ns][id]; ++ subnodes = selector.call(node, node.__data__, i, j); ++ subgroups.push(subgroup = []); ++ for (var k = -1, o = subnodes.length; ++k < o; ) { ++ if (subnode = subnodes[k]) d3_transitionNode(subnode, k, ns, id, transition); ++ subgroup.push(subnode); ++ } ++ } ++ } ++ } ++ return d3_transition(subgroups, ns, id); ++ }; ++ d3_transitionPrototype.filter = function(filter) { ++ var subgroups = [], subgroup, group, node; ++ if (typeof filter !== "function") filter = d3_selection_filter(filter); ++ for (var j = 0, m = this.length; j < m; j++) { ++ subgroups.push(subgroup = []); ++ for (var group = this[j], i = 0, n = group.length; i < n; i++) { ++ if ((node = group[i]) && filter.call(node, node.__data__, i, j)) { ++ subgroup.push(node); ++ } ++ } ++ } ++ return d3_transition(subgroups, this.namespace, this.id); ++ }; ++ d3_transitionPrototype.tween = function(name, tween) { ++ var id = this.id, ns = this.namespace; ++ if (arguments.length < 2) return this.node()[ns][id].tween.get(name); ++ return d3_selection_each(this, tween == null ? function(node) { ++ node[ns][id].tween.remove(name); ++ } : function(node) { ++ node[ns][id].tween.set(name, tween); ++ }); ++ }; ++ function d3_transition_tween(groups, name, value, tween) { ++ var id = groups.id, ns = groups.namespace; ++ return d3_selection_each(groups, typeof value === "function" ? function(node, i, j) { ++ node[ns][id].tween.set(name, tween(value.call(node, node.__data__, i, j))); ++ } : (value = tween(value), function(node) { ++ node[ns][id].tween.set(name, value); ++ })); ++ } ++ d3_transitionPrototype.attr = function(nameNS, value) { ++ if (arguments.length < 2) { ++ for (value in nameNS) this.attr(value, nameNS[value]); ++ return this; ++ } ++ var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate, name = d3.ns.qualify(nameNS); ++ function attrNull() { ++ this.removeAttribute(name); ++ } ++ function attrNullNS() { ++ this.removeAttributeNS(name.space, name.local); ++ } ++ function attrTween(b) { ++ return b == null ? attrNull : (b += "", function() { ++ var a = this.getAttribute(name), i; ++ return a !== b && (i = interpolate(a, b), function(t) { ++ this.setAttribute(name, i(t)); ++ }); ++ }); ++ } ++ function attrTweenNS(b) { ++ return b == null ? attrNullNS : (b += "", function() { ++ var a = this.getAttributeNS(name.space, name.local), i; ++ return a !== b && (i = interpolate(a, b), function(t) { ++ this.setAttributeNS(name.space, name.local, i(t)); ++ }); ++ }); ++ } ++ return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween); ++ }; ++ d3_transitionPrototype.attrTween = function(nameNS, tween) { ++ var name = d3.ns.qualify(nameNS); ++ function attrTween(d, i) { ++ var f = tween.call(this, d, i, this.getAttribute(name)); ++ return f && function(t) { ++ this.setAttribute(name, f(t)); ++ }; ++ } ++ function attrTweenNS(d, i) { ++ var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local)); ++ return f && function(t) { ++ this.setAttributeNS(name.space, name.local, f(t)); ++ }; ++ } ++ return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween); ++ }; ++ d3_transitionPrototype.style = function(name, value, priority) { ++ var n = arguments.length; ++ if (n < 3) { ++ if (typeof name !== "string") { ++ if (n < 2) value = ""; ++ for (priority in name) this.style(priority, name[priority], value); ++ return this; ++ } ++ priority = ""; ++ } ++ function styleNull() { ++ this.style.removeProperty(name); ++ } ++ function styleString(b) { ++ return b == null ? styleNull : (b += "", function() { ++ var a = d3_window(this).getComputedStyle(this, null).getPropertyValue(name), i; ++ return a !== b && (i = d3_interpolate(a, b), function(t) { ++ this.style.setProperty(name, i(t), priority); ++ }); ++ }); ++ } ++ return d3_transition_tween(this, "style." + name, value, styleString); ++ }; ++ d3_transitionPrototype.styleTween = function(name, tween, priority) { ++ if (arguments.length < 3) priority = ""; ++ function styleTween(d, i) { ++ var f = tween.call(this, d, i, d3_window(this).getComputedStyle(this, null).getPropertyValue(name)); ++ return f && function(t) { ++ this.style.setProperty(name, f(t), priority); ++ }; ++ } ++ return this.tween("style." + name, styleTween); ++ }; ++ d3_transitionPrototype.text = function(value) { ++ return d3_transition_tween(this, "text", value, d3_transition_text); ++ }; ++ function d3_transition_text(b) { ++ if (b == null) b = ""; ++ return function() { ++ this.textContent = b; ++ }; ++ } ++ d3_transitionPrototype.remove = function() { ++ var ns = this.namespace; ++ return this.each("end.transition", function() { ++ var p; ++ if (this[ns].count < 2 && (p = this.parentNode)) p.removeChild(this); ++ }); ++ }; ++ d3_transitionPrototype.ease = function(value) { ++ var id = this.id, ns = this.namespace; ++ if (arguments.length < 1) return this.node()[ns][id].ease; ++ if (typeof value !== "function") value = d3.ease.apply(d3, arguments); ++ return d3_selection_each(this, function(node) { ++ node[ns][id].ease = value; ++ }); ++ }; ++ d3_transitionPrototype.delay = function(value) { ++ var id = this.id, ns = this.namespace; ++ if (arguments.length < 1) return this.node()[ns][id].delay; ++ return d3_selection_each(this, typeof value === "function" ? function(node, i, j) { ++ node[ns][id].delay = +value.call(node, node.__data__, i, j); ++ } : (value = +value, function(node) { ++ node[ns][id].delay = value; ++ })); ++ }; ++ d3_transitionPrototype.duration = function(value) { ++ var id = this.id, ns = this.namespace; ++ if (arguments.length < 1) return this.node()[ns][id].duration; ++ return d3_selection_each(this, typeof value === "function" ? function(node, i, j) { ++ node[ns][id].duration = Math.max(1, value.call(node, node.__data__, i, j)); ++ } : (value = Math.max(1, value), function(node) { ++ node[ns][id].duration = value; ++ })); ++ }; ++ d3_transitionPrototype.each = function(type, listener) { ++ var id = this.id, ns = this.namespace; ++ if (arguments.length < 2) { ++ var inherit = d3_transitionInherit, inheritId = d3_transitionInheritId; ++ try { ++ d3_transitionInheritId = id; ++ d3_selection_each(this, function(node, i, j) { ++ d3_transitionInherit = node[ns][id]; ++ type.call(node, node.__data__, i, j); ++ }); ++ } finally { ++ d3_transitionInherit = inherit; ++ d3_transitionInheritId = inheritId; ++ } ++ } else { ++ d3_selection_each(this, function(node) { ++ var transition = node[ns][id]; ++ (transition.event || (transition.event = d3.dispatch("start", "end", "interrupt"))).on(type, listener); ++ }); ++ } ++ return this; ++ }; ++ d3_transitionPrototype.transition = function() { ++ var id0 = this.id, id1 = ++d3_transitionId, ns = this.namespace, subgroups = [], subgroup, group, node, transition; ++ for (var j = 0, m = this.length; j < m; j++) { ++ subgroups.push(subgroup = []); ++ for (var group = this[j], i = 0, n = group.length; i < n; i++) { ++ if (node = group[i]) { ++ transition = node[ns][id0]; ++ d3_transitionNode(node, i, ns, id1, { ++ time: transition.time, ++ ease: transition.ease, ++ delay: transition.delay + transition.duration, ++ duration: transition.duration ++ }); ++ } ++ subgroup.push(node); ++ } ++ } ++ return d3_transition(subgroups, ns, id1); ++ }; ++ function d3_transitionNamespace(name) { ++ return name == null ? "__transition__" : "__transition_" + name + "__"; ++ } ++ function d3_transitionNode(node, i, ns, id, inherit) { ++ var lock = node[ns] || (node[ns] = { ++ active: 0, ++ count: 0 ++ }), transition = lock[id], time, timer, duration, ease, tweens; ++ function schedule(elapsed) { ++ var delay = transition.delay; ++ timer.t = delay + time; ++ if (delay <= elapsed) return start(elapsed - delay); ++ timer.c = start; ++ } ++ function start(elapsed) { ++ var activeId = lock.active, active = lock[activeId]; ++ if (active) { ++ active.timer.c = null; ++ active.timer.t = NaN; ++ --lock.count; ++ delete lock[activeId]; ++ active.event && active.event.interrupt.call(node, node.__data__, active.index); ++ } ++ for (var cancelId in lock) { ++ if (+cancelId < id) { ++ var cancel = lock[cancelId]; ++ cancel.timer.c = null; ++ cancel.timer.t = NaN; ++ --lock.count; ++ delete lock[cancelId]; ++ } ++ } ++ timer.c = tick; ++ d3_timer(function() { ++ if (timer.c && tick(elapsed || 1)) { ++ timer.c = null; ++ timer.t = NaN; ++ } ++ return 1; ++ }, 0, time); ++ lock.active = id; ++ transition.event && transition.event.start.call(node, node.__data__, i); ++ tweens = []; ++ transition.tween.forEach(function(key, value) { ++ if (value = value.call(node, node.__data__, i)) { ++ tweens.push(value); ++ } ++ }); ++ ease = transition.ease; ++ duration = transition.duration; ++ } ++ function tick(elapsed) { ++ var t = elapsed / duration, e = ease(t), n = tweens.length; ++ while (n > 0) { ++ tweens[--n].call(node, e); ++ } ++ if (t >= 1) { ++ transition.event && transition.event.end.call(node, node.__data__, i); ++ if (--lock.count) delete lock[id]; else delete node[ns]; ++ return 1; ++ } ++ } ++ if (!transition) { ++ time = inherit.time; ++ timer = d3_timer(schedule, 0, time); ++ transition = lock[id] = { ++ tween: new d3_Map(), ++ time: time, ++ timer: timer, ++ delay: inherit.delay, ++ duration: inherit.duration, ++ ease: inherit.ease, ++ index: i ++ }; ++ inherit = null; ++ ++lock.count; ++ } ++ } ++ d3.svg.axis = function() { ++ var scale = d3.scale.linear(), orient = d3_svg_axisDefaultOrient, innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickArguments_ = [ 10 ], tickValues = null, tickFormat_; ++ function axis(g) { ++ g.each(function() { ++ var g = d3.select(this); ++ var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = scale.copy(); ++ var ticks = tickValues == null ? scale1.ticks ? scale1.ticks.apply(scale1, tickArguments_) : scale1.domain() : tickValues, tickFormat = tickFormat_ == null ? scale1.tickFormat ? scale1.tickFormat.apply(scale1, tickArguments_) : d3_identity : tickFormat_, tick = g.selectAll(".tick").data(ticks, scale1), tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", ε), tickExit = d3.transition(tick.exit()).style("opacity", ε).remove(), tickUpdate = d3.transition(tick.order()).style("opacity", 1), tickSpacing = Math.max(innerTickSize, 0) + tickPadding, tickTransform; ++ var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"), ++ d3.transition(path)); ++ tickEnter.append("line"); ++ tickEnter.append("text"); ++ var lineEnter = tickEnter.select("line"), lineUpdate = tickUpdate.select("line"), text = tick.select("text").text(tickFormat), textEnter = tickEnter.select("text"), textUpdate = tickUpdate.select("text"), sign = orient === "top" || orient === "left" ? -1 : 1, x1, x2, y1, y2; ++ if (orient === "bottom" || orient === "top") { ++ tickTransform = d3_svg_axisX, x1 = "x", y1 = "y", x2 = "x2", y2 = "y2"; ++ text.attr("dy", sign < 0 ? "0em" : ".71em").style("text-anchor", "middle"); ++ pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outerTickSize); ++ } else { ++ tickTransform = d3_svg_axisY, x1 = "y", y1 = "x", x2 = "y2", y2 = "x2"; ++ text.attr("dy", ".32em").style("text-anchor", sign < 0 ? "end" : "start"); ++ pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outerTickSize); ++ } ++ lineEnter.attr(y2, sign * innerTickSize); ++ textEnter.attr(y1, sign * tickSpacing); ++ lineUpdate.attr(x2, 0).attr(y2, sign * innerTickSize); ++ textUpdate.attr(x1, 0).attr(y1, sign * tickSpacing); ++ if (scale1.rangeBand) { ++ var x = scale1, dx = x.rangeBand() / 2; ++ scale0 = scale1 = function(d) { ++ return x(d) + dx; ++ }; ++ } else if (scale0.rangeBand) { ++ scale0 = scale1; ++ } else { ++ tickExit.call(tickTransform, scale1, scale0); ++ } ++ tickEnter.call(tickTransform, scale0, scale1); ++ tickUpdate.call(tickTransform, scale1, scale1); ++ }); ++ } ++ axis.scale = function(x) { ++ if (!arguments.length) return scale; ++ scale = x; ++ return axis; ++ }; ++ axis.orient = function(x) { ++ if (!arguments.length) return orient; ++ orient = x in d3_svg_axisOrients ? x + "" : d3_svg_axisDefaultOrient; ++ return axis; ++ }; ++ axis.ticks = function() { ++ if (!arguments.length) return tickArguments_; ++ tickArguments_ = d3_array(arguments); ++ return axis; ++ }; ++ axis.tickValues = function(x) { ++ if (!arguments.length) return tickValues; ++ tickValues = x; ++ return axis; ++ }; ++ axis.tickFormat = function(x) { ++ if (!arguments.length) return tickFormat_; ++ tickFormat_ = x; ++ return axis; ++ }; ++ axis.tickSize = function(x) { ++ var n = arguments.length; ++ if (!n) return innerTickSize; ++ innerTickSize = +x; ++ outerTickSize = +arguments[n - 1]; ++ return axis; ++ }; ++ axis.innerTickSize = function(x) { ++ if (!arguments.length) return innerTickSize; ++ innerTickSize = +x; ++ return axis; ++ }; ++ axis.outerTickSize = function(x) { ++ if (!arguments.length) return outerTickSize; ++ outerTickSize = +x; ++ return axis; ++ }; ++ axis.tickPadding = function(x) { ++ if (!arguments.length) return tickPadding; ++ tickPadding = +x; ++ return axis; ++ }; ++ axis.tickSubdivide = function() { ++ return arguments.length && axis; ++ }; ++ return axis; ++ }; ++ var d3_svg_axisDefaultOrient = "bottom", d3_svg_axisOrients = { ++ top: 1, ++ right: 1, ++ bottom: 1, ++ left: 1 ++ }; ++ function d3_svg_axisX(selection, x0, x1) { ++ selection.attr("transform", function(d) { ++ var v0 = x0(d); ++ return "translate(" + (isFinite(v0) ? v0 : x1(d)) + ",0)"; ++ }); ++ } ++ function d3_svg_axisY(selection, y0, y1) { ++ selection.attr("transform", function(d) { ++ var v0 = y0(d); ++ return "translate(0," + (isFinite(v0) ? v0 : y1(d)) + ")"; ++ }); ++ } ++ d3.svg.brush = function() { ++ var event = d3_eventDispatch(brush, "brushstart", "brush", "brushend"), x = null, y = null, xExtent = [ 0, 0 ], yExtent = [ 0, 0 ], xExtentDomain, yExtentDomain, xClamp = true, yClamp = true, resizes = d3_svg_brushResizes[0]; ++ function brush(g) { ++ g.each(function() { ++ var g = d3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", brushstart).on("touchstart.brush", brushstart); ++ var background = g.selectAll(".background").data([ 0 ]); ++ background.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair"); ++ g.selectAll(".extent").data([ 0 ]).enter().append("rect").attr("class", "extent").style("cursor", "move"); ++ var resize = g.selectAll(".resize").data(resizes, d3_identity); ++ resize.exit().remove(); ++ resize.enter().append("g").attr("class", function(d) { ++ return "resize " + d; ++ }).style("cursor", function(d) { ++ return d3_svg_brushCursor[d]; ++ }).append("rect").attr("x", function(d) { ++ return /[ew]$/.test(d) ? -3 : null; ++ }).attr("y", function(d) { ++ return /^[ns]/.test(d) ? -3 : null; ++ }).attr("width", 6).attr("height", 6).style("visibility", "hidden"); ++ resize.style("display", brush.empty() ? "none" : null); ++ var gUpdate = d3.transition(g), backgroundUpdate = d3.transition(background), range; ++ if (x) { ++ range = d3_scaleRange(x); ++ backgroundUpdate.attr("x", range[0]).attr("width", range[1] - range[0]); ++ redrawX(gUpdate); ++ } ++ if (y) { ++ range = d3_scaleRange(y); ++ backgroundUpdate.attr("y", range[0]).attr("height", range[1] - range[0]); ++ redrawY(gUpdate); ++ } ++ redraw(gUpdate); ++ }); ++ } ++ brush.event = function(g) { ++ g.each(function() { ++ var event_ = event.of(this, arguments), extent1 = { ++ x: xExtent, ++ y: yExtent, ++ i: xExtentDomain, ++ j: yExtentDomain ++ }, extent0 = this.__chart__ || extent1; ++ this.__chart__ = extent1; ++ if (d3_transitionInheritId) { ++ d3.select(this).transition().each("start.brush", function() { ++ xExtentDomain = extent0.i; ++ yExtentDomain = extent0.j; ++ xExtent = extent0.x; ++ yExtent = extent0.y; ++ event_({ ++ type: "brushstart" ++ }); ++ }).tween("brush:brush", function() { ++ var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y); ++ xExtentDomain = yExtentDomain = null; ++ return function(t) { ++ xExtent = extent1.x = xi(t); ++ yExtent = extent1.y = yi(t); ++ event_({ ++ type: "brush", ++ mode: "resize" ++ }); ++ }; ++ }).each("end.brush", function() { ++ xExtentDomain = extent1.i; ++ yExtentDomain = extent1.j; ++ event_({ ++ type: "brush", ++ mode: "resize" ++ }); ++ event_({ ++ type: "brushend" ++ }); ++ }); ++ } else { ++ event_({ ++ type: "brushstart" ++ }); ++ event_({ ++ type: "brush", ++ mode: "resize" ++ }); ++ event_({ ++ type: "brushend" ++ }); ++ } ++ }); ++ }; ++ function redraw(g) { ++ g.selectAll(".resize").attr("transform", function(d) { ++ return "translate(" + xExtent[+/e$/.test(d)] + "," + yExtent[+/^s/.test(d)] + ")"; ++ }); ++ } ++ function redrawX(g) { ++ g.select(".extent").attr("x", xExtent[0]); ++ g.selectAll(".extent,.n>rect,.s>rect").attr("width", xExtent[1] - xExtent[0]); ++ } ++ function redrawY(g) { ++ g.select(".extent").attr("y", yExtent[0]); ++ g.selectAll(".extent,.e>rect,.w>rect").attr("height", yExtent[1] - yExtent[0]); ++ } ++ function brushstart() { ++ var target = this, eventTarget = d3.select(d3.event.target), event_ = event.of(target, arguments), g = d3.select(target), resizing = eventTarget.datum(), resizingX = !/^(n|s)$/.test(resizing) && x, resizingY = !/^(e|w)$/.test(resizing) && y, dragging = eventTarget.classed("extent"), dragRestore = d3_event_dragSuppress(target), center, origin = d3.mouse(target), offset; ++ var w = d3.select(d3_window(target)).on("keydown.brush", keydown).on("keyup.brush", keyup); ++ if (d3.event.changedTouches) { ++ w.on("touchmove.brush", brushmove).on("touchend.brush", brushend); ++ } else { ++ w.on("mousemove.brush", brushmove).on("mouseup.brush", brushend); ++ } ++ g.interrupt().selectAll("*").interrupt(); ++ if (dragging) { ++ origin[0] = xExtent[0] - origin[0]; ++ origin[1] = yExtent[0] - origin[1]; ++ } else if (resizing) { ++ var ex = +/w$/.test(resizing), ey = +/^n/.test(resizing); ++ offset = [ xExtent[1 - ex] - origin[0], yExtent[1 - ey] - origin[1] ]; ++ origin[0] = xExtent[ex]; ++ origin[1] = yExtent[ey]; ++ } else if (d3.event.altKey) center = origin.slice(); ++ g.style("pointer-events", "none").selectAll(".resize").style("display", null); ++ d3.select("body").style("cursor", eventTarget.style("cursor")); ++ event_({ ++ type: "brushstart" ++ }); ++ brushmove(); ++ function keydown() { ++ if (d3.event.keyCode == 32) { ++ if (!dragging) { ++ center = null; ++ origin[0] -= xExtent[1]; ++ origin[1] -= yExtent[1]; ++ dragging = 2; ++ } ++ d3_eventPreventDefault(); ++ } ++ } ++ function keyup() { ++ if (d3.event.keyCode == 32 && dragging == 2) { ++ origin[0] += xExtent[1]; ++ origin[1] += yExtent[1]; ++ dragging = 0; ++ d3_eventPreventDefault(); ++ } ++ } ++ function brushmove() { ++ var point = d3.mouse(target), moved = false; ++ if (offset) { ++ point[0] += offset[0]; ++ point[1] += offset[1]; ++ } ++ if (!dragging) { ++ if (d3.event.altKey) { ++ if (!center) center = [ (xExtent[0] + xExtent[1]) / 2, (yExtent[0] + yExtent[1]) / 2 ]; ++ origin[0] = xExtent[+(point[0] < center[0])]; ++ origin[1] = yExtent[+(point[1] < center[1])]; ++ } else center = null; ++ } ++ if (resizingX && move1(point, x, 0)) { ++ redrawX(g); ++ moved = true; ++ } ++ if (resizingY && move1(point, y, 1)) { ++ redrawY(g); ++ moved = true; ++ } ++ if (moved) { ++ redraw(g); ++ event_({ ++ type: "brush", ++ mode: dragging ? "move" : "resize" ++ }); ++ } ++ } ++ function move1(point, scale, i) { ++ var range = d3_scaleRange(scale), r0 = range[0], r1 = range[1], position = origin[i], extent = i ? yExtent : xExtent, size = extent[1] - extent[0], min, max; ++ if (dragging) { ++ r0 -= position; ++ r1 -= size + position; ++ } ++ min = (i ? yClamp : xClamp) ? Math.max(r0, Math.min(r1, point[i])) : point[i]; ++ if (dragging) { ++ max = (min += position) + size; ++ } else { ++ if (center) position = Math.max(r0, Math.min(r1, 2 * center[i] - min)); ++ if (position < min) { ++ max = min; ++ min = position; ++ } else { ++ max = position; ++ } ++ } ++ if (extent[0] != min || extent[1] != max) { ++ if (i) yExtentDomain = null; else xExtentDomain = null; ++ extent[0] = min; ++ extent[1] = max; ++ return true; ++ } ++ } ++ function brushend() { ++ brushmove(); ++ g.style("pointer-events", "all").selectAll(".resize").style("display", brush.empty() ? "none" : null); ++ d3.select("body").style("cursor", null); ++ w.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null); ++ dragRestore(); ++ event_({ ++ type: "brushend" ++ }); ++ } ++ } ++ brush.x = function(z) { ++ if (!arguments.length) return x; ++ x = z; ++ resizes = d3_svg_brushResizes[!x << 1 | !y]; ++ return brush; ++ }; ++ brush.y = function(z) { ++ if (!arguments.length) return y; ++ y = z; ++ resizes = d3_svg_brushResizes[!x << 1 | !y]; ++ return brush; ++ }; ++ brush.clamp = function(z) { ++ if (!arguments.length) return x && y ? [ xClamp, yClamp ] : x ? xClamp : y ? yClamp : null; ++ if (x && y) xClamp = !!z[0], yClamp = !!z[1]; else if (x) xClamp = !!z; else if (y) yClamp = !!z; ++ return brush; ++ }; ++ brush.extent = function(z) { ++ var x0, x1, y0, y1, t; ++ if (!arguments.length) { ++ if (x) { ++ if (xExtentDomain) { ++ x0 = xExtentDomain[0], x1 = xExtentDomain[1]; ++ } else { ++ x0 = xExtent[0], x1 = xExtent[1]; ++ if (x.invert) x0 = x.invert(x0), x1 = x.invert(x1); ++ if (x1 < x0) t = x0, x0 = x1, x1 = t; ++ } ++ } ++ if (y) { ++ if (yExtentDomain) { ++ y0 = yExtentDomain[0], y1 = yExtentDomain[1]; ++ } else { ++ y0 = yExtent[0], y1 = yExtent[1]; ++ if (y.invert) y0 = y.invert(y0), y1 = y.invert(y1); ++ if (y1 < y0) t = y0, y0 = y1, y1 = t; ++ } ++ } ++ return x && y ? [ [ x0, y0 ], [ x1, y1 ] ] : x ? [ x0, x1 ] : y && [ y0, y1 ]; ++ } ++ if (x) { ++ x0 = z[0], x1 = z[1]; ++ if (y) x0 = x0[0], x1 = x1[0]; ++ xExtentDomain = [ x0, x1 ]; ++ if (x.invert) x0 = x(x0), x1 = x(x1); ++ if (x1 < x0) t = x0, x0 = x1, x1 = t; ++ if (x0 != xExtent[0] || x1 != xExtent[1]) xExtent = [ x0, x1 ]; ++ } ++ if (y) { ++ y0 = z[0], y1 = z[1]; ++ if (x) y0 = y0[1], y1 = y1[1]; ++ yExtentDomain = [ y0, y1 ]; ++ if (y.invert) y0 = y(y0), y1 = y(y1); ++ if (y1 < y0) t = y0, y0 = y1, y1 = t; ++ if (y0 != yExtent[0] || y1 != yExtent[1]) yExtent = [ y0, y1 ]; ++ } ++ return brush; ++ }; ++ brush.clear = function() { ++ if (!brush.empty()) { ++ xExtent = [ 0, 0 ], yExtent = [ 0, 0 ]; ++ xExtentDomain = yExtentDomain = null; ++ } ++ return brush; ++ }; ++ brush.empty = function() { ++ return !!x && xExtent[0] == xExtent[1] || !!y && yExtent[0] == yExtent[1]; ++ }; ++ return d3.rebind(brush, event, "on"); ++ }; ++ var d3_svg_brushCursor = { ++ 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 d3_svg_brushResizes = [ [ "n", "e", "s", "w", "nw", "ne", "se", "sw" ], [ "e", "w" ], [ "n", "s" ], [] ]; ++ var d3_time_format = d3_time.format = d3_locale_enUS.timeFormat; ++ var d3_time_formatUtc = d3_time_format.utc; ++ var d3_time_formatIso = d3_time_formatUtc("%Y-%m-%dT%H:%M:%S.%LZ"); ++ d3_time_format.iso = Date.prototype.toISOString && +new Date("2000-01-01T00:00:00.000Z") ? d3_time_formatIsoNative : d3_time_formatIso; ++ function d3_time_formatIsoNative(date) { ++ return date.toISOString(); ++ } ++ d3_time_formatIsoNative.parse = function(string) { ++ var date = new Date(string); ++ return isNaN(date) ? null : date; ++ }; ++ d3_time_formatIsoNative.toString = d3_time_formatIso.toString; ++ d3_time.second = d3_time_interval(function(date) { ++ return new d3_date(Math.floor(date / 1e3) * 1e3); ++ }, function(date, offset) { ++ date.setTime(date.getTime() + Math.floor(offset) * 1e3); ++ }, function(date) { ++ return date.getSeconds(); ++ }); ++ d3_time.seconds = d3_time.second.range; ++ d3_time.seconds.utc = d3_time.second.utc.range; ++ d3_time.minute = d3_time_interval(function(date) { ++ return new d3_date(Math.floor(date / 6e4) * 6e4); ++ }, function(date, offset) { ++ date.setTime(date.getTime() + Math.floor(offset) * 6e4); ++ }, function(date) { ++ return date.getMinutes(); ++ }); ++ d3_time.minutes = d3_time.minute.range; ++ d3_time.minutes.utc = d3_time.minute.utc.range; ++ d3_time.hour = d3_time_interval(function(date) { ++ var timezone = date.getTimezoneOffset() / 60; ++ return new d3_date((Math.floor(date / 36e5 - timezone) + timezone) * 36e5); ++ }, function(date, offset) { ++ date.setTime(date.getTime() + Math.floor(offset) * 36e5); ++ }, function(date) { ++ return date.getHours(); ++ }); ++ d3_time.hours = d3_time.hour.range; ++ d3_time.hours.utc = d3_time.hour.utc.range; ++ d3_time.month = d3_time_interval(function(date) { ++ date = d3_time.day(date); ++ date.setDate(1); ++ return date; ++ }, function(date, offset) { ++ date.setMonth(date.getMonth() + offset); ++ }, function(date) { ++ return date.getMonth(); ++ }); ++ d3_time.months = d3_time.month.range; ++ d3_time.months.utc = d3_time.month.utc.range; ++ function d3_time_scale(linear, methods, format) { ++ function scale(x) { ++ return linear(x); ++ } ++ scale.invert = function(x) { ++ return d3_time_scaleDate(linear.invert(x)); ++ }; ++ scale.domain = function(x) { ++ if (!arguments.length) return linear.domain().map(d3_time_scaleDate); ++ linear.domain(x); ++ return scale; ++ }; ++ function tickMethod(extent, count) { ++ var span = extent[1] - extent[0], target = span / count, i = d3.bisect(d3_time_scaleSteps, target); ++ return i == d3_time_scaleSteps.length ? [ methods.year, d3_scale_linearTickRange(extent.map(function(d) { ++ return d / 31536e6; ++ }), count)[2] ] : !i ? [ d3_time_scaleMilliseconds, d3_scale_linearTickRange(extent, count)[2] ] : methods[target / d3_time_scaleSteps[i - 1] < d3_time_scaleSteps[i] / target ? i - 1 : i]; ++ } ++ scale.nice = function(interval, skip) { ++ var domain = scale.domain(), extent = d3_scaleExtent(domain), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" && tickMethod(extent, interval); ++ if (method) interval = method[0], skip = method[1]; ++ function skipped(date) { ++ return !isNaN(date) && !interval.range(date, d3_time_scaleDate(+date + 1), skip).length; ++ } ++ return scale.domain(d3_scale_nice(domain, skip > 1 ? { ++ floor: function(date) { ++ while (skipped(date = interval.floor(date))) date = d3_time_scaleDate(date - 1); ++ return date; ++ }, ++ ceil: function(date) { ++ while (skipped(date = interval.ceil(date))) date = d3_time_scaleDate(+date + 1); ++ return date; ++ } ++ } : interval)); ++ }; ++ scale.ticks = function(interval, skip) { ++ var extent = d3_scaleExtent(scale.domain()), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" ? tickMethod(extent, interval) : !interval.range && [ { ++ range: interval ++ }, skip ]; ++ if (method) interval = method[0], skip = method[1]; ++ return interval.range(extent[0], d3_time_scaleDate(+extent[1] + 1), skip < 1 ? 1 : skip); ++ }; ++ scale.tickFormat = function() { ++ return format; ++ }; ++ scale.copy = function() { ++ return d3_time_scale(linear.copy(), methods, format); ++ }; ++ return d3_scale_linearRebind(scale, linear); ++ } ++ function d3_time_scaleDate(t) { ++ return new Date(t); ++ } ++ var d3_time_scaleSteps = [ 1e3, 5e3, 15e3, 3e4, 6e4, 3e5, 9e5, 18e5, 36e5, 108e5, 216e5, 432e5, 864e5, 1728e5, 6048e5, 2592e6, 7776e6, 31536e6 ]; ++ var d3_time_scaleLocalMethods = [ [ d3_time.second, 1 ], [ d3_time.second, 5 ], [ d3_time.second, 15 ], [ d3_time.second, 30 ], [ d3_time.minute, 1 ], [ d3_time.minute, 5 ], [ d3_time.minute, 15 ], [ d3_time.minute, 30 ], [ d3_time.hour, 1 ], [ d3_time.hour, 3 ], [ d3_time.hour, 6 ], [ d3_time.hour, 12 ], [ d3_time.day, 1 ], [ d3_time.day, 2 ], [ d3_time.week, 1 ], [ d3_time.month, 1 ], [ d3_time.month, 3 ], [ d3_time.year, 1 ] ]; ++ var d3_time_scaleLocalFormat = d3_time_format.multi([ [ ".%L", function(d) { ++ return d.getMilliseconds(); ++ } ], [ ":%S", function(d) { ++ return d.getSeconds(); ++ } ], [ "%I:%M", function(d) { ++ return d.getMinutes(); ++ } ], [ "%I %p", function(d) { ++ return d.getHours(); ++ } ], [ "%a %d", function(d) { ++ return d.getDay() && d.getDate() != 1; ++ } ], [ "%b %d", function(d) { ++ return d.getDate() != 1; ++ } ], [ "%B", function(d) { ++ return d.getMonth(); ++ } ], [ "%Y", d3_true ] ]); ++ var d3_time_scaleMilliseconds = { ++ range: function(start, stop, step) { ++ return d3.range(Math.ceil(start / step) * step, +stop, step).map(d3_time_scaleDate); ++ }, ++ floor: d3_identity, ++ ceil: d3_identity ++ }; ++ d3_time_scaleLocalMethods.year = d3_time.year; ++ d3_time.scale = function() { ++ return d3_time_scale(d3.scale.linear(), d3_time_scaleLocalMethods, d3_time_scaleLocalFormat); ++ }; ++ var d3_time_scaleUtcMethods = d3_time_scaleLocalMethods.map(function(m) { ++ return [ m[0].utc, m[1] ]; ++ }); ++ var d3_time_scaleUtcFormat = d3_time_formatUtc.multi([ [ ".%L", function(d) { ++ return d.getUTCMilliseconds(); ++ } ], [ ":%S", function(d) { ++ return d.getUTCSeconds(); ++ } ], [ "%I:%M", function(d) { ++ return d.getUTCMinutes(); ++ } ], [ "%I %p", function(d) { ++ return d.getUTCHours(); ++ } ], [ "%a %d", function(d) { ++ return d.getUTCDay() && d.getUTCDate() != 1; ++ } ], [ "%b %d", function(d) { ++ return d.getUTCDate() != 1; ++ } ], [ "%B", function(d) { ++ return d.getUTCMonth(); ++ } ], [ "%Y", d3_true ] ]); ++ d3_time_scaleUtcMethods.year = d3_time.year.utc; ++ d3_time.scale.utc = function() { ++ return d3_time_scale(d3.scale.linear(), d3_time_scaleUtcMethods, d3_time_scaleUtcFormat); ++ }; ++ d3.text = d3_xhrType(function(request) { ++ return request.responseText; ++ }); ++ d3.json = function(url, callback) { ++ return d3_xhr(url, "application/json", d3_json, callback); ++ }; ++ function d3_json(request) { ++ return JSON.parse(request.responseText); ++ } ++ d3.html = function(url, callback) { ++ return d3_xhr(url, "text/html", d3_html, callback); ++ }; ++ function d3_html(request) { ++ var range = d3_document.createRange(); ++ range.selectNode(d3_document.body); ++ return range.createContextualFragment(request.responseText); ++ } ++ d3.xml = d3_xhrType(function(request) { ++ return request.responseXML; ++ }); ++ if (typeof define === "function" && define.amd) this.d3 = d3, define(d3); else if (typeof module === "object" && module.exports) module.exports = d3; else this.d3 = d3; ++}(); +\ No newline at end of file +diff --git a/pagure/static/vendor/d3/d3.v3.min.js b/pagure/static/vendor/d3/d3.v3.min.js +new file mode 100644 +index 00000000..16648730 +--- /dev/null ++++ b/pagure/static/vendor/d3/d3.v3.min.js +@@ -0,0 +1,5 @@ ++!function(){function n(n){return n&&(n.ownerDocument||n.document||n).documentElement}function t(n){return n&&(n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView)}function e(n,t){return t>n?-1:n>t?1:n>=t?0:NaN}function r(n){return null===n?NaN:+n}function i(n){return!isNaN(n)}function u(n){return{left:function(t,e,r,i){for(arguments.length<3&&(r=0),arguments.length<4&&(i=t.length);i>r;){var u=r+i>>>1;n(t[u],e)<0?r=u+1:i=u}return r},right:function(t,e,r,i){for(arguments.length<3&&(r=0),arguments.length<4&&(i=t.length);i>r;){var u=r+i>>>1;n(t[u],e)>0?i=u:r=u+1}return r}}}function o(n){return n.length}function a(n){for(var t=1;n*t%1;)t*=10;return t}function l(n,t){for(var e in t)Object.defineProperty(n.prototype,e,{value:t[e],enumerable:!1})}function c(){this._=Object.create(null)}function f(n){return(n+="")===bo||n[0]===_o?_o+n:n}function s(n){return(n+="")[0]===_o?n.slice(1):n}function h(n){return f(n)in this._}function p(n){return(n=f(n))in this._&&delete this._[n]}function g(){var n=[];for(var t in this._)n.push(s(t));return n}function v(){var n=0;for(var t in this._)++n;return n}function d(){for(var n in this._)return!1;return!0}function y(){this._=Object.create(null)}function m(n){return n}function M(n,t,e){return function(){var r=e.apply(t,arguments);return r===t?n:r}}function x(n,t){if(t in n)return t;t=t.charAt(0).toUpperCase()+t.slice(1);for(var e=0,r=wo.length;r>e;++e){var i=wo[e]+t;if(i in n)return i}}function b(){}function _(){}function w(n){function t(){for(var t,r=e,i=-1,u=r.length;++ie;e++)for(var i,u=n[e],o=0,a=u.length;a>o;o++)(i=u[o])&&t(i,o,e);return n}function Z(n){return ko(n,qo),n}function V(n){var t,e;return function(r,i,u){var o,a=n[u].update,l=a.length;for(u!=e&&(e=u,t=0),i>=t&&(t=i+1);!(o=a[t])&&++t0&&(n=n.slice(0,a));var c=To.get(n);return c&&(n=c,l=B),a?t?i:r:t?b:u}function $(n,t){return function(e){var r=ao.event;ao.event=e,t[0]=this.__data__;try{n.apply(this,t)}finally{ao.event=r}}}function B(n,t){var e=$(n,t);return function(n){var t=this,r=n.relatedTarget;r&&(r===t||8&r.compareDocumentPosition(t))||e.call(t,n)}}function W(e){var r=".dragsuppress-"+ ++Do,i="click"+r,u=ao.select(t(e)).on("touchmove"+r,S).on("dragstart"+r,S).on("selectstart"+r,S);if(null==Ro&&(Ro="onselectstart"in e?!1:x(e.style,"userSelect")),Ro){var o=n(e).style,a=o[Ro];o[Ro]="none"}return function(n){if(u.on(r,null),Ro&&(o[Ro]=a),n){var t=function(){u.on(i,null)};u.on(i,function(){S(),t()},!0),setTimeout(t,0)}}}function J(n,e){e.changedTouches&&(e=e.changedTouches[0]);var r=n.ownerSVGElement||n;if(r.createSVGPoint){var i=r.createSVGPoint();if(0>Po){var u=t(n);if(u.scrollX||u.scrollY){r=ao.select("body").append("svg").style({position:"absolute",top:0,left:0,margin:0,padding:0,border:"none"},"important");var o=r[0][0].getScreenCTM();Po=!(o.f||o.e),r.remove()}}return Po?(i.x=e.pageX,i.y=e.pageY):(i.x=e.clientX,i.y=e.clientY),i=i.matrixTransform(n.getScreenCTM().inverse()),[i.x,i.y]}var a=n.getBoundingClientRect();return[e.clientX-a.left-n.clientLeft,e.clientY-a.top-n.clientTop]}function G(){return ao.event.changedTouches[0].identifier}function K(n){return n>0?1:0>n?-1:0}function Q(n,t,e){return(t[0]-n[0])*(e[1]-n[1])-(t[1]-n[1])*(e[0]-n[0])}function nn(n){return n>1?0:-1>n?Fo:Math.acos(n)}function tn(n){return n>1?Io:-1>n?-Io:Math.asin(n)}function en(n){return((n=Math.exp(n))-1/n)/2}function rn(n){return((n=Math.exp(n))+1/n)/2}function un(n){return((n=Math.exp(2*n))-1)/(n+1)}function on(n){return(n=Math.sin(n/2))*n}function an(){}function ln(n,t,e){return this instanceof ln?(this.h=+n,this.s=+t,void(this.l=+e)):arguments.length<2?n instanceof ln?new ln(n.h,n.s,n.l):_n(""+n,wn,ln):new ln(n,t,e)}function cn(n,t,e){function r(n){return n>360?n-=360:0>n&&(n+=360),60>n?u+(o-u)*n/60:180>n?o:240>n?u+(o-u)*(240-n)/60:u}function i(n){return Math.round(255*r(n))}var u,o;return n=isNaN(n)?0:(n%=360)<0?n+360:n,t=isNaN(t)?0:0>t?0:t>1?1:t,e=0>e?0:e>1?1:e,o=.5>=e?e*(1+t):e+t-e*t,u=2*e-o,new mn(i(n+120),i(n),i(n-120))}function fn(n,t,e){return this instanceof fn?(this.h=+n,this.c=+t,void(this.l=+e)):arguments.length<2?n instanceof fn?new fn(n.h,n.c,n.l):n instanceof hn?gn(n.l,n.a,n.b):gn((n=Sn((n=ao.rgb(n)).r,n.g,n.b)).l,n.a,n.b):new fn(n,t,e)}function sn(n,t,e){return isNaN(n)&&(n=0),isNaN(t)&&(t=0),new hn(e,Math.cos(n*=Yo)*t,Math.sin(n)*t)}function hn(n,t,e){return this instanceof hn?(this.l=+n,this.a=+t,void(this.b=+e)):arguments.length<2?n instanceof hn?new hn(n.l,n.a,n.b):n instanceof fn?sn(n.h,n.c,n.l):Sn((n=mn(n)).r,n.g,n.b):new hn(n,t,e)}function pn(n,t,e){var r=(n+16)/116,i=r+t/500,u=r-e/200;return i=vn(i)*na,r=vn(r)*ta,u=vn(u)*ea,new mn(yn(3.2404542*i-1.5371385*r-.4985314*u),yn(-.969266*i+1.8760108*r+.041556*u),yn(.0556434*i-.2040259*r+1.0572252*u))}function gn(n,t,e){return n>0?new fn(Math.atan2(e,t)*Zo,Math.sqrt(t*t+e*e),n):new fn(NaN,NaN,n)}function vn(n){return n>.206893034?n*n*n:(n-4/29)/7.787037}function dn(n){return n>.008856?Math.pow(n,1/3):7.787037*n+4/29}function yn(n){return Math.round(255*(.00304>=n?12.92*n:1.055*Math.pow(n,1/2.4)-.055))}function mn(n,t,e){return this instanceof mn?(this.r=~~n,this.g=~~t,void(this.b=~~e)):arguments.length<2?n instanceof mn?new mn(n.r,n.g,n.b):_n(""+n,mn,cn):new mn(n,t,e)}function Mn(n){return new mn(n>>16,n>>8&255,255&n)}function xn(n){return Mn(n)+""}function bn(n){return 16>n?"0"+Math.max(0,n).toString(16):Math.min(255,n).toString(16)}function _n(n,t,e){var r,i,u,o=0,a=0,l=0;if(r=/([a-z]+)\((.*)\)/.exec(n=n.toLowerCase()))switch(i=r[2].split(","),r[1]){case"hsl":return e(parseFloat(i[0]),parseFloat(i[1])/100,parseFloat(i[2])/100);case"rgb":return t(Nn(i[0]),Nn(i[1]),Nn(i[2]))}return(u=ua.get(n))?t(u.r,u.g,u.b):(null==n||"#"!==n.charAt(0)||isNaN(u=parseInt(n.slice(1),16))||(4===n.length?(o=(3840&u)>>4,o=o>>4|o,a=240&u,a=a>>4|a,l=15&u,l=l<<4|l):7===n.length&&(o=(16711680&u)>>16,a=(65280&u)>>8,l=255&u)),t(o,a,l))}function wn(n,t,e){var r,i,u=Math.min(n/=255,t/=255,e/=255),o=Math.max(n,t,e),a=o-u,l=(o+u)/2;return a?(i=.5>l?a/(o+u):a/(2-o-u),r=n==o?(t-e)/a+(e>t?6:0):t==o?(e-n)/a+2:(n-t)/a+4,r*=60):(r=NaN,i=l>0&&1>l?0:r),new ln(r,i,l)}function Sn(n,t,e){n=kn(n),t=kn(t),e=kn(e);var r=dn((.4124564*n+.3575761*t+.1804375*e)/na),i=dn((.2126729*n+.7151522*t+.072175*e)/ta),u=dn((.0193339*n+.119192*t+.9503041*e)/ea);return hn(116*i-16,500*(r-i),200*(i-u))}function kn(n){return(n/=255)<=.04045?n/12.92:Math.pow((n+.055)/1.055,2.4)}function Nn(n){var t=parseFloat(n);return"%"===n.charAt(n.length-1)?Math.round(2.55*t):t}function En(n){return"function"==typeof n?n:function(){return n}}function An(n){return function(t,e,r){return 2===arguments.length&&"function"==typeof e&&(r=e,e=null),Cn(t,e,n,r)}}function Cn(n,t,e,r){function i(){var n,t=l.status;if(!t&&Ln(l)||t>=200&&300>t||304===t){try{n=e.call(u,l)}catch(r){return void o.error.call(u,r)}o.load.call(u,n)}else o.error.call(u,l)}var u={},o=ao.dispatch("beforesend","progress","load","error"),a={},l=new XMLHttpRequest,c=null;return!this.XDomainRequest||"withCredentials"in l||!/^(http(s)?:)?\/\//.test(n)||(l=new XDomainRequest),"onload"in l?l.onload=l.onerror=i:l.onreadystatechange=function(){l.readyState>3&&i()},l.onprogress=function(n){var t=ao.event;ao.event=n;try{o.progress.call(u,l)}finally{ao.event=t}},u.header=function(n,t){return n=(n+"").toLowerCase(),arguments.length<2?a[n]:(null==t?delete a[n]:a[n]=t+"",u)},u.mimeType=function(n){return arguments.length?(t=null==n?null:n+"",u):t},u.responseType=function(n){return arguments.length?(c=n,u):c},u.response=function(n){return e=n,u},["get","post"].forEach(function(n){u[n]=function(){return u.send.apply(u,[n].concat(co(arguments)))}}),u.send=function(e,r,i){if(2===arguments.length&&"function"==typeof r&&(i=r,r=null),l.open(e,n,!0),null==t||"accept"in a||(a.accept=t+",*/*"),l.setRequestHeader)for(var f in a)l.setRequestHeader(f,a[f]);return null!=t&&l.overrideMimeType&&l.overrideMimeType(t),null!=c&&(l.responseType=c),null!=i&&u.on("error",i).on("load",function(n){i(null,n)}),o.beforesend.call(u,l),l.send(null==r?null:r),u},u.abort=function(){return l.abort(),u},ao.rebind(u,o,"on"),null==r?u:u.get(zn(r))}function zn(n){return 1===n.length?function(t,e){n(null==t?e:null)}:n}function Ln(n){var t=n.responseType;return t&&"text"!==t?n.response:n.responseText}function qn(n,t,e){var r=arguments.length;2>r&&(t=0),3>r&&(e=Date.now());var i=e+t,u={c:n,t:i,n:null};return aa?aa.n=u:oa=u,aa=u,la||(ca=clearTimeout(ca),la=1,fa(Tn)),u}function Tn(){var n=Rn(),t=Dn()-n;t>24?(isFinite(t)&&(clearTimeout(ca),ca=setTimeout(Tn,t)),la=0):(la=1,fa(Tn))}function Rn(){for(var n=Date.now(),t=oa;t;)n>=t.t&&t.c(n-t.t)&&(t.c=null),t=t.n;return n}function Dn(){for(var n,t=oa,e=1/0;t;)t.c?(t.t8?function(n){return n/e}:function(n){return n*e},symbol:n}}function jn(n){var t=n.decimal,e=n.thousands,r=n.grouping,i=n.currency,u=r&&e?function(n,t){for(var i=n.length,u=[],o=0,a=r[0],l=0;i>0&&a>0&&(l+a+1>t&&(a=Math.max(1,t-l)),u.push(n.substring(i-=a,i+a)),!((l+=a+1)>t));)a=r[o=(o+1)%r.length];return u.reverse().join(e)}:m;return function(n){var e=ha.exec(n),r=e[1]||" ",o=e[2]||">",a=e[3]||"-",l=e[4]||"",c=e[5],f=+e[6],s=e[7],h=e[8],p=e[9],g=1,v="",d="",y=!1,m=!0;switch(h&&(h=+h.substring(1)),(c||"0"===r&&"="===o)&&(c=r="0",o="="),p){case"n":s=!0,p="g";break;case"%":g=100,d="%",p="f";break;case"p":g=100,d="%",p="r";break;case"b":case"o":case"x":case"X":"#"===l&&(v="0"+p.toLowerCase());case"c":m=!1;case"d":y=!0,h=0;break;case"s":g=-1,p="r"}"$"===l&&(v=i[0],d=i[1]),"r"!=p||h||(p="g"),null!=h&&("g"==p?h=Math.max(1,Math.min(21,h)):"e"!=p&&"f"!=p||(h=Math.max(0,Math.min(20,h)))),p=pa.get(p)||Fn;var M=c&&s;return function(n){var e=d;if(y&&n%1)return"";var i=0>n||0===n&&0>1/n?(n=-n,"-"):"-"===a?"":a;if(0>g){var l=ao.formatPrefix(n,h);n=l.scale(n),e=l.symbol+d}else n*=g;n=p(n,h);var x,b,_=n.lastIndexOf(".");if(0>_){var w=m?n.lastIndexOf("e"):-1;0>w?(x=n,b=""):(x=n.substring(0,w),b=n.substring(w))}else x=n.substring(0,_),b=t+n.substring(_+1);!c&&s&&(x=u(x,1/0));var S=v.length+x.length+b.length+(M?0:i.length),k=f>S?new Array(S=f-S+1).join(r):"";return M&&(x=u(k+x,k.length?f-b.length:1/0)),i+=v,n=x+b,("<"===o?i+n+k:">"===o?k+i+n:"^"===o?k.substring(0,S>>=1)+i+n+k.substring(S):i+(M?n:k+n))+e}}}function Fn(n){return n+""}function Hn(){this._=new Date(arguments.length>1?Date.UTC.apply(this,arguments):arguments[0])}function On(n,t,e){function r(t){var e=n(t),r=u(e,1);return r-t>t-e?e:r}function i(e){return t(e=n(new va(e-1)),1),e}function u(n,e){return t(n=new va(+n),e),n}function o(n,r,u){var o=i(n),a=[];if(u>1)for(;r>o;)e(o)%u||a.push(new Date(+o)),t(o,1);else for(;r>o;)a.push(new Date(+o)),t(o,1);return a}function a(n,t,e){try{va=Hn;var r=new Hn;return r._=n,o(r,t,e)}finally{va=Date}}n.floor=n,n.round=r,n.ceil=i,n.offset=u,n.range=o;var l=n.utc=In(n);return l.floor=l,l.round=In(r),l.ceil=In(i),l.offset=In(u),l.range=a,n}function In(n){return function(t,e){try{va=Hn;var r=new Hn;return r._=t,n(r,e)._}finally{va=Date}}}function Yn(n){function t(n){function t(t){for(var e,i,u,o=[],a=-1,l=0;++aa;){if(r>=c)return-1;if(i=t.charCodeAt(a++),37===i){if(o=t.charAt(a++),u=C[o in ya?t.charAt(a++):o],!u||(r=u(n,e,r))<0)return-1}else if(i!=e.charCodeAt(r++))return-1}return r}function r(n,t,e){_.lastIndex=0;var r=_.exec(t.slice(e));return r?(n.w=w.get(r[0].toLowerCase()),e+r[0].length):-1}function i(n,t,e){x.lastIndex=0;var r=x.exec(t.slice(e));return r?(n.w=b.get(r[0].toLowerCase()),e+r[0].length):-1}function u(n,t,e){N.lastIndex=0;var r=N.exec(t.slice(e));return r?(n.m=E.get(r[0].toLowerCase()),e+r[0].length):-1}function o(n,t,e){S.lastIndex=0;var r=S.exec(t.slice(e));return r?(n.m=k.get(r[0].toLowerCase()),e+r[0].length):-1}function a(n,t,r){return e(n,A.c.toString(),t,r)}function l(n,t,r){return e(n,A.x.toString(),t,r)}function c(n,t,r){return e(n,A.X.toString(),t,r)}function f(n,t,e){var r=M.get(t.slice(e,e+=2).toLowerCase());return null==r?-1:(n.p=r,e)}var s=n.dateTime,h=n.date,p=n.time,g=n.periods,v=n.days,d=n.shortDays,y=n.months,m=n.shortMonths;t.utc=function(n){function e(n){try{va=Hn;var t=new va;return t._=n,r(t)}finally{va=Date}}var r=t(n);return e.parse=function(n){try{va=Hn;var t=r.parse(n);return t&&t._}finally{va=Date}},e.toString=r.toString,e},t.multi=t.utc.multi=ct;var M=ao.map(),x=Vn(v),b=Xn(v),_=Vn(d),w=Xn(d),S=Vn(y),k=Xn(y),N=Vn(m),E=Xn(m);g.forEach(function(n,t){M.set(n.toLowerCase(),t)});var A={a:function(n){return d[n.getDay()]},A:function(n){return v[n.getDay()]},b:function(n){return m[n.getMonth()]},B:function(n){return y[n.getMonth()]},c:t(s),d:function(n,t){return Zn(n.getDate(),t,2)},e:function(n,t){return Zn(n.getDate(),t,2)},H:function(n,t){return Zn(n.getHours(),t,2)},I:function(n,t){return Zn(n.getHours()%12||12,t,2)},j:function(n,t){return Zn(1+ga.dayOfYear(n),t,3)},L:function(n,t){return Zn(n.getMilliseconds(),t,3)},m:function(n,t){return Zn(n.getMonth()+1,t,2)},M:function(n,t){return Zn(n.getMinutes(),t,2)},p:function(n){return g[+(n.getHours()>=12)]},S:function(n,t){return Zn(n.getSeconds(),t,2)},U:function(n,t){return Zn(ga.sundayOfYear(n),t,2)},w:function(n){return n.getDay()},W:function(n,t){return Zn(ga.mondayOfYear(n),t,2)},x:t(h),X:t(p),y:function(n,t){return Zn(n.getFullYear()%100,t,2)},Y:function(n,t){return Zn(n.getFullYear()%1e4,t,4)},Z:at,"%":function(){return"%"}},C={a:r,A:i,b:u,B:o,c:a,d:tt,e:tt,H:rt,I:rt,j:et,L:ot,m:nt,M:it,p:f,S:ut,U:Bn,w:$n,W:Wn,x:l,X:c,y:Gn,Y:Jn,Z:Kn,"%":lt};return t}function Zn(n,t,e){var r=0>n?"-":"",i=(r?-n:n)+"",u=i.length;return r+(e>u?new Array(e-u+1).join(t)+i:i)}function Vn(n){return new RegExp("^(?:"+n.map(ao.requote).join("|")+")","i")}function Xn(n){for(var t=new c,e=-1,r=n.length;++e68?1900:2e3)}function nt(n,t,e){ma.lastIndex=0;var r=ma.exec(t.slice(e,e+2));return r?(n.m=r[0]-1,e+r[0].length):-1}function tt(n,t,e){ma.lastIndex=0;var r=ma.exec(t.slice(e,e+2));return r?(n.d=+r[0],e+r[0].length):-1}function et(n,t,e){ma.lastIndex=0;var r=ma.exec(t.slice(e,e+3));return r?(n.j=+r[0],e+r[0].length):-1}function rt(n,t,e){ma.lastIndex=0;var r=ma.exec(t.slice(e,e+2));return r?(n.H=+r[0],e+r[0].length):-1}function it(n,t,e){ma.lastIndex=0;var r=ma.exec(t.slice(e,e+2));return r?(n.M=+r[0],e+r[0].length):-1}function ut(n,t,e){ma.lastIndex=0;var r=ma.exec(t.slice(e,e+2));return r?(n.S=+r[0],e+r[0].length):-1}function ot(n,t,e){ma.lastIndex=0;var r=ma.exec(t.slice(e,e+3));return r?(n.L=+r[0],e+r[0].length):-1}function at(n){var t=n.getTimezoneOffset(),e=t>0?"-":"+",r=xo(t)/60|0,i=xo(t)%60;return e+Zn(r,"0",2)+Zn(i,"0",2)}function lt(n,t,e){Ma.lastIndex=0;var r=Ma.exec(t.slice(e,e+1));return r?e+r[0].length:-1}function ct(n){for(var t=n.length,e=-1;++e=0?1:-1,a=o*e,l=Math.cos(t),c=Math.sin(t),f=u*c,s=i*l+f*Math.cos(a),h=f*o*Math.sin(a);ka.add(Math.atan2(h,s)),r=n,i=l,u=c}var t,e,r,i,u;Na.point=function(o,a){Na.point=n,r=(t=o)*Yo,i=Math.cos(a=(e=a)*Yo/2+Fo/4),u=Math.sin(a)},Na.lineEnd=function(){n(t,e)}}function dt(n){var t=n[0],e=n[1],r=Math.cos(e);return[r*Math.cos(t),r*Math.sin(t),Math.sin(e)]}function yt(n,t){return n[0]*t[0]+n[1]*t[1]+n[2]*t[2]}function mt(n,t){return[n[1]*t[2]-n[2]*t[1],n[2]*t[0]-n[0]*t[2],n[0]*t[1]-n[1]*t[0]]}function Mt(n,t){n[0]+=t[0],n[1]+=t[1],n[2]+=t[2]}function xt(n,t){return[n[0]*t,n[1]*t,n[2]*t]}function bt(n){var t=Math.sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);n[0]/=t,n[1]/=t,n[2]/=t}function _t(n){return[Math.atan2(n[1],n[0]),tn(n[2])]}function wt(n,t){return xo(n[0]-t[0])a;++a)i.point((e=n[a])[0],e[1]);return void i.lineEnd()}var l=new Tt(e,n,null,!0),c=new Tt(e,null,l,!1);l.o=c,u.push(l),o.push(c),l=new Tt(r,n,null,!1),c=new Tt(r,null,l,!0),l.o=c,u.push(l),o.push(c)}}),o.sort(t),qt(u),qt(o),u.length){for(var a=0,l=e,c=o.length;c>a;++a)o[a].e=l=!l;for(var f,s,h=u[0];;){for(var p=h,g=!0;p.v;)if((p=p.n)===h)return;f=p.z,i.lineStart();do{if(p.v=p.o.v=!0,p.e){if(g)for(var a=0,c=f.length;c>a;++a)i.point((s=f[a])[0],s[1]);else r(p.x,p.n.x,1,i);p=p.n}else{if(g){f=p.p.z;for(var a=f.length-1;a>=0;--a)i.point((s=f[a])[0],s[1])}else r(p.x,p.p.x,-1,i);p=p.p}p=p.o,f=p.z,g=!g}while(!p.v);i.lineEnd()}}}function qt(n){if(t=n.length){for(var t,e,r=0,i=n[0];++r0){for(b||(u.polygonStart(),b=!0),u.lineStart();++o1&&2&t&&e.push(e.pop().concat(e.shift())),p.push(e.filter(Dt))}var p,g,v,d=t(u),y=i.invert(r[0],r[1]),m={point:o,lineStart:l,lineEnd:c,polygonStart:function(){m.point=f,m.lineStart=s,m.lineEnd=h,p=[],g=[]},polygonEnd:function(){m.point=o,m.lineStart=l,m.lineEnd=c,p=ao.merge(p);var n=Ot(y,g);p.length?(b||(u.polygonStart(),b=!0),Lt(p,Ut,n,e,u)):n&&(b||(u.polygonStart(),b=!0),u.lineStart(),e(null,null,1,u),u.lineEnd()),b&&(u.polygonEnd(),b=!1),p=g=null},sphere:function(){u.polygonStart(),u.lineStart(),e(null,null,1,u),u.lineEnd(),u.polygonEnd()}},M=Pt(),x=t(M),b=!1;return m}}function Dt(n){return n.length>1}function Pt(){var n,t=[];return{lineStart:function(){t.push(n=[])},point:function(t,e){n.push([t,e])},lineEnd:b,buffer:function(){var e=t;return t=[],n=null,e},rejoin:function(){t.length>1&&t.push(t.pop().concat(t.shift()))}}}function Ut(n,t){return((n=n.x)[0]<0?n[1]-Io-Uo:Io-n[1])-((t=t.x)[0]<0?t[1]-Io-Uo:Io-t[1])}function jt(n){var t,e=NaN,r=NaN,i=NaN;return{lineStart:function(){n.lineStart(),t=1},point:function(u,o){var a=u>0?Fo:-Fo,l=xo(u-e);xo(l-Fo)0?Io:-Io),n.point(i,r),n.lineEnd(),n.lineStart(),n.point(a,r),n.point(u,r),t=0):i!==a&&l>=Fo&&(xo(e-i)Uo?Math.atan((Math.sin(t)*(u=Math.cos(r))*Math.sin(e)-Math.sin(r)*(i=Math.cos(t))*Math.sin(n))/(i*u*o)):(t+r)/2}function Ht(n,t,e,r){var i;if(null==n)i=e*Io,r.point(-Fo,i),r.point(0,i),r.point(Fo,i),r.point(Fo,0),r.point(Fo,-i),r.point(0,-i),r.point(-Fo,-i),r.point(-Fo,0),r.point(-Fo,i);else if(xo(n[0]-t[0])>Uo){var u=n[0]a;++a){var c=t[a],f=c.length;if(f)for(var s=c[0],h=s[0],p=s[1]/2+Fo/4,g=Math.sin(p),v=Math.cos(p),d=1;;){d===f&&(d=0),n=c[d];var y=n[0],m=n[1]/2+Fo/4,M=Math.sin(m),x=Math.cos(m),b=y-h,_=b>=0?1:-1,w=_*b,S=w>Fo,k=g*M;if(ka.add(Math.atan2(k*_*Math.sin(w),v*x+k*Math.cos(w))),u+=S?b+_*Ho:b,S^h>=e^y>=e){var N=mt(dt(s),dt(n));bt(N);var E=mt(i,N);bt(E);var A=(S^b>=0?-1:1)*tn(E[2]);(r>A||r===A&&(N[0]||N[1]))&&(o+=S^b>=0?1:-1)}if(!d++)break;h=y,g=M,v=x,s=n}}return(-Uo>u||Uo>u&&-Uo>ka)^1&o}function It(n){function t(n,t){return Math.cos(n)*Math.cos(t)>u}function e(n){var e,u,l,c,f;return{lineStart:function(){c=l=!1,f=1},point:function(s,h){var p,g=[s,h],v=t(s,h),d=o?v?0:i(s,h):v?i(s+(0>s?Fo:-Fo),h):0;if(!e&&(c=l=v)&&n.lineStart(),v!==l&&(p=r(e,g),(wt(e,p)||wt(g,p))&&(g[0]+=Uo,g[1]+=Uo,v=t(g[0],g[1]))),v!==l)f=0,v?(n.lineStart(),p=r(g,e),n.point(p[0],p[1])):(p=r(e,g),n.point(p[0],p[1]),n.lineEnd()),e=p;else if(a&&e&&o^v){var y;d&u||!(y=r(g,e,!0))||(f=0,o?(n.lineStart(),n.point(y[0][0],y[0][1]),n.point(y[1][0],y[1][1]),n.lineEnd()):(n.point(y[1][0],y[1][1]),n.lineEnd(),n.lineStart(),n.point(y[0][0],y[0][1])))}!v||e&&wt(e,g)||n.point(g[0],g[1]),e=g,l=v,u=d},lineEnd:function(){l&&n.lineEnd(),e=null},clean:function(){return f|(c&&l)<<1}}}function r(n,t,e){var r=dt(n),i=dt(t),o=[1,0,0],a=mt(r,i),l=yt(a,a),c=a[0],f=l-c*c;if(!f)return!e&&n;var s=u*l/f,h=-u*c/f,p=mt(o,a),g=xt(o,s),v=xt(a,h);Mt(g,v);var d=p,y=yt(g,d),m=yt(d,d),M=y*y-m*(yt(g,g)-1);if(!(0>M)){var x=Math.sqrt(M),b=xt(d,(-y-x)/m);if(Mt(b,g),b=_t(b),!e)return b;var _,w=n[0],S=t[0],k=n[1],N=t[1];w>S&&(_=w,w=S,S=_);var E=S-w,A=xo(E-Fo)E;if(!A&&k>N&&(_=k,k=N,N=_),C?A?k+N>0^b[1]<(xo(b[0]-w)Fo^(w<=b[0]&&b[0]<=S)){var z=xt(d,(-y+x)/m);return Mt(z,g),[b,_t(z)]}}}function i(t,e){var r=o?n:Fo-n,i=0;return-r>t?i|=1:t>r&&(i|=2),-r>e?i|=4:e>r&&(i|=8),i}var u=Math.cos(n),o=u>0,a=xo(u)>Uo,l=ve(n,6*Yo);return Rt(t,e,l,o?[0,-n]:[-Fo,n-Fo])}function Yt(n,t,e,r){return function(i){var u,o=i.a,a=i.b,l=o.x,c=o.y,f=a.x,s=a.y,h=0,p=1,g=f-l,v=s-c;if(u=n-l,g||!(u>0)){if(u/=g,0>g){if(h>u)return;p>u&&(p=u)}else if(g>0){if(u>p)return;u>h&&(h=u)}if(u=e-l,g||!(0>u)){if(u/=g,0>g){if(u>p)return;u>h&&(h=u)}else if(g>0){if(h>u)return;p>u&&(p=u)}if(u=t-c,v||!(u>0)){if(u/=v,0>v){if(h>u)return;p>u&&(p=u)}else if(v>0){if(u>p)return;u>h&&(h=u)}if(u=r-c,v||!(0>u)){if(u/=v,0>v){if(u>p)return;u>h&&(h=u)}else if(v>0){if(h>u)return;p>u&&(p=u)}return h>0&&(i.a={x:l+h*g,y:c+h*v}),1>p&&(i.b={x:l+p*g,y:c+p*v}),i}}}}}}function Zt(n,t,e,r){function i(r,i){return xo(r[0]-n)0?0:3:xo(r[0]-e)0?2:1:xo(r[1]-t)0?1:0:i>0?3:2}function u(n,t){return o(n.x,t.x)}function o(n,t){var e=i(n,1),r=i(t,1);return e!==r?e-r:0===e?t[1]-n[1]:1===e?n[0]-t[0]:2===e?n[1]-t[1]:t[0]-n[0]}return function(a){function l(n){for(var t=0,e=d.length,r=n[1],i=0;e>i;++i)for(var u,o=1,a=d[i],l=a.length,c=a[0];l>o;++o)u=a[o],c[1]<=r?u[1]>r&&Q(c,u,n)>0&&++t:u[1]<=r&&Q(c,u,n)<0&&--t,c=u;return 0!==t}function c(u,a,l,c){var f=0,s=0;if(null==u||(f=i(u,l))!==(s=i(a,l))||o(u,a)<0^l>0){do c.point(0===f||3===f?n:e,f>1?r:t);while((f=(f+l+4)%4)!==s)}else c.point(a[0],a[1])}function f(i,u){return i>=n&&e>=i&&u>=t&&r>=u}function s(n,t){f(n,t)&&a.point(n,t)}function h(){C.point=g,d&&d.push(y=[]),S=!0,w=!1,b=_=NaN}function p(){v&&(g(m,M),x&&w&&E.rejoin(),v.push(E.buffer())),C.point=s,w&&a.lineEnd()}function g(n,t){n=Math.max(-Ha,Math.min(Ha,n)),t=Math.max(-Ha,Math.min(Ha,t));var e=f(n,t);if(d&&y.push([n,t]),S)m=n,M=t,x=e,S=!1,e&&(a.lineStart(),a.point(n,t));else if(e&&w)a.point(n,t);else{var r={a:{x:b,y:_},b:{x:n,y:t}};A(r)?(w||(a.lineStart(),a.point(r.a.x,r.a.y)),a.point(r.b.x,r.b.y),e||a.lineEnd(),k=!1):e&&(a.lineStart(),a.point(n,t),k=!1)}b=n,_=t,w=e}var v,d,y,m,M,x,b,_,w,S,k,N=a,E=Pt(),A=Yt(n,t,e,r),C={point:s,lineStart:h,lineEnd:p,polygonStart:function(){a=E,v=[],d=[],k=!0},polygonEnd:function(){a=N,v=ao.merge(v);var t=l([n,r]),e=k&&t,i=v.length;(e||i)&&(a.polygonStart(),e&&(a.lineStart(),c(null,null,1,a),a.lineEnd()),i&&Lt(v,u,t,c,a),a.polygonEnd()),v=d=y=null}};return C}}function Vt(n){var t=0,e=Fo/3,r=ae(n),i=r(t,e);return i.parallels=function(n){return arguments.length?r(t=n[0]*Fo/180,e=n[1]*Fo/180):[t/Fo*180,e/Fo*180]},i}function Xt(n,t){function e(n,t){var e=Math.sqrt(u-2*i*Math.sin(t))/i;return[e*Math.sin(n*=i),o-e*Math.cos(n)]}var r=Math.sin(n),i=(r+Math.sin(t))/2,u=1+r*(2*i-r),o=Math.sqrt(u)/i;return e.invert=function(n,t){var e=o-t;return[Math.atan2(n,e)/i,tn((u-(n*n+e*e)*i*i)/(2*i))]},e}function $t(){function n(n,t){Ia+=i*n-r*t,r=n,i=t}var t,e,r,i;$a.point=function(u,o){$a.point=n,t=r=u,e=i=o},$a.lineEnd=function(){n(t,e)}}function Bt(n,t){Ya>n&&(Ya=n),n>Va&&(Va=n),Za>t&&(Za=t),t>Xa&&(Xa=t)}function Wt(){function n(n,t){o.push("M",n,",",t,u)}function t(n,t){o.push("M",n,",",t),a.point=e}function e(n,t){o.push("L",n,",",t)}function r(){a.point=n}function i(){o.push("Z")}var u=Jt(4.5),o=[],a={point:n,lineStart:function(){a.point=t},lineEnd:r,polygonStart:function(){a.lineEnd=i},polygonEnd:function(){a.lineEnd=r,a.point=n},pointRadius:function(n){return u=Jt(n),a},result:function(){if(o.length){var n=o.join("");return o=[],n}}};return a}function Jt(n){return"m0,"+n+"a"+n+","+n+" 0 1,1 0,"+-2*n+"a"+n+","+n+" 0 1,1 0,"+2*n+"z"}function Gt(n,t){Ca+=n,za+=t,++La}function Kt(){function n(n,r){var i=n-t,u=r-e,o=Math.sqrt(i*i+u*u);qa+=o*(t+n)/2,Ta+=o*(e+r)/2,Ra+=o,Gt(t=n,e=r)}var t,e;Wa.point=function(r,i){Wa.point=n,Gt(t=r,e=i)}}function Qt(){Wa.point=Gt}function ne(){function n(n,t){var e=n-r,u=t-i,o=Math.sqrt(e*e+u*u);qa+=o*(r+n)/2,Ta+=o*(i+t)/2,Ra+=o,o=i*n-r*t,Da+=o*(r+n),Pa+=o*(i+t),Ua+=3*o,Gt(r=n,i=t)}var t,e,r,i;Wa.point=function(u,o){Wa.point=n,Gt(t=r=u,e=i=o)},Wa.lineEnd=function(){n(t,e)}}function te(n){function t(t,e){n.moveTo(t+o,e),n.arc(t,e,o,0,Ho)}function e(t,e){n.moveTo(t,e),a.point=r}function r(t,e){n.lineTo(t,e)}function i(){a.point=t}function u(){n.closePath()}var o=4.5,a={point:t,lineStart:function(){a.point=e},lineEnd:i,polygonStart:function(){a.lineEnd=u},polygonEnd:function(){a.lineEnd=i,a.point=t},pointRadius:function(n){return o=n,a},result:b};return a}function ee(n){function t(n){return(a?r:e)(n)}function e(t){return ue(t,function(e,r){e=n(e,r),t.point(e[0],e[1])})}function r(t){function e(e,r){e=n(e,r),t.point(e[0],e[1])}function r(){M=NaN,S.point=u,t.lineStart()}function u(e,r){var u=dt([e,r]),o=n(e,r);i(M,x,m,b,_,w,M=o[0],x=o[1],m=e,b=u[0],_=u[1],w=u[2],a,t),t.point(M,x)}function o(){S.point=e,t.lineEnd()}function l(){ ++r(),S.point=c,S.lineEnd=f}function c(n,t){u(s=n,h=t),p=M,g=x,v=b,d=_,y=w,S.point=u}function f(){i(M,x,m,b,_,w,p,g,s,v,d,y,a,t),S.lineEnd=o,o()}var s,h,p,g,v,d,y,m,M,x,b,_,w,S={point:e,lineStart:r,lineEnd:o,polygonStart:function(){t.polygonStart(),S.lineStart=l},polygonEnd:function(){t.polygonEnd(),S.lineStart=r}};return S}function i(t,e,r,a,l,c,f,s,h,p,g,v,d,y){var m=f-t,M=s-e,x=m*m+M*M;if(x>4*u&&d--){var b=a+p,_=l+g,w=c+v,S=Math.sqrt(b*b+_*_+w*w),k=Math.asin(w/=S),N=xo(xo(w)-1)u||xo((m*z+M*L)/x-.5)>.3||o>a*p+l*g+c*v)&&(i(t,e,r,a,l,c,A,C,N,b/=S,_/=S,w,d,y),y.point(A,C),i(A,C,N,b,_,w,f,s,h,p,g,v,d,y))}}var u=.5,o=Math.cos(30*Yo),a=16;return t.precision=function(n){return arguments.length?(a=(u=n*n)>0&&16,t):Math.sqrt(u)},t}function re(n){var t=ee(function(t,e){return n([t*Zo,e*Zo])});return function(n){return le(t(n))}}function ie(n){this.stream=n}function ue(n,t){return{point:t,sphere:function(){n.sphere()},lineStart:function(){n.lineStart()},lineEnd:function(){n.lineEnd()},polygonStart:function(){n.polygonStart()},polygonEnd:function(){n.polygonEnd()}}}function oe(n){return ae(function(){return n})()}function ae(n){function t(n){return n=a(n[0]*Yo,n[1]*Yo),[n[0]*h+l,c-n[1]*h]}function e(n){return n=a.invert((n[0]-l)/h,(c-n[1])/h),n&&[n[0]*Zo,n[1]*Zo]}function r(){a=Ct(o=se(y,M,x),u);var n=u(v,d);return l=p-n[0]*h,c=g+n[1]*h,i()}function i(){return f&&(f.valid=!1,f=null),t}var u,o,a,l,c,f,s=ee(function(n,t){return n=u(n,t),[n[0]*h+l,c-n[1]*h]}),h=150,p=480,g=250,v=0,d=0,y=0,M=0,x=0,b=Fa,_=m,w=null,S=null;return t.stream=function(n){return f&&(f.valid=!1),f=le(b(o,s(_(n)))),f.valid=!0,f},t.clipAngle=function(n){return arguments.length?(b=null==n?(w=n,Fa):It((w=+n)*Yo),i()):w},t.clipExtent=function(n){return arguments.length?(S=n,_=n?Zt(n[0][0],n[0][1],n[1][0],n[1][1]):m,i()):S},t.scale=function(n){return arguments.length?(h=+n,r()):h},t.translate=function(n){return arguments.length?(p=+n[0],g=+n[1],r()):[p,g]},t.center=function(n){return arguments.length?(v=n[0]%360*Yo,d=n[1]%360*Yo,r()):[v*Zo,d*Zo]},t.rotate=function(n){return arguments.length?(y=n[0]%360*Yo,M=n[1]%360*Yo,x=n.length>2?n[2]%360*Yo:0,r()):[y*Zo,M*Zo,x*Zo]},ao.rebind(t,s,"precision"),function(){return u=n.apply(this,arguments),t.invert=u.invert&&e,r()}}function le(n){return ue(n,function(t,e){n.point(t*Yo,e*Yo)})}function ce(n,t){return[n,t]}function fe(n,t){return[n>Fo?n-Ho:-Fo>n?n+Ho:n,t]}function se(n,t,e){return n?t||e?Ct(pe(n),ge(t,e)):pe(n):t||e?ge(t,e):fe}function he(n){return function(t,e){return t+=n,[t>Fo?t-Ho:-Fo>t?t+Ho:t,e]}}function pe(n){var t=he(n);return t.invert=he(-n),t}function ge(n,t){function e(n,t){var e=Math.cos(t),a=Math.cos(n)*e,l=Math.sin(n)*e,c=Math.sin(t),f=c*r+a*i;return[Math.atan2(l*u-f*o,a*r-c*i),tn(f*u+l*o)]}var r=Math.cos(n),i=Math.sin(n),u=Math.cos(t),o=Math.sin(t);return e.invert=function(n,t){var e=Math.cos(t),a=Math.cos(n)*e,l=Math.sin(n)*e,c=Math.sin(t),f=c*u-l*o;return[Math.atan2(l*u+c*o,a*r+f*i),tn(f*r-a*i)]},e}function ve(n,t){var e=Math.cos(n),r=Math.sin(n);return function(i,u,o,a){var l=o*t;null!=i?(i=de(e,i),u=de(e,u),(o>0?u>i:i>u)&&(i+=o*Ho)):(i=n+o*Ho,u=n-.5*l);for(var c,f=i;o>0?f>u:u>f;f-=l)a.point((c=_t([e,-r*Math.cos(f),-r*Math.sin(f)]))[0],c[1])}}function de(n,t){var e=dt(t);e[0]-=n,bt(e);var r=nn(-e[1]);return((-e[2]<0?-r:r)+2*Math.PI-Uo)%(2*Math.PI)}function ye(n,t,e){var r=ao.range(n,t-Uo,e).concat(t);return function(n){return r.map(function(t){return[n,t]})}}function me(n,t,e){var r=ao.range(n,t-Uo,e).concat(t);return function(n){return r.map(function(t){return[t,n]})}}function Me(n){return n.source}function xe(n){return n.target}function be(n,t,e,r){var i=Math.cos(t),u=Math.sin(t),o=Math.cos(r),a=Math.sin(r),l=i*Math.cos(n),c=i*Math.sin(n),f=o*Math.cos(e),s=o*Math.sin(e),h=2*Math.asin(Math.sqrt(on(r-t)+i*o*on(e-n))),p=1/Math.sin(h),g=h?function(n){var t=Math.sin(n*=h)*p,e=Math.sin(h-n)*p,r=e*l+t*f,i=e*c+t*s,o=e*u+t*a;return[Math.atan2(i,r)*Zo,Math.atan2(o,Math.sqrt(r*r+i*i))*Zo]}:function(){return[n*Zo,t*Zo]};return g.distance=h,g}function _e(){function n(n,i){var u=Math.sin(i*=Yo),o=Math.cos(i),a=xo((n*=Yo)-t),l=Math.cos(a);Ja+=Math.atan2(Math.sqrt((a=o*Math.sin(a))*a+(a=r*u-e*o*l)*a),e*u+r*o*l),t=n,e=u,r=o}var t,e,r;Ga.point=function(i,u){t=i*Yo,e=Math.sin(u*=Yo),r=Math.cos(u),Ga.point=n},Ga.lineEnd=function(){Ga.point=Ga.lineEnd=b}}function we(n,t){function e(t,e){var r=Math.cos(t),i=Math.cos(e),u=n(r*i);return[u*i*Math.sin(t),u*Math.sin(e)]}return e.invert=function(n,e){var r=Math.sqrt(n*n+e*e),i=t(r),u=Math.sin(i),o=Math.cos(i);return[Math.atan2(n*u,r*o),Math.asin(r&&e*u/r)]},e}function Se(n,t){function e(n,t){o>0?-Io+Uo>t&&(t=-Io+Uo):t>Io-Uo&&(t=Io-Uo);var e=o/Math.pow(i(t),u);return[e*Math.sin(u*n),o-e*Math.cos(u*n)]}var r=Math.cos(n),i=function(n){return Math.tan(Fo/4+n/2)},u=n===t?Math.sin(n):Math.log(r/Math.cos(t))/Math.log(i(t)/i(n)),o=r*Math.pow(i(n),u)/u;return u?(e.invert=function(n,t){var e=o-t,r=K(u)*Math.sqrt(n*n+e*e);return[Math.atan2(n,e)/u,2*Math.atan(Math.pow(o/r,1/u))-Io]},e):Ne}function ke(n,t){function e(n,t){var e=u-t;return[e*Math.sin(i*n),u-e*Math.cos(i*n)]}var r=Math.cos(n),i=n===t?Math.sin(n):(r-Math.cos(t))/(t-n),u=r/i+n;return xo(i)i;i++){for(;r>1&&Q(n[e[r-2]],n[e[r-1]],n[i])<=0;)--r;e[r++]=i}return e.slice(0,r)}function qe(n,t){return n[0]-t[0]||n[1]-t[1]}function Te(n,t,e){return(e[0]-t[0])*(n[1]-t[1])<(e[1]-t[1])*(n[0]-t[0])}function Re(n,t,e,r){var i=n[0],u=e[0],o=t[0]-i,a=r[0]-u,l=n[1],c=e[1],f=t[1]-l,s=r[1]-c,h=(a*(l-c)-s*(i-u))/(s*o-a*f);return[i+h*o,l+h*f]}function De(n){var t=n[0],e=n[n.length-1];return!(t[0]-e[0]||t[1]-e[1])}function Pe(){rr(this),this.edge=this.site=this.circle=null}function Ue(n){var t=cl.pop()||new Pe;return t.site=n,t}function je(n){Be(n),ol.remove(n),cl.push(n),rr(n)}function Fe(n){var t=n.circle,e=t.x,r=t.cy,i={x:e,y:r},u=n.P,o=n.N,a=[n];je(n);for(var l=u;l.circle&&xo(e-l.circle.x)f;++f)c=a[f],l=a[f-1],nr(c.edge,l.site,c.site,i);l=a[0],c=a[s-1],c.edge=Ke(l.site,c.site,null,i),$e(l),$e(c)}function He(n){for(var t,e,r,i,u=n.x,o=n.y,a=ol._;a;)if(r=Oe(a,o)-u,r>Uo)a=a.L;else{if(i=u-Ie(a,o),!(i>Uo)){r>-Uo?(t=a.P,e=a):i>-Uo?(t=a,e=a.N):t=e=a;break}if(!a.R){t=a;break}a=a.R}var l=Ue(n);if(ol.insert(t,l),t||e){if(t===e)return Be(t),e=Ue(t.site),ol.insert(l,e),l.edge=e.edge=Ke(t.site,l.site),$e(t),void $e(e);if(!e)return void(l.edge=Ke(t.site,l.site));Be(t),Be(e);var c=t.site,f=c.x,s=c.y,h=n.x-f,p=n.y-s,g=e.site,v=g.x-f,d=g.y-s,y=2*(h*d-p*v),m=h*h+p*p,M=v*v+d*d,x={x:(d*m-p*M)/y+f,y:(h*M-v*m)/y+s};nr(e.edge,c,g,x),l.edge=Ke(c,n,null,x),e.edge=Ke(n,g,null,x),$e(t),$e(e)}}function Oe(n,t){var e=n.site,r=e.x,i=e.y,u=i-t;if(!u)return r;var o=n.P;if(!o)return-(1/0);e=o.site;var a=e.x,l=e.y,c=l-t;if(!c)return a;var f=a-r,s=1/u-1/c,h=f/c;return s?(-h+Math.sqrt(h*h-2*s*(f*f/(-2*c)-l+c/2+i-u/2)))/s+r:(r+a)/2}function Ie(n,t){var e=n.N;if(e)return Oe(e,t);var r=n.site;return r.y===t?r.x:1/0}function Ye(n){this.site=n,this.edges=[]}function Ze(n){for(var t,e,r,i,u,o,a,l,c,f,s=n[0][0],h=n[1][0],p=n[0][1],g=n[1][1],v=ul,d=v.length;d--;)if(u=v[d],u&&u.prepare())for(a=u.edges,l=a.length,o=0;l>o;)f=a[o].end(),r=f.x,i=f.y,c=a[++o%l].start(),t=c.x,e=c.y,(xo(r-t)>Uo||xo(i-e)>Uo)&&(a.splice(o,0,new tr(Qe(u.site,f,xo(r-s)Uo?{x:s,y:xo(t-s)Uo?{x:xo(e-g)Uo?{x:h,y:xo(t-h)Uo?{x:xo(e-p)=-jo)){var p=l*l+c*c,g=f*f+s*s,v=(s*p-c*g)/h,d=(l*g-f*p)/h,s=d+a,y=fl.pop()||new Xe;y.arc=n,y.site=i,y.x=v+o,y.y=s+Math.sqrt(v*v+d*d),y.cy=s,n.circle=y;for(var m=null,M=ll._;M;)if(y.yd||d>=a)return;if(h>g){if(u){if(u.y>=c)return}else u={x:d,y:l};e={x:d,y:c}}else{if(u){if(u.yr||r>1)if(h>g){if(u){if(u.y>=c)return}else u={x:(l-i)/r,y:l};e={x:(c-i)/r,y:c}}else{if(u){if(u.yp){if(u){if(u.x>=a)return}else u={x:o,y:r*o+i};e={x:a,y:r*a+i}}else{if(u){if(u.xu||s>o||r>h||i>p)){if(g=n.point){var g,v=t-n.x,d=e-n.y,y=v*v+d*d;if(l>y){var m=Math.sqrt(l=y);r=t-m,i=e-m,u=t+m,o=e+m,a=g}}for(var M=n.nodes,x=.5*(f+h),b=.5*(s+p),_=t>=x,w=e>=b,S=w<<1|_,k=S+4;k>S;++S)if(n=M[3&S])switch(3&S){case 0:c(n,f,s,x,b);break;case 1:c(n,x,s,h,b);break;case 2:c(n,f,b,x,p);break;case 3:c(n,x,b,h,p)}}}(n,r,i,u,o),a}function vr(n,t){n=ao.rgb(n),t=ao.rgb(t);var e=n.r,r=n.g,i=n.b,u=t.r-e,o=t.g-r,a=t.b-i;return function(n){return"#"+bn(Math.round(e+u*n))+bn(Math.round(r+o*n))+bn(Math.round(i+a*n))}}function dr(n,t){var e,r={},i={};for(e in n)e in t?r[e]=Mr(n[e],t[e]):i[e]=n[e];for(e in t)e in n||(i[e]=t[e]);return function(n){for(e in r)i[e]=r[e](n);return i}}function yr(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function mr(n,t){var e,r,i,u=hl.lastIndex=pl.lastIndex=0,o=-1,a=[],l=[];for(n+="",t+="";(e=hl.exec(n))&&(r=pl.exec(t));)(i=r.index)>u&&(i=t.slice(u,i),a[o]?a[o]+=i:a[++o]=i),(e=e[0])===(r=r[0])?a[o]?a[o]+=r:a[++o]=r:(a[++o]=null,l.push({i:o,x:yr(e,r)})),u=pl.lastIndex;return ur;++r)a[(e=l[r]).i]=e.x(n);return a.join("")})}function Mr(n,t){for(var e,r=ao.interpolators.length;--r>=0&&!(e=ao.interpolators[r](n,t)););return e}function xr(n,t){var e,r=[],i=[],u=n.length,o=t.length,a=Math.min(n.length,t.length);for(e=0;a>e;++e)r.push(Mr(n[e],t[e]));for(;u>e;++e)i[e]=n[e];for(;o>e;++e)i[e]=t[e];return function(n){for(e=0;a>e;++e)i[e]=r[e](n);return i}}function br(n){return function(t){return 0>=t?0:t>=1?1:n(t)}}function _r(n){return function(t){return 1-n(1-t)}}function wr(n){return function(t){return.5*(.5>t?n(2*t):2-n(2-2*t))}}function Sr(n){return n*n}function kr(n){return n*n*n}function Nr(n){if(0>=n)return 0;if(n>=1)return 1;var t=n*n,e=t*n;return 4*(.5>n?e:3*(n-t)+e-.75)}function Er(n){return function(t){return Math.pow(t,n)}}function Ar(n){return 1-Math.cos(n*Io)}function Cr(n){return Math.pow(2,10*(n-1))}function zr(n){return 1-Math.sqrt(1-n*n)}function Lr(n,t){var e;return arguments.length<2&&(t=.45),arguments.length?e=t/Ho*Math.asin(1/n):(n=1,e=t/4),function(r){return 1+n*Math.pow(2,-10*r)*Math.sin((r-e)*Ho/t)}}function qr(n){return n||(n=1.70158),function(t){return t*t*((n+1)*t-n)}}function Tr(n){return 1/2.75>n?7.5625*n*n:2/2.75>n?7.5625*(n-=1.5/2.75)*n+.75:2.5/2.75>n?7.5625*(n-=2.25/2.75)*n+.9375:7.5625*(n-=2.625/2.75)*n+.984375}function Rr(n,t){n=ao.hcl(n),t=ao.hcl(t);var e=n.h,r=n.c,i=n.l,u=t.h-e,o=t.c-r,a=t.l-i;return isNaN(o)&&(o=0,r=isNaN(r)?t.c:r),isNaN(u)?(u=0,e=isNaN(e)?t.h:e):u>180?u-=360:-180>u&&(u+=360),function(n){return sn(e+u*n,r+o*n,i+a*n)+""}}function Dr(n,t){n=ao.hsl(n),t=ao.hsl(t);var e=n.h,r=n.s,i=n.l,u=t.h-e,o=t.s-r,a=t.l-i;return isNaN(o)&&(o=0,r=isNaN(r)?t.s:r),isNaN(u)?(u=0,e=isNaN(e)?t.h:e):u>180?u-=360:-180>u&&(u+=360),function(n){return cn(e+u*n,r+o*n,i+a*n)+""}}function Pr(n,t){n=ao.lab(n),t=ao.lab(t);var e=n.l,r=n.a,i=n.b,u=t.l-e,o=t.a-r,a=t.b-i;return function(n){return pn(e+u*n,r+o*n,i+a*n)+""}}function Ur(n,t){return t-=n,function(e){return Math.round(n+t*e)}}function jr(n){var t=[n.a,n.b],e=[n.c,n.d],r=Hr(t),i=Fr(t,e),u=Hr(Or(e,t,-i))||0;t[0]*e[1]180?t+=360:t-n>180&&(n+=360),r.push({i:e.push(Ir(e)+"rotate(",null,")")-2,x:yr(n,t)})):t&&e.push(Ir(e)+"rotate("+t+")")}function Vr(n,t,e,r){n!==t?r.push({i:e.push(Ir(e)+"skewX(",null,")")-2,x:yr(n,t)}):t&&e.push(Ir(e)+"skewX("+t+")")}function Xr(n,t,e,r){if(n[0]!==t[0]||n[1]!==t[1]){var i=e.push(Ir(e)+"scale(",null,",",null,")");r.push({i:i-4,x:yr(n[0],t[0])},{i:i-2,x:yr(n[1],t[1])})}else 1===t[0]&&1===t[1]||e.push(Ir(e)+"scale("+t+")")}function $r(n,t){var e=[],r=[];return n=ao.transform(n),t=ao.transform(t),Yr(n.translate,t.translate,e,r),Zr(n.rotate,t.rotate,e,r),Vr(n.skew,t.skew,e,r),Xr(n.scale,t.scale,e,r),n=t=null,function(n){for(var t,i=-1,u=r.length;++i=0;)e.push(i[r])}function oi(n,t){for(var e=[n],r=[];null!=(n=e.pop());)if(r.push(n),(u=n.children)&&(i=u.length))for(var i,u,o=-1;++oe;++e)(t=n[e][1])>i&&(r=e,i=t);return r}function yi(n){return n.reduce(mi,0)}function mi(n,t){return n+t[1]}function Mi(n,t){return xi(n,Math.ceil(Math.log(t.length)/Math.LN2+1))}function xi(n,t){for(var e=-1,r=+n[0],i=(n[1]-r)/t,u=[];++e<=t;)u[e]=i*e+r;return u}function bi(n){return[ao.min(n),ao.max(n)]}function _i(n,t){return n.value-t.value}function wi(n,t){var e=n._pack_next;n._pack_next=t,t._pack_prev=n,t._pack_next=e,e._pack_prev=t}function Si(n,t){n._pack_next=t,t._pack_prev=n}function ki(n,t){var e=t.x-n.x,r=t.y-n.y,i=n.r+t.r;return.999*i*i>e*e+r*r}function Ni(n){function t(n){f=Math.min(n.x-n.r,f),s=Math.max(n.x+n.r,s),h=Math.min(n.y-n.r,h),p=Math.max(n.y+n.r,p)}if((e=n.children)&&(c=e.length)){var e,r,i,u,o,a,l,c,f=1/0,s=-(1/0),h=1/0,p=-(1/0);if(e.forEach(Ei),r=e[0],r.x=-r.r,r.y=0,t(r),c>1&&(i=e[1],i.x=i.r,i.y=0,t(i),c>2))for(u=e[2],zi(r,i,u),t(u),wi(r,u),r._pack_prev=u,wi(u,i),i=r._pack_next,o=3;c>o;o++){zi(r,i,u=e[o]);var g=0,v=1,d=1;for(a=i._pack_next;a!==i;a=a._pack_next,v++)if(ki(a,u)){g=1;break}if(1==g)for(l=r._pack_prev;l!==a._pack_prev&&!ki(l,u);l=l._pack_prev,d++);g?(d>v||v==d&&i.ro;o++)u=e[o],u.x-=y,u.y-=m,M=Math.max(M,u.r+Math.sqrt(u.x*u.x+u.y*u.y));n.r=M,e.forEach(Ai)}}function Ei(n){n._pack_next=n._pack_prev=n}function Ai(n){delete n._pack_next,delete n._pack_prev}function Ci(n,t,e,r){var i=n.children;if(n.x=t+=r*n.x,n.y=e+=r*n.y,n.r*=r,i)for(var u=-1,o=i.length;++u=0;)t=i[u],t.z+=e,t.m+=e,e+=t.s+(r+=t.c)}function Pi(n,t,e){return n.a.parent===t.parent?n.a:e}function Ui(n){return 1+ao.max(n,function(n){return n.y})}function ji(n){return n.reduce(function(n,t){return n+t.x},0)/n.length}function Fi(n){var t=n.children;return t&&t.length?Fi(t[0]):n}function Hi(n){var t,e=n.children;return e&&(t=e.length)?Hi(e[t-1]):n}function Oi(n){return{x:n.x,y:n.y,dx:n.dx,dy:n.dy}}function Ii(n,t){var e=n.x+t[3],r=n.y+t[0],i=n.dx-t[1]-t[3],u=n.dy-t[0]-t[2];return 0>i&&(e+=i/2,i=0),0>u&&(r+=u/2,u=0),{x:e,y:r,dx:i,dy:u}}function Yi(n){var t=n[0],e=n[n.length-1];return e>t?[t,e]:[e,t]}function Zi(n){return n.rangeExtent?n.rangeExtent():Yi(n.range())}function Vi(n,t,e,r){var i=e(n[0],n[1]),u=r(t[0],t[1]);return function(n){return u(i(n))}}function Xi(n,t){var e,r=0,i=n.length-1,u=n[r],o=n[i];return u>o&&(e=r,r=i,i=e,e=u,u=o,o=e),n[r]=t.floor(u),n[i]=t.ceil(o),n}function $i(n){return n?{floor:function(t){return Math.floor(t/n)*n},ceil:function(t){return Math.ceil(t/n)*n}}:Sl}function Bi(n,t,e,r){var i=[],u=[],o=0,a=Math.min(n.length,t.length)-1;for(n[a]2?Bi:Vi,l=r?Wr:Br;return o=i(n,t,l,e),a=i(t,n,l,Mr),u}function u(n){return o(n)}var o,a;return u.invert=function(n){return a(n)},u.domain=function(t){return arguments.length?(n=t.map(Number),i()):n},u.range=function(n){return arguments.length?(t=n,i()):t},u.rangeRound=function(n){return u.range(n).interpolate(Ur)},u.clamp=function(n){return arguments.length?(r=n,i()):r},u.interpolate=function(n){return arguments.length?(e=n,i()):e},u.ticks=function(t){return Qi(n,t)},u.tickFormat=function(t,e){return nu(n,t,e)},u.nice=function(t){return Gi(n,t),i()},u.copy=function(){return Wi(n,t,e,r)},i()}function Ji(n,t){return ao.rebind(n,t,"range","rangeRound","interpolate","clamp")}function Gi(n,t){return Xi(n,$i(Ki(n,t)[2])),Xi(n,$i(Ki(n,t)[2])),n}function Ki(n,t){null==t&&(t=10);var e=Yi(n),r=e[1]-e[0],i=Math.pow(10,Math.floor(Math.log(r/t)/Math.LN10)),u=t/r*i;return.15>=u?i*=10:.35>=u?i*=5:.75>=u&&(i*=2),e[0]=Math.ceil(e[0]/i)*i,e[1]=Math.floor(e[1]/i)*i+.5*i,e[2]=i,e}function Qi(n,t){return ao.range.apply(ao,Ki(n,t))}function nu(n,t,e){var r=Ki(n,t);if(e){var i=ha.exec(e);if(i.shift(),"s"===i[8]){var u=ao.formatPrefix(Math.max(xo(r[0]),xo(r[1])));return i[7]||(i[7]="."+tu(u.scale(r[2]))),i[8]="f",e=ao.format(i.join("")),function(n){return e(u.scale(n))+u.symbol}}i[7]||(i[7]="."+eu(i[8],r)),e=i.join("")}else e=",."+tu(r[2])+"f";return ao.format(e)}function tu(n){return-Math.floor(Math.log(n)/Math.LN10+.01)}function eu(n,t){var e=tu(t[2]);return n in kl?Math.abs(e-tu(Math.max(xo(t[0]),xo(t[1]))))+ +("e"!==n):e-2*("%"===n)}function ru(n,t,e,r){function i(n){return(e?Math.log(0>n?0:n):-Math.log(n>0?0:-n))/Math.log(t)}function u(n){return e?Math.pow(t,n):-Math.pow(t,-n)}function o(t){return n(i(t))}return o.invert=function(t){return u(n.invert(t))},o.domain=function(t){return arguments.length?(e=t[0]>=0,n.domain((r=t.map(Number)).map(i)),o):r},o.base=function(e){return arguments.length?(t=+e,n.domain(r.map(i)),o):t},o.nice=function(){var t=Xi(r.map(i),e?Math:El);return n.domain(t),r=t.map(u),o},o.ticks=function(){var n=Yi(r),o=[],a=n[0],l=n[1],c=Math.floor(i(a)),f=Math.ceil(i(l)),s=t%1?2:t;if(isFinite(f-c)){if(e){for(;f>c;c++)for(var h=1;s>h;h++)o.push(u(c)*h);o.push(u(c))}else for(o.push(u(c));c++0;h--)o.push(u(c)*h);for(c=0;o[c]l;f--);o=o.slice(c,f)}return o},o.tickFormat=function(n,e){if(!arguments.length)return Nl;arguments.length<2?e=Nl:"function"!=typeof e&&(e=ao.format(e));var r=Math.max(1,t*n/o.ticks().length);return function(n){var o=n/u(Math.round(i(n)));return t-.5>o*t&&(o*=t),r>=o?e(n):""}},o.copy=function(){return ru(n.copy(),t,e,r)},Ji(o,n)}function iu(n,t,e){function r(t){return n(i(t))}var i=uu(t),u=uu(1/t);return r.invert=function(t){return u(n.invert(t))},r.domain=function(t){return arguments.length?(n.domain((e=t.map(Number)).map(i)),r):e},r.ticks=function(n){return Qi(e,n)},r.tickFormat=function(n,t){return nu(e,n,t)},r.nice=function(n){return r.domain(Gi(e,n))},r.exponent=function(o){return arguments.length?(i=uu(t=o),u=uu(1/t),n.domain(e.map(i)),r):t},r.copy=function(){return iu(n.copy(),t,e)},Ji(r,n)}function uu(n){return function(t){return 0>t?-Math.pow(-t,n):Math.pow(t,n)}}function ou(n,t){function e(e){return u[((i.get(e)||("range"===t.t?i.set(e,n.push(e)):NaN))-1)%u.length]}function r(t,e){return ao.range(n.length).map(function(n){return t+e*n})}var i,u,o;return e.domain=function(r){if(!arguments.length)return n;n=[],i=new c;for(var u,o=-1,a=r.length;++oe?[NaN,NaN]:[e>0?a[e-1]:n[0],et?NaN:t/u+n,[t,t+1/u]},r.copy=function(){return lu(n,t,e)},i()}function cu(n,t){function e(e){return e>=e?t[ao.bisect(n,e)]:void 0}return e.domain=function(t){return arguments.length?(n=t,e):n},e.range=function(n){return arguments.length?(t=n,e):t},e.invertExtent=function(e){return e=t.indexOf(e),[n[e-1],n[e]]},e.copy=function(){return cu(n,t)},e}function fu(n){function t(n){return+n}return t.invert=t,t.domain=t.range=function(e){return arguments.length?(n=e.map(t),t):n},t.ticks=function(t){return Qi(n,t)},t.tickFormat=function(t,e){return nu(n,t,e)},t.copy=function(){return fu(n)},t}function su(){return 0}function hu(n){return n.innerRadius}function pu(n){return n.outerRadius}function gu(n){return n.startAngle}function vu(n){return n.endAngle}function du(n){return n&&n.padAngle}function yu(n,t,e,r){return(n-e)*t-(t-r)*n>0?0:1}function mu(n,t,e,r,i){var u=n[0]-t[0],o=n[1]-t[1],a=(i?r:-r)/Math.sqrt(u*u+o*o),l=a*o,c=-a*u,f=n[0]+l,s=n[1]+c,h=t[0]+l,p=t[1]+c,g=(f+h)/2,v=(s+p)/2,d=h-f,y=p-s,m=d*d+y*y,M=e-r,x=f*p-h*s,b=(0>y?-1:1)*Math.sqrt(Math.max(0,M*M*m-x*x)),_=(x*y-d*b)/m,w=(-x*d-y*b)/m,S=(x*y+d*b)/m,k=(-x*d+y*b)/m,N=_-g,E=w-v,A=S-g,C=k-v;return N*N+E*E>A*A+C*C&&(_=S,w=k),[[_-l,w-c],[_*e/M,w*e/M]]}function Mu(n){function t(t){function o(){c.push("M",u(n(f),a))}for(var l,c=[],f=[],s=-1,h=t.length,p=En(e),g=En(r);++s1?n.join("L"):n+"Z"}function bu(n){return n.join("L")+"Z"}function _u(n){for(var t=0,e=n.length,r=n[0],i=[r[0],",",r[1]];++t1&&i.push("H",r[0]),i.join("")}function wu(n){for(var t=0,e=n.length,r=n[0],i=[r[0],",",r[1]];++t1){a=t[1],u=n[l],l++,r+="C"+(i[0]+o[0])+","+(i[1]+o[1])+","+(u[0]-a[0])+","+(u[1]-a[1])+","+u[0]+","+u[1];for(var c=2;c9&&(i=3*t/Math.sqrt(i),o[a]=i*e,o[a+1]=i*r));for(a=-1;++a<=l;)i=(n[Math.min(l,a+1)][0]-n[Math.max(0,a-1)][0])/(6*(1+o[a]*o[a])),u.push([i||0,o[a]*i||0]);return u}function Fu(n){return n.length<3?xu(n):n[0]+Au(n,ju(n))}function Hu(n){for(var t,e,r,i=-1,u=n.length;++i=t?o(n-t):void(f.c=o)}function o(e){var i=g.active,u=g[i];u&&(u.timer.c=null,u.timer.t=NaN,--g.count,delete g[i],u.event&&u.event.interrupt.call(n,n.__data__,u.index));for(var o in g)if(r>+o){var c=g[o];c.timer.c=null,c.timer.t=NaN,--g.count,delete g[o]}f.c=a,qn(function(){return f.c&&a(e||1)&&(f.c=null,f.t=NaN),1},0,l),g.active=r,v.event&&v.event.start.call(n,n.__data__,t),p=[],v.tween.forEach(function(e,r){(r=r.call(n,n.__data__,t))&&p.push(r)}),h=v.ease,s=v.duration}function a(i){for(var u=i/s,o=h(u),a=p.length;a>0;)p[--a].call(n,o);return u>=1?(v.event&&v.event.end.call(n,n.__data__,t),--g.count?delete g[r]:delete n[e],1):void 0}var l,f,s,h,p,g=n[e]||(n[e]={active:0,count:0}),v=g[r];v||(l=i.time,f=qn(u,0,l),v=g[r]={tween:new c,time:l,timer:f,delay:i.delay,duration:i.duration,ease:i.ease,index:t},i=null,++g.count)}function no(n,t,e){n.attr("transform",function(n){var r=t(n);return"translate("+(isFinite(r)?r:e(n))+",0)"})}function to(n,t,e){n.attr("transform",function(n){var r=t(n);return"translate(0,"+(isFinite(r)?r:e(n))+")"})}function eo(n){return n.toISOString()}function ro(n,t,e){function r(t){return n(t)}function i(n,e){var r=n[1]-n[0],i=r/e,u=ao.bisect(Kl,i);return u==Kl.length?[t.year,Ki(n.map(function(n){return n/31536e6}),e)[2]]:u?t[i/Kl[u-1]1?{floor:function(t){for(;e(t=n.floor(t));)t=io(t-1);return t},ceil:function(t){for(;e(t=n.ceil(t));)t=io(+t+1);return t}}:n))},r.ticks=function(n,t){var e=Yi(r.domain()),u=null==n?i(e,10):"number"==typeof n?i(e,n):!n.range&&[{range:n},t];return u&&(n=u[0],t=u[1]),n.range(e[0],io(+e[1]+1),1>t?1:t)},r.tickFormat=function(){return e},r.copy=function(){return ro(n.copy(),t,e)},Ji(r,n)}function io(n){return new Date(n)}function uo(n){return JSON.parse(n.responseText)}function oo(n){var t=fo.createRange();return t.selectNode(fo.body),t.createContextualFragment(n.responseText)}var ao={version:"3.5.17"},lo=[].slice,co=function(n){return lo.call(n)},fo=this.document;if(fo)try{co(fo.documentElement.childNodes)[0].nodeType}catch(so){co=function(n){for(var t=n.length,e=new Array(t);t--;)e[t]=n[t];return e}}if(Date.now||(Date.now=function(){return+new Date}),fo)try{fo.createElement("DIV").style.setProperty("opacity",0,"")}catch(ho){var po=this.Element.prototype,go=po.setAttribute,vo=po.setAttributeNS,yo=this.CSSStyleDeclaration.prototype,mo=yo.setProperty;po.setAttribute=function(n,t){go.call(this,n,t+"")},po.setAttributeNS=function(n,t,e){vo.call(this,n,t,e+"")},yo.setProperty=function(n,t,e){mo.call(this,n,t+"",e)}}ao.ascending=e,ao.descending=function(n,t){return n>t?-1:t>n?1:t>=n?0:NaN},ao.min=function(n,t){var e,r,i=-1,u=n.length;if(1===arguments.length){for(;++i=r){e=r;break}for(;++ir&&(e=r)}else{for(;++i=r){e=r;break}for(;++ir&&(e=r)}return e},ao.max=function(n,t){var e,r,i=-1,u=n.length;if(1===arguments.length){for(;++i=r){e=r;break}for(;++ie&&(e=r)}else{for(;++i=r){e=r;break}for(;++ie&&(e=r)}return e},ao.extent=function(n,t){var e,r,i,u=-1,o=n.length;if(1===arguments.length){for(;++u=r){e=i=r;break}for(;++ur&&(e=r),r>i&&(i=r))}else{for(;++u=r){e=i=r;break}for(;++ur&&(e=r),r>i&&(i=r))}return[e,i]},ao.sum=function(n,t){var e,r=0,u=n.length,o=-1;if(1===arguments.length)for(;++o1?l/(f-1):void 0},ao.deviation=function(){var n=ao.variance.apply(this,arguments);return n?Math.sqrt(n):n};var Mo=u(e);ao.bisectLeft=Mo.left,ao.bisect=ao.bisectRight=Mo.right,ao.bisector=function(n){return u(1===n.length?function(t,r){return e(n(t),r)}:n)},ao.shuffle=function(n,t,e){(u=arguments.length)<3&&(e=n.length,2>u&&(t=0));for(var r,i,u=e-t;u;)i=Math.random()*u--|0,r=n[u+t],n[u+t]=n[i+t],n[i+t]=r;return n},ao.permute=function(n,t){for(var e=t.length,r=new Array(e);e--;)r[e]=n[t[e]];return r},ao.pairs=function(n){for(var t,e=0,r=n.length-1,i=n[0],u=new Array(0>r?0:r);r>e;)u[e]=[t=i,i=n[++e]];return u},ao.transpose=function(n){if(!(i=n.length))return[];for(var t=-1,e=ao.min(n,o),r=new Array(e);++t=0;)for(r=n[i],t=r.length;--t>=0;)e[--o]=r[t];return e};var xo=Math.abs;ao.range=function(n,t,e){if(arguments.length<3&&(e=1,arguments.length<2&&(t=n,n=0)),(t-n)/e===1/0)throw new Error("infinite range");var r,i=[],u=a(xo(e)),o=-1;if(n*=u,t*=u,e*=u,0>e)for(;(r=n+e*++o)>t;)i.push(r/u);else for(;(r=n+e*++o)=u.length)return r?r.call(i,o):e?o.sort(e):o;for(var l,f,s,h,p=-1,g=o.length,v=u[a++],d=new c;++p=u.length)return n;var r=[],i=o[e++];return n.forEach(function(n,i){r.push({key:n,values:t(i,e)})}),i?r.sort(function(n,t){return i(n.key,t.key)}):r}var e,r,i={},u=[],o=[];return i.map=function(t,e){return n(e,t,0)},i.entries=function(e){return t(n(ao.map,e,0),0)},i.key=function(n){return u.push(n),i},i.sortKeys=function(n){return o[u.length-1]=n,i},i.sortValues=function(n){return e=n,i},i.rollup=function(n){return r=n,i},i},ao.set=function(n){var t=new y;if(n)for(var e=0,r=n.length;r>e;++e)t.add(n[e]);return t},l(y,{has:h,add:function(n){return this._[f(n+="")]=!0,n},remove:p,values:g,size:v,empty:d,forEach:function(n){for(var t in this._)n.call(this,s(t))}}),ao.behavior={},ao.rebind=function(n,t){for(var e,r=1,i=arguments.length;++r=0&&(r=n.slice(e+1),n=n.slice(0,e)),n)return arguments.length<2?this[n].on(r):this[n].on(r,t);if(2===arguments.length){if(null==t)for(n in this)this.hasOwnProperty(n)&&this[n].on(r,null);return this}},ao.event=null,ao.requote=function(n){return n.replace(So,"\\$&")};var So=/[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g,ko={}.__proto__?function(n,t){n.__proto__=t}:function(n,t){for(var e in t)n[e]=t[e]},No=function(n,t){return t.querySelector(n)},Eo=function(n,t){return t.querySelectorAll(n)},Ao=function(n,t){var e=n.matches||n[x(n,"matchesSelector")];return(Ao=function(n,t){return e.call(n,t)})(n,t)};"function"==typeof Sizzle&&(No=function(n,t){return Sizzle(n,t)[0]||null},Eo=Sizzle,Ao=Sizzle.matchesSelector),ao.selection=function(){return ao.select(fo.documentElement)};var Co=ao.selection.prototype=[];Co.select=function(n){var t,e,r,i,u=[];n=A(n);for(var o=-1,a=this.length;++o=0&&"xmlns"!==(e=n.slice(0,t))&&(n=n.slice(t+1)),Lo.hasOwnProperty(e)?{space:Lo[e],local:n}:n}},Co.attr=function(n,t){if(arguments.length<2){if("string"==typeof n){var e=this.node();return n=ao.ns.qualify(n),n.local?e.getAttributeNS(n.space,n.local):e.getAttribute(n)}for(t in n)this.each(z(t,n[t]));return this}return this.each(z(n,t))},Co.classed=function(n,t){if(arguments.length<2){if("string"==typeof n){var e=this.node(),r=(n=T(n)).length,i=-1;if(t=e.classList){for(;++ii){if("string"!=typeof n){2>i&&(e="");for(r in n)this.each(P(r,n[r],e));return this}if(2>i){var u=this.node();return t(u).getComputedStyle(u,null).getPropertyValue(n)}r=""}return this.each(P(n,e,r))},Co.property=function(n,t){if(arguments.length<2){if("string"==typeof n)return this.node()[n];for(t in n)this.each(U(t,n[t]));return this}return this.each(U(n,t))},Co.text=function(n){return arguments.length?this.each("function"==typeof n?function(){var t=n.apply(this,arguments);this.textContent=null==t?"":t}:null==n?function(){this.textContent=""}:function(){this.textContent=n}):this.node().textContent},Co.html=function(n){return arguments.length?this.each("function"==typeof n?function(){var t=n.apply(this,arguments);this.innerHTML=null==t?"":t}:null==n?function(){this.innerHTML=""}:function(){this.innerHTML=n}):this.node().innerHTML},Co.append=function(n){return n=j(n),this.select(function(){return this.appendChild(n.apply(this,arguments))})},Co.insert=function(n,t){return n=j(n),t=A(t),this.select(function(){return this.insertBefore(n.apply(this,arguments),t.apply(this,arguments)||null)})},Co.remove=function(){return this.each(F)},Co.data=function(n,t){function e(n,e){var r,i,u,o=n.length,s=e.length,h=Math.min(o,s),p=new Array(s),g=new Array(s),v=new Array(o);if(t){var d,y=new c,m=new Array(o);for(r=-1;++rr;++r)g[r]=H(e[r]);for(;o>r;++r)v[r]=n[r]}g.update=p,g.parentNode=p.parentNode=v.parentNode=n.parentNode,a.push(g),l.push(p),f.push(v)}var r,i,u=-1,o=this.length;if(!arguments.length){for(n=new Array(o=(r=this[0]).length);++uu;u++){i.push(t=[]),t.parentNode=(e=this[u]).parentNode;for(var a=0,l=e.length;l>a;a++)(r=e[a])&&n.call(r,r.__data__,a,u)&&t.push(r)}return E(i)},Co.order=function(){for(var n=-1,t=this.length;++n=0;)(e=r[i])&&(u&&u!==e.nextSibling&&u.parentNode.insertBefore(e,u),u=e);return this},Co.sort=function(n){n=I.apply(this,arguments);for(var t=-1,e=this.length;++tn;n++)for(var e=this[n],r=0,i=e.length;i>r;r++){var u=e[r];if(u)return u}return null},Co.size=function(){var n=0;return Y(this,function(){++n}),n};var qo=[];ao.selection.enter=Z,ao.selection.enter.prototype=qo,qo.append=Co.append,qo.empty=Co.empty,qo.node=Co.node,qo.call=Co.call,qo.size=Co.size,qo.select=function(n){for(var t,e,r,i,u,o=[],a=-1,l=this.length;++ar){if("string"!=typeof n){2>r&&(t=!1);for(e in n)this.each(X(e,n[e],t));return this}if(2>r)return(r=this.node()["__on"+n])&&r._;e=!1}return this.each(X(n,t,e))};var To=ao.map({mouseenter:"mouseover",mouseleave:"mouseout"});fo&&To.forEach(function(n){"on"+n in fo&&To.remove(n)});var Ro,Do=0;ao.mouse=function(n){return J(n,k())};var Po=this.navigator&&/WebKit/.test(this.navigator.userAgent)?-1:0;ao.touch=function(n,t,e){if(arguments.length<3&&(e=t,t=k().changedTouches),t)for(var r,i=0,u=t.length;u>i;++i)if((r=t[i]).identifier===e)return J(n,r)},ao.behavior.drag=function(){function n(){this.on("mousedown.drag",u).on("touchstart.drag",o)}function e(n,t,e,u,o){return function(){function a(){var n,e,r=t(h,v);r&&(n=r[0]-M[0],e=r[1]-M[1],g|=n|e,M=r,p({type:"drag",x:r[0]+c[0],y:r[1]+c[1],dx:n,dy:e}))}function l(){t(h,v)&&(y.on(u+d,null).on(o+d,null),m(g),p({type:"dragend"}))}var c,f=this,s=ao.event.target.correspondingElement||ao.event.target,h=f.parentNode,p=r.of(f,arguments),g=0,v=n(),d=".drag"+(null==v?"":"-"+v),y=ao.select(e(s)).on(u+d,a).on(o+d,l),m=W(s),M=t(h,v);i?(c=i.apply(f,arguments),c=[c.x-M[0],c.y-M[1]]):c=[0,0],p({type:"dragstart"})}}var r=N(n,"drag","dragstart","dragend"),i=null,u=e(b,ao.mouse,t,"mousemove","mouseup"),o=e(G,ao.touch,m,"touchmove","touchend");return n.origin=function(t){return arguments.length?(i=t,n):i},ao.rebind(n,r,"on")},ao.touches=function(n,t){return arguments.length<2&&(t=k().touches),t?co(t).map(function(t){var e=J(n,t);return e.identifier=t.identifier,e}):[]};var Uo=1e-6,jo=Uo*Uo,Fo=Math.PI,Ho=2*Fo,Oo=Ho-Uo,Io=Fo/2,Yo=Fo/180,Zo=180/Fo,Vo=Math.SQRT2,Xo=2,$o=4;ao.interpolateZoom=function(n,t){var e,r,i=n[0],u=n[1],o=n[2],a=t[0],l=t[1],c=t[2],f=a-i,s=l-u,h=f*f+s*s;if(jo>h)r=Math.log(c/o)/Vo,e=function(n){return[i+n*f,u+n*s,o*Math.exp(Vo*n*r)]};else{var p=Math.sqrt(h),g=(c*c-o*o+$o*h)/(2*o*Xo*p),v=(c*c-o*o-$o*h)/(2*c*Xo*p),d=Math.log(Math.sqrt(g*g+1)-g),y=Math.log(Math.sqrt(v*v+1)-v);r=(y-d)/Vo,e=function(n){var t=n*r,e=rn(d),a=o/(Xo*p)*(e*un(Vo*t+d)-en(d));return[i+a*f,u+a*s,o*e/rn(Vo*t+d)]}}return e.duration=1e3*r,e},ao.behavior.zoom=function(){function n(n){n.on(L,s).on(Wo+".zoom",p).on("dblclick.zoom",g).on(R,h)}function e(n){return[(n[0]-k.x)/k.k,(n[1]-k.y)/k.k]}function r(n){return[n[0]*k.k+k.x,n[1]*k.k+k.y]}function i(n){k.k=Math.max(A[0],Math.min(A[1],n))}function u(n,t){t=r(t),k.x+=n[0]-t[0],k.y+=n[1]-t[1]}function o(t,e,r,o){t.__chart__={x:k.x,y:k.y,k:k.k},i(Math.pow(2,o)),u(d=e,r),t=ao.select(t),C>0&&(t=t.transition().duration(C)),t.call(n.event)}function a(){b&&b.domain(x.range().map(function(n){return(n-k.x)/k.k}).map(x.invert)),w&&w.domain(_.range().map(function(n){return(n-k.y)/k.k}).map(_.invert))}function l(n){z++||n({type:"zoomstart"})}function c(n){a(),n({type:"zoom",scale:k.k,translate:[k.x,k.y]})}function f(n){--z||(n({type:"zoomend"}),d=null)}function s(){function n(){a=1,u(ao.mouse(i),h),c(o)}function r(){s.on(q,null).on(T,null),p(a),f(o)}var i=this,o=D.of(i,arguments),a=0,s=ao.select(t(i)).on(q,n).on(T,r),h=e(ao.mouse(i)),p=W(i);Il.call(i),l(o)}function h(){function n(){var n=ao.touches(g);return p=k.k,n.forEach(function(n){n.identifier in d&&(d[n.identifier]=e(n))}),n}function t(){var t=ao.event.target;ao.select(t).on(x,r).on(b,a),_.push(t);for(var e=ao.event.changedTouches,i=0,u=e.length;u>i;++i)d[e[i].identifier]=null;var l=n(),c=Date.now();if(1===l.length){if(500>c-M){var f=l[0];o(g,f,d[f.identifier],Math.floor(Math.log(k.k)/Math.LN2)+1),S()}M=c}else if(l.length>1){var f=l[0],s=l[1],h=f[0]-s[0],p=f[1]-s[1];y=h*h+p*p}}function r(){var n,t,e,r,o=ao.touches(g);Il.call(g);for(var a=0,l=o.length;l>a;++a,r=null)if(e=o[a],r=d[e.identifier]){if(t)break;n=e,t=r}if(r){var f=(f=e[0]-n[0])*f+(f=e[1]-n[1])*f,s=y&&Math.sqrt(f/y);n=[(n[0]+e[0])/2,(n[1]+e[1])/2],t=[(t[0]+r[0])/2,(t[1]+r[1])/2],i(s*p)}M=null,u(n,t),c(v)}function a(){if(ao.event.touches.length){for(var t=ao.event.changedTouches,e=0,r=t.length;r>e;++e)delete d[t[e].identifier];for(var i in d)return void n()}ao.selectAll(_).on(m,null),w.on(L,s).on(R,h),N(),f(v)}var p,g=this,v=D.of(g,arguments),d={},y=0,m=".zoom-"+ao.event.changedTouches[0].identifier,x="touchmove"+m,b="touchend"+m,_=[],w=ao.select(g),N=W(g);t(),l(v),w.on(L,null).on(R,t)}function p(){var n=D.of(this,arguments);m?clearTimeout(m):(Il.call(this),v=e(d=y||ao.mouse(this)),l(n)),m=setTimeout(function(){m=null,f(n)},50),S(),i(Math.pow(2,.002*Bo())*k.k),u(d,v),c(n)}function g(){var n=ao.mouse(this),t=Math.log(k.k)/Math.LN2;o(this,n,e(n),ao.event.shiftKey?Math.ceil(t)-1:Math.floor(t)+1)}var v,d,y,m,M,x,b,_,w,k={x:0,y:0,k:1},E=[960,500],A=Jo,C=250,z=0,L="mousedown.zoom",q="mousemove.zoom",T="mouseup.zoom",R="touchstart.zoom",D=N(n,"zoomstart","zoom","zoomend");return Wo||(Wo="onwheel"in fo?(Bo=function(){return-ao.event.deltaY*(ao.event.deltaMode?120:1)},"wheel"):"onmousewheel"in fo?(Bo=function(){return ao.event.wheelDelta},"mousewheel"):(Bo=function(){return-ao.event.detail},"MozMousePixelScroll")),n.event=function(n){n.each(function(){var n=D.of(this,arguments),t=k;Hl?ao.select(this).transition().each("start.zoom",function(){k=this.__chart__||{x:0,y:0,k:1},l(n)}).tween("zoom:zoom",function(){var e=E[0],r=E[1],i=d?d[0]:e/2,u=d?d[1]:r/2,o=ao.interpolateZoom([(i-k.x)/k.k,(u-k.y)/k.k,e/k.k],[(i-t.x)/t.k,(u-t.y)/t.k,e/t.k]);return function(t){var r=o(t),a=e/r[2];this.__chart__=k={x:i-r[0]*a,y:u-r[1]*a,k:a},c(n)}}).each("interrupt.zoom",function(){f(n)}).each("end.zoom",function(){f(n)}):(this.__chart__=k,l(n),c(n),f(n))})},n.translate=function(t){return arguments.length?(k={x:+t[0],y:+t[1],k:k.k},a(),n):[k.x,k.y]},n.scale=function(t){return arguments.length?(k={x:k.x,y:k.y,k:null},i(+t),a(),n):k.k},n.scaleExtent=function(t){return arguments.length?(A=null==t?Jo:[+t[0],+t[1]],n):A},n.center=function(t){return arguments.length?(y=t&&[+t[0],+t[1]],n):y},n.size=function(t){return arguments.length?(E=t&&[+t[0],+t[1]],n):E},n.duration=function(t){return arguments.length?(C=+t,n):C},n.x=function(t){return arguments.length?(b=t,x=t.copy(),k={x:0,y:0,k:1},n):b},n.y=function(t){return arguments.length?(w=t,_=t.copy(),k={x:0,y:0,k:1},n):w},ao.rebind(n,D,"on")};var Bo,Wo,Jo=[0,1/0];ao.color=an,an.prototype.toString=function(){return this.rgb()+""},ao.hsl=ln;var Go=ln.prototype=new an;Go.brighter=function(n){return n=Math.pow(.7,arguments.length?n:1),new ln(this.h,this.s,this.l/n)},Go.darker=function(n){return n=Math.pow(.7,arguments.length?n:1),new ln(this.h,this.s,n*this.l)},Go.rgb=function(){return cn(this.h,this.s,this.l)},ao.hcl=fn;var Ko=fn.prototype=new an;Ko.brighter=function(n){return new fn(this.h,this.c,Math.min(100,this.l+Qo*(arguments.length?n:1)))},Ko.darker=function(n){return new fn(this.h,this.c,Math.max(0,this.l-Qo*(arguments.length?n:1)))},Ko.rgb=function(){return sn(this.h,this.c,this.l).rgb()},ao.lab=hn;var Qo=18,na=.95047,ta=1,ea=1.08883,ra=hn.prototype=new an;ra.brighter=function(n){return new hn(Math.min(100,this.l+Qo*(arguments.length?n:1)),this.a,this.b)},ra.darker=function(n){return new hn(Math.max(0,this.l-Qo*(arguments.length?n:1)),this.a,this.b)},ra.rgb=function(){return pn(this.l,this.a,this.b)},ao.rgb=mn;var ia=mn.prototype=new an;ia.brighter=function(n){n=Math.pow(.7,arguments.length?n:1);var t=this.r,e=this.g,r=this.b,i=30;return t||e||r?(t&&i>t&&(t=i),e&&i>e&&(e=i),r&&i>r&&(r=i),new mn(Math.min(255,t/n),Math.min(255,e/n),Math.min(255,r/n))):new mn(i,i,i)},ia.darker=function(n){return n=Math.pow(.7,arguments.length?n:1),new mn(n*this.r,n*this.g,n*this.b)},ia.hsl=function(){return wn(this.r,this.g,this.b)},ia.toString=function(){return"#"+bn(this.r)+bn(this.g)+bn(this.b)};var ua=ao.map({aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074});ua.forEach(function(n,t){ua.set(n,Mn(t))}),ao.functor=En,ao.xhr=An(m),ao.dsv=function(n,t){function e(n,e,u){arguments.length<3&&(u=e,e=null);var o=Cn(n,t,null==e?r:i(e),u);return o.row=function(n){return arguments.length?o.response(null==(e=n)?r:i(n)):e},o}function r(n){return e.parse(n.responseText)}function i(n){return function(t){return e.parse(t.responseText,n)}}function u(t){return t.map(o).join(n)}function o(n){return a.test(n)?'"'+n.replace(/\"/g,'""')+'"':n}var a=new RegExp('["'+n+"\n]"),l=n.charCodeAt(0);return e.parse=function(n,t){var r;return e.parseRows(n,function(n,e){if(r)return r(n,e-1);var i=new Function("d","return {"+n.map(function(n,t){return JSON.stringify(n)+": d["+t+"]"}).join(",")+"}");r=t?function(n,e){return t(i(n),e)}:i})},e.parseRows=function(n,t){function e(){if(f>=c)return o;if(i)return i=!1,u;var t=f;if(34===n.charCodeAt(t)){for(var e=t;e++f;){var r=n.charCodeAt(f++),a=1;if(10===r)i=!0;else if(13===r)i=!0,10===n.charCodeAt(f)&&(++f,++a);else if(r!==l)continue;return n.slice(t,f-a)}return n.slice(t)}for(var r,i,u={},o={},a=[],c=n.length,f=0,s=0;(r=e())!==o;){for(var h=[];r!==u&&r!==o;)h.push(r),r=e();t&&null==(h=t(h,s++))||a.push(h)}return a},e.format=function(t){if(Array.isArray(t[0]))return e.formatRows(t);var r=new y,i=[];return t.forEach(function(n){for(var t in n)r.has(t)||i.push(r.add(t))}),[i.map(o).join(n)].concat(t.map(function(t){return i.map(function(n){return o(t[n])}).join(n)})).join("\n")},e.formatRows=function(n){return n.map(u).join("\n")},e},ao.csv=ao.dsv(",","text/csv"),ao.tsv=ao.dsv(" ","text/tab-separated-values");var oa,aa,la,ca,fa=this[x(this,"requestAnimationFrame")]||function(n){setTimeout(n,17)};ao.timer=function(){qn.apply(this,arguments)},ao.timer.flush=function(){Rn(),Dn()},ao.round=function(n,t){return t?Math.round(n*(t=Math.pow(10,t)))/t:Math.round(n)};var sa=["y","z","a","f","p","n","\xb5","m","","k","M","G","T","P","E","Z","Y"].map(Un);ao.formatPrefix=function(n,t){var e=0;return(n=+n)&&(0>n&&(n*=-1),t&&(n=ao.round(n,Pn(n,t))),e=1+Math.floor(1e-12+Math.log(n)/Math.LN10),e=Math.max(-24,Math.min(24,3*Math.floor((e-1)/3)))),sa[8+e/3]};var ha=/(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i,pa=ao.map({b:function(n){return n.toString(2)},c:function(n){return String.fromCharCode(n)},o:function(n){return n.toString(8)},x:function(n){return n.toString(16)},X:function(n){return n.toString(16).toUpperCase()},g:function(n,t){return n.toPrecision(t)},e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},r:function(n,t){return(n=ao.round(n,Pn(n,t))).toFixed(Math.max(0,Math.min(20,Pn(n*(1+1e-15),t))))}}),ga=ao.time={},va=Date;Hn.prototype={getDate:function(){return this._.getUTCDate()},getDay:function(){return this._.getUTCDay()},getFullYear:function(){return this._.getUTCFullYear()},getHours:function(){return this._.getUTCHours()},getMilliseconds:function(){return this._.getUTCMilliseconds()},getMinutes:function(){return this._.getUTCMinutes()},getMonth:function(){return this._.getUTCMonth()},getSeconds:function(){return this._.getUTCSeconds()},getTime:function(){return this._.getTime()},getTimezoneOffset:function(){return 0},valueOf:function(){return this._.valueOf()},setDate:function(){da.setUTCDate.apply(this._,arguments)},setDay:function(){da.setUTCDay.apply(this._,arguments)},setFullYear:function(){da.setUTCFullYear.apply(this._,arguments)},setHours:function(){da.setUTCHours.apply(this._,arguments)},setMilliseconds:function(){da.setUTCMilliseconds.apply(this._,arguments)},setMinutes:function(){da.setUTCMinutes.apply(this._,arguments)},setMonth:function(){da.setUTCMonth.apply(this._,arguments)},setSeconds:function(){da.setUTCSeconds.apply(this._,arguments)},setTime:function(){da.setTime.apply(this._,arguments)}};var da=Date.prototype;ga.year=On(function(n){return n=ga.day(n),n.setMonth(0,1),n},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n){return n.getFullYear()}),ga.years=ga.year.range,ga.years.utc=ga.year.utc.range,ga.day=On(function(n){var t=new va(2e3,0);return t.setFullYear(n.getFullYear(),n.getMonth(),n.getDate()),t},function(n,t){n.setDate(n.getDate()+t)},function(n){return n.getDate()-1}),ga.days=ga.day.range,ga.days.utc=ga.day.utc.range,ga.dayOfYear=function(n){var t=ga.year(n);return Math.floor((n-t-6e4*(n.getTimezoneOffset()-t.getTimezoneOffset()))/864e5)},["sunday","monday","tuesday","wednesday","thursday","friday","saturday"].forEach(function(n,t){t=7-t;var e=ga[n]=On(function(n){return(n=ga.day(n)).setDate(n.getDate()-(n.getDay()+t)%7),n},function(n,t){n.setDate(n.getDate()+7*Math.floor(t))},function(n){var e=ga.year(n).getDay();return Math.floor((ga.dayOfYear(n)+(e+t)%7)/7)-(e!==t)});ga[n+"s"]=e.range,ga[n+"s"].utc=e.utc.range,ga[n+"OfYear"]=function(n){var e=ga.year(n).getDay();return Math.floor((ga.dayOfYear(n)+(e+t)%7)/7)}}),ga.week=ga.sunday,ga.weeks=ga.sunday.range,ga.weeks.utc=ga.sunday.utc.range,ga.weekOfYear=ga.sundayOfYear;var ya={"-":"",_:" ",0:"0"},ma=/^\s*\d+/,Ma=/^%/;ao.locale=function(n){return{numberFormat:jn(n),timeFormat:Yn(n)}};var xa=ao.locale({decimal:".",thousands:",",grouping:[3],currency:["$",""],dateTime:"%a %b %e %X %Y",date:"%m/%d/%Y",time:"%H:%M:%S",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"]});ao.format=xa.numberFormat,ao.geo={},ft.prototype={s:0,t:0,add:function(n){st(n,this.t,ba),st(ba.s,this.s,this),this.s?this.t+=ba.t:this.s=ba.t},reset:function(){this.s=this.t=0},valueOf:function(){return this.s}};var ba=new ft;ao.geo.stream=function(n,t){n&&_a.hasOwnProperty(n.type)?_a[n.type](n,t):ht(n,t)};var _a={Feature:function(n,t){ht(n.geometry,t)},FeatureCollection:function(n,t){for(var e=n.features,r=-1,i=e.length;++rn?4*Fo+n:n,Na.lineStart=Na.lineEnd=Na.point=b}};ao.geo.bounds=function(){function n(n,t){M.push(x=[f=n,h=n]),s>t&&(s=t),t>p&&(p=t)}function t(t,e){var r=dt([t*Yo,e*Yo]);if(y){var i=mt(y,r),u=[i[1],-i[0],0],o=mt(u,i);bt(o),o=_t(o);var l=t-g,c=l>0?1:-1,v=o[0]*Zo*c,d=xo(l)>180;if(d^(v>c*g&&c*t>v)){var m=o[1]*Zo;m>p&&(p=m)}else if(v=(v+360)%360-180,d^(v>c*g&&c*t>v)){var m=-o[1]*Zo;s>m&&(s=m)}else s>e&&(s=e),e>p&&(p=e);d?g>t?a(f,t)>a(f,h)&&(h=t):a(t,h)>a(f,h)&&(f=t):h>=f?(f>t&&(f=t),t>h&&(h=t)):t>g?a(f,t)>a(f,h)&&(h=t):a(t,h)>a(f,h)&&(f=t)}else n(t,e);y=r,g=t}function e(){b.point=t}function r(){x[0]=f,x[1]=h,b.point=n,y=null}function i(n,e){if(y){var r=n-g;m+=xo(r)>180?r+(r>0?360:-360):r}else v=n,d=e;Na.point(n,e),t(n,e)}function u(){Na.lineStart()}function o(){i(v,d),Na.lineEnd(),xo(m)>Uo&&(f=-(h=180)),x[0]=f,x[1]=h,y=null}function a(n,t){return(t-=n)<0?t+360:t}function l(n,t){return n[0]-t[0]}function c(n,t){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:nka?(f=-(h=180),s=-(p=90)):m>Uo?p=90:-Uo>m&&(s=-90),x[0]=f,x[1]=h}};return function(n){p=h=-(f=s=1/0),M=[],ao.geo.stream(n,b);var t=M.length;if(t){M.sort(l);for(var e,r=1,i=M[0],u=[i];t>r;++r)e=M[r],c(e[0],i)||c(e[1],i)?(a(i[0],e[1])>a(i[0],i[1])&&(i[1]=e[1]),a(e[0],i[1])>a(i[0],i[1])&&(i[0]=e[0])):u.push(i=e);for(var o,e,g=-(1/0),t=u.length-1,r=0,i=u[t];t>=r;i=e,++r)e=u[r],(o=a(i[1],e[0]))>g&&(g=o,f=e[0],h=i[1])}return M=x=null,f===1/0||s===1/0?[[NaN,NaN],[NaN,NaN]]:[[f,s],[h,p]]}}(),ao.geo.centroid=function(n){Ea=Aa=Ca=za=La=qa=Ta=Ra=Da=Pa=Ua=0,ao.geo.stream(n,ja);var t=Da,e=Pa,r=Ua,i=t*t+e*e+r*r;return jo>i&&(t=qa,e=Ta,r=Ra,Uo>Aa&&(t=Ca,e=za,r=La),i=t*t+e*e+r*r,jo>i)?[NaN,NaN]:[Math.atan2(e,t)*Zo,tn(r/Math.sqrt(i))*Zo]};var Ea,Aa,Ca,za,La,qa,Ta,Ra,Da,Pa,Ua,ja={sphere:b,point:St,lineStart:Nt,lineEnd:Et,polygonStart:function(){ja.lineStart=At},polygonEnd:function(){ja.lineStart=Nt}},Fa=Rt(zt,jt,Ht,[-Fo,-Fo/2]),Ha=1e9;ao.geo.clipExtent=function(){var n,t,e,r,i,u,o={stream:function(n){return i&&(i.valid=!1),i=u(n),i.valid=!0,i},extent:function(a){return arguments.length?(u=Zt(n=+a[0][0],t=+a[0][1],e=+a[1][0],r=+a[1][1]),i&&(i.valid=!1,i=null),o):[[n,t],[e,r]]}};return o.extent([[0,0],[960,500]])},(ao.geo.conicEqualArea=function(){return Vt(Xt)}).raw=Xt,ao.geo.albers=function(){return ao.geo.conicEqualArea().rotate([96,0]).center([-.6,38.7]).parallels([29.5,45.5]).scale(1070)},ao.geo.albersUsa=function(){function n(n){var u=n[0],o=n[1];return t=null,e(u,o),t||(r(u,o),t)||i(u,o),t}var t,e,r,i,u=ao.geo.albers(),o=ao.geo.conicEqualArea().rotate([154,0]).center([-2,58.5]).parallels([55,65]),a=ao.geo.conicEqualArea().rotate([157,0]).center([-3,19.9]).parallels([8,18]),l={point:function(n,e){t=[n,e]}};return n.invert=function(n){var t=u.scale(),e=u.translate(),r=(n[0]-e[0])/t,i=(n[1]-e[1])/t;return(i>=.12&&.234>i&&r>=-.425&&-.214>r?o:i>=.166&&.234>i&&r>=-.214&&-.115>r?a:u).invert(n)},n.stream=function(n){var t=u.stream(n),e=o.stream(n),r=a.stream(n);return{point:function(n,i){t.point(n,i),e.point(n,i),r.point(n,i)},sphere:function(){t.sphere(),e.sphere(),r.sphere()},lineStart:function(){t.lineStart(),e.lineStart(),r.lineStart()},lineEnd:function(){t.lineEnd(),e.lineEnd(),r.lineEnd()},polygonStart:function(){t.polygonStart(),e.polygonStart(),r.polygonStart()},polygonEnd:function(){t.polygonEnd(),e.polygonEnd(),r.polygonEnd()}}},n.precision=function(t){return arguments.length?(u.precision(t),o.precision(t),a.precision(t),n):u.precision()},n.scale=function(t){return arguments.length?(u.scale(t),o.scale(.35*t),a.scale(t),n.translate(u.translate())):u.scale()},n.translate=function(t){if(!arguments.length)return u.translate();var c=u.scale(),f=+t[0],s=+t[1];return e=u.translate(t).clipExtent([[f-.455*c,s-.238*c],[f+.455*c,s+.238*c]]).stream(l).point,r=o.translate([f-.307*c,s+.201*c]).clipExtent([[f-.425*c+Uo,s+.12*c+Uo],[f-.214*c-Uo,s+.234*c-Uo]]).stream(l).point,i=a.translate([f-.205*c,s+.212*c]).clipExtent([[f-.214*c+Uo,s+.166*c+Uo],[f-.115*c-Uo,s+.234*c-Uo]]).stream(l).point,n},n.scale(1070)};var Oa,Ia,Ya,Za,Va,Xa,$a={point:b,lineStart:b,lineEnd:b,polygonStart:function(){Ia=0,$a.lineStart=$t},polygonEnd:function(){$a.lineStart=$a.lineEnd=$a.point=b,Oa+=xo(Ia/2)}},Ba={point:Bt,lineStart:b,lineEnd:b,polygonStart:b,polygonEnd:b},Wa={point:Gt,lineStart:Kt,lineEnd:Qt,polygonStart:function(){Wa.lineStart=ne},polygonEnd:function(){Wa.point=Gt,Wa.lineStart=Kt,Wa.lineEnd=Qt}};ao.geo.path=function(){function n(n){return n&&("function"==typeof a&&u.pointRadius(+a.apply(this,arguments)),o&&o.valid||(o=i(u)),ao.geo.stream(n,o)),u.result()}function t(){return o=null,n}var e,r,i,u,o,a=4.5;return n.area=function(n){return Oa=0,ao.geo.stream(n,i($a)),Oa},n.centroid=function(n){return Ca=za=La=qa=Ta=Ra=Da=Pa=Ua=0,ao.geo.stream(n,i(Wa)),Ua?[Da/Ua,Pa/Ua]:Ra?[qa/Ra,Ta/Ra]:La?[Ca/La,za/La]:[NaN,NaN]},n.bounds=function(n){return Va=Xa=-(Ya=Za=1/0),ao.geo.stream(n,i(Ba)),[[Ya,Za],[Va,Xa]]},n.projection=function(n){return arguments.length?(i=(e=n)?n.stream||re(n):m,t()):e},n.context=function(n){return arguments.length?(u=null==(r=n)?new Wt:new te(n),"function"!=typeof a&&u.pointRadius(a),t()):r},n.pointRadius=function(t){return arguments.length?(a="function"==typeof t?t:(u.pointRadius(+t),+t),n):a},n.projection(ao.geo.albersUsa()).context(null)},ao.geo.transform=function(n){return{stream:function(t){var e=new ie(t);for(var r in n)e[r]=n[r];return e}}},ie.prototype={point:function(n,t){this.stream.point(n,t)},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()}},ao.geo.projection=oe,ao.geo.projectionMutator=ae,(ao.geo.equirectangular=function(){return oe(ce)}).raw=ce.invert=ce,ao.geo.rotation=function(n){function t(t){return t=n(t[0]*Yo,t[1]*Yo),t[0]*=Zo,t[1]*=Zo,t}return n=se(n[0]%360*Yo,n[1]*Yo,n.length>2?n[2]*Yo:0),t.invert=function(t){return t=n.invert(t[0]*Yo,t[1]*Yo),t[0]*=Zo,t[1]*=Zo,t},t},fe.invert=ce,ao.geo.circle=function(){function n(){var n="function"==typeof r?r.apply(this,arguments):r,t=se(-n[0]*Yo,-n[1]*Yo,0).invert,i=[];return e(null,null,1,{point:function(n,e){i.push(n=t(n,e)),n[0]*=Zo,n[1]*=Zo}}),{type:"Polygon",coordinates:[i]}}var t,e,r=[0,0],i=6;return n.origin=function(t){return arguments.length?(r=t,n):r},n.angle=function(r){return arguments.length?(e=ve((t=+r)*Yo,i*Yo),n):t},n.precision=function(r){return arguments.length?(e=ve(t*Yo,(i=+r)*Yo),n):i},n.angle(90)},ao.geo.distance=function(n,t){var e,r=(t[0]-n[0])*Yo,i=n[1]*Yo,u=t[1]*Yo,o=Math.sin(r),a=Math.cos(r),l=Math.sin(i),c=Math.cos(i),f=Math.sin(u),s=Math.cos(u);return Math.atan2(Math.sqrt((e=s*o)*e+(e=c*f-l*s*a)*e),l*f+c*s*a)},ao.geo.graticule=function(){function n(){return{type:"MultiLineString",coordinates:t()}}function t(){return ao.range(Math.ceil(u/d)*d,i,d).map(h).concat(ao.range(Math.ceil(c/y)*y,l,y).map(p)).concat(ao.range(Math.ceil(r/g)*g,e,g).filter(function(n){return xo(n%d)>Uo}).map(f)).concat(ao.range(Math.ceil(a/v)*v,o,v).filter(function(n){return xo(n%y)>Uo}).map(s))}var e,r,i,u,o,a,l,c,f,s,h,p,g=10,v=g,d=90,y=360,m=2.5;return n.lines=function(){return t().map(function(n){return{type:"LineString",coordinates:n}})},n.outline=function(){return{type:"Polygon",coordinates:[h(u).concat(p(l).slice(1),h(i).reverse().slice(1),p(c).reverse().slice(1))]}},n.extent=function(t){return arguments.length?n.majorExtent(t).minorExtent(t):n.minorExtent()},n.majorExtent=function(t){return arguments.length?(u=+t[0][0],i=+t[1][0],c=+t[0][1],l=+t[1][1],u>i&&(t=u,u=i,i=t),c>l&&(t=c,c=l,l=t),n.precision(m)):[[u,c],[i,l]]},n.minorExtent=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],a=+t[0][1],o=+t[1][1],r>e&&(t=r,r=e,e=t),a>o&&(t=a,a=o,o=t),n.precision(m)):[[r,a],[e,o]]},n.step=function(t){return arguments.length?n.majorStep(t).minorStep(t):n.minorStep()},n.majorStep=function(t){return arguments.length?(d=+t[0],y=+t[1],n):[d,y]},n.minorStep=function(t){return arguments.length?(g=+t[0],v=+t[1],n):[g,v]},n.precision=function(t){return arguments.length?(m=+t,f=ye(a,o,90),s=me(r,e,m),h=ye(c,l,90),p=me(u,i,m),n):m},n.majorExtent([[-180,-90+Uo],[180,90-Uo]]).minorExtent([[-180,-80-Uo],[180,80+Uo]])},ao.geo.greatArc=function(){function n(){return{type:"LineString",coordinates:[t||r.apply(this,arguments),e||i.apply(this,arguments)]}}var t,e,r=Me,i=xe;return n.distance=function(){return ao.geo.distance(t||r.apply(this,arguments),e||i.apply(this,arguments))},n.source=function(e){return arguments.length?(r=e,t="function"==typeof e?null:e,n):r},n.target=function(t){return arguments.length?(i=t,e="function"==typeof t?null:t,n):i},n.precision=function(){return arguments.length?n:0},n},ao.geo.interpolate=function(n,t){return be(n[0]*Yo,n[1]*Yo,t[0]*Yo,t[1]*Yo)},ao.geo.length=function(n){return Ja=0,ao.geo.stream(n,Ga),Ja};var Ja,Ga={sphere:b,point:b,lineStart:_e,lineEnd:b,polygonStart:b,polygonEnd:b},Ka=we(function(n){return Math.sqrt(2/(1+n))},function(n){return 2*Math.asin(n/2)});(ao.geo.azimuthalEqualArea=function(){return oe(Ka)}).raw=Ka;var Qa=we(function(n){var t=Math.acos(n);return t&&t/Math.sin(t)},m);(ao.geo.azimuthalEquidistant=function(){return oe(Qa)}).raw=Qa,(ao.geo.conicConformal=function(){return Vt(Se)}).raw=Se,(ao.geo.conicEquidistant=function(){return Vt(ke)}).raw=ke;var nl=we(function(n){return 1/n},Math.atan);(ao.geo.gnomonic=function(){return oe(nl)}).raw=nl,Ne.invert=function(n,t){return[n,2*Math.atan(Math.exp(t))-Io]},(ao.geo.mercator=function(){return Ee(Ne)}).raw=Ne;var tl=we(function(){return 1},Math.asin);(ao.geo.orthographic=function(){return oe(tl)}).raw=tl;var el=we(function(n){return 1/(1+n)},function(n){return 2*Math.atan(n)});(ao.geo.stereographic=function(){return oe(el)}).raw=el,Ae.invert=function(n,t){return[-t,2*Math.atan(Math.exp(n))-Io]},(ao.geo.transverseMercator=function(){var n=Ee(Ae),t=n.center,e=n.rotate;return n.center=function(n){return n?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},n.rotate=function(n){return n?e([n[0],n[1],n.length>2?n[2]+90:90]):(n=e(),[n[0],n[1],n[2]-90])},e([0,0,90])}).raw=Ae,ao.geom={},ao.geom.hull=function(n){function t(n){if(n.length<3)return[];var t,i=En(e),u=En(r),o=n.length,a=[],l=[];for(t=0;o>t;t++)a.push([+i.call(this,n[t],t),+u.call(this,n[t],t),t]);for(a.sort(qe),t=0;o>t;t++)l.push([a[t][0],-a[t][1]]);var c=Le(a),f=Le(l),s=f[0]===c[0],h=f[f.length-1]===c[c.length-1],p=[];for(t=c.length-1;t>=0;--t)p.push(n[a[c[t]][2]]);for(t=+s;t=r&&c.x<=u&&c.y>=i&&c.y<=o?[[r,o],[u,o],[u,i],[r,i]]:[];f.point=n[a]}),t}function e(n){return n.map(function(n,t){return{x:Math.round(u(n,t)/Uo)*Uo,y:Math.round(o(n,t)/Uo)*Uo,i:t}})}var r=Ce,i=ze,u=r,o=i,a=sl;return n?t(n):(t.links=function(n){return ar(e(n)).edges.filter(function(n){return n.l&&n.r}).map(function(t){return{source:n[t.l.i],target:n[t.r.i]}})},t.triangles=function(n){var t=[];return ar(e(n)).cells.forEach(function(e,r){for(var i,u,o=e.site,a=e.edges.sort(Ve),l=-1,c=a.length,f=a[c-1].edge,s=f.l===o?f.r:f.l;++l=c,h=r>=f,p=h<<1|s;n.leaf=!1,n=n.nodes[p]||(n.nodes[p]=hr()),s?i=c:a=c,h?o=f:l=f,u(n,t,e,r,i,o,a,l)}var f,s,h,p,g,v,d,y,m,M=En(a),x=En(l);if(null!=t)v=t,d=e,y=r,m=i;else if(y=m=-(v=d=1/0),s=[],h=[],g=n.length,o)for(p=0;g>p;++p)f=n[p],f.xy&&(y=f.x),f.y>m&&(m=f.y),s.push(f.x),h.push(f.y);else for(p=0;g>p;++p){var b=+M(f=n[p],p),_=+x(f,p);v>b&&(v=b),d>_&&(d=_),b>y&&(y=b),_>m&&(m=_),s.push(b),h.push(_)}var w=y-v,S=m-d;w>S?m=d+w:y=v+S;var k=hr();if(k.add=function(n){u(k,n,+M(n,++p),+x(n,p),v,d,y,m)},k.visit=function(n){pr(n,k,v,d,y,m)},k.find=function(n){return gr(k,n[0],n[1],v,d,y,m)},p=-1,null==t){for(;++p=0?n.slice(0,t):n,r=t>=0?n.slice(t+1):"in";return e=vl.get(e)||gl,r=dl.get(r)||m,br(r(e.apply(null,lo.call(arguments,1))))},ao.interpolateHcl=Rr,ao.interpolateHsl=Dr,ao.interpolateLab=Pr,ao.interpolateRound=Ur,ao.transform=function(n){var t=fo.createElementNS(ao.ns.prefix.svg,"g");return(ao.transform=function(n){if(null!=n){t.setAttribute("transform",n);var e=t.transform.baseVal.consolidate()}return new jr(e?e.matrix:yl)})(n)},jr.prototype.toString=function(){return"translate("+this.translate+")rotate("+this.rotate+")skewX("+this.skew+")scale("+this.scale+")"};var yl={a:1,b:0,c:0,d:1,e:0,f:0};ao.interpolateTransform=$r,ao.layout={},ao.layout.bundle=function(){return function(n){for(var t=[],e=-1,r=n.length;++ea*a/y){if(v>l){var c=t.charge/l;n.px-=u*c,n.py-=o*c}return!0}if(t.point&&l&&v>l){var c=t.pointCharge/l;n.px-=u*c,n.py-=o*c}}return!t.charge}}function t(n){n.px=ao.event.x,n.py=ao.event.y,l.resume()}var e,r,i,u,o,a,l={},c=ao.dispatch("start","tick","end"),f=[1,1],s=.9,h=ml,p=Ml,g=-30,v=xl,d=.1,y=.64,M=[],x=[];return l.tick=function(){if((i*=.99)<.005)return e=null,c.end({type:"end",alpha:i=0}),!0;var t,r,l,h,p,v,y,m,b,_=M.length,w=x.length;for(r=0;w>r;++r)l=x[r],h=l.source,p=l.target,m=p.x-h.x,b=p.y-h.y,(v=m*m+b*b)&&(v=i*o[r]*((v=Math.sqrt(v))-u[r])/v,m*=v,b*=v,p.x-=m*(y=h.weight+p.weight?h.weight/(h.weight+p.weight):.5),p.y-=b*y,h.x+=m*(y=1-y),h.y+=b*y);if((y=i*d)&&(m=f[0]/2,b=f[1]/2,r=-1,y))for(;++r<_;)l=M[r],l.x+=(m-l.x)*y,l.y+=(b-l.y)*y;if(g)for(ri(t=ao.geom.quadtree(M),i,a),r=-1;++r<_;)(l=M[r]).fixed||t.visit(n(l));for(r=-1;++r<_;)l=M[r],l.fixed?(l.x=l.px,l.y=l.py):(l.x-=(l.px-(l.px=l.x))*s,l.y-=(l.py-(l.py=l.y))*s);c.tick({type:"tick",alpha:i})},l.nodes=function(n){return arguments.length?(M=n,l):M},l.links=function(n){return arguments.length?(x=n,l):x},l.size=function(n){return arguments.length?(f=n,l):f},l.linkDistance=function(n){return arguments.length?(h="function"==typeof n?n:+n,l):h},l.distance=l.linkDistance,l.linkStrength=function(n){return arguments.length?(p="function"==typeof n?n:+n,l):p},l.friction=function(n){return arguments.length?(s=+n,l):s},l.charge=function(n){return arguments.length?(g="function"==typeof n?n:+n,l):g},l.chargeDistance=function(n){return arguments.length?(v=n*n,l):Math.sqrt(v)},l.gravity=function(n){return arguments.length?(d=+n,l):d},l.theta=function(n){return arguments.length?(y=n*n,l):Math.sqrt(y)},l.alpha=function(n){return arguments.length?(n=+n,i?n>0?i=n:(e.c=null,e.t=NaN,e=null,c.end({type:"end",alpha:i=0})):n>0&&(c.start({type:"start",alpha:i=n}),e=qn(l.tick)),l):i},l.start=function(){function n(n,r){if(!e){for(e=new Array(i),l=0;i>l;++l)e[l]=[];for(l=0;c>l;++l){var u=x[l];e[u.source.index].push(u.target),e[u.target.index].push(u.source)}}for(var o,a=e[t],l=-1,f=a.length;++lt;++t)(r=M[t]).index=t,r.weight=0;for(t=0;c>t;++t)r=x[t],"number"==typeof r.source&&(r.source=M[r.source]),"number"==typeof r.target&&(r.target=M[r.target]),++r.source.weight,++r.target.weight;for(t=0;i>t;++t)r=M[t],isNaN(r.x)&&(r.x=n("x",s)),isNaN(r.y)&&(r.y=n("y",v)),isNaN(r.px)&&(r.px=r.x),isNaN(r.py)&&(r.py=r.y);if(u=[],"function"==typeof h)for(t=0;c>t;++t)u[t]=+h.call(this,x[t],t);else for(t=0;c>t;++t)u[t]=h;if(o=[],"function"==typeof p)for(t=0;c>t;++t)o[t]=+p.call(this,x[t],t);else for(t=0;c>t;++t)o[t]=p;if(a=[],"function"==typeof g)for(t=0;i>t;++t)a[t]=+g.call(this,M[t],t);else for(t=0;i>t;++t)a[t]=g;return l.resume()},l.resume=function(){return l.alpha(.1)},l.stop=function(){return l.alpha(0)},l.drag=function(){return r||(r=ao.behavior.drag().origin(m).on("dragstart.force",Qr).on("drag.force",t).on("dragend.force",ni)),arguments.length?void this.on("mouseover.force",ti).on("mouseout.force",ei).call(r):r},ao.rebind(l,c,"on")};var ml=20,Ml=1,xl=1/0;ao.layout.hierarchy=function(){function n(i){var u,o=[i],a=[];for(i.depth=0;null!=(u=o.pop());)if(a.push(u),(c=e.call(n,u,u.depth))&&(l=c.length)){for(var l,c,f;--l>=0;)o.push(f=c[l]),f.parent=u,f.depth=u.depth+1;r&&(u.value=0),u.children=c}else r&&(u.value=+r.call(n,u,u.depth)||0),delete u.children;return oi(i,function(n){var e,i;t&&(e=n.children)&&e.sort(t),r&&(i=n.parent)&&(i.value+=n.value)}),a}var t=ci,e=ai,r=li;return n.sort=function(e){return arguments.length?(t=e,n):t},n.children=function(t){return arguments.length?(e=t,n):e},n.value=function(t){return arguments.length?(r=t,n):r},n.revalue=function(t){return r&&(ui(t,function(n){n.children&&(n.value=0)}),oi(t,function(t){var e;t.children||(t.value=+r.call(n,t,t.depth)||0),(e=t.parent)&&(e.value+=t.value)})),t},n},ao.layout.partition=function(){function n(t,e,r,i){var u=t.children;if(t.x=e,t.y=t.depth*i,t.dx=r,t.dy=i,u&&(o=u.length)){var o,a,l,c=-1;for(r=t.value?r/t.value:0;++cs?-1:1),g=ao.sum(c),v=g?(s-l*p)/g:0,d=ao.range(l),y=[];return null!=e&&d.sort(e===bl?function(n,t){return c[t]-c[n]}:function(n,t){return e(o[n],o[t])}),d.forEach(function(n){y[n]={data:o[n],value:a=c[n],startAngle:f,endAngle:f+=a*v+p,padAngle:h}}),y}var t=Number,e=bl,r=0,i=Ho,u=0;return n.value=function(e){return arguments.length?(t=e,n):t},n.sort=function(t){return arguments.length?(e=t,n):e},n.startAngle=function(t){return arguments.length?(r=t,n):r},n.endAngle=function(t){return arguments.length?(i=t,n):i},n.padAngle=function(t){return arguments.length?(u=t,n):u},n};var bl={};ao.layout.stack=function(){function n(a,l){if(!(h=a.length))return a;var c=a.map(function(e,r){return t.call(n,e,r)}),f=c.map(function(t){return t.map(function(t,e){return[u.call(n,t,e),o.call(n,t,e)]})}),s=e.call(n,f,l);c=ao.permute(c,s),f=ao.permute(f,s);var h,p,g,v,d=r.call(n,f,l),y=c[0].length;for(g=0;y>g;++g)for(i.call(n,c[0][g],v=d[g],f[0][g][1]),p=1;h>p;++p)i.call(n,c[p][g],v+=f[p-1][g][1],f[p][g][1]);return a}var t=m,e=gi,r=vi,i=pi,u=si,o=hi;return n.values=function(e){return arguments.length?(t=e,n):t},n.order=function(t){return arguments.length?(e="function"==typeof t?t:_l.get(t)||gi,n):e},n.offset=function(t){return arguments.length?(r="function"==typeof t?t:wl.get(t)||vi,n):r},n.x=function(t){return arguments.length?(u=t,n):u},n.y=function(t){return arguments.length?(o=t,n):o},n.out=function(t){return arguments.length?(i=t,n):i},n};var _l=ao.map({"inside-out":function(n){var t,e,r=n.length,i=n.map(di),u=n.map(yi),o=ao.range(r).sort(function(n,t){return i[n]-i[t]}),a=0,l=0,c=[],f=[];for(t=0;r>t;++t)e=o[t],l>a?(a+=u[e],c.push(e)):(l+=u[e],f.push(e));return f.reverse().concat(c)},reverse:function(n){return ao.range(n.length).reverse()},"default":gi}),wl=ao.map({silhouette:function(n){var t,e,r,i=n.length,u=n[0].length,o=[],a=0,l=[];for(e=0;u>e;++e){for(t=0,r=0;i>t;t++)r+=n[t][e][1];r>a&&(a=r),o.push(r)}for(e=0;u>e;++e)l[e]=(a-o[e])/2;return l},wiggle:function(n){var t,e,r,i,u,o,a,l,c,f=n.length,s=n[0],h=s.length,p=[];for(p[0]=l=c=0,e=1;h>e;++e){for(t=0,i=0;f>t;++t)i+=n[t][e][1];for(t=0,u=0,a=s[e][0]-s[e-1][0];f>t;++t){for(r=0,o=(n[t][e][1]-n[t][e-1][1])/(2*a);t>r;++r)o+=(n[r][e][1]-n[r][e-1][1])/a;u+=o*n[t][e][1]}p[e]=l-=i?u/i*a:0,c>l&&(c=l)}for(e=0;h>e;++e)p[e]-=c;return p},expand:function(n){var t,e,r,i=n.length,u=n[0].length,o=1/i,a=[];for(e=0;u>e;++e){for(t=0,r=0;i>t;t++)r+=n[t][e][1];if(r)for(t=0;i>t;t++)n[t][e][1]/=r;else for(t=0;i>t;t++)n[t][e][1]=o}for(e=0;u>e;++e)a[e]=0;return a},zero:vi});ao.layout.histogram=function(){function n(n,u){for(var o,a,l=[],c=n.map(e,this),f=r.call(this,c,u),s=i.call(this,f,c,u),u=-1,h=c.length,p=s.length-1,g=t?1:1/h;++u0)for(u=-1;++u=f[0]&&a<=f[1]&&(o=l[ao.bisect(s,a,1,p)-1],o.y+=g,o.push(n[u]));return l}var t=!0,e=Number,r=bi,i=Mi;return n.value=function(t){return arguments.length?(e=t,n):e},n.range=function(t){return arguments.length?(r=En(t),n):r},n.bins=function(t){return arguments.length?(i="number"==typeof t?function(n){return xi(n,t)}:En(t),n):i},n.frequency=function(e){return arguments.length?(t=!!e,n):t},n},ao.layout.pack=function(){function n(n,u){var o=e.call(this,n,u),a=o[0],l=i[0],c=i[1],f=null==t?Math.sqrt:"function"==typeof t?t:function(){return t};if(a.x=a.y=0,oi(a,function(n){n.r=+f(n.value)}),oi(a,Ni),r){var s=r*(t?1:Math.max(2*a.r/l,2*a.r/c))/2;oi(a,function(n){n.r+=s}),oi(a,Ni),oi(a,function(n){n.r-=s})}return Ci(a,l/2,c/2,t?1:1/Math.max(2*a.r/l,2*a.r/c)),o}var t,e=ao.layout.hierarchy().sort(_i),r=0,i=[1,1];return n.size=function(t){return arguments.length?(i=t,n):i},n.radius=function(e){return arguments.length?(t=null==e||"function"==typeof e?e:+e,n):t},n.padding=function(t){return arguments.length?(r=+t,n):r},ii(n,e)},ao.layout.tree=function(){function n(n,i){var f=o.call(this,n,i),s=f[0],h=t(s);if(oi(h,e),h.parent.m=-h.z,ui(h,r),c)ui(s,u);else{var p=s,g=s,v=s;ui(s,function(n){n.xg.x&&(g=n),n.depth>v.depth&&(v=n)});var d=a(p,g)/2-p.x,y=l[0]/(g.x+a(g,p)/2+d),m=l[1]/(v.depth||1);ui(s,function(n){n.x=(n.x+d)*y,n.y=n.depth*m})}return f}function t(n){for(var t,e={A:null,children:[n]},r=[e];null!=(t=r.pop());)for(var i,u=t.children,o=0,a=u.length;a>o;++o)r.push((u[o]=i={_:u[o],parent:t,children:(i=u[o].children)&&i.slice()||[],A:null,a:null,z:0,m:0,c:0,s:0,t:null,i:o}).a=i);return e.children[0]}function e(n){var t=n.children,e=n.parent.children,r=n.i?e[n.i-1]:null;if(t.length){Di(n);var u=(t[0].z+t[t.length-1].z)/2;r?(n.z=r.z+a(n._,r._),n.m=n.z-u):n.z=u}else r&&(n.z=r.z+a(n._,r._));n.parent.A=i(n,r,n.parent.A||e[0])}function r(n){n._.x=n.z+n.parent.m,n.m+=n.parent.m}function i(n,t,e){if(t){for(var r,i=n,u=n,o=t,l=i.parent.children[0],c=i.m,f=u.m,s=o.m,h=l.m;o=Ti(o),i=qi(i),o&&i;)l=qi(l),u=Ti(u),u.a=n,r=o.z+s-i.z-c+a(o._,i._),r>0&&(Ri(Pi(o,n,e),n,r),c+=r,f+=r),s+=o.m,c+=i.m,h+=l.m,f+=u.m;o&&!Ti(u)&&(u.t=o,u.m+=s-f),i&&!qi(l)&&(l.t=i,l.m+=c-h,e=n)}return e}function u(n){n.x*=l[0],n.y=n.depth*l[1]}var o=ao.layout.hierarchy().sort(null).value(null),a=Li,l=[1,1],c=null;return n.separation=function(t){return arguments.length?(a=t,n):a},n.size=function(t){return arguments.length?(c=null==(l=t)?u:null,n):c?null:l},n.nodeSize=function(t){return arguments.length?(c=null==(l=t)?null:u,n):c?l:null},ii(n,o)},ao.layout.cluster=function(){function n(n,u){var o,a=t.call(this,n,u),l=a[0],c=0;oi(l,function(n){var t=n.children;t&&t.length?(n.x=ji(t),n.y=Ui(t)):(n.x=o?c+=e(n,o):0,n.y=0,o=n)});var f=Fi(l),s=Hi(l),h=f.x-e(f,s)/2,p=s.x+e(s,f)/2;return oi(l,i?function(n){n.x=(n.x-l.x)*r[0],n.y=(l.y-n.y)*r[1]}:function(n){n.x=(n.x-h)/(p-h)*r[0],n.y=(1-(l.y?n.y/l.y:1))*r[1]}),a}var t=ao.layout.hierarchy().sort(null).value(null),e=Li,r=[1,1],i=!1;return n.separation=function(t){return arguments.length?(e=t,n):e},n.size=function(t){return arguments.length?(i=null==(r=t),n):i?null:r},n.nodeSize=function(t){return arguments.length?(i=null!=(r=t),n):i?r:null},ii(n,t)},ao.layout.treemap=function(){function n(n,t){for(var e,r,i=-1,u=n.length;++it?0:t),e.area=isNaN(r)||0>=r?0:r}function t(e){var u=e.children;if(u&&u.length){var o,a,l,c=s(e),f=[],h=u.slice(),g=1/0,v="slice"===p?c.dx:"dice"===p?c.dy:"slice-dice"===p?1&e.depth?c.dy:c.dx:Math.min(c.dx,c.dy);for(n(h,c.dx*c.dy/e.value),f.area=0;(l=h.length)>0;)f.push(o=h[l-1]),f.area+=o.area,"squarify"!==p||(a=r(f,v))<=g?(h.pop(),g=a):(f.area-=f.pop().area,i(f,v,c,!1),v=Math.min(c.dx,c.dy),f.length=f.area=0,g=1/0);f.length&&(i(f,v,c,!0),f.length=f.area=0),u.forEach(t)}}function e(t){var r=t.children;if(r&&r.length){var u,o=s(t),a=r.slice(),l=[];for(n(a,o.dx*o.dy/t.value),l.area=0;u=a.pop();)l.push(u),l.area+=u.area,null!=u.z&&(i(l,u.z?o.dx:o.dy,o,!a.length),l.length=l.area=0);r.forEach(e)}}function r(n,t){for(var e,r=n.area,i=0,u=1/0,o=-1,a=n.length;++oe&&(u=e),e>i&&(i=e));return r*=r,t*=t,r?Math.max(t*i*g/r,r/(t*u*g)):1/0}function i(n,t,e,r){var i,u=-1,o=n.length,a=e.x,c=e.y,f=t?l(n.area/t):0; ++if(t==e.dx){for((r||f>e.dy)&&(f=e.dy);++ue.dx)&&(f=e.dx);++ue&&(t=1),1>e&&(n=0),function(){var e,r,i;do e=2*Math.random()-1,r=2*Math.random()-1,i=e*e+r*r;while(!i||i>1);return n+t*e*Math.sqrt(-2*Math.log(i)/i)}},logNormal:function(){var n=ao.random.normal.apply(ao,arguments);return function(){return Math.exp(n())}},bates:function(n){var t=ao.random.irwinHall(n);return function(){return t()/n}},irwinHall:function(n){return function(){for(var t=0,e=0;n>e;e++)t+=Math.random();return t}}},ao.scale={};var Sl={floor:m,ceil:m};ao.scale.linear=function(){return Wi([0,1],[0,1],Mr,!1)};var kl={s:1,g:1,p:1,r:1,e:1};ao.scale.log=function(){return ru(ao.scale.linear().domain([0,1]),10,!0,[1,10])};var Nl=ao.format(".0e"),El={floor:function(n){return-Math.ceil(-n)},ceil:function(n){return-Math.floor(-n)}};ao.scale.pow=function(){return iu(ao.scale.linear(),1,[0,1])},ao.scale.sqrt=function(){return ao.scale.pow().exponent(.5)},ao.scale.ordinal=function(){return ou([],{t:"range",a:[[]]})},ao.scale.category10=function(){return ao.scale.ordinal().range(Al)},ao.scale.category20=function(){return ao.scale.ordinal().range(Cl)},ao.scale.category20b=function(){return ao.scale.ordinal().range(zl)},ao.scale.category20c=function(){return ao.scale.ordinal().range(Ll)};var Al=[2062260,16744206,2924588,14034728,9725885,9197131,14907330,8355711,12369186,1556175].map(xn),Cl=[2062260,11454440,16744206,16759672,2924588,10018698,14034728,16750742,9725885,12955861,9197131,12885140,14907330,16234194,8355711,13092807,12369186,14408589,1556175,10410725].map(xn),zl=[3750777,5395619,7040719,10264286,6519097,9216594,11915115,13556636,9202993,12426809,15186514,15190932,8666169,11356490,14049643,15177372,8077683,10834324,13528509,14589654].map(xn),Ll=[3244733,7057110,10406625,13032431,15095053,16616764,16625259,16634018,3253076,7652470,10607003,13101504,7695281,10394312,12369372,14342891,6513507,9868950,12434877,14277081].map(xn);ao.scale.quantile=function(){return au([],[])},ao.scale.quantize=function(){return lu(0,1,[0,1])},ao.scale.threshold=function(){return cu([.5],[0,1])},ao.scale.identity=function(){return fu([0,1])},ao.svg={},ao.svg.arc=function(){function n(){var n=Math.max(0,+e.apply(this,arguments)),c=Math.max(0,+r.apply(this,arguments)),f=o.apply(this,arguments)-Io,s=a.apply(this,arguments)-Io,h=Math.abs(s-f),p=f>s?0:1;if(n>c&&(g=c,c=n,n=g),h>=Oo)return t(c,p)+(n?t(n,1-p):"")+"Z";var g,v,d,y,m,M,x,b,_,w,S,k,N=0,E=0,A=[];if((y=(+l.apply(this,arguments)||0)/2)&&(d=u===ql?Math.sqrt(n*n+c*c):+u.apply(this,arguments),p||(E*=-1),c&&(E=tn(d/c*Math.sin(y))),n&&(N=tn(d/n*Math.sin(y)))),c){m=c*Math.cos(f+E),M=c*Math.sin(f+E),x=c*Math.cos(s-E),b=c*Math.sin(s-E);var C=Math.abs(s-f-2*E)<=Fo?0:1;if(E&&yu(m,M,x,b)===p^C){var z=(f+s)/2;m=c*Math.cos(z),M=c*Math.sin(z),x=b=null}}else m=M=0;if(n){_=n*Math.cos(s-N),w=n*Math.sin(s-N),S=n*Math.cos(f+N),k=n*Math.sin(f+N);var L=Math.abs(f-s+2*N)<=Fo?0:1;if(N&&yu(_,w,S,k)===1-p^L){var q=(f+s)/2;_=n*Math.cos(q),w=n*Math.sin(q),S=k=null}}else _=w=0;if(h>Uo&&(g=Math.min(Math.abs(c-n)/2,+i.apply(this,arguments)))>.001){v=c>n^p?0:1;var T=g,R=g;if(Fo>h){var D=null==S?[_,w]:null==x?[m,M]:Re([m,M],[S,k],[x,b],[_,w]),P=m-D[0],U=M-D[1],j=x-D[0],F=b-D[1],H=1/Math.sin(Math.acos((P*j+U*F)/(Math.sqrt(P*P+U*U)*Math.sqrt(j*j+F*F)))/2),O=Math.sqrt(D[0]*D[0]+D[1]*D[1]);R=Math.min(g,(n-O)/(H-1)),T=Math.min(g,(c-O)/(H+1))}if(null!=x){var I=mu(null==S?[_,w]:[S,k],[m,M],c,T,p),Y=mu([x,b],[_,w],c,T,p);g===T?A.push("M",I[0],"A",T,",",T," 0 0,",v," ",I[1],"A",c,",",c," 0 ",1-p^yu(I[1][0],I[1][1],Y[1][0],Y[1][1]),",",p," ",Y[1],"A",T,",",T," 0 0,",v," ",Y[0]):A.push("M",I[0],"A",T,",",T," 0 1,",v," ",Y[0])}else A.push("M",m,",",M);if(null!=S){var Z=mu([m,M],[S,k],n,-R,p),V=mu([_,w],null==x?[m,M]:[x,b],n,-R,p);g===R?A.push("L",V[0],"A",R,",",R," 0 0,",v," ",V[1],"A",n,",",n," 0 ",p^yu(V[1][0],V[1][1],Z[1][0],Z[1][1]),",",1-p," ",Z[1],"A",R,",",R," 0 0,",v," ",Z[0]):A.push("L",V[0],"A",R,",",R," 0 0,",v," ",Z[0])}else A.push("L",_,",",w)}else A.push("M",m,",",M),null!=x&&A.push("A",c,",",c," 0 ",C,",",p," ",x,",",b),A.push("L",_,",",w),null!=S&&A.push("A",n,",",n," 0 ",L,",",1-p," ",S,",",k);return A.push("Z"),A.join("")}function t(n,t){return"M0,"+n+"A"+n+","+n+" 0 1,"+t+" 0,"+-n+"A"+n+","+n+" 0 1,"+t+" 0,"+n}var e=hu,r=pu,i=su,u=ql,o=gu,a=vu,l=du;return n.innerRadius=function(t){return arguments.length?(e=En(t),n):e},n.outerRadius=function(t){return arguments.length?(r=En(t),n):r},n.cornerRadius=function(t){return arguments.length?(i=En(t),n):i},n.padRadius=function(t){return arguments.length?(u=t==ql?ql:En(t),n):u},n.startAngle=function(t){return arguments.length?(o=En(t),n):o},n.endAngle=function(t){return arguments.length?(a=En(t),n):a},n.padAngle=function(t){return arguments.length?(l=En(t),n):l},n.centroid=function(){var n=(+e.apply(this,arguments)+ +r.apply(this,arguments))/2,t=(+o.apply(this,arguments)+ +a.apply(this,arguments))/2-Io;return[Math.cos(t)*n,Math.sin(t)*n]},n};var ql="auto";ao.svg.line=function(){return Mu(m)};var Tl=ao.map({linear:xu,"linear-closed":bu,step:_u,"step-before":wu,"step-after":Su,basis:zu,"basis-open":Lu,"basis-closed":qu,bundle:Tu,cardinal:Eu,"cardinal-open":ku,"cardinal-closed":Nu,monotone:Fu});Tl.forEach(function(n,t){t.key=n,t.closed=/-closed$/.test(n)});var Rl=[0,2/3,1/3,0],Dl=[0,1/3,2/3,0],Pl=[0,1/6,2/3,1/6];ao.svg.line.radial=function(){var n=Mu(Hu);return n.radius=n.x,delete n.x,n.angle=n.y,delete n.y,n},wu.reverse=Su,Su.reverse=wu,ao.svg.area=function(){return Ou(m)},ao.svg.area.radial=function(){var n=Ou(Hu);return n.radius=n.x,delete n.x,n.innerRadius=n.x0,delete n.x0,n.outerRadius=n.x1,delete n.x1,n.angle=n.y,delete n.y,n.startAngle=n.y0,delete n.y0,n.endAngle=n.y1,delete n.y1,n},ao.svg.chord=function(){function n(n,a){var l=t(this,u,n,a),c=t(this,o,n,a);return"M"+l.p0+r(l.r,l.p1,l.a1-l.a0)+(e(l,c)?i(l.r,l.p1,l.r,l.p0):i(l.r,l.p1,c.r,c.p0)+r(c.r,c.p1,c.a1-c.a0)+i(c.r,c.p1,l.r,l.p0))+"Z"}function t(n,t,e,r){var i=t.call(n,e,r),u=a.call(n,i,r),o=l.call(n,i,r)-Io,f=c.call(n,i,r)-Io;return{r:u,a0:o,a1:f,p0:[u*Math.cos(o),u*Math.sin(o)],p1:[u*Math.cos(f),u*Math.sin(f)]}}function e(n,t){return n.a0==t.a0&&n.a1==t.a1}function r(n,t,e){return"A"+n+","+n+" 0 "+ +(e>Fo)+",1 "+t}function i(n,t,e,r){return"Q 0,0 "+r}var u=Me,o=xe,a=Iu,l=gu,c=vu;return n.radius=function(t){return arguments.length?(a=En(t),n):a},n.source=function(t){return arguments.length?(u=En(t),n):u},n.target=function(t){return arguments.length?(o=En(t),n):o},n.startAngle=function(t){return arguments.length?(l=En(t),n):l},n.endAngle=function(t){return arguments.length?(c=En(t),n):c},n},ao.svg.diagonal=function(){function n(n,i){var u=t.call(this,n,i),o=e.call(this,n,i),a=(u.y+o.y)/2,l=[u,{x:u.x,y:a},{x:o.x,y:a},o];return l=l.map(r),"M"+l[0]+"C"+l[1]+" "+l[2]+" "+l[3]}var t=Me,e=xe,r=Yu;return n.source=function(e){return arguments.length?(t=En(e),n):t},n.target=function(t){return arguments.length?(e=En(t),n):e},n.projection=function(t){return arguments.length?(r=t,n):r},n},ao.svg.diagonal.radial=function(){var n=ao.svg.diagonal(),t=Yu,e=n.projection;return n.projection=function(n){return arguments.length?e(Zu(t=n)):t},n},ao.svg.symbol=function(){function n(n,r){return(Ul.get(t.call(this,n,r))||$u)(e.call(this,n,r))}var t=Xu,e=Vu;return n.type=function(e){return arguments.length?(t=En(e),n):t},n.size=function(t){return arguments.length?(e=En(t),n):e},n};var Ul=ao.map({circle:$u,cross:function(n){var t=Math.sqrt(n/5)/2;return"M"+-3*t+","+-t+"H"+-t+"V"+-3*t+"H"+t+"V"+-t+"H"+3*t+"V"+t+"H"+t+"V"+3*t+"H"+-t+"V"+t+"H"+-3*t+"Z"},diamond:function(n){var t=Math.sqrt(n/(2*Fl)),e=t*Fl;return"M0,"+-t+"L"+e+",0 0,"+t+" "+-e+",0Z"},square:function(n){var t=Math.sqrt(n)/2;return"M"+-t+","+-t+"L"+t+","+-t+" "+t+","+t+" "+-t+","+t+"Z"},"triangle-down":function(n){var t=Math.sqrt(n/jl),e=t*jl/2;return"M0,"+e+"L"+t+","+-e+" "+-t+","+-e+"Z"},"triangle-up":function(n){var t=Math.sqrt(n/jl),e=t*jl/2;return"M0,"+-e+"L"+t+","+e+" "+-t+","+e+"Z"}});ao.svg.symbolTypes=Ul.keys();var jl=Math.sqrt(3),Fl=Math.tan(30*Yo);Co.transition=function(n){for(var t,e,r=Hl||++Zl,i=Ku(n),u=[],o=Ol||{time:Date.now(),ease:Nr,delay:0,duration:250},a=-1,l=this.length;++au;u++){i.push(t=[]);for(var e=this[u],a=0,l=e.length;l>a;a++)(r=e[a])&&n.call(r,r.__data__,a,u)&&t.push(r)}return Wu(i,this.namespace,this.id)},Yl.tween=function(n,t){var e=this.id,r=this.namespace;return arguments.length<2?this.node()[r][e].tween.get(n):Y(this,null==t?function(t){t[r][e].tween.remove(n)}:function(i){i[r][e].tween.set(n,t)})},Yl.attr=function(n,t){function e(){this.removeAttribute(a)}function r(){this.removeAttributeNS(a.space,a.local)}function i(n){return null==n?e:(n+="",function(){var t,e=this.getAttribute(a);return e!==n&&(t=o(e,n),function(n){this.setAttribute(a,t(n))})})}function u(n){return null==n?r:(n+="",function(){var t,e=this.getAttributeNS(a.space,a.local);return e!==n&&(t=o(e,n),function(n){this.setAttributeNS(a.space,a.local,t(n))})})}if(arguments.length<2){for(t in n)this.attr(t,n[t]);return this}var o="transform"==n?$r:Mr,a=ao.ns.qualify(n);return Ju(this,"attr."+n,t,a.local?u:i)},Yl.attrTween=function(n,t){function e(n,e){var r=t.call(this,n,e,this.getAttribute(i));return r&&function(n){this.setAttribute(i,r(n))}}function r(n,e){var r=t.call(this,n,e,this.getAttributeNS(i.space,i.local));return r&&function(n){this.setAttributeNS(i.space,i.local,r(n))}}var i=ao.ns.qualify(n);return this.tween("attr."+n,i.local?r:e)},Yl.style=function(n,e,r){function i(){this.style.removeProperty(n)}function u(e){return null==e?i:(e+="",function(){var i,u=t(this).getComputedStyle(this,null).getPropertyValue(n);return u!==e&&(i=Mr(u,e),function(t){this.style.setProperty(n,i(t),r)})})}var o=arguments.length;if(3>o){if("string"!=typeof n){2>o&&(e="");for(r in n)this.style(r,n[r],e);return this}r=""}return Ju(this,"style."+n,e,u)},Yl.styleTween=function(n,e,r){function i(i,u){var o=e.call(this,i,u,t(this).getComputedStyle(this,null).getPropertyValue(n));return o&&function(t){this.style.setProperty(n,o(t),r)}}return arguments.length<3&&(r=""),this.tween("style."+n,i)},Yl.text=function(n){return Ju(this,"text",n,Gu)},Yl.remove=function(){var n=this.namespace;return this.each("end.transition",function(){var t;this[n].count<2&&(t=this.parentNode)&&t.removeChild(this)})},Yl.ease=function(n){var t=this.id,e=this.namespace;return arguments.length<1?this.node()[e][t].ease:("function"!=typeof n&&(n=ao.ease.apply(ao,arguments)),Y(this,function(r){r[e][t].ease=n}))},Yl.delay=function(n){var t=this.id,e=this.namespace;return arguments.length<1?this.node()[e][t].delay:Y(this,"function"==typeof n?function(r,i,u){r[e][t].delay=+n.call(r,r.__data__,i,u)}:(n=+n,function(r){r[e][t].delay=n}))},Yl.duration=function(n){var t=this.id,e=this.namespace;return arguments.length<1?this.node()[e][t].duration:Y(this,"function"==typeof n?function(r,i,u){r[e][t].duration=Math.max(1,n.call(r,r.__data__,i,u))}:(n=Math.max(1,n),function(r){r[e][t].duration=n}))},Yl.each=function(n,t){var e=this.id,r=this.namespace;if(arguments.length<2){var i=Ol,u=Hl;try{Hl=e,Y(this,function(t,i,u){Ol=t[r][e],n.call(t,t.__data__,i,u)})}finally{Ol=i,Hl=u}}else Y(this,function(i){var u=i[r][e];(u.event||(u.event=ao.dispatch("start","end","interrupt"))).on(n,t)});return this},Yl.transition=function(){for(var n,t,e,r,i=this.id,u=++Zl,o=this.namespace,a=[],l=0,c=this.length;c>l;l++){a.push(n=[]);for(var t=this[l],f=0,s=t.length;s>f;f++)(e=t[f])&&(r=e[o][i],Qu(e,f,o,u,{time:r.time,ease:r.ease,delay:r.delay+r.duration,duration:r.duration})),n.push(e)}return Wu(a,o,u)},ao.svg.axis=function(){function n(n){n.each(function(){var n,c=ao.select(this),f=this.__chart__||e,s=this.__chart__=e.copy(),h=null==l?s.ticks?s.ticks.apply(s,a):s.domain():l,p=null==t?s.tickFormat?s.tickFormat.apply(s,a):m:t,g=c.selectAll(".tick").data(h,s),v=g.enter().insert("g",".domain").attr("class","tick").style("opacity",Uo),d=ao.transition(g.exit()).style("opacity",Uo).remove(),y=ao.transition(g.order()).style("opacity",1),M=Math.max(i,0)+o,x=Zi(s),b=c.selectAll(".domain").data([0]),_=(b.enter().append("path").attr("class","domain"),ao.transition(b));v.append("line"),v.append("text");var w,S,k,N,E=v.select("line"),A=y.select("line"),C=g.select("text").text(p),z=v.select("text"),L=y.select("text"),q="top"===r||"left"===r?-1:1;if("bottom"===r||"top"===r?(n=no,w="x",k="y",S="x2",N="y2",C.attr("dy",0>q?"0em":".71em").style("text-anchor","middle"),_.attr("d","M"+x[0]+","+q*u+"V0H"+x[1]+"V"+q*u)):(n=to,w="y",k="x",S="y2",N="x2",C.attr("dy",".32em").style("text-anchor",0>q?"end":"start"),_.attr("d","M"+q*u+","+x[0]+"H0V"+x[1]+"H"+q*u)),E.attr(N,q*i),z.attr(k,q*M),A.attr(S,0).attr(N,q*i),L.attr(w,0).attr(k,q*M),s.rangeBand){var T=s,R=T.rangeBand()/2;f=s=function(n){return T(n)+R}}else f.rangeBand?f=s:d.call(n,s,f);v.call(n,f,s),y.call(n,s,s)})}var t,e=ao.scale.linear(),r=Vl,i=6,u=6,o=3,a=[10],l=null;return n.scale=function(t){return arguments.length?(e=t,n):e},n.orient=function(t){return arguments.length?(r=t in Xl?t+"":Vl,n):r},n.ticks=function(){return arguments.length?(a=co(arguments),n):a},n.tickValues=function(t){return arguments.length?(l=t,n):l},n.tickFormat=function(e){return arguments.length?(t=e,n):t},n.tickSize=function(t){var e=arguments.length;return e?(i=+t,u=+arguments[e-1],n):i},n.innerTickSize=function(t){return arguments.length?(i=+t,n):i},n.outerTickSize=function(t){return arguments.length?(u=+t,n):u},n.tickPadding=function(t){return arguments.length?(o=+t,n):o},n.tickSubdivide=function(){return arguments.length&&n},n};var Vl="bottom",Xl={top:1,right:1,bottom:1,left:1};ao.svg.brush=function(){function n(t){t.each(function(){var t=ao.select(this).style("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush",u).on("touchstart.brush",u),o=t.selectAll(".background").data([0]);o.enter().append("rect").attr("class","background").style("visibility","hidden").style("cursor","crosshair"),t.selectAll(".extent").data([0]).enter().append("rect").attr("class","extent").style("cursor","move");var a=t.selectAll(".resize").data(v,m);a.exit().remove(),a.enter().append("g").attr("class",function(n){return"resize "+n}).style("cursor",function(n){return $l[n]}).append("rect").attr("x",function(n){return/[ew]$/.test(n)?-3:null}).attr("y",function(n){return/^[ns]/.test(n)?-3:null}).attr("width",6).attr("height",6).style("visibility","hidden"),a.style("display",n.empty()?"none":null);var l,s=ao.transition(t),h=ao.transition(o);c&&(l=Zi(c),h.attr("x",l[0]).attr("width",l[1]-l[0]),r(s)),f&&(l=Zi(f),h.attr("y",l[0]).attr("height",l[1]-l[0]),i(s)),e(s)})}function e(n){n.selectAll(".resize").attr("transform",function(n){return"translate("+s[+/e$/.test(n)]+","+h[+/^s/.test(n)]+")"})}function r(n){n.select(".extent").attr("x",s[0]),n.selectAll(".extent,.n>rect,.s>rect").attr("width",s[1]-s[0])}function i(n){n.select(".extent").attr("y",h[0]),n.selectAll(".extent,.e>rect,.w>rect").attr("height",h[1]-h[0])}function u(){function u(){32==ao.event.keyCode&&(C||(M=null,L[0]-=s[1],L[1]-=h[1],C=2),S())}function v(){32==ao.event.keyCode&&2==C&&(L[0]+=s[1],L[1]+=h[1],C=0,S())}function d(){var n=ao.mouse(b),t=!1;x&&(n[0]+=x[0],n[1]+=x[1]),C||(ao.event.altKey?(M||(M=[(s[0]+s[1])/2,(h[0]+h[1])/2]),L[0]=s[+(n[0]f?(i=r,r=f):i=f),v[0]!=r||v[1]!=i?(e?a=null:o=null,v[0]=r,v[1]=i,!0):void 0}function m(){d(),k.style("pointer-events","all").selectAll(".resize").style("display",n.empty()?"none":null),ao.select("body").style("cursor",null),q.on("mousemove.brush",null).on("mouseup.brush",null).on("touchmove.brush",null).on("touchend.brush",null).on("keydown.brush",null).on("keyup.brush",null),z(),w({type:"brushend"})}var M,x,b=this,_=ao.select(ao.event.target),w=l.of(b,arguments),k=ao.select(b),N=_.datum(),E=!/^(n|s)$/.test(N)&&c,A=!/^(e|w)$/.test(N)&&f,C=_.classed("extent"),z=W(b),L=ao.mouse(b),q=ao.select(t(b)).on("keydown.brush",u).on("keyup.brush",v);if(ao.event.changedTouches?q.on("touchmove.brush",d).on("touchend.brush",m):q.on("mousemove.brush",d).on("mouseup.brush",m),k.interrupt().selectAll("*").interrupt(),C)L[0]=s[0]-L[0],L[1]=h[0]-L[1];else if(N){var T=+/w$/.test(N),R=+/^n/.test(N);x=[s[1-T]-L[0],h[1-R]-L[1]],L[0]=s[T],L[1]=h[R]}else ao.event.altKey&&(M=L.slice());k.style("pointer-events","none").selectAll(".resize").style("display",null),ao.select("body").style("cursor",_.style("cursor")),w({type:"brushstart"}),d()}var o,a,l=N(n,"brushstart","brush","brushend"),c=null,f=null,s=[0,0],h=[0,0],p=!0,g=!0,v=Bl[0];return n.event=function(n){n.each(function(){var n=l.of(this,arguments),t={x:s,y:h,i:o,j:a},e=this.__chart__||t;this.__chart__=t,Hl?ao.select(this).transition().each("start.brush",function(){o=e.i,a=e.j,s=e.x,h=e.y,n({type:"brushstart"})}).tween("brush:brush",function(){var e=xr(s,t.x),r=xr(h,t.y);return o=a=null,function(i){s=t.x=e(i),h=t.y=r(i),n({type:"brush",mode:"resize"})}}).each("end.brush",function(){o=t.i,a=t.j,n({type:"brush",mode:"resize"}),n({type:"brushend"})}):(n({type:"brushstart"}),n({type:"brush",mode:"resize"}),n({type:"brushend"}))})},n.x=function(t){return arguments.length?(c=t,v=Bl[!c<<1|!f],n):c},n.y=function(t){return arguments.length?(f=t,v=Bl[!c<<1|!f],n):f},n.clamp=function(t){return arguments.length?(c&&f?(p=!!t[0],g=!!t[1]):c?p=!!t:f&&(g=!!t),n):c&&f?[p,g]:c?p:f?g:null},n.extent=function(t){var e,r,i,u,l;return arguments.length?(c&&(e=t[0],r=t[1],f&&(e=e[0],r=r[0]),o=[e,r],c.invert&&(e=c(e),r=c(r)),e>r&&(l=e,e=r,r=l),e==s[0]&&r==s[1]||(s=[e,r])),f&&(i=t[0],u=t[1],c&&(i=i[1],u=u[1]),a=[i,u],f.invert&&(i=f(i),u=f(u)),i>u&&(l=i,i=u,u=l),i==h[0]&&u==h[1]||(h=[i,u])),n):(c&&(o?(e=o[0],r=o[1]):(e=s[0],r=s[1],c.invert&&(e=c.invert(e),r=c.invert(r)),e>r&&(l=e,e=r,r=l))),f&&(a?(i=a[0],u=a[1]):(i=h[0],u=h[1],f.invert&&(i=f.invert(i),u=f.invert(u)),i>u&&(l=i,i=u,u=l))),c&&f?[[e,i],[r,u]]:c?[e,r]:f&&[i,u])},n.clear=function(){return n.empty()||(s=[0,0],h=[0,0],o=a=null),n},n.empty=function(){return!!c&&s[0]==s[1]||!!f&&h[0]==h[1]},ao.rebind(n,l,"on")};var $l={n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Bl=[["n","e","s","w","nw","ne","se","sw"],["e","w"],["n","s"],[]],Wl=ga.format=xa.timeFormat,Jl=Wl.utc,Gl=Jl("%Y-%m-%dT%H:%M:%S.%LZ");Wl.iso=Date.prototype.toISOString&&+new Date("2000-01-01T00:00:00.000Z")?eo:Gl,eo.parse=function(n){var t=new Date(n);return isNaN(t)?null:t},eo.toString=Gl.toString,ga.second=On(function(n){return new va(1e3*Math.floor(n/1e3))},function(n,t){n.setTime(n.getTime()+1e3*Math.floor(t))},function(n){return n.getSeconds()}),ga.seconds=ga.second.range,ga.seconds.utc=ga.second.utc.range,ga.minute=On(function(n){return new va(6e4*Math.floor(n/6e4))},function(n,t){n.setTime(n.getTime()+6e4*Math.floor(t))},function(n){return n.getMinutes()}),ga.minutes=ga.minute.range,ga.minutes.utc=ga.minute.utc.range,ga.hour=On(function(n){var t=n.getTimezoneOffset()/60;return new va(36e5*(Math.floor(n/36e5-t)+t))},function(n,t){n.setTime(n.getTime()+36e5*Math.floor(t))},function(n){return n.getHours()}),ga.hours=ga.hour.range,ga.hours.utc=ga.hour.utc.range,ga.month=On(function(n){return n=ga.day(n),n.setDate(1),n},function(n,t){n.setMonth(n.getMonth()+t)},function(n){return n.getMonth()}),ga.months=ga.month.range,ga.months.utc=ga.month.utc.range;var Kl=[1e3,5e3,15e3,3e4,6e4,3e5,9e5,18e5,36e5,108e5,216e5,432e5,864e5,1728e5,6048e5,2592e6,7776e6,31536e6],Ql=[[ga.second,1],[ga.second,5],[ga.second,15],[ga.second,30],[ga.minute,1],[ga.minute,5],[ga.minute,15],[ga.minute,30],[ga.hour,1],[ga.hour,3],[ga.hour,6],[ga.hour,12],[ga.day,1],[ga.day,2],[ga.week,1],[ga.month,1],[ga.month,3],[ga.year,1]],nc=Wl.multi([[".%L",function(n){return n.getMilliseconds()}],[":%S",function(n){return n.getSeconds()}],["%I:%M",function(n){return n.getMinutes()}],["%I %p",function(n){return n.getHours()}],["%a %d",function(n){return n.getDay()&&1!=n.getDate()}],["%b %d",function(n){return 1!=n.getDate()}],["%B",function(n){return n.getMonth()}],["%Y",zt]]),tc={range:function(n,t,e){return ao.range(Math.ceil(n/e)*e,+t,e).map(io)},floor:m,ceil:m};Ql.year=ga.year,ga.scale=function(){return ro(ao.scale.linear(),Ql,nc)};var ec=Ql.map(function(n){return[n[0].utc,n[1]]}),rc=Jl.multi([[".%L",function(n){return n.getUTCMilliseconds()}],[":%S",function(n){return n.getUTCSeconds()}],["%I:%M",function(n){return n.getUTCMinutes()}],["%I %p",function(n){return n.getUTCHours()}],["%a %d",function(n){return n.getUTCDay()&&1!=n.getUTCDate()}],["%b %d",function(n){return 1!=n.getUTCDate()}],["%B",function(n){return n.getUTCMonth()}],["%Y",zt]]);ec.year=ga.year.utc,ga.scale.utc=function(){return ro(ao.scale.linear(),ec,rc)},ao.text=An(function(n){return n.responseText}),ao.json=function(n,t){return Cn(n,"application/json",uo,t)},ao.html=function(n,t){return Cn(n,"text/html",oo,t)},ao.xml=An(function(n){return n.responseXML}),"function"==typeof define&&define.amd?(this.d3=ao,define(ao)):"object"==typeof module&&module.exports?module.exports=ao:this.d3=ao}(); +\ No newline at end of file +-- +2.26.2 + diff --git a/0001-Do-not-assume-there-is-a-SMTP_STARTTLS-configuration.patch b/0001-Do-not-assume-there-is-a-SMTP_STARTTLS-configuration.patch new file mode 100644 index 0000000..ca8abef --- /dev/null +++ b/0001-Do-not-assume-there-is-a-SMTP_STARTTLS-configuration.patch @@ -0,0 +1,30 @@ +From a5a0e792e8491f416d3188c42861ba0c62e94a79 Mon Sep 17 00:00:00 2001 +From: Pierre-Yves Chibon +Date: Wed, 3 Jun 2020 20:19:48 +0200 +Subject: [PATCH] Do not assume there is a SMTP_STARTTLS configuration key set + +This is a new key that was introduced in 5.10.0 and that isn't set +in the default_config. So we cannot assume it is defined and thus +the code needs to not make this assumption either. + +Signed-off-by: Pierre-Yves Chibon +--- + pagure/lib/notify.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pagure/lib/notify.py b/pagure/lib/notify.py +index 2c4ee30f..0c124db9 100644 +--- a/pagure/lib/notify.py ++++ b/pagure/lib/notify.py +@@ -506,7 +506,7 @@ def send_email( + pagure_config["SMTP_PORT"], + ) + +- if pagure_config["SMTP_STARTTLS"]: ++ if pagure_config.get("SMTP_STARTTLS"): + context = ssl.create_default_context() + keyfile = pagure_config.get("SMTP_KEYFILE") or None + certfile = pagure_config.get("SMTP_CERTFILE") or None +-- +2.26.2 + diff --git a/0001-Ensure-the-title-name-of-the-headers-are-strings.patch b/0001-Ensure-the-title-name-of-the-headers-are-strings.patch new file mode 100644 index 0000000..2b62b09 --- /dev/null +++ b/0001-Ensure-the-title-name-of-the-headers-are-strings.patch @@ -0,0 +1,28 @@ +From 8f8e201bf25e5ee1fd359ecf97eb41d09320bcb2 Mon Sep 17 00:00:00 2001 +From: Pierre-Yves Chibon +Date: Wed, 3 Jun 2020 20:21:31 +0200 +Subject: [PATCH] Ensure the title/name of the headers are strings + +Whether this is running py2 or py3, the headers should be strings. + +Signed-off-by: Pierre-Yves Chibon +--- + pagure/ui/clone.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pagure/ui/clone.py b/pagure/ui/clone.py +index 61615cc8..33732a41 100644 +--- a/pagure/ui/clone.py ++++ b/pagure/ui/clone.py +@@ -205,7 +205,7 @@ def proxy_raw_git(project): + break + header = line.split(b": ", 1) + header[0] = header[0].decode("utf-8") +- headers[header[0].lower()] = header[1] ++ headers[str(header[0].lower())] = header[1] + + if len(headers) == 0: + raise Exception("No response at all received") +-- +2.26.2 + diff --git a/0001-Fix-repotype-spelling.patch b/0001-Fix-repotype-spelling.patch new file mode 100644 index 0000000..3ad2001 --- /dev/null +++ b/0001-Fix-repotype-spelling.patch @@ -0,0 +1,30 @@ +From 86c9a6f729968432b9f0dd785548fbe8065f6f4b Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Lubom=C3=ADr=20Sedl=C3=A1=C5=99?= +Date: Fri, 22 May 2020 11:49:10 +0200 +Subject: [PATCH] Fix repotype spelling + +--- + pagure/internal/__init__.py | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/pagure/internal/__init__.py b/pagure/internal/__init__.py +index 4f106e8b..3fa7edfa 100644 +--- a/pagure/internal/__init__.py ++++ b/pagure/internal/__init__.py +@@ -157,11 +157,11 @@ def check_ssh_access(): + return flask.jsonify({"access": False}) + _log.info("Checking ACLs on project: %s" % project.fullname) + +- if repotype not in ["main", "doc"] and not pagure.utils.is_repo_user( ++ if repotype not in ["main", "docs"] and not pagure.utils.is_repo_user( + project, remoteuser + ): + # Deploy keys are not allowed on ticket and PR repos but they are +- # allowed for main and doc repos. ++ # allowed for main and docs repos. + _log.info("%s is not a contributor to this project" % remoteuser) + return flask.jsonify({"access": False}) + +-- +2.26.1 + diff --git a/0001-Fix-the-title-of-the-graph-showing-the-evolution-of-.patch b/0001-Fix-the-title-of-the-graph-showing-the-evolution-of-.patch new file mode 100644 index 0000000..642223c --- /dev/null +++ b/0001-Fix-the-title-of-the-graph-showing-the-evolution-of-.patch @@ -0,0 +1,27 @@ +From 907ba17242490b767c21cec877dd3ad322526ef6 Mon Sep 17 00:00:00 2001 +From: Pierre-Yves Chibon +Date: Wed, 3 Jun 2020 20:23:45 +0200 +Subject: [PATCH] Fix the title of the graph showing the evolution of the + number of open tickets on a project + +Signed-off-by: Pierre-Yves Chibon +--- + pagure/static/issues_stats.js | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pagure/static/issues_stats.js b/pagure/static/issues_stats.js +index 32b4c2a9..5e81a3ab 100644 +--- a/pagure/static/issues_stats.js ++++ b/pagure/static/issues_stats.js +@@ -70,7 +70,7 @@ function issues_history_stats_plot(data) { + }, + title: { + display: true, +- text: 'Evolution of the number of commits over the last year' ++ text: 'Evolution of the number of open tickets over the last year' + } + } + }); +-- +2.26.2 + diff --git a/0001-Make-sure-authorized_keys-file-has-mode-600.patch b/0001-Make-sure-authorized_keys-file-has-mode-600.patch new file mode 100644 index 0000000..aadbaca --- /dev/null +++ b/0001-Make-sure-authorized_keys-file-has-mode-600.patch @@ -0,0 +1,30 @@ +From 2691e9d47d45be9a72798bd84166d09b5c3c8d82 Mon Sep 17 00:00:00 2001 +From: Sergio Durigan Junior +Date: Sun, 7 Jun 2020 17:16:15 -0400 +Subject: [PATCH] Make sure authorized_keys file has mode 600. + +Only the pagure user needs to be able to read and write the file. +--- + pagure/lib/tasks.py | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/pagure/lib/tasks.py b/pagure/lib/tasks.py +index eaef5cdb..73323ef7 100644 +--- a/pagure/lib/tasks.py ++++ b/pagure/lib/tasks.py +@@ -1270,6 +1270,7 @@ def add_key_to_authorized_keys(self, session, ssh_folder, username, sshkey): + sshkey.strip(), + ) + ) ++ os.chmod(fullpath, 0o600) + + + @conn.task(queue=pagure_config.get("AUTHORIZED_KEYS_QUEUE", None), bind=True) +@@ -1294,3 +1295,4 @@ def remove_key_from_authorized_keys(self, session, ssh_folder, sshkey): + + with open(fullpath, "w") as stream: + stream.write("\n".join(output)) ++ os.chmod(fullpath, 0o600) +-- +2.26.2 + diff --git a/0001-Show-the-ACL-name-in-addition-to-the-description-whe.patch b/0001-Show-the-ACL-name-in-addition-to-the-description-whe.patch new file mode 100644 index 0000000..ddcebff --- /dev/null +++ b/0001-Show-the-ACL-name-in-addition-to-the-description-whe.patch @@ -0,0 +1,33 @@ +From 98d320cad34ed2defadeb4828a9d5d7690a06ffd Mon Sep 17 00:00:00 2001 +From: Pierre-Yves Chibon +Date: Sun, 31 May 2020 21:16:36 +0200 +Subject: [PATCH] Show the ACL name in addition to the description when + creating API tokens + +So in addition to the description of the ACL, we will now show the +actual name of the ACL, which hopefully will help people when they +meet documentation that says: create a token with the update_issue ACL. + +Relates to https://pagure.io/pagure/issue/4765 + +Signed-off-by: Pierre-Yves Chibon +--- + pagure/templates/add_token.html | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pagure/templates/add_token.html b/pagure/templates/add_token.html +index 02f5a80a..bf8a571b 100644 +--- a/pagure/templates/add_token.html ++++ b/pagure/templates/add_token.html +@@ -44,7 +44,7 @@ + + + {% endfor %} +-- +2.26.1 + diff --git a/0001-api-fix-apidoc-format-on-api_view_issues_history_det.patch b/0001-api-fix-apidoc-format-on-api_view_issues_history_det.patch new file mode 100644 index 0000000..010163d --- /dev/null +++ b/0001-api-fix-apidoc-format-on-api_view_issues_history_det.patch @@ -0,0 +1,25 @@ +From 656ef585dce90201f6e5e13f527284672a5fd7ee Mon Sep 17 00:00:00 2001 +From: Julen Landa Alustiza +Date: Wed, 27 May 2020 13:18:17 +0200 +Subject: [PATCH] api: fix apidoc format on + api_view_issues_history_detailed_stats Fixes web api doc view template issues + +--- + pagure/api/issue.py | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/pagure/api/issue.py b/pagure/api/issue.py +index 99e3c7e6..3f9af2a6 100644 +--- a/pagure/api/issue.py ++++ b/pagure/api/issue.py +@@ -1568,6 +1568,7 @@ def api_view_issues_history_detailed_stats( + ^^^^^^^^^^^^^^^ + + :: ++ + { + "stats": { + "2020-03-26T19:21:51.348451": { +-- +2.26.1 + diff --git a/0002-starttls-support-via-SMTP_STARTTLS-provide-additiona.patch b/0002-starttls-support-via-SMTP_STARTTLS-provide-additiona.patch new file mode 100644 index 0000000..e463416 --- /dev/null +++ b/0002-starttls-support-via-SMTP_STARTTLS-provide-additiona.patch @@ -0,0 +1,40 @@ +From 27ab4efb3bfad27e036602e88c7d5de666c3d80b Mon Sep 17 00:00:00 2001 +From: midipix +Date: Thu, 21 May 2020 15:09:30 +0000 +Subject: [PATCH 2/2] starttls support via SMTP_STARTTLS: provide additional + documentation. + +--- + doc/configuration.rst | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/doc/configuration.rst b/doc/configuration.rst +index 25dee387..942aeb83 100644 +--- a/doc/configuration.rst ++++ b/doc/configuration.rst +@@ -938,6 +938,8 @@ sending emails. + + Defaults to: ``localhost``. + ++See also the SMTP_STARTTLS section. ++ + + SMTP_PORT + ^^^^^^^^^ +@@ -967,6 +969,13 @@ SMTP_STARTTLS + This configuration key specifies instructs pagure to starts connecting to + the SMTP server via a `starttls` command. + ++When enabling STARTTLS in conjunction with a local smtp server, you should ++replace ``localhost`` with a host name that is included in the server's ++certificate. If the server only relays messages originating from ``localhost``, ++then you should also ensure that the above host name resolves to the same ++tcp address as ``localhost``, for instance by adding an appropriate record ++to */etc/hosts*. ++ + Defaults to: ``False`` + + +-- +2.26.1 + diff --git a/0101-Use-WhiteNoise-to-serve-static-assets-for-the-Pagure.patch b/0101-Use-WhiteNoise-to-serve-static-assets-for-the-Pagure.patch new file mode 100644 index 0000000..a53c2a6 --- /dev/null +++ b/0101-Use-WhiteNoise-to-serve-static-assets-for-the-Pagure.patch @@ -0,0 +1,179 @@ +From 89f18ee38de1e6cb3ac482f865e6352ed340d763 Mon Sep 17 00:00:00 2001 +From: Neal Gompa +Date: Sun, 31 May 2020 11:56:38 -0400 +Subject: [PATCH] Use WhiteNoise to serve static assets for the Pagure web + interface + +In order to make it easier to run Pagure in a containerized environment, +the web frontend needs to be capable of serving all of the frontend static +files. This change introduces WhiteNoise as a dependency that would enable +the Flask application itself to serve the static assets correctly. + +This makes it possible to run a Pagure server without Apache or Nginx at all +in a containerized environment for all of the main functions. + +Note that the releases folder is still not served through WhiteNoise, and +deployments that have uploading releases enabled will need something to +serve them. + +Signed-off-by: Neal Gompa +--- + files/pagure-apache-httpd.conf | 3 --- + files/pagure-nginx.conf | 9 --------- + files/pagure.spec | 13 ++----------- + pagure/docs_server.py | 9 +++++++++ + pagure/flask_app.py | 7 +++++++ + requirements.txt | 1 + + 6 files changed, 19 insertions(+), 23 deletions(-) + +diff --git a/files/pagure-apache-httpd.conf b/files/pagure-apache-httpd.conf +index cf61e7f4..5724deb4 100644 +--- a/files/pagure-apache-httpd.conf ++++ b/files/pagure-apache-httpd.conf +@@ -33,8 +33,6 @@ + #SSLCertificateChainFile /etc/pki/tls/....intermediate.crt + #SSLCertificateKeyFile /etc/pki/tls/....key + +- #Alias /static /usr/lib/pythonX.Y/site-packages/pagure/static/ +- + # + #WSGIProcessGroup paguredocs + # +@@ -64,7 +62,6 @@ + #SSLCertificateChainFile /etc/pki/tls/....intermediate.crt + #SSLCertificateKeyFile /etc/pki/tls/....key + +- #Alias /static /usr/lib/pythonX.Y/site-packages/pagure/static/ + #Alias /releases /var/www/releases + + ## Section used to support cloning git repo over http (https in this case) +diff --git a/files/pagure-nginx.conf b/files/pagure-nginx.conf +index fe3ff832..a5d196a6 100644 +--- a/files/pagure-nginx.conf ++++ b/files/pagure-nginx.conf +@@ -27,11 +27,6 @@ + #try_files $uri @pagure_docs; + #} + +- #location /static { +- #alias /usr/lib/pythonX.Y/site-packages/pagure/static/; +- #try_files $uri $uri/; +- #} +- + #} + + #server { +@@ -63,10 +58,6 @@ + #try_files $uri @pagure; + #} + +- #location /static { +- #alias /usr/lib/pythonX.Y/site-packages/pagure/static/; +- #} +- + #location /releases { + #alias /var/www/releases/; + #autoindex on; +diff --git a/files/pagure.spec b/files/pagure.spec +index 5c084436..24fd5b37 100644 +--- a/files/pagure.spec ++++ b/files/pagure.spec +@@ -75,6 +75,7 @@ Requires: python%{python_pkgversion}-requests + Requires: python%{python_pkgversion}-six + Requires: python%{python_pkgversion}-sqlalchemy >= 0.8 + Requires: python%{python_pkgversion}-straight-plugin ++Requires: python%{python_pkgversion}-whitenoise + Requires: python%{python_pkgversion}-wtforms + %endif + +@@ -365,22 +366,12 @@ sed -e "s|#!/usr/bin/env python|#!%{__python}|" -i \ + # Switch interpreter for systemd units + sed -e "s|/usr/bin/python|%{__python}|g" -i $RPM_BUILD_ROOT/%{_unitdir}/*.service + +-%if 0%{?rhel} && 0%{?rhel} < 8 +-# Change to correct static file path for apache httpd and nginx +-sed -e "s/pythonX.Y/python%{python2_version}/g" -i \ +- $RPM_BUILD_ROOT/%{_sysconfdir}/httpd/conf.d/pagure.conf \ +- $RPM_BUILD_ROOT/%{_sysconfdir}/nginx/conf.d/pagure.conf +-%else ++%if ! (0%{?rhel} && 0%{?rhel} < 8) + # Switch all systemd units to use the correct celery + sed -e "s|/usr/bin/celery|/usr/bin/celery-3|g" -i $RPM_BUILD_ROOT/%{_unitdir}/*.service + + # Switch all systemd units to use the correct gunicorn + sed -e "s|/usr/bin/gunicorn|/usr/bin/gunicorn-3|g" -i $RPM_BUILD_ROOT/%{_unitdir}/*.service +- +-# Change to correct static file path for apache httpd and nginx +-sed -e "s/pythonX.Y/python%{python3_version}/g" -i \ +- $RPM_BUILD_ROOT/%{_sysconfdir}/httpd/conf.d/pagure.conf \ +- $RPM_BUILD_ROOT/%{_sysconfdir}/nginx/conf.d/pagure.conf + %endif + + # Make log directories +diff --git a/pagure/docs_server.py b/pagure/docs_server.py +index fd7b2778..dc5e297b 100644 +--- a/pagure/docs_server.py ++++ b/pagure/docs_server.py +@@ -17,6 +17,7 @@ import flask + import pygit2 + + from binaryornot.helpers import is_binary_string ++from whitenoise import WhiteNoise + + import pagure.config + import pagure.doc_utils +@@ -29,6 +30,14 @@ import pagure.forms + # Create the application. + APP = flask.Flask(__name__) + ++# Setup WhiteNoise for serving static files ++here = os.path.abspath( ++ os.path.join(os.path.dirname(os.path.abspath(__file__))) ++) ++APP.wsgi_app = WhiteNoise( ++ APP.wsgi_app, root=os.path.join(here, "static"), prefix="/static" ++) ++ + # set up FAS + APP.config = pagure.config.reload_config() + +diff --git a/pagure/flask_app.py b/pagure/flask_app.py +index 7d533b63..34eb4783 100644 +--- a/pagure/flask_app.py ++++ b/pagure/flask_app.py +@@ -21,6 +21,8 @@ import warnings + import flask + import pygit2 + ++from whitenoise import WhiteNoise ++ + import pagure.doc_utils + import pagure.exceptions + import pagure.forms +@@ -188,6 +190,11 @@ def create_app(config=None): + app.jinja_loader = jinja2.ChoiceLoader(templ_loaders) + app.register_blueprint(themeblueprint) + ++ # Setup WhiteNoise for serving static files ++ app.wsgi_app = WhiteNoise( ++ app.wsgi_app, root=os.path.join(here, "static"), prefix="/static" ++ ) ++ + app.before_request(set_request) + app.after_request(after_request) + app.teardown_request(end_request) +diff --git a/requirements.txt b/requirements.txt +index dcde36ce..fa538676 100644 +--- a/requirements.txt ++++ b/requirements.txt +@@ -33,6 +33,7 @@ sqlalchemy >= 0.8 + # 1.4.0 is broken, 1.4.0-post-1 works but gives odd results on newer setuptools + # the latest version 1.5.0 is also known to work + straight.plugin ++whitenoise + wtforms + + # Required only for the `oidc` authentication backend +-- +2.26.2 + diff --git a/pagure-5.0-default-example-cfg.patch b/pagure-5.0-default-example-cfg.patch index 70325e0..fbe0ebd 100644 --- a/pagure-5.0-default-example-cfg.patch +++ b/pagure-5.0-default-example-cfg.patch @@ -1,6 +1,6 @@ diff -rup pagure/files/gitolite3.rc pagure.cfg-defs/files/gitolite3.rc ---- pagure/files/gitolite3.rc 2020-05-08 21:32:56.673172022 -0400 -+++ pagure.cfg-defs/files/gitolite3.rc 2020-05-08 21:37:03.018641878 -0400 +--- pagure/files/gitolite3.rc 2020-06-21 09:19:34.924187087 -0400 ++++ pagure.cfg-defs/files/gitolite3.rc 2020-06-21 09:20:06.922455887 -0400 @@ -16,7 +16,7 @@ # ------------------------------------------------------------------ @@ -11,8 +11,8 @@ diff -rup pagure/files/gitolite3.rc pagure.cfg-defs/files/gitolite3.rc # default umask gives you perms of '0700'; see the rc file docs for # how/why you might change this diff -rup pagure/files/pagure-apache-httpd.conf pagure.cfg-defs/files/pagure-apache-httpd.conf ---- pagure/files/pagure-apache-httpd.conf 2020-05-08 21:33:38.860594994 -0400 -+++ pagure.cfg-defs/files/pagure-apache-httpd.conf 2020-05-08 21:39:33.815153778 -0400 +--- pagure/files/pagure-apache-httpd.conf 2020-06-21 09:19:34.926187104 -0400 ++++ pagure.cfg-defs/files/pagure-apache-httpd.conf 2020-06-21 09:20:06.923455896 -0400 @@ -29,9 +29,9 @@ ## Use secure TLSv1.1 and TLSv1.2 ciphers #Header always add Strict-Transport-Security "max-age=15768000; includeSubDomains; preload" @@ -24,9 +24,9 @@ diff -rup pagure/files/pagure-apache-httpd.conf pagure.cfg-defs/files/pagure-apa + #SSLCertificateChainFile /etc/ssl/....intermediate.crt + #SSLCertificateKeyFile /etc/ssl/....key - #Alias /static /usr/lib/pythonX.Y/site-packages/pagure/static/ - -@@ -60,9 +60,9 @@ + # + #WSGIProcessGroup paguredocs +@@ -58,9 +58,9 @@ ## Use secure TLSv1.1 and TLSv1.2 ciphers #Header always add Strict-Transport-Security "max-age=15768000; includeSubDomains; preload" @@ -37,9 +37,9 @@ diff -rup pagure/files/pagure-apache-httpd.conf pagure.cfg-defs/files/pagure-apa + #SSLCertificateChainFile /etc/ssl/....intermediate.crt + #SSLCertificateKeyFile /etc/ssl/....key - #Alias /static /usr/lib/pythonX.Y/site-packages/pagure/static/ #Alias /releases /var/www/releases -@@ -97,7 +97,7 @@ + +@@ -94,7 +94,7 @@ # # @@ -49,8 +49,8 @@ diff -rup pagure/files/pagure-apache-httpd.conf pagure.cfg-defs/files/pagure-apa # diff -rup pagure/files/pagure.cfg.sample pagure.cfg-defs/files/pagure.cfg.sample ---- pagure/files/pagure.cfg.sample 2020-05-08 21:32:56.679172082 -0400 -+++ pagure.cfg-defs/files/pagure.cfg.sample 2020-05-08 22:03:36.961622933 -0400 +--- pagure/files/pagure.cfg.sample 2020-06-21 09:19:34.927187112 -0400 ++++ pagure.cfg-defs/files/pagure.cfg.sample 2020-06-21 09:20:06.923455896 -0400 @@ -72,25 +72,33 @@ DOC_APP_URL = 'http://docs.localhost.loc ### The URL to use to clone git repositories. @@ -121,10 +121,9 @@ diff -rup pagure/files/pagure.cfg.sample pagure.cfg-defs/files/pagure.cfg.sample ### Path to the gitolite.rc file GL_RC = None -Only in pagure.cfg-defs/files: pagure.cfg.sample.orig diff -rup pagure/files/pagure_docs_web.service pagure.cfg-defs/files/pagure_docs_web.service ---- pagure/files/pagure_docs_web.service 2020-05-08 21:33:38.862595014 -0400 -+++ pagure.cfg-defs/files/pagure_docs_web.service 2020-05-08 21:41:42.996448966 -0400 +--- pagure/files/pagure_docs_web.service 2020-06-21 09:19:34.928187121 -0400 ++++ pagure.cfg-defs/files/pagure_docs_web.service 2020-06-21 09:20:06.924455904 -0400 @@ -5,7 +5,7 @@ Documentation=https://pagure.io/pagure @@ -135,8 +134,8 @@ diff -rup pagure/files/pagure_docs_web.service pagure.cfg-defs/files/pagure_docs User=git Group=git diff -rup pagure/files/pagure-nginx.conf pagure.cfg-defs/files/pagure-nginx.conf ---- pagure/files/pagure-nginx.conf 2020-05-08 21:33:38.860594994 -0400 -+++ pagure.cfg-defs/files/pagure-nginx.conf 2020-05-08 21:43:48.199704257 -0400 +--- pagure/files/pagure-nginx.conf 2020-06-21 09:19:34.926187104 -0400 ++++ pagure.cfg-defs/files/pagure-nginx.conf 2020-06-21 09:20:06.924455904 -0400 @@ -12,15 +12,15 @@ #access_log /var/log/nginx/pagure_docs.access.log; #error_log /var/log/nginx/pagure_docs.error.log; @@ -156,7 +155,7 @@ diff -rup pagure/files/pagure-nginx.conf pagure.cfg-defs/files/pagure-nginx.conf #} #location / { -@@ -48,15 +48,15 @@ +@@ -43,15 +43,15 @@ #access_log /var/log/nginx/pagure.access.log; #error_log /var/log/nginx/pagure.error.log; @@ -175,7 +174,7 @@ diff -rup pagure/files/pagure-nginx.conf pagure.cfg-defs/files/pagure-nginx.conf #} #location / { -@@ -68,7 +68,7 @@ +@@ -59,7 +59,7 @@ #} #location /releases { @@ -185,8 +184,8 @@ diff -rup pagure/files/pagure-nginx.conf pagure.cfg-defs/files/pagure-nginx.conf #} diff -rup pagure/files/pagure_web.service pagure.cfg-defs/files/pagure_web.service ---- pagure/files/pagure_web.service 2020-05-08 21:33:38.862595014 -0400 -+++ pagure.cfg-defs/files/pagure_web.service 2020-05-08 21:41:26.941287994 -0400 +--- pagure/files/pagure_web.service 2020-06-21 09:19:34.928187121 -0400 ++++ pagure.cfg-defs/files/pagure_web.service 2020-06-21 09:20:06.924455904 -0400 @@ -5,7 +5,7 @@ Documentation=https://pagure.io/pagure diff --git a/pagure.changes b/pagure.changes index 502e39f..6accf4f 100644 --- a/pagure.changes +++ b/pagure.changes @@ -1,3 +1,30 @@ +------------------------------------------------------------------- +Sun Jun 21 12:57:17 UTC 2020 - Neal Gompa + +- Backport fixes for STARTTLS support + + Patch: 0002-starttls-support-via-SMTP_STARTTLS-provide-additiona.patch + + Patch: 0001-Do-not-assume-there-is-a-SMTP_STARTTLS-configuration.patch +- Backport fix for docs repo access grant + + Patch: 0001-Fix-repotype-spelling.patch +- Backport fix for visual bug on API docs formatting + + Patch: 0001-api-fix-apidoc-format-on-api_view_issues_history_det.patch +- Backport fix to changing pull mirror settings + + Patch: 0001-Allow-editing-the-URL-a-project-is-mirrored-from.patch +- Backport fix to add descriptions to API scopes + + Patch: 0001-Show-the-ACL-name-in-addition-to-the-description-whe.patch +- Backport fix to make heatmap UI functional again + + Patch: 0001-Bring-back-JS-library-used-for-the-heatmap.patch +- Backport fix for handling headers + + Patch: 0001-Ensure-the-title-name-of-the-headers-are-strings.patch +- Backport fix for burndown graph title + + Patch: 0001-Fix-the-title-of-the-graph-showing-the-evolution-of-.patch +- Backport fix for permissions on authorized_keys file + + Patch: 0001-Make-sure-authorized_keys-file-has-mode-600.patch +- Add patch to use whitenoise for rendering static assets + + Patch: 0101-Use-WhiteNoise-to-serve-static-assets-for-the-Pagure.patch +- Refresh default configuration patch + + Patch: pagure-5.0-default-example-cfg.patch + ------------------------------------------------------------------- Wed May 20 23:34:26 UTC 2020 - Neal Gompa diff --git a/pagure.spec b/pagure.spec index 759e050..85cb30a 100644 --- a/pagure.spec +++ b/pagure.spec @@ -40,11 +40,35 @@ Source1: https://raw.githubusercontent.com/fedora-infra/python-fedora # SUSE-specific README providing a quickstart guide Source10: pagure-README.SUSE + # Backports from upstream ## Backport fix to make stats page work Patch0001: 0001-Make-the-stats-page-use-the-new-stats-API-endpoint.patch ## Backport support for STARTTLS support for SMTP servers Patch0002: 0001-Add-support-for-smtp-server-requiring-starttls-to-wo.patch +Patch0003: 0002-starttls-support-via-SMTP_STARTTLS-provide-additiona.patch +Patch0004: 0001-Do-not-assume-there-is-a-SMTP_STARTTLS-configuration.patch +## Fix access grants for docs repo +Patch0005: 0001-Fix-repotype-spelling.patch +## Fix visual bug on api documentation formatting +Patch0006: 0001-api-fix-apidoc-format-on-api_view_issues_history_det.patch +## Add setting for changing pull mirror source for projects +Patch0007: 0001-Allow-editing-the-URL-a-project-is-mirrored-from.patch +## Add descriptions to API scopes listed at API token creation page +Patch0008: 0001-Show-the-ACL-name-in-addition-to-the-description-whe.patch +## Restore heatmap JS library +Patch0009: 0001-Bring-back-JS-library-used-for-the-heatmap.patch +## Ensure header keys are rendered as strings +Patch0010: 0001-Ensure-the-title-name-of-the-headers-are-strings.patch +## Fix title of burndown graph +Patch0011: 0001-Fix-the-title-of-the-graph-showing-the-evolution-of-.patch +## Fix permissions for generated authorized_keys file +Patch0012: 0001-Make-sure-authorized_keys-file-has-mode-600.patch + +# Changes proposed upstream +## Use whitenoise to render static assets +## From: https://pagure.io/pagure/pull-request/4885 +Patch0101: 0101-Use-WhiteNoise-to-serve-static-assets-for-the-Pagure.patch # SUSE-specific fixes ## Change the defaults in the example config to match packaging @@ -86,6 +110,7 @@ BuildRequires: python3-straight-plugin BuildRequires: python3-WTForms BuildRequires: python3-munch BuildRequires: python3-redis +BuildRequires: python3-whitenoise # We require OpenSSH 7.4+ for SHA256 support Requires: openssh >= 7.4 @@ -116,6 +141,7 @@ Requires: python3-straight-plugin Requires: python3-WTForms Requires: python3-munch Requires: python3-redis +Requires: python3-whitenoise # Required for celery Requires: python3-pytz @@ -464,11 +490,6 @@ sed -e "s|#!/usr/bin/env python|#!%{__python3}|" -i \ # Switch interpreter for systemd units to correct Python interpreter sed -e "s|/usr/bin/python|%{__python3}|g" -i %{buildroot}/%{_unitdir}/*.service -# Change to correct static file path for apache httpd and nginx -sed -e "s/pythonX.Y/python%{python3_version}/g" -i \ - %{buildroot}/%{_sysconfdir}/apache2/vhosts.d/pagure.conf \ - %{buildroot}/%{_sysconfdir}/nginx/vhosts.d/pagure.conf - # Make symlinks for default theme packages mv %{buildroot}/%{python3_sitelib}/pagure/themes/default %{buildroot}/%{python3_sitelib}/pagure/themes/upstream ln -sr %{buildroot}/%{python3_sitelib}/pagure/themes/upstream %{buildroot}/%{python3_sitelib}/pagure/themes/default