Custom build of D3 with d3-jetpack-module and geoNaturalEarth
To modify:
- add or remove packages in index.js
npm run build
Forked from D3 Custom Bundle II
.DS_Store | |
node_modules | |
npm-debug.log |
Custom build of D3 with d3-jetpack-module and geoNaturalEarth
To modify:
npm run build
Forked from D3 Custom Bundle II
(function (global, factory) { | |
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
(factory((global.d3 = global.d3 || {}))); | |
}(this, (function (exports) { 'use strict'; | |
var version = "4.4.0"; | |
function ascending(a, b) { | |
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
} | |
function bisector(compare) { | |
if (compare.length === 1) compare = ascendingComparator(compare); | |
return { | |
left: function(a, x, lo, hi) { | |
if (lo == null) lo = 0; | |
if (hi == null) 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 (lo == null) lo = 0; | |
if (hi == null) 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; | |
} | |
}; | |
} | |
function ascendingComparator(f) { | |
return function(d, x) { | |
return ascending(f(d), x); | |
}; | |
} | |
var ascendingBisect = bisector(ascending); | |
var bisectRight = ascendingBisect.right; | |
var bisectLeft = ascendingBisect.left; | |
function descending(a, b) { | |
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; | |
} | |
function number(x) { | |
return x === null ? NaN : +x; | |
} | |
function variance(array, f) { | |
var n = array.length, | |
m = 0, | |
a, | |
d, | |
s = 0, | |
i = -1, | |
j = 0; | |
if (f == null) { | |
while (++i < n) { | |
if (!isNaN(a = number(array[i]))) { | |
d = a - m; | |
m += d / ++j; | |
s += d * (a - m); | |
} | |
} | |
} | |
else { | |
while (++i < n) { | |
if (!isNaN(a = number(f(array[i], i, array)))) { | |
d = a - m; | |
m += d / ++j; | |
s += d * (a - m); | |
} | |
} | |
} | |
if (j > 1) return s / (j - 1); | |
} | |
function deviation(array, f) { | |
var v = variance(array, f); | |
return v ? Math.sqrt(v) : v; | |
} | |
function extent(array, f) { | |
var i = -1, | |
n = array.length, | |
a, | |
b, | |
c; | |
if (f == null) { | |
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(array[i], i, array)) != null && b >= b) { a = c = b; break; } | |
while (++i < n) if ((b = f(array[i], i, array)) != null) { | |
if (a > b) a = b; | |
if (c < b) c = b; | |
} | |
} | |
return [a, c]; | |
} | |
var array = Array.prototype; | |
var slice = array.slice; | |
var map = array.map; | |
function constant(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function identity(x) { | |
return x; | |
} | |
function range(start, stop, step) { | |
start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; | |
var i = -1, | |
n = Math.max(0, Math.ceil((stop - start) / step)) | 0, | |
range = new Array(n); | |
while (++i < n) { | |
range[i] = start + i * step; | |
} | |
return range; | |
} | |
var e10 = Math.sqrt(50); | |
var e5 = Math.sqrt(10); | |
var e2 = Math.sqrt(2); | |
function ticks(start, stop, count) { | |
var step = tickStep(start, stop, count); | |
return range( | |
Math.ceil(start / step) * step, | |
Math.floor(stop / step) * step + step / 2, // inclusive | |
step | |
); | |
} | |
function tickStep(start, stop, count) { | |
var step0 = Math.abs(stop - start) / Math.max(0, count), | |
step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), | |
error = step0 / step1; | |
if (error >= e10) step1 *= 10; | |
else if (error >= e5) step1 *= 5; | |
else if (error >= e2) step1 *= 2; | |
return stop < start ? -step1 : step1; | |
} | |
function sturges(values) { | |
return Math.ceil(Math.log(values.length) / Math.LN2) + 1; | |
} | |
function histogram() { | |
var value = identity, | |
domain = extent, | |
threshold = sturges; | |
function histogram(data) { | |
var i, | |
n = data.length, | |
x, | |
values = new Array(n); | |
for (i = 0; i < n; ++i) { | |
values[i] = value(data[i], i, data); | |
} | |
var xz = domain(values), | |
x0 = xz[0], | |
x1 = xz[1], | |
tz = threshold(values, x0, x1); | |
// Convert number of thresholds into uniform thresholds. | |
if (!Array.isArray(tz)) tz = ticks(x0, x1, tz); | |
// Remove any thresholds outside the domain. | |
var m = tz.length; | |
while (tz[0] <= x0) tz.shift(), --m; | |
while (tz[m - 1] >= x1) tz.pop(), --m; | |
var bins = new Array(m + 1), | |
bin; | |
// Initialize bins. | |
for (i = 0; i <= m; ++i) { | |
bin = bins[i] = []; | |
bin.x0 = i > 0 ? tz[i - 1] : x0; | |
bin.x1 = i < m ? tz[i] : x1; | |
} | |
// Assign data to bins by value, ignoring any outside the domain. | |
for (i = 0; i < n; ++i) { | |
x = values[i]; | |
if (x0 <= x && x <= x1) { | |
bins[bisectRight(tz, x, 0, m)].push(data[i]); | |
} | |
} | |
return bins; | |
} | |
histogram.value = function(_) { | |
return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value; | |
}; | |
histogram.domain = function(_) { | |
return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain; | |
}; | |
histogram.thresholds = function(_) { | |
return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold; | |
}; | |
return histogram; | |
} | |
function threshold(array, p, f) { | |
if (f == null) f = number; | |
if (!(n = array.length)) return; | |
if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array); | |
if (p >= 1) return +f(array[n - 1], n - 1, array); | |
var n, | |
h = (n - 1) * p, | |
i = Math.floor(h), | |
a = +f(array[i], i, array), | |
b = +f(array[i + 1], i + 1, array); | |
return a + (b - a) * (h - i); | |
} | |
function freedmanDiaconis(values, min, max) { | |
values = map.call(values, number).sort(ascending); | |
return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3))); | |
} | |
function scott(values, min, max) { | |
return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3))); | |
} | |
function max(array, f) { | |
var i = -1, | |
n = array.length, | |
a, | |
b; | |
if (f == null) { | |
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(array[i], i, array)) != null && b >= b) { a = b; break; } | |
while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b; | |
} | |
return a; | |
} | |
function mean(array, f) { | |
var s = 0, | |
n = array.length, | |
a, | |
i = -1, | |
j = n; | |
if (f == null) { | |
while (++i < n) if (!isNaN(a = number(array[i]))) s += a; else --j; | |
} | |
else { | |
while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) s += a; else --j; | |
} | |
if (j) return s / j; | |
} | |
function median(array, f) { | |
var numbers = [], | |
n = array.length, | |
a, | |
i = -1; | |
if (f == null) { | |
while (++i < n) if (!isNaN(a = number(array[i]))) numbers.push(a); | |
} | |
else { | |
while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) numbers.push(a); | |
} | |
return threshold(numbers.sort(ascending), 0.5); | |
} | |
function merge(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; | |
} | |
function min(array, f) { | |
var i = -1, | |
n = array.length, | |
a, | |
b; | |
if (f == null) { | |
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(array[i], i, array)) != null && b >= b) { a = b; break; } | |
while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b; | |
} | |
return a; | |
} | |
function pairs(array) { | |
var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n); | |
while (i < n) pairs[i] = [p, p = array[++i]]; | |
return pairs; | |
} | |
function permute(array, indexes) { | |
var i = indexes.length, permutes = new Array(i); | |
while (i--) permutes[i] = array[indexes[i]]; | |
return permutes; | |
} | |
function scan(array, compare) { | |
if (!(n = array.length)) return; | |
var i = 0, | |
n, | |
j = 0, | |
xi, | |
xj = array[j]; | |
if (!compare) compare = ascending; | |
while (++i < n) if (compare(xi = array[i], xj) < 0 || compare(xj, xj) !== 0) xj = xi, j = i; | |
if (compare(xj, xj) === 0) return j; | |
} | |
function shuffle(array, i0, i1) { | |
var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +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; | |
} | |
function sum(array, f) { | |
var s = 0, | |
n = array.length, | |
a, | |
i = -1; | |
if (f == null) { | |
while (++i < n) if (a = +array[i]) s += a; // Note: zero and null are equivalent. | |
} | |
else { | |
while (++i < n) if (a = +f(array[i], i, array)) s += a; | |
} | |
return s; | |
} | |
function transpose(matrix) { | |
if (!(n = matrix.length)) return []; | |
for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) { | |
for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) { | |
row[j] = matrix[j][i]; | |
} | |
} | |
return transpose; | |
} | |
function length(d) { | |
return d.length; | |
} | |
function zip() { | |
return transpose(arguments); | |
} | |
var prefix = "$"; | |
function Map() {} | |
Map.prototype = map$1.prototype = { | |
constructor: Map, | |
has: function(key) { | |
return (prefix + key) in this; | |
}, | |
get: function(key) { | |
return this[prefix + key]; | |
}, | |
set: function(key, value) { | |
this[prefix + key] = value; | |
return this; | |
}, | |
remove: function(key) { | |
var property = prefix + key; | |
return property in this && delete this[property]; | |
}, | |
clear: function() { | |
for (var property in this) if (property[0] === prefix) delete this[property]; | |
}, | |
keys: function() { | |
var keys = []; | |
for (var property in this) if (property[0] === prefix) keys.push(property.slice(1)); | |
return keys; | |
}, | |
values: function() { | |
var values = []; | |
for (var property in this) if (property[0] === prefix) values.push(this[property]); | |
return values; | |
}, | |
entries: function() { | |
var entries = []; | |
for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]}); | |
return entries; | |
}, | |
size: function() { | |
var size = 0; | |
for (var property in this) if (property[0] === prefix) ++size; | |
return size; | |
}, | |
empty: function() { | |
for (var property in this) if (property[0] === prefix) return false; | |
return true; | |
}, | |
each: function(f) { | |
for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this); | |
} | |
}; | |
function map$1(object, f) { | |
var map = new Map; | |
// Copy constructor. | |
if (object instanceof Map) object.each(function(value, key) { map.set(key, value); }); | |
// Index array by numeric index or specified key function. | |
else if (Array.isArray(object)) { | |
var i = -1, | |
n = object.length, | |
o; | |
if (f == null) while (++i < n) map.set(i, object[i]); | |
else while (++i < n) map.set(f(o = object[i], i, object), o); | |
} | |
// Convert object to map. | |
else if (object) for (var key in object) map.set(key, object[key]); | |
return map; | |
} | |
function nest() { | |
var keys = [], | |
sortKeys = [], | |
sortValues, | |
rollup, | |
nest; | |
function apply(array, depth, createResult, setResult) { | |
if (depth >= keys.length) return rollup != null | |
? rollup(array) : (sortValues != null | |
? array.sort(sortValues) | |
: array); | |
var i = -1, | |
n = array.length, | |
key = keys[depth++], | |
keyValue, | |
value, | |
valuesByKey = map$1(), | |
values, | |
result = createResult(); | |
while (++i < n) { | |
if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) { | |
values.push(value); | |
} else { | |
valuesByKey.set(keyValue, [value]); | |
} | |
} | |
valuesByKey.each(function(values, key) { | |
setResult(result, key, apply(values, depth, createResult, setResult)); | |
}); | |
return result; | |
} | |
function entries(map, depth) { | |
if (++depth > keys.length) return map; | |
var array, sortKey = sortKeys[depth - 1]; | |
if (rollup != null && depth >= keys.length) array = map.entries(); | |
else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); }); | |
return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array; | |
} | |
return nest = { | |
object: function(array) { return apply(array, 0, createObject, setObject); }, | |
map: function(array) { return apply(array, 0, createMap, setMap); }, | |
entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); }, | |
key: function(d) { keys.push(d); return nest; }, | |
sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; }, | |
sortValues: function(order) { sortValues = order; return nest; }, | |
rollup: function(f) { rollup = f; return nest; } | |
}; | |
} | |
function createObject() { | |
return {}; | |
} | |
function setObject(object, key, value) { | |
object[key] = value; | |
} | |
function createMap() { | |
return map$1(); | |
} | |
function setMap(map, key, value) { | |
map.set(key, value); | |
} | |
function Set() {} | |
var proto = map$1.prototype; | |
Set.prototype = set.prototype = { | |
constructor: Set, | |
has: proto.has, | |
add: function(value) { | |
value += ""; | |
this[prefix + value] = value; | |
return this; | |
}, | |
remove: proto.remove, | |
clear: proto.clear, | |
values: proto.keys, | |
size: proto.size, | |
empty: proto.empty, | |
each: proto.each | |
}; | |
function set(object, f) { | |
var set = new Set; | |
// Copy constructor. | |
if (object instanceof Set) object.each(function(value) { set.add(value); }); | |
// Otherwise, assume it’s an array. | |
else if (object) { | |
var i = -1, n = object.length; | |
if (f == null) while (++i < n) set.add(object[i]); | |
else while (++i < n) set.add(f(object[i], i, object)); | |
} | |
return set; | |
} | |
function d3keys(map) { | |
var keys = []; | |
for (var key in map) keys.push(key); | |
return keys; | |
} | |
function values(map) { | |
var values = []; | |
for (var key in map) values.push(map[key]); | |
return values; | |
} | |
function entries(map) { | |
var entries = []; | |
for (var key in map) entries.push({key: key, value: map[key]}); | |
return entries; | |
} | |
function uniform(min, max) { | |
min = min == null ? 0 : +min; | |
max = max == null ? 1 : +max; | |
if (arguments.length === 1) max = min, min = 0; | |
else max -= min; | |
return function() { | |
return Math.random() * max + min; | |
}; | |
} | |
function normal(mu, sigma) { | |
var x, r; | |
mu = mu == null ? 0 : +mu; | |
sigma = sigma == null ? 1 : +sigma; | |
return function() { | |
var y; | |
// If available, use the second previously-generated uniform random. | |
if (x != null) y = x, x = null; | |
// Otherwise, generate a new x and y. | |
else do { | |
x = Math.random() * 2 - 1; | |
y = Math.random() * 2 - 1; | |
r = x * x + y * y; | |
} while (!r || r > 1); | |
return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r); | |
}; | |
} | |
function logNormal() { | |
var randomNormal = normal.apply(this, arguments); | |
return function() { | |
return Math.exp(randomNormal()); | |
}; | |
} | |
function irwinHall(n) { | |
return function() { | |
for (var sum = 0, i = 0; i < n; ++i) sum += Math.random(); | |
return sum; | |
}; | |
} | |
function bates(n) { | |
var randomIrwinHall = irwinHall(n); | |
return function() { | |
return randomIrwinHall() / n; | |
}; | |
} | |
function exponential(lambda) { | |
return function() { | |
return -Math.log(1 - Math.random()) / lambda; | |
}; | |
} | |
function linear(t) { | |
return +t; | |
} | |
function quadIn(t) { | |
return t * t; | |
} | |
function quadOut(t) { | |
return t * (2 - t); | |
} | |
function quadInOut(t) { | |
return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; | |
} | |
function cubicIn(t) { | |
return t * t * t; | |
} | |
function cubicOut(t) { | |
return --t * t * t + 1; | |
} | |
function easeCubicInOut(t) { | |
return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; | |
} | |
var exponent = 3; | |
var polyIn = (function custom(e) { | |
e = +e; | |
function polyIn(t) { | |
return Math.pow(t, e); | |
} | |
polyIn.exponent = custom; | |
return polyIn; | |
})(exponent); | |
var polyOut = (function custom(e) { | |
e = +e; | |
function polyOut(t) { | |
return 1 - Math.pow(1 - t, e); | |
} | |
polyOut.exponent = custom; | |
return polyOut; | |
})(exponent); | |
var polyInOut = (function custom(e) { | |
e = +e; | |
function polyInOut(t) { | |
return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; | |
} | |
polyInOut.exponent = custom; | |
return polyInOut; | |
})(exponent); | |
var pi = Math.PI; | |
var halfPi = pi / 2; | |
function sinIn(t) { | |
return 1 - Math.cos(t * halfPi); | |
} | |
function sinOut(t) { | |
return Math.sin(t * halfPi); | |
} | |
function sinInOut(t) { | |
return (1 - Math.cos(pi * t)) / 2; | |
} | |
function expIn(t) { | |
return Math.pow(2, 10 * t - 10); | |
} | |
function expOut(t) { | |
return 1 - Math.pow(2, -10 * t); | |
} | |
function expInOut(t) { | |
return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2; | |
} | |
function circleIn(t) { | |
return 1 - Math.sqrt(1 - t * t); | |
} | |
function circleOut(t) { | |
return Math.sqrt(1 - --t * t); | |
} | |
function circleInOut(t) { | |
return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2; | |
} | |
var b1 = 4 / 11; | |
var b2 = 6 / 11; | |
var b3 = 8 / 11; | |
var b4 = 3 / 4; | |
var b5 = 9 / 11; | |
var b6 = 10 / 11; | |
var b7 = 15 / 16; | |
var b8 = 21 / 22; | |
var b9 = 63 / 64; | |
var b0 = 1 / b1 / b1; | |
function bounceIn(t) { | |
return 1 - bounceOut(1 - t); | |
} | |
function bounceOut(t) { | |
return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9; | |
} | |
function bounceInOut(t) { | |
return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2; | |
} | |
var overshoot = 1.70158; | |
var backIn = (function custom(s) { | |
s = +s; | |
function backIn(t) { | |
return t * t * ((s + 1) * t - s); | |
} | |
backIn.overshoot = custom; | |
return backIn; | |
})(overshoot); | |
var backOut = (function custom(s) { | |
s = +s; | |
function backOut(t) { | |
return --t * t * ((s + 1) * t + s) + 1; | |
} | |
backOut.overshoot = custom; | |
return backOut; | |
})(overshoot); | |
var backInOut = (function custom(s) { | |
s = +s; | |
function backInOut(t) { | |
return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; | |
} | |
backInOut.overshoot = custom; | |
return backInOut; | |
})(overshoot); | |
var tau = 2 * Math.PI; | |
var amplitude = 1; | |
var period = 0.3; | |
var elasticIn = (function custom(a, p) { | |
var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
function elasticIn(t) { | |
return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p); | |
} | |
elasticIn.amplitude = function(a) { return custom(a, p * tau); }; | |
elasticIn.period = function(p) { return custom(a, p); }; | |
return elasticIn; | |
})(amplitude, period); | |
var elasticOut = (function custom(a, p) { | |
var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
function elasticOut(t) { | |
return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p); | |
} | |
elasticOut.amplitude = function(a) { return custom(a, p * tau); }; | |
elasticOut.period = function(p) { return custom(a, p); }; | |
return elasticOut; | |
})(amplitude, period); | |
var elasticInOut = (function custom(a, p) { | |
var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
function elasticInOut(t) { | |
return ((t = t * 2 - 1) < 0 | |
? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p) | |
: 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2; | |
} | |
elasticInOut.amplitude = function(a) { return custom(a, p * tau); }; | |
elasticInOut.period = function(p) { return custom(a, p); }; | |
return elasticInOut; | |
})(amplitude, period); | |
function area(polygon) { | |
var i = -1, | |
n = polygon.length, | |
a, | |
b = polygon[n - 1], | |
area = 0; | |
while (++i < n) { | |
a = b; | |
b = polygon[i]; | |
area += a[1] * b[0] - a[0] * b[1]; | |
} | |
return area / 2; | |
} | |
function centroid(polygon) { | |
var i = -1, | |
n = polygon.length, | |
x = 0, | |
y = 0, | |
a, | |
b = polygon[n - 1], | |
c, | |
k = 0; | |
while (++i < n) { | |
a = b; | |
b = polygon[i]; | |
k += c = a[0] * b[1] - b[0] * a[1]; | |
x += (a[0] + b[0]) * c; | |
y += (a[1] + b[1]) * c; | |
} | |
return k *= 3, [x / k, y / k]; | |
} | |
// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of | |
// the 3D cross product in a quadrant I Cartesian coordinate system (+x is | |
// right, +y is up). Returns a positive value if ABC is counter-clockwise, | |
// negative if clockwise, and zero if the points are collinear. | |
function cross(a, b, c) { | |
return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); | |
} | |
function lexicographicOrder(a, b) { | |
return a[0] - b[0] || a[1] - b[1]; | |
} | |
// Computes the upper convex hull per the monotone chain algorithm. | |
// Assumes points.length >= 3, is sorted by x, unique in y. | |
// Returns an array of indices into points in left-to-right order. | |
function computeUpperHullIndexes(points) { | |
var n = points.length, | |
indexes = [0, 1], | |
size = 2; | |
for (var i = 2; i < n; ++i) { | |
while (size > 1 && cross(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size; | |
indexes[size++] = i; | |
} | |
return indexes.slice(0, size); // remove popped points | |
} | |
function hull(points) { | |
if ((n = points.length) < 3) return null; | |
var i, | |
n, | |
sortedPoints = new Array(n), | |
flippedPoints = new Array(n); | |
for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i]; | |
sortedPoints.sort(lexicographicOrder); | |
for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]]; | |
var upperIndexes = computeUpperHullIndexes(sortedPoints), | |
lowerIndexes = computeUpperHullIndexes(flippedPoints); | |
// Construct the hull polygon, removing possible duplicate endpoints. | |
var skipLeft = lowerIndexes[0] === upperIndexes[0], | |
skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1], | |
hull = []; | |
// Add upper hull in right-to-l order. | |
// Then add lower hull in left-to-right order. | |
for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]); | |
for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]); | |
return hull; | |
} | |
function contains(polygon, point) { | |
var n = polygon.length, | |
p = polygon[n - 1], | |
x = point[0], y = point[1], | |
x0 = p[0], y0 = p[1], | |
x1, y1, | |
inside = false; | |
for (var i = 0; i < n; ++i) { | |
p = polygon[i], x1 = p[0], y1 = p[1]; | |
if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside; | |
x0 = x1, y0 = y1; | |
} | |
return inside; | |
} | |
function length$1(polygon) { | |
var i = -1, | |
n = polygon.length, | |
b = polygon[n - 1], | |
xa, | |
ya, | |
xb = b[0], | |
yb = b[1], | |
perimeter = 0; | |
while (++i < n) { | |
xa = xb; | |
ya = yb; | |
b = polygon[i]; | |
xb = b[0]; | |
yb = b[1]; | |
xa -= xb; | |
ya -= yb; | |
perimeter += Math.sqrt(xa * xa + ya * ya); | |
} | |
return perimeter; | |
} | |
var pi$1 = Math.PI; | |
var tau$1 = 2 * pi$1; | |
var epsilon = 1e-6; | |
var tauEpsilon = tau$1 - epsilon; | |
function Path() { | |
this._x0 = this._y0 = // start of current subpath | |
this._x1 = this._y1 = null; // end of current subpath | |
this._ = ""; | |
} | |
function path() { | |
return new Path; | |
} | |
Path.prototype = path.prototype = { | |
constructor: Path, | |
moveTo: function(x, y) { | |
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y); | |
}, | |
closePath: function() { | |
if (this._x1 !== null) { | |
this._x1 = this._x0, this._y1 = this._y0; | |
this._ += "Z"; | |
} | |
}, | |
lineTo: function(x, y) { | |
this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y); | |
}, | |
quadraticCurveTo: function(x1, y1, x, y) { | |
this._ += "Q" + (+x1) + "," + (+y1) + "," + (this._x1 = +x) + "," + (this._y1 = +y); | |
}, | |
bezierCurveTo: function(x1, y1, x2, y2, x, y) { | |
this._ += "C" + (+x1) + "," + (+y1) + "," + (+x2) + "," + (+y2) + "," + (this._x1 = +x) + "," + (this._y1 = +y); | |
}, | |
arcTo: function(x1, y1, x2, y2, r) { | |
x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r; | |
var x0 = this._x1, | |
y0 = this._y1, | |
x21 = x2 - x1, | |
y21 = y2 - y1, | |
x01 = x0 - x1, | |
y01 = y0 - y1, | |
l01_2 = x01 * x01 + y01 * y01; | |
// Is the radius negative? Error. | |
if (r < 0) throw new Error("negative radius: " + r); | |
// Is this path empty? Move to (x1,y1). | |
if (this._x1 === null) { | |
this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1); | |
} | |
// Or, is (x1,y1) coincident with (x0,y0)? Do nothing. | |
else if (!(l01_2 > epsilon)) {} | |
// Or, are (x0,y0), (x1,y1) and (x2,y2) collinear? | |
// Equivalently, is (x1,y1) coincident with (x2,y2)? | |
// Or, is the radius zero? Line to (x1,y1). | |
else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) { | |
this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1); | |
} | |
// Otherwise, draw an arc! | |
else { | |
var x20 = x2 - x0, | |
y20 = y2 - y0, | |
l21_2 = x21 * x21 + y21 * y21, | |
l20_2 = x20 * x20 + y20 * y20, | |
l21 = Math.sqrt(l21_2), | |
l01 = Math.sqrt(l01_2), | |
l = r * Math.tan((pi$1 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), | |
t01 = l / l01, | |
t21 = l / l21; | |
// If the start tangent is not coincident with (x0,y0), line to. | |
if (Math.abs(t01 - 1) > epsilon) { | |
this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01); | |
} | |
this._ += "A" + r + "," + r + ",0,0," + (+(y01 * x20 > x01 * y20)) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21); | |
} | |
}, | |
arc: function(x, y, r, a0, a1, ccw) { | |
x = +x, y = +y, r = +r; | |
var dx = r * Math.cos(a0), | |
dy = r * Math.sin(a0), | |
x0 = x + dx, | |
y0 = y + dy, | |
cw = 1 ^ ccw, | |
da = ccw ? a0 - a1 : a1 - a0; | |
// Is the radius negative? Error. | |
if (r < 0) throw new Error("negative radius: " + r); | |
// Is this path empty? Move to (x0,y0). | |
if (this._x1 === null) { | |
this._ += "M" + x0 + "," + y0; | |
} | |
// Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0). | |
else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) { | |
this._ += "L" + x0 + "," + y0; | |
} | |
// Is this arc empty? We’re done. | |
if (!r) return; | |
// Is this a complete circle? Draw two arcs to complete the circle. | |
if (da > tauEpsilon) { | |
this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0); | |
} | |
// Otherwise, draw an arc! | |
else { | |
if (da < 0) da = da % tau$1 + tau$1; | |
this._ += "A" + r + "," + r + ",0," + (+(da >= pi$1)) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1)); | |
} | |
}, | |
rect: function(x, y, w, h) { | |
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + (+w) + "v" + (+h) + "h" + (-w) + "Z"; | |
}, | |
toString: function() { | |
return this._; | |
} | |
}; | |
function tree_add(d) { | |
var x = +this._x.call(null, d), | |
y = +this._y.call(null, d); | |
return add(this.cover(x, y), x, y, d); | |
} | |
function add(tree, x, y, d) { | |
if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points | |
var parent, | |
node = tree._root, | |
leaf = {data: d}, | |
x0 = tree._x0, | |
y0 = tree._y0, | |
x1 = tree._x1, | |
y1 = tree._y1, | |
xm, | |
ym, | |
xp, | |
yp, | |
right, | |
bottom, | |
i, | |
j; | |
// If the tree is empty, initialize the root as a leaf. | |
if (!node) return tree._root = leaf, tree; | |
// Find the existing leaf for the new point, or add it. | |
while (node.length) { | |
if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree; | |
} | |
// Is the new point is exactly coincident with the existing point? | |
xp = +tree._x.call(null, node.data); | |
yp = +tree._y.call(null, node.data); | |
if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree; | |
// Otherwise, split the leaf node until the old and new point are separated. | |
do { | |
parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4); | |
if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
} while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm))); | |
return parent[j] = node, parent[i] = leaf, tree; | |
} | |
function addAll(data) { | |
var d, i, n = data.length, | |
x, | |
y, | |
xz = new Array(n), | |
yz = new Array(n), | |
x0 = Infinity, | |
y0 = Infinity, | |
x1 = -Infinity, | |
y1 = -Infinity; | |
// Compute the points and their extent. | |
for (i = 0; i < n; ++i) { | |
if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue; | |
xz[i] = x; | |
yz[i] = y; | |
if (x < x0) x0 = x; | |
if (x > x1) x1 = x; | |
if (y < y0) y0 = y; | |
if (y > y1) y1 = y; | |
} | |
// If there were no (valid) points, inherit the existing extent. | |
if (x1 < x0) x0 = this._x0, x1 = this._x1; | |
if (y1 < y0) y0 = this._y0, y1 = this._y1; | |
// Expand the tree to cover the new points. | |
this.cover(x0, y0).cover(x1, y1); | |
// Add the new points. | |
for (i = 0; i < n; ++i) { | |
add(this, xz[i], yz[i], data[i]); | |
} | |
return this; | |
} | |
function tree_cover(x, y) { | |
if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points | |
var x0 = this._x0, | |
y0 = this._y0, | |
x1 = this._x1, | |
y1 = this._y1; | |
// If the quadtree has no extent, initialize them. | |
// Integer extent are necessary so that if we later double the extent, | |
// the existing quadrant boundaries don’t change due to floating point error! | |
if (isNaN(x0)) { | |
x1 = (x0 = Math.floor(x)) + 1; | |
y1 = (y0 = Math.floor(y)) + 1; | |
} | |
// Otherwise, double repeatedly to cover. | |
else if (x0 > x || x > x1 || y0 > y || y > y1) { | |
var z = x1 - x0, | |
node = this._root, | |
parent, | |
i; | |
switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) { | |
case 0: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1); | |
break; | |
} | |
case 1: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1); | |
break; | |
} | |
case 2: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y); | |
break; | |
} | |
case 3: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y); | |
break; | |
} | |
} | |
if (this._root && this._root.length) this._root = node; | |
} | |
// If the quadtree covers the point already, just return. | |
else return this; | |
this._x0 = x0; | |
this._y0 = y0; | |
this._x1 = x1; | |
this._y1 = y1; | |
return this; | |
} | |
function tree_data() { | |
var data = []; | |
this.visit(function(node) { | |
if (!node.length) do data.push(node.data); while (node = node.next) | |
}); | |
return data; | |
} | |
function tree_extent(_) { | |
return arguments.length | |
? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) | |
: isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]]; | |
} | |
function Quad(node, x0, y0, x1, y1) { | |
this.node = node; | |
this.x0 = x0; | |
this.y0 = y0; | |
this.x1 = x1; | |
this.y1 = y1; | |
} | |
function tree_find(x, y, radius) { | |
var data, | |
x0 = this._x0, | |
y0 = this._y0, | |
x1, | |
y1, | |
x2, | |
y2, | |
x3 = this._x1, | |
y3 = this._y1, | |
quads = [], | |
node = this._root, | |
q, | |
i; | |
if (node) quads.push(new Quad(node, x0, y0, x3, y3)); | |
if (radius == null) radius = Infinity; | |
else { | |
x0 = x - radius, y0 = y - radius; | |
x3 = x + radius, y3 = y + radius; | |
radius *= radius; | |
} | |
while (q = quads.pop()) { | |
// Stop searching if this quadrant can’t contain a closer node. | |
if (!(node = q.node) | |
|| (x1 = q.x0) > x3 | |
|| (y1 = q.y0) > y3 | |
|| (x2 = q.x1) < x0 | |
|| (y2 = q.y1) < y0) continue; | |
// Bisect the current quadrant. | |
if (node.length) { | |
var xm = (x1 + x2) / 2, | |
ym = (y1 + y2) / 2; | |
quads.push( | |
new Quad(node[3], xm, ym, x2, y2), | |
new Quad(node[2], x1, ym, xm, y2), | |
new Quad(node[1], xm, y1, x2, ym), | |
new Quad(node[0], x1, y1, xm, ym) | |
); | |
// Visit the closest quadrant first. | |
if (i = (y >= ym) << 1 | (x >= xm)) { | |
q = quads[quads.length - 1]; | |
quads[quads.length - 1] = quads[quads.length - 1 - i]; | |
quads[quads.length - 1 - i] = q; | |
} | |
} | |
// Visit this point. (Visiting coincident points isn’t necessary!) | |
else { | |
var dx = x - +this._x.call(null, node.data), | |
dy = y - +this._y.call(null, node.data), | |
d2 = dx * dx + dy * dy; | |
if (d2 < radius) { | |
var d = Math.sqrt(radius = d2); | |
x0 = x - d, y0 = y - d; | |
x3 = x + d, y3 = y + d; | |
data = node.data; | |
} | |
} | |
} | |
return data; | |
} | |
function tree_remove(d) { | |
if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points | |
var parent, | |
node = this._root, | |
retainer, | |
previous, | |
next, | |
x0 = this._x0, | |
y0 = this._y0, | |
x1 = this._x1, | |
y1 = this._y1, | |
x, | |
y, | |
xm, | |
ym, | |
right, | |
bottom, | |
i, | |
j; | |
// If the tree is empty, initialize the root as a leaf. | |
if (!node) return this; | |
// Find the leaf node for the point. | |
// While descending, also retain the deepest parent with a non-removed sibling. | |
if (node.length) while (true) { | |
if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
if (!(parent = node, node = node[i = bottom << 1 | right])) return this; | |
if (!node.length) break; | |
if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i; | |
} | |
// Find the point to remove. | |
while (node.data !== d) if (!(previous = node, node = node.next)) return this; | |
if (next = node.next) delete node.next; | |
// If there are multiple coincident points, remove just the point. | |
if (previous) return (next ? previous.next = next : delete previous.next), this; | |
// If this is the root point, remove it. | |
if (!parent) return this._root = next, this; | |
// Remove this leaf. | |
next ? parent[i] = next : delete parent[i]; | |
// If the parent now contains exactly one leaf, collapse superfluous parents. | |
if ((node = parent[0] || parent[1] || parent[2] || parent[3]) | |
&& node === (parent[3] || parent[2] || parent[1] || parent[0]) | |
&& !node.length) { | |
if (retainer) retainer[j] = node; | |
else this._root = node; | |
} | |
return this; | |
} | |
function removeAll(data) { | |
for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]); | |
return this; | |
} | |
function tree_root() { | |
return this._root; | |
} | |
function tree_size() { | |
var size = 0; | |
this.visit(function(node) { | |
if (!node.length) do ++size; while (node = node.next) | |
}); | |
return size; | |
} | |
function tree_visit(callback) { | |
var quads = [], q, node = this._root, child, x0, y0, x1, y1; | |
if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1)); | |
while (q = quads.pop()) { | |
if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) { | |
var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; | |
if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); | |
if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); | |
if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); | |
if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); | |
} | |
} | |
return this; | |
} | |
function tree_visitAfter(callback) { | |
var quads = [], next = [], q; | |
if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1)); | |
while (q = quads.pop()) { | |
var node = q.node; | |
if (node.length) { | |
var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; | |
if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); | |
if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); | |
if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); | |
if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); | |
} | |
next.push(q); | |
} | |
while (q = next.pop()) { | |
callback(q.node, q.x0, q.y0, q.x1, q.y1); | |
} | |
return this; | |
} | |
function defaultX(d) { | |
return d[0]; | |
} | |
function tree_x(_) { | |
return arguments.length ? (this._x = _, this) : this._x; | |
} | |
function defaultY(d) { | |
return d[1]; | |
} | |
function tree_y(_) { | |
return arguments.length ? (this._y = _, this) : this._y; | |
} | |
function quadtree(nodes, x, y) { | |
var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN); | |
return nodes == null ? tree : tree.addAll(nodes); | |
} | |
function Quadtree(x, y, x0, y0, x1, y1) { | |
this._x = x; | |
this._y = y; | |
this._x0 = x0; | |
this._y0 = y0; | |
this._x1 = x1; | |
this._y1 = y1; | |
this._root = undefined; | |
} | |
function leaf_copy(leaf) { | |
var copy = {data: leaf.data}, next = copy; | |
while (leaf = leaf.next) next = next.next = {data: leaf.data}; | |
return copy; | |
} | |
var treeProto = quadtree.prototype = Quadtree.prototype; | |
treeProto.copy = function() { | |
var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), | |
node = this._root, | |
nodes, | |
child; | |
if (!node) return copy; | |
if (!node.length) return copy._root = leaf_copy(node), copy; | |
nodes = [{source: node, target: copy._root = new Array(4)}]; | |
while (node = nodes.pop()) { | |
for (var i = 0; i < 4; ++i) { | |
if (child = node.source[i]) { | |
if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)}); | |
else node.target[i] = leaf_copy(child); | |
} | |
} | |
} | |
return copy; | |
}; | |
treeProto.add = tree_add; | |
treeProto.addAll = addAll; | |
treeProto.cover = tree_cover; | |
treeProto.data = tree_data; | |
treeProto.extent = tree_extent; | |
treeProto.find = tree_find; | |
treeProto.remove = tree_remove; | |
treeProto.removeAll = removeAll; | |
treeProto.root = tree_root; | |
treeProto.size = tree_size; | |
treeProto.visit = tree_visit; | |
treeProto.visitAfter = tree_visitAfter; | |
treeProto.x = tree_x; | |
treeProto.y = tree_y; | |
var slice$1 = [].slice; | |
var noabort = {}; | |
function Queue(size) { | |
if (!(size >= 1)) throw new Error; | |
this._size = size; | |
this._call = | |
this._error = null; | |
this._tasks = []; | |
this._data = []; | |
this._waiting = | |
this._active = | |
this._ended = | |
this._start = 0; // inside a synchronous task callback? | |
} | |
Queue.prototype = queue.prototype = { | |
constructor: Queue, | |
defer: function(callback) { | |
if (typeof callback !== "function" || this._call) throw new Error; | |
if (this._error != null) return this; | |
var t = slice$1.call(arguments, 1); | |
t.push(callback); | |
++this._waiting, this._tasks.push(t); | |
poke(this); | |
return this; | |
}, | |
abort: function() { | |
if (this._error == null) abort(this, new Error("abort")); | |
return this; | |
}, | |
await: function(callback) { | |
if (typeof callback !== "function" || this._call) throw new Error; | |
this._call = function(error, results) { callback.apply(null, [error].concat(results)); }; | |
maybeNotify(this); | |
return this; | |
}, | |
awaitAll: function(callback) { | |
if (typeof callback !== "function" || this._call) throw new Error; | |
this._call = callback; | |
maybeNotify(this); | |
return this; | |
} | |
}; | |
function poke(q) { | |
if (!q._start) { | |
try { start(q); } // let the current task complete | |
catch (e) { | |
if (q._tasks[q._ended + q._active - 1]) abort(q, e); // task errored synchronously | |
else if (!q._data) throw e; // await callback errored synchronously | |
} | |
} | |
} | |
function start(q) { | |
while (q._start = q._waiting && q._active < q._size) { | |
var i = q._ended + q._active, | |
t = q._tasks[i], | |
j = t.length - 1, | |
c = t[j]; | |
t[j] = end(q, i); | |
--q._waiting, ++q._active; | |
t = c.apply(null, t); | |
if (!q._tasks[i]) continue; // task finished synchronously | |
q._tasks[i] = t || noabort; | |
} | |
} | |
function end(q, i) { | |
return function(e, r) { | |
if (!q._tasks[i]) return; // ignore multiple callbacks | |
--q._active, ++q._ended; | |
q._tasks[i] = null; | |
if (q._error != null) return; // ignore secondary errors | |
if (e != null) { | |
abort(q, e); | |
} else { | |
q._data[i] = r; | |
if (q._waiting) poke(q); | |
else maybeNotify(q); | |
} | |
}; | |
} | |
function abort(q, e) { | |
var i = q._tasks.length, t; | |
q._error = e; // ignore active callbacks | |
q._data = undefined; // allow gc | |
q._waiting = NaN; // prevent starting | |
while (--i >= 0) { | |
if (t = q._tasks[i]) { | |
q._tasks[i] = null; | |
if (t.abort) { | |
try { t.abort(); } | |
catch (e) { /* ignore */ } | |
} | |
} | |
} | |
q._active = NaN; // allow notification | |
maybeNotify(q); | |
} | |
function maybeNotify(q) { | |
if (!q._active && q._call) { | |
var d = q._data; | |
q._data = undefined; // allow gc | |
q._call(q._error, d); | |
} | |
} | |
function queue(concurrency) { | |
return new Queue(arguments.length ? +concurrency : Infinity); | |
} | |
function constant$1(x) { | |
return function constant() { | |
return x; | |
}; | |
} | |
var epsilon$1 = 1e-12; | |
var pi$2 = Math.PI; | |
var halfPi$1 = pi$2 / 2; | |
var tau$2 = 2 * pi$2; | |
function arcInnerRadius(d) { | |
return d.innerRadius; | |
} | |
function arcOuterRadius(d) { | |
return d.outerRadius; | |
} | |
function arcStartAngle(d) { | |
return d.startAngle; | |
} | |
function arcEndAngle(d) { | |
return d.endAngle; | |
} | |
function arcPadAngle(d) { | |
return d && d.padAngle; // Note: optional! | |
} | |
function asin(x) { | |
return x >= 1 ? halfPi$1 : x <= -1 ? -halfPi$1 : Math.asin(x); | |
} | |
function intersect(x0, y0, x1, y1, x2, y2, x3, y3) { | |
var x10 = x1 - x0, y10 = y1 - y0, | |
x32 = x3 - x2, y32 = y3 - y2, | |
t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10); | |
return [x0 + t * x10, y0 + t * y10]; | |
} | |
// Compute perpendicular offset line of length rc. | |
// http://mathworld.wolfram.com/Circle-LineIntersection.html | |
function cornerTangents(x0, y0, x1, y1, r1, rc, cw) { | |
var x01 = x0 - x1, | |
y01 = y0 - y1, | |
lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01), | |
ox = lo * y01, | |
oy = -lo * x01, | |
x11 = x0 + ox, | |
y11 = y0 + oy, | |
x10 = x1 + ox, | |
y10 = y1 + oy, | |
x00 = (x11 + x10) / 2, | |
y00 = (y11 + y10) / 2, | |
dx = x10 - x11, | |
dy = y10 - y11, | |
d2 = dx * dx + dy * dy, | |
r = r1 - rc, | |
D = x11 * y10 - x10 * y11, | |
d = (dy < 0 ? -1 : 1) * 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 - x00, | |
dy0 = cy0 - y00, | |
dx1 = cx1 - x00, | |
dy1 = cy1 - y00; | |
// Pick the closer of the two intersection points. | |
// TODO Is there a faster way to determine which intersection to use? | |
if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1; | |
return { | |
cx: cx0, | |
cy: cy0, | |
x01: -ox, | |
y01: -oy, | |
x11: cx0 * (r1 / r - 1), | |
y11: cy0 * (r1 / r - 1) | |
}; | |
} | |
function arc() { | |
var innerRadius = arcInnerRadius, | |
outerRadius = arcOuterRadius, | |
cornerRadius = constant$1(0), | |
padRadius = null, | |
startAngle = arcStartAngle, | |
endAngle = arcEndAngle, | |
padAngle = arcPadAngle, | |
context = null; | |
function arc() { | |
var buffer, | |
r, | |
r0 = +innerRadius.apply(this, arguments), | |
r1 = +outerRadius.apply(this, arguments), | |
a0 = startAngle.apply(this, arguments) - halfPi$1, | |
a1 = endAngle.apply(this, arguments) - halfPi$1, | |
da = Math.abs(a1 - a0), | |
cw = a1 > a0; | |
if (!context) context = buffer = path(); | |
// Ensure that the outer radius is always larger than the inner radius. | |
if (r1 < r0) r = r1, r1 = r0, r0 = r; | |
// Is it a point? | |
if (!(r1 > epsilon$1)) context.moveTo(0, 0); | |
// Or is it a circle or annulus? | |
else if (da > tau$2 - epsilon$1) { | |
context.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0)); | |
context.arc(0, 0, r1, a0, a1, !cw); | |
if (r0 > epsilon$1) { | |
context.moveTo(r0 * Math.cos(a1), r0 * Math.sin(a1)); | |
context.arc(0, 0, r0, a1, a0, cw); | |
} | |
} | |
// Or is it a circular or annular sector? | |
else { | |
var a01 = a0, | |
a11 = a1, | |
a00 = a0, | |
a10 = a1, | |
da0 = da, | |
da1 = da, | |
ap = padAngle.apply(this, arguments) / 2, | |
rp = (ap > epsilon$1) && (padRadius ? +padRadius.apply(this, arguments) : Math.sqrt(r0 * r0 + r1 * r1)), | |
rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), | |
rc0 = rc, | |
rc1 = rc, | |
t0, | |
t1; | |
// Apply padding? Note that since r1 ≥ r0, da1 ≥ da0. | |
if (rp > epsilon$1) { | |
var p0 = asin(rp / r0 * Math.sin(ap)), | |
p1 = asin(rp / r1 * Math.sin(ap)); | |
if ((da0 -= p0 * 2) > epsilon$1) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0; | |
else da0 = 0, a00 = a10 = (a0 + a1) / 2; | |
if ((da1 -= p1 * 2) > epsilon$1) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1; | |
else da1 = 0, a01 = a11 = (a0 + a1) / 2; | |
} | |
var x01 = r1 * Math.cos(a01), | |
y01 = r1 * Math.sin(a01), | |
x10 = r0 * Math.cos(a10), | |
y10 = r0 * Math.sin(a10); | |
// Apply rounded corners? | |
if (rc > epsilon$1) { | |
var x11 = r1 * Math.cos(a11), | |
y11 = r1 * Math.sin(a11), | |
x00 = r0 * Math.cos(a00), | |
y00 = r0 * Math.sin(a00); | |
// Restrict the corner radius according to the sector angle. | |
if (da < pi$2) { | |
var oc = da0 > epsilon$1 ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10], | |
ax = x01 - oc[0], | |
ay = y01 - oc[1], | |
bx = x11 - oc[0], | |
by = y11 - 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)); | |
} | |
} | |
// Is the sector collapsed to a line? | |
if (!(da1 > epsilon$1)) context.moveTo(x01, y01); | |
// Does the sector’s outer ring have rounded corners? | |
else if (rc1 > epsilon$1) { | |
t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw); | |
t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw); | |
context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01); | |
// Have the corners merged? | |
if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw); | |
// Otherwise, draw the two corners and the ring. | |
else { | |
context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw); | |
context.arc(0, 0, r1, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw); | |
context.arc(t1.cx, t1.cy, rc1, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw); | |
} | |
} | |
// Or is the outer ring just a circular arc? | |
else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw); | |
// Is there no inner ring, and it’s a circular sector? | |
// Or perhaps it’s an annular sector collapsed due to padding? | |
if (!(r0 > epsilon$1) || !(da0 > epsilon$1)) context.lineTo(x10, y10); | |
// Does the sector’s inner ring (or point) have rounded corners? | |
else if (rc0 > epsilon$1) { | |
t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw); | |
t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw); | |
context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01); | |
// Have the corners merged? | |
if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw); | |
// Otherwise, draw the two corners and the ring. | |
else { | |
context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw); | |
context.arc(0, 0, r0, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw); | |
context.arc(t1.cx, t1.cy, rc0, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw); | |
} | |
} | |
// Or is the inner ring just a circular arc? | |
else context.arc(0, 0, r0, a10, a00, cw); | |
} | |
context.closePath(); | |
if (buffer) return context = null, buffer + "" || null; | |
} | |
arc.centroid = function() { | |
var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, | |
a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi$2 / 2; | |
return [Math.cos(a) * r, Math.sin(a) * r]; | |
}; | |
arc.innerRadius = function(_) { | |
return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : innerRadius; | |
}; | |
arc.outerRadius = function(_) { | |
return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : outerRadius; | |
}; | |
arc.cornerRadius = function(_) { | |
return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : cornerRadius; | |
}; | |
arc.padRadius = function(_) { | |
return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), arc) : padRadius; | |
}; | |
arc.startAngle = function(_) { | |
return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : startAngle; | |
}; | |
arc.endAngle = function(_) { | |
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : endAngle; | |
}; | |
arc.padAngle = function(_) { | |
return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : padAngle; | |
}; | |
arc.context = function(_) { | |
return arguments.length ? ((context = _ == null ? null : _), arc) : context; | |
}; | |
return arc; | |
} | |
function Linear(context) { | |
this._context = context; | |
} | |
Linear.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
case 1: this._point = 2; // proceed | |
default: this._context.lineTo(x, y); break; | |
} | |
} | |
}; | |
function curveLinear(context) { | |
return new Linear(context); | |
} | |
function x(p) { | |
return p[0]; | |
} | |
function y(p) { | |
return p[1]; | |
} | |
function line() { | |
var x$$ = x, | |
y$$ = y, | |
defined = constant$1(true), | |
context = null, | |
curve = curveLinear, | |
output = null; | |
function line(data) { | |
var i, | |
n = data.length, | |
d, | |
defined0 = false, | |
buffer; | |
if (context == null) output = curve(buffer = path()); | |
for (i = 0; i <= n; ++i) { | |
if (!(i < n && defined(d = data[i], i, data)) === defined0) { | |
if (defined0 = !defined0) output.lineStart(); | |
else output.lineEnd(); | |
} | |
if (defined0) output.point(+x$$(d, i, data), +y$$(d, i, data)); | |
} | |
if (buffer) return output = null, buffer + "" || null; | |
} | |
line.x = function(_) { | |
return arguments.length ? (x$$ = typeof _ === "function" ? _ : constant$1(+_), line) : x$$; | |
}; | |
line.y = function(_) { | |
return arguments.length ? (y$$ = typeof _ === "function" ? _ : constant$1(+_), line) : y$$; | |
}; | |
line.defined = function(_) { | |
return arguments.length ? (defined = typeof _ === "function" ? _ : constant$1(!!_), line) : defined; | |
}; | |
line.curve = function(_) { | |
return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve; | |
}; | |
line.context = function(_) { | |
return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context; | |
}; | |
return line; | |
} | |
function area$1() { | |
var x0 = x, | |
x1 = null, | |
y0 = constant$1(0), | |
y1 = y, | |
defined = constant$1(true), | |
context = null, | |
curve = curveLinear, | |
output = null; | |
function area(data) { | |
var i, | |
j, | |
k, | |
n = data.length, | |
d, | |
defined0 = false, | |
buffer, | |
x0z = new Array(n), | |
y0z = new Array(n); | |
if (context == null) output = curve(buffer = path()); | |
for (i = 0; i <= n; ++i) { | |
if (!(i < n && defined(d = data[i], i, data)) === defined0) { | |
if (defined0 = !defined0) { | |
j = i; | |
output.areaStart(); | |
output.lineStart(); | |
} else { | |
output.lineEnd(); | |
output.lineStart(); | |
for (k = i - 1; k >= j; --k) { | |
output.point(x0z[k], y0z[k]); | |
} | |
output.lineEnd(); | |
output.areaEnd(); | |
} | |
} | |
if (defined0) { | |
x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data); | |
output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]); | |
} | |
} | |
if (buffer) return output = null, buffer + "" || null; | |
} | |
function arealine() { | |
return line().defined(defined).curve(curve).context(context); | |
} | |
area.x = function(_) { | |
return arguments.length ? (x0 = typeof _ === "function" ? _ : constant$1(+_), x1 = null, area) : x0; | |
}; | |
area.x0 = function(_) { | |
return arguments.length ? (x0 = typeof _ === "function" ? _ : constant$1(+_), area) : x0; | |
}; | |
area.x1 = function(_) { | |
return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), area) : x1; | |
}; | |
area.y = function(_) { | |
return arguments.length ? (y0 = typeof _ === "function" ? _ : constant$1(+_), y1 = null, area) : y0; | |
}; | |
area.y0 = function(_) { | |
return arguments.length ? (y0 = typeof _ === "function" ? _ : constant$1(+_), area) : y0; | |
}; | |
area.y1 = function(_) { | |
return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), area) : y1; | |
}; | |
area.lineX0 = | |
area.lineY0 = function() { | |
return arealine().x(x0).y(y0); | |
}; | |
area.lineY1 = function() { | |
return arealine().x(x0).y(y1); | |
}; | |
area.lineX1 = function() { | |
return arealine().x(x1).y(y0); | |
}; | |
area.defined = function(_) { | |
return arguments.length ? (defined = typeof _ === "function" ? _ : constant$1(!!_), area) : defined; | |
}; | |
area.curve = function(_) { | |
return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve; | |
}; | |
area.context = function(_) { | |
return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context; | |
}; | |
return area; | |
} | |
function descending$1(a, b) { | |
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; | |
} | |
function identity$1(d) { | |
return d; | |
} | |
function pie() { | |
var value = identity$1, | |
sortValues = descending$1, | |
sort = null, | |
startAngle = constant$1(0), | |
endAngle = constant$1(tau$2), | |
padAngle = constant$1(0); | |
function pie(data) { | |
var i, | |
n = data.length, | |
j, | |
k, | |
sum = 0, | |
index = new Array(n), | |
arcs = new Array(n), | |
a0 = +startAngle.apply(this, arguments), | |
da = Math.min(tau$2, Math.max(-tau$2, endAngle.apply(this, arguments) - a0)), | |
a1, | |
p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), | |
pa = p * (da < 0 ? -1 : 1), | |
v; | |
for (i = 0; i < n; ++i) { | |
if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) { | |
sum += v; | |
} | |
} | |
// Optionally sort the arcs by previously-computed values or by data. | |
if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); }); | |
else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); }); | |
// Compute the arcs! They are stored in the original data's order. | |
for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) { | |
j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = { | |
data: data[j], | |
index: i, | |
value: v, | |
startAngle: a0, | |
endAngle: a1, | |
padAngle: p | |
}; | |
} | |
return arcs; | |
} | |
pie.value = function(_) { | |
return arguments.length ? (value = typeof _ === "function" ? _ : constant$1(+_), pie) : value; | |
}; | |
pie.sortValues = function(_) { | |
return arguments.length ? (sortValues = _, sort = null, pie) : sortValues; | |
}; | |
pie.sort = function(_) { | |
return arguments.length ? (sort = _, sortValues = null, pie) : sort; | |
}; | |
pie.startAngle = function(_) { | |
return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant$1(+_), pie) : startAngle; | |
}; | |
pie.endAngle = function(_) { | |
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$1(+_), pie) : endAngle; | |
}; | |
pie.padAngle = function(_) { | |
return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant$1(+_), pie) : padAngle; | |
}; | |
return pie; | |
} | |
var curveRadialLinear = curveRadial(curveLinear); | |
function Radial(curve) { | |
this._curve = curve; | |
} | |
Radial.prototype = { | |
areaStart: function() { | |
this._curve.areaStart(); | |
}, | |
areaEnd: function() { | |
this._curve.areaEnd(); | |
}, | |
lineStart: function() { | |
this._curve.lineStart(); | |
}, | |
lineEnd: function() { | |
this._curve.lineEnd(); | |
}, | |
point: function(a, r) { | |
this._curve.point(r * Math.sin(a), r * -Math.cos(a)); | |
} | |
}; | |
function curveRadial(curve) { | |
function radial(context) { | |
return new Radial(curve(context)); | |
} | |
radial._curve = curve; | |
return radial; | |
} | |
function radialLine(l) { | |
var c = l.curve; | |
l.angle = l.x, delete l.x; | |
l.radius = l.y, delete l.y; | |
l.curve = function(_) { | |
return arguments.length ? c(curveRadial(_)) : c()._curve; | |
}; | |
return l; | |
} | |
function radialLine$1() { | |
return radialLine(line().curve(curveRadialLinear)); | |
} | |
function radialArea() { | |
var a = area$1().curve(curveRadialLinear), | |
c = a.curve, | |
x0 = a.lineX0, | |
x1 = a.lineX1, | |
y0 = a.lineY0, | |
y1 = a.lineY1; | |
a.angle = a.x, delete a.x; | |
a.startAngle = a.x0, delete a.x0; | |
a.endAngle = a.x1, delete a.x1; | |
a.radius = a.y, delete a.y; | |
a.innerRadius = a.y0, delete a.y0; | |
a.outerRadius = a.y1, delete a.y1; | |
a.lineStartAngle = function() { return radialLine(x0()); }, delete a.lineX0; | |
a.lineEndAngle = function() { return radialLine(x1()); }, delete a.lineX1; | |
a.lineInnerRadius = function() { return radialLine(y0()); }, delete a.lineY0; | |
a.lineOuterRadius = function() { return radialLine(y1()); }, delete a.lineY1; | |
a.curve = function(_) { | |
return arguments.length ? c(curveRadial(_)) : c()._curve; | |
}; | |
return a; | |
} | |
var circle = { | |
draw: function(context, size) { | |
var r = Math.sqrt(size / pi$2); | |
context.moveTo(r, 0); | |
context.arc(0, 0, r, 0, tau$2); | |
} | |
}; | |
var cross$1 = { | |
draw: function(context, size) { | |
var r = Math.sqrt(size / 5) / 2; | |
context.moveTo(-3 * r, -r); | |
context.lineTo(-r, -r); | |
context.lineTo(-r, -3 * r); | |
context.lineTo(r, -3 * r); | |
context.lineTo(r, -r); | |
context.lineTo(3 * r, -r); | |
context.lineTo(3 * r, r); | |
context.lineTo(r, r); | |
context.lineTo(r, 3 * r); | |
context.lineTo(-r, 3 * r); | |
context.lineTo(-r, r); | |
context.lineTo(-3 * r, r); | |
context.closePath(); | |
} | |
}; | |
var tan30 = Math.sqrt(1 / 3); | |
var tan30_2 = tan30 * 2; | |
var diamond = { | |
draw: function(context, size) { | |
var y = Math.sqrt(size / tan30_2), | |
x = y * tan30; | |
context.moveTo(0, -y); | |
context.lineTo(x, 0); | |
context.lineTo(0, y); | |
context.lineTo(-x, 0); | |
context.closePath(); | |
} | |
}; | |
var ka = 0.89081309152928522810; | |
var kr = Math.sin(pi$2 / 10) / Math.sin(7 * pi$2 / 10); | |
var kx = Math.sin(tau$2 / 10) * kr; | |
var ky = -Math.cos(tau$2 / 10) * kr; | |
var star = { | |
draw: function(context, size) { | |
var r = Math.sqrt(size * ka), | |
x = kx * r, | |
y = ky * r; | |
context.moveTo(0, -r); | |
context.lineTo(x, y); | |
for (var i = 1; i < 5; ++i) { | |
var a = tau$2 * i / 5, | |
c = Math.cos(a), | |
s = Math.sin(a); | |
context.lineTo(s * r, -c * r); | |
context.lineTo(c * x - s * y, s * x + c * y); | |
} | |
context.closePath(); | |
} | |
}; | |
var square = { | |
draw: function(context, size) { | |
var w = Math.sqrt(size), | |
x = -w / 2; | |
context.rect(x, x, w, w); | |
} | |
}; | |
var sqrt3 = Math.sqrt(3); | |
var triangle = { | |
draw: function(context, size) { | |
var y = -Math.sqrt(size / (sqrt3 * 3)); | |
context.moveTo(0, y * 2); | |
context.lineTo(-sqrt3 * y, -y); | |
context.lineTo(sqrt3 * y, -y); | |
context.closePath(); | |
} | |
}; | |
var c = -0.5; | |
var s = Math.sqrt(3) / 2; | |
var k = 1 / Math.sqrt(12); | |
var a = (k / 2 + 1) * 3; | |
var wye = { | |
draw: function(context, size) { | |
var r = Math.sqrt(size / a), | |
x0 = r / 2, | |
y0 = r * k, | |
x1 = x0, | |
y1 = r * k + r, | |
x2 = -x1, | |
y2 = y1; | |
context.moveTo(x0, y0); | |
context.lineTo(x1, y1); | |
context.lineTo(x2, y2); | |
context.lineTo(c * x0 - s * y0, s * x0 + c * y0); | |
context.lineTo(c * x1 - s * y1, s * x1 + c * y1); | |
context.lineTo(c * x2 - s * y2, s * x2 + c * y2); | |
context.lineTo(c * x0 + s * y0, c * y0 - s * x0); | |
context.lineTo(c * x1 + s * y1, c * y1 - s * x1); | |
context.lineTo(c * x2 + s * y2, c * y2 - s * x2); | |
context.closePath(); | |
} | |
}; | |
var symbols = [ | |
circle, | |
cross$1, | |
diamond, | |
square, | |
star, | |
triangle, | |
wye | |
]; | |
function symbol() { | |
var type = constant$1(circle), | |
size = constant$1(64), | |
context = null; | |
function symbol() { | |
var buffer; | |
if (!context) context = buffer = path(); | |
type.apply(this, arguments).draw(context, +size.apply(this, arguments)); | |
if (buffer) return context = null, buffer + "" || null; | |
} | |
symbol.type = function(_) { | |
return arguments.length ? (type = typeof _ === "function" ? _ : constant$1(_), symbol) : type; | |
}; | |
symbol.size = function(_) { | |
return arguments.length ? (size = typeof _ === "function" ? _ : constant$1(+_), symbol) : size; | |
}; | |
symbol.context = function(_) { | |
return arguments.length ? (context = _ == null ? null : _, symbol) : context; | |
}; | |
return symbol; | |
} | |
function noop() {} | |
function point(that, x, y) { | |
that._context.bezierCurveTo( | |
(2 * that._x0 + that._x1) / 3, | |
(2 * that._y0 + that._y1) / 3, | |
(that._x0 + 2 * that._x1) / 3, | |
(that._y0 + 2 * that._y1) / 3, | |
(that._x0 + 4 * that._x1 + x) / 6, | |
(that._y0 + 4 * that._y1 + y) / 6 | |
); | |
} | |
function Basis(context) { | |
this._context = context; | |
} | |
Basis.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x0 = this._x1 = | |
this._y0 = this._y1 = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
switch (this._point) { | |
case 3: point(this, this._x1, this._y1); // proceed | |
case 2: this._context.lineTo(this._x1, this._y1); break; | |
} | |
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
case 1: this._point = 2; break; | |
case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed | |
default: point(this, x, y); break; | |
} | |
this._x0 = this._x1, this._x1 = x; | |
this._y0 = this._y1, this._y1 = y; | |
} | |
}; | |
function basis(context) { | |
return new Basis(context); | |
} | |
function BasisClosed(context) { | |
this._context = context; | |
} | |
BasisClosed.prototype = { | |
areaStart: noop, | |
areaEnd: noop, | |
lineStart: function() { | |
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = | |
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
switch (this._point) { | |
case 1: { | |
this._context.moveTo(this._x2, this._y2); | |
this._context.closePath(); | |
break; | |
} | |
case 2: { | |
this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3); | |
this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3); | |
this._context.closePath(); | |
break; | |
} | |
case 3: { | |
this.point(this._x2, this._y2); | |
this.point(this._x3, this._y3); | |
this.point(this._x4, this._y4); | |
break; | |
} | |
} | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; this._x2 = x, this._y2 = y; break; | |
case 1: this._point = 2; this._x3 = x, this._y3 = y; break; | |
case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break; | |
default: point(this, x, y); break; | |
} | |
this._x0 = this._x1, this._x1 = x; | |
this._y0 = this._y1, this._y1 = y; | |
} | |
}; | |
function basisClosed(context) { | |
return new BasisClosed(context); | |
} | |
function BasisOpen(context) { | |
this._context = context; | |
} | |
BasisOpen.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x0 = this._x1 = | |
this._y0 = this._y1 = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; break; | |
case 1: this._point = 2; break; | |
case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break; | |
case 3: this._point = 4; // proceed | |
default: point(this, x, y); break; | |
} | |
this._x0 = this._x1, this._x1 = x; | |
this._y0 = this._y1, this._y1 = y; | |
} | |
}; | |
function basisOpen(context) { | |
return new BasisOpen(context); | |
} | |
function Bundle(context, beta) { | |
this._basis = new Basis(context); | |
this._beta = beta; | |
} | |
Bundle.prototype = { | |
lineStart: function() { | |
this._x = []; | |
this._y = []; | |
this._basis.lineStart(); | |
}, | |
lineEnd: function() { | |
var x = this._x, | |
y = this._y, | |
j = x.length - 1; | |
if (j > 0) { | |
var x0 = x[0], | |
y0 = y[0], | |
dx = x[j] - x0, | |
dy = y[j] - y0, | |
i = -1, | |
t; | |
while (++i <= j) { | |
t = i / j; | |
this._basis.point( | |
this._beta * x[i] + (1 - this._beta) * (x0 + t * dx), | |
this._beta * y[i] + (1 - this._beta) * (y0 + t * dy) | |
); | |
} | |
} | |
this._x = this._y = null; | |
this._basis.lineEnd(); | |
}, | |
point: function(x, y) { | |
this._x.push(+x); | |
this._y.push(+y); | |
} | |
}; | |
var bundle = (function custom(beta) { | |
function bundle(context) { | |
return beta === 1 ? new Basis(context) : new Bundle(context, beta); | |
} | |
bundle.beta = function(beta) { | |
return custom(+beta); | |
}; | |
return bundle; | |
})(0.85); | |
function point$1(that, x, y) { | |
that._context.bezierCurveTo( | |
that._x1 + that._k * (that._x2 - that._x0), | |
that._y1 + that._k * (that._y2 - that._y0), | |
that._x2 + that._k * (that._x1 - x), | |
that._y2 + that._k * (that._y1 - y), | |
that._x2, | |
that._y2 | |
); | |
} | |
function Cardinal(context, tension) { | |
this._context = context; | |
this._k = (1 - tension) / 6; | |
} | |
Cardinal.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x0 = this._x1 = this._x2 = | |
this._y0 = this._y1 = this._y2 = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
switch (this._point) { | |
case 2: this._context.lineTo(this._x2, this._y2); break; | |
case 3: point$1(this, this._x1, this._y1); break; | |
} | |
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
case 1: this._point = 2; this._x1 = x, this._y1 = y; break; | |
case 2: this._point = 3; // proceed | |
default: point$1(this, x, y); break; | |
} | |
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
} | |
}; | |
var cardinal = (function custom(tension) { | |
function cardinal(context) { | |
return new Cardinal(context, tension); | |
} | |
cardinal.tension = function(tension) { | |
return custom(+tension); | |
}; | |
return cardinal; | |
})(0); | |
function CardinalClosed(context, tension) { | |
this._context = context; | |
this._k = (1 - tension) / 6; | |
} | |
CardinalClosed.prototype = { | |
areaStart: noop, | |
areaEnd: noop, | |
lineStart: function() { | |
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = | |
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
switch (this._point) { | |
case 1: { | |
this._context.moveTo(this._x3, this._y3); | |
this._context.closePath(); | |
break; | |
} | |
case 2: { | |
this._context.lineTo(this._x3, this._y3); | |
this._context.closePath(); | |
break; | |
} | |
case 3: { | |
this.point(this._x3, this._y3); | |
this.point(this._x4, this._y4); | |
this.point(this._x5, this._y5); | |
break; | |
} | |
} | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; this._x3 = x, this._y3 = y; break; | |
case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; | |
case 2: this._point = 3; this._x5 = x, this._y5 = y; break; | |
default: point$1(this, x, y); break; | |
} | |
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
} | |
}; | |
var cardinalClosed = (function custom(tension) { | |
function cardinal(context) { | |
return new CardinalClosed(context, tension); | |
} | |
cardinal.tension = function(tension) { | |
return custom(+tension); | |
}; | |
return cardinal; | |
})(0); | |
function CardinalOpen(context, tension) { | |
this._context = context; | |
this._k = (1 - tension) / 6; | |
} | |
CardinalOpen.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x0 = this._x1 = this._x2 = | |
this._y0 = this._y1 = this._y2 = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; break; | |
case 1: this._point = 2; break; | |
case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break; | |
case 3: this._point = 4; // proceed | |
default: point$1(this, x, y); break; | |
} | |
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
} | |
}; | |
var cardinalOpen = (function custom(tension) { | |
function cardinal(context) { | |
return new CardinalOpen(context, tension); | |
} | |
cardinal.tension = function(tension) { | |
return custom(+tension); | |
}; | |
return cardinal; | |
})(0); | |
function point$2(that, x, y) { | |
var x1 = that._x1, | |
y1 = that._y1, | |
x2 = that._x2, | |
y2 = that._y2; | |
if (that._l01_a > epsilon$1) { | |
var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a, | |
n = 3 * that._l01_a * (that._l01_a + that._l12_a); | |
x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n; | |
y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n; | |
} | |
if (that._l23_a > epsilon$1) { | |
var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a, | |
m = 3 * that._l23_a * (that._l23_a + that._l12_a); | |
x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m; | |
y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m; | |
} | |
that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2); | |
} | |
function CatmullRom(context, alpha) { | |
this._context = context; | |
this._alpha = alpha; | |
} | |
CatmullRom.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x0 = this._x1 = this._x2 = | |
this._y0 = this._y1 = this._y2 = NaN; | |
this._l01_a = this._l12_a = this._l23_a = | |
this._l01_2a = this._l12_2a = this._l23_2a = | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
switch (this._point) { | |
case 2: this._context.lineTo(this._x2, this._y2); break; | |
case 3: this.point(this._x2, this._y2); break; | |
} | |
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
if (this._point) { | |
var x23 = this._x2 - x, | |
y23 = this._y2 - y; | |
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); | |
} | |
switch (this._point) { | |
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
case 1: this._point = 2; break; | |
case 2: this._point = 3; // proceed | |
default: point$2(this, x, y); break; | |
} | |
this._l01_a = this._l12_a, this._l12_a = this._l23_a; | |
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; | |
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
} | |
}; | |
var catmullRom = (function custom(alpha) { | |
function catmullRom(context) { | |
return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0); | |
} | |
catmullRom.alpha = function(alpha) { | |
return custom(+alpha); | |
}; | |
return catmullRom; | |
})(0.5); | |
function CatmullRomClosed(context, alpha) { | |
this._context = context; | |
this._alpha = alpha; | |
} | |
CatmullRomClosed.prototype = { | |
areaStart: noop, | |
areaEnd: noop, | |
lineStart: function() { | |
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = | |
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; | |
this._l01_a = this._l12_a = this._l23_a = | |
this._l01_2a = this._l12_2a = this._l23_2a = | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
switch (this._point) { | |
case 1: { | |
this._context.moveTo(this._x3, this._y3); | |
this._context.closePath(); | |
break; | |
} | |
case 2: { | |
this._context.lineTo(this._x3, this._y3); | |
this._context.closePath(); | |
break; | |
} | |
case 3: { | |
this.point(this._x3, this._y3); | |
this.point(this._x4, this._y4); | |
this.point(this._x5, this._y5); | |
break; | |
} | |
} | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
if (this._point) { | |
var x23 = this._x2 - x, | |
y23 = this._y2 - y; | |
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); | |
} | |
switch (this._point) { | |
case 0: this._point = 1; this._x3 = x, this._y3 = y; break; | |
case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; | |
case 2: this._point = 3; this._x5 = x, this._y5 = y; break; | |
default: point$2(this, x, y); break; | |
} | |
this._l01_a = this._l12_a, this._l12_a = this._l23_a; | |
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; | |
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
} | |
}; | |
var catmullRomClosed = (function custom(alpha) { | |
function catmullRom(context) { | |
return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0); | |
} | |
catmullRom.alpha = function(alpha) { | |
return custom(+alpha); | |
}; | |
return catmullRom; | |
})(0.5); | |
function CatmullRomOpen(context, alpha) { | |
this._context = context; | |
this._alpha = alpha; | |
} | |
CatmullRomOpen.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x0 = this._x1 = this._x2 = | |
this._y0 = this._y1 = this._y2 = NaN; | |
this._l01_a = this._l12_a = this._l23_a = | |
this._l01_2a = this._l12_2a = this._l23_2a = | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
if (this._point) { | |
var x23 = this._x2 - x, | |
y23 = this._y2 - y; | |
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); | |
} | |
switch (this._point) { | |
case 0: this._point = 1; break; | |
case 1: this._point = 2; break; | |
case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break; | |
case 3: this._point = 4; // proceed | |
default: point$2(this, x, y); break; | |
} | |
this._l01_a = this._l12_a, this._l12_a = this._l23_a; | |
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; | |
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
} | |
}; | |
var catmullRomOpen = (function custom(alpha) { | |
function catmullRom(context) { | |
return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0); | |
} | |
catmullRom.alpha = function(alpha) { | |
return custom(+alpha); | |
}; | |
return catmullRom; | |
})(0.5); | |
function LinearClosed(context) { | |
this._context = context; | |
} | |
LinearClosed.prototype = { | |
areaStart: noop, | |
areaEnd: noop, | |
lineStart: function() { | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (this._point) this._context.closePath(); | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
if (this._point) this._context.lineTo(x, y); | |
else this._point = 1, this._context.moveTo(x, y); | |
} | |
}; | |
function linearClosed(context) { | |
return new LinearClosed(context); | |
} | |
function sign(x) { | |
return x < 0 ? -1 : 1; | |
} | |
// Calculate the slopes of the tangents (Hermite-type interpolation) based on | |
// the following paper: Steffen, M. 1990. A Simple Method for Monotonic | |
// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO. | |
// NOV(II), P. 443, 1990. | |
function slope3(that, x2, y2) { | |
var h0 = that._x1 - that._x0, | |
h1 = x2 - that._x1, | |
s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), | |
s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0), | |
p = (s0 * h1 + s1 * h0) / (h0 + h1); | |
return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0; | |
} | |
// Calculate a one-sided slope. | |
function slope2(that, t) { | |
var h = that._x1 - that._x0; | |
return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t; | |
} | |
// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations | |
// "you can express cubic Hermite interpolation in terms of cubic Bézier curves | |
// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1". | |
function point$3(that, t0, t1) { | |
var x0 = that._x0, | |
y0 = that._y0, | |
x1 = that._x1, | |
y1 = that._y1, | |
dx = (x1 - x0) / 3; | |
that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1); | |
} | |
function MonotoneX(context) { | |
this._context = context; | |
} | |
MonotoneX.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x0 = this._x1 = | |
this._y0 = this._y1 = | |
this._t0 = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
switch (this._point) { | |
case 2: this._context.lineTo(this._x1, this._y1); break; | |
case 3: point$3(this, this._t0, slope2(this, this._t0)); break; | |
} | |
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
var t1 = NaN; | |
x = +x, y = +y; | |
if (x === this._x1 && y === this._y1) return; // Ignore coincident points. | |
switch (this._point) { | |
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
case 1: this._point = 2; break; | |
case 2: this._point = 3; point$3(this, slope2(this, t1 = slope3(this, x, y)), t1); break; | |
default: point$3(this, this._t0, t1 = slope3(this, x, y)); break; | |
} | |
this._x0 = this._x1, this._x1 = x; | |
this._y0 = this._y1, this._y1 = y; | |
this._t0 = t1; | |
} | |
} | |
function MonotoneY(context) { | |
this._context = new ReflectContext(context); | |
} | |
(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) { | |
MonotoneX.prototype.point.call(this, y, x); | |
}; | |
function ReflectContext(context) { | |
this._context = context; | |
} | |
ReflectContext.prototype = { | |
moveTo: function(x, y) { this._context.moveTo(y, x); }, | |
closePath: function() { this._context.closePath(); }, | |
lineTo: function(x, y) { this._context.lineTo(y, x); }, | |
bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); } | |
}; | |
function monotoneX(context) { | |
return new MonotoneX(context); | |
} | |
function monotoneY(context) { | |
return new MonotoneY(context); | |
} | |
function Natural(context) { | |
this._context = context; | |
} | |
Natural.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x = []; | |
this._y = []; | |
}, | |
lineEnd: function() { | |
var x = this._x, | |
y = this._y, | |
n = x.length; | |
if (n) { | |
this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]); | |
if (n === 2) { | |
this._context.lineTo(x[1], y[1]); | |
} else { | |
var px = controlPoints(x), | |
py = controlPoints(y); | |
for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) { | |
this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]); | |
} | |
} | |
} | |
if (this._line || (this._line !== 0 && n === 1)) this._context.closePath(); | |
this._line = 1 - this._line; | |
this._x = this._y = null; | |
}, | |
point: function(x, y) { | |
this._x.push(+x); | |
this._y.push(+y); | |
} | |
}; | |
// See https://www.particleincell.com/2012/bezier-splines/ for derivation. | |
function controlPoints(x) { | |
var i, | |
n = x.length - 1, | |
m, | |
a = new Array(n), | |
b = new Array(n), | |
r = new Array(n); | |
a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1]; | |
for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1]; | |
a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n]; | |
for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1]; | |
a[n - 1] = r[n - 1] / b[n - 1]; | |
for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i]; | |
b[n - 1] = (x[n] + a[n - 1]) / 2; | |
for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1]; | |
return [a, b]; | |
} | |
function natural(context) { | |
return new Natural(context); | |
} | |
function Step(context, t) { | |
this._context = context; | |
this._t = t; | |
} | |
Step.prototype = { | |
areaStart: function() { | |
this._line = 0; | |
}, | |
areaEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._x = this._y = NaN; | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y); | |
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line; | |
}, | |
point: function(x, y) { | |
x = +x, y = +y; | |
switch (this._point) { | |
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
case 1: this._point = 2; // proceed | |
default: { | |
if (this._t <= 0) { | |
this._context.lineTo(this._x, y); | |
this._context.lineTo(x, y); | |
} else { | |
var x1 = this._x * (1 - this._t) + x * this._t; | |
this._context.lineTo(x1, this._y); | |
this._context.lineTo(x1, y); | |
} | |
break; | |
} | |
} | |
this._x = x, this._y = y; | |
} | |
}; | |
function step(context) { | |
return new Step(context, 0.5); | |
} | |
function stepBefore(context) { | |
return new Step(context, 0); | |
} | |
function stepAfter(context) { | |
return new Step(context, 1); | |
} | |
var slice$2 = Array.prototype.slice; | |
function none(series, order) { | |
if (!((n = series.length) > 1)) return; | |
for (var i = 1, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) { | |
s0 = s1, s1 = series[order[i]]; | |
for (var j = 0; j < m; ++j) { | |
s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1]; | |
} | |
} | |
} | |
function none$1(series) { | |
var n = series.length, o = new Array(n); | |
while (--n >= 0) o[n] = n; | |
return o; | |
} | |
function stackValue(d, key) { | |
return d[key]; | |
} | |
function stack() { | |
var keys = constant$1([]), | |
order = none$1, | |
offset = none, | |
value = stackValue; | |
function stack(data) { | |
var kz = keys.apply(this, arguments), | |
i, | |
m = data.length, | |
n = kz.length, | |
sz = new Array(n), | |
oz; | |
for (i = 0; i < n; ++i) { | |
for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) { | |
si[j] = sij = [0, +value(data[j], ki, j, data)]; | |
sij.data = data[j]; | |
} | |
si.key = ki; | |
} | |
for (i = 0, oz = order(sz); i < n; ++i) { | |
sz[oz[i]].index = i; | |
} | |
offset(sz, oz); | |
return sz; | |
} | |
stack.keys = function(_) { | |
return arguments.length ? (keys = typeof _ === "function" ? _ : constant$1(slice$2.call(_)), stack) : keys; | |
}; | |
stack.value = function(_) { | |
return arguments.length ? (value = typeof _ === "function" ? _ : constant$1(+_), stack) : value; | |
}; | |
stack.order = function(_) { | |
return arguments.length ? (order = _ == null ? none$1 : typeof _ === "function" ? _ : constant$1(slice$2.call(_)), stack) : order; | |
}; | |
stack.offset = function(_) { | |
return arguments.length ? (offset = _ == null ? none : _, stack) : offset; | |
}; | |
return stack; | |
} | |
function expand(series, order) { | |
if (!((n = series.length) > 0)) return; | |
for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) { | |
for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0; | |
if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y; | |
} | |
none(series, order); | |
} | |
function silhouette(series, order) { | |
if (!((n = series.length) > 0)) return; | |
for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) { | |
for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0; | |
s0[j][1] += s0[j][0] = -y / 2; | |
} | |
none(series, order); | |
} | |
function wiggle(series, order) { | |
if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return; | |
for (var y = 0, j = 1, s0, m, n; j < m; ++j) { | |
for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) { | |
var si = series[order[i]], | |
sij0 = si[j][1] || 0, | |
sij1 = si[j - 1][1] || 0, | |
s3 = (sij0 - sij1) / 2; | |
for (var k = 0; k < i; ++k) { | |
var sk = series[order[k]], | |
skj0 = sk[j][1] || 0, | |
skj1 = sk[j - 1][1] || 0; | |
s3 += skj0 - skj1; | |
} | |
s1 += sij0, s2 += s3 * sij0; | |
} | |
s0[j - 1][1] += s0[j - 1][0] = y; | |
if (s1) y -= s2 / s1; | |
} | |
s0[j - 1][1] += s0[j - 1][0] = y; | |
none(series, order); | |
} | |
function ascending$1(series) { | |
var sums = series.map(sum$1); | |
return none$1(series).sort(function(a, b) { return sums[a] - sums[b]; }); | |
} | |
function sum$1(series) { | |
var s = 0, i = -1, n = series.length, v; | |
while (++i < n) if (v = +series[i][1]) s += v; | |
return s; | |
} | |
function descending$2(series) { | |
return ascending$1(series).reverse(); | |
} | |
function insideOut(series) { | |
var n = series.length, | |
i, | |
j, | |
sums = series.map(sum$1), | |
order = none$1(series).sort(function(a, b) { return sums[b] - sums[a]; }), | |
top = 0, | |
bottom = 0, | |
tops = [], | |
bottoms = []; | |
for (i = 0; i < n; ++i) { | |
j = order[i]; | |
if (top < bottom) { | |
top += sums[j]; | |
tops.push(j); | |
} else { | |
bottom += sums[j]; | |
bottoms.push(j); | |
} | |
} | |
return bottoms.reverse().concat(tops); | |
} | |
function reverse(series) { | |
return none$1(series).reverse(); | |
} | |
function define(constructor, factory, prototype) { | |
constructor.prototype = factory.prototype = prototype; | |
prototype.constructor = constructor; | |
} | |
function extend(parent, definition) { | |
var prototype = Object.create(parent.prototype); | |
for (var key in definition) prototype[key] = definition[key]; | |
return prototype; | |
} | |
function Color() {} | |
var darker = 0.7; | |
var brighter = 1 / darker; | |
var reI = "\\s*([+-]?\\d+)\\s*"; | |
var reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*"; | |
var reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*"; | |
var reHex3 = /^#([0-9a-f]{3})$/; | |
var reHex6 = /^#([0-9a-f]{6})$/; | |
var reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"); | |
var reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"); | |
var reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"); | |
var reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"); | |
var reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"); | |
var reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$"); | |
var named = { | |
aliceblue: 0xf0f8ff, | |
antiquewhite: 0xfaebd7, | |
aqua: 0x00ffff, | |
aquamarine: 0x7fffd4, | |
azure: 0xf0ffff, | |
beige: 0xf5f5dc, | |
bisque: 0xffe4c4, | |
black: 0x000000, | |
blanchedalmond: 0xffebcd, | |
blue: 0x0000ff, | |
blueviolet: 0x8a2be2, | |
brown: 0xa52a2a, | |
burlywood: 0xdeb887, | |
cadetblue: 0x5f9ea0, | |
chartreuse: 0x7fff00, | |
chocolate: 0xd2691e, | |
coral: 0xff7f50, | |
cornflowerblue: 0x6495ed, | |
cornsilk: 0xfff8dc, | |
crimson: 0xdc143c, | |
cyan: 0x00ffff, | |
darkblue: 0x00008b, | |
darkcyan: 0x008b8b, | |
darkgoldenrod: 0xb8860b, | |
darkgray: 0xa9a9a9, | |
darkgreen: 0x006400, | |
darkgrey: 0xa9a9a9, | |
darkkhaki: 0xbdb76b, | |
darkmagenta: 0x8b008b, | |
darkolivegreen: 0x556b2f, | |
darkorange: 0xff8c00, | |
darkorchid: 0x9932cc, | |
darkred: 0x8b0000, | |
darksalmon: 0xe9967a, | |
darkseagreen: 0x8fbc8f, | |
darkslateblue: 0x483d8b, | |
darkslategray: 0x2f4f4f, | |
darkslategrey: 0x2f4f4f, | |
darkturquoise: 0x00ced1, | |
darkviolet: 0x9400d3, | |
deeppink: 0xff1493, | |
deepskyblue: 0x00bfff, | |
dimgray: 0x696969, | |
dimgrey: 0x696969, | |
dodgerblue: 0x1e90ff, | |
firebrick: 0xb22222, | |
floralwhite: 0xfffaf0, | |
forestgreen: 0x228b22, | |
fuchsia: 0xff00ff, | |
gainsboro: 0xdcdcdc, | |
ghostwhite: 0xf8f8ff, | |
gold: 0xffd700, | |
goldenrod: 0xdaa520, | |
gray: 0x808080, | |
green: 0x008000, | |
greenyellow: 0xadff2f, | |
grey: 0x808080, | |
honeydew: 0xf0fff0, | |
hotpink: 0xff69b4, | |
indianred: 0xcd5c5c, | |
indigo: 0x4b0082, | |
ivory: 0xfffff0, | |
khaki: 0xf0e68c, | |
lavender: 0xe6e6fa, | |
lavenderblush: 0xfff0f5, | |
lawngreen: 0x7cfc00, | |
lemonchiffon: 0xfffacd, | |
lightblue: 0xadd8e6, | |
lightcoral: 0xf08080, | |
lightcyan: 0xe0ffff, | |
lightgoldenrodyellow: 0xfafad2, | |
lightgray: 0xd3d3d3, | |
lightgreen: 0x90ee90, | |
lightgrey: 0xd3d3d3, | |
lightpink: 0xffb6c1, | |
lightsalmon: 0xffa07a, | |
lightseagreen: 0x20b2aa, | |
lightskyblue: 0x87cefa, | |
lightslategray: 0x778899, | |
lightslategrey: 0x778899, | |
lightsteelblue: 0xb0c4de, | |
lightyellow: 0xffffe0, | |
lime: 0x00ff00, | |
limegreen: 0x32cd32, | |
linen: 0xfaf0e6, | |
magenta: 0xff00ff, | |
maroon: 0x800000, | |
mediumaquamarine: 0x66cdaa, | |
mediumblue: 0x0000cd, | |
mediumorchid: 0xba55d3, | |
mediumpurple: 0x9370db, | |
mediumseagreen: 0x3cb371, | |
mediumslateblue: 0x7b68ee, | |
mediumspringgreen: 0x00fa9a, | |
mediumturquoise: 0x48d1cc, | |
mediumvioletred: 0xc71585, | |
midnightblue: 0x191970, | |
mintcream: 0xf5fffa, | |
mistyrose: 0xffe4e1, | |
moccasin: 0xffe4b5, | |
navajowhite: 0xffdead, | |
navy: 0x000080, | |
oldlace: 0xfdf5e6, | |
olive: 0x808000, | |
olivedrab: 0x6b8e23, | |
orange: 0xffa500, | |
orangered: 0xff4500, | |
orchid: 0xda70d6, | |
palegoldenrod: 0xeee8aa, | |
palegreen: 0x98fb98, | |
paleturquoise: 0xafeeee, | |
palevioletred: 0xdb7093, | |
papayawhip: 0xffefd5, | |
peachpuff: 0xffdab9, | |
peru: 0xcd853f, | |
pink: 0xffc0cb, | |
plum: 0xdda0dd, | |
powderblue: 0xb0e0e6, | |
purple: 0x800080, | |
rebeccapurple: 0x663399, | |
red: 0xff0000, | |
rosybrown: 0xbc8f8f, | |
royalblue: 0x4169e1, | |
saddlebrown: 0x8b4513, | |
salmon: 0xfa8072, | |
sandybrown: 0xf4a460, | |
seagreen: 0x2e8b57, | |
seashell: 0xfff5ee, | |
sienna: 0xa0522d, | |
silver: 0xc0c0c0, | |
skyblue: 0x87ceeb, | |
slateblue: 0x6a5acd, | |
slategray: 0x708090, | |
slategrey: 0x708090, | |
snow: 0xfffafa, | |
springgreen: 0x00ff7f, | |
steelblue: 0x4682b4, | |
tan: 0xd2b48c, | |
teal: 0x008080, | |
thistle: 0xd8bfd8, | |
tomato: 0xff6347, | |
turquoise: 0x40e0d0, | |
violet: 0xee82ee, | |
wheat: 0xf5deb3, | |
white: 0xffffff, | |
whitesmoke: 0xf5f5f5, | |
yellow: 0xffff00, | |
yellowgreen: 0x9acd32 | |
}; | |
define(Color, color, { | |
displayable: function() { | |
return this.rgb().displayable(); | |
}, | |
toString: function() { | |
return this.rgb() + ""; | |
} | |
}); | |
function color(format) { | |
var m; | |
format = (format + "").trim().toLowerCase(); | |
return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00 | |
: (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000 | |
: (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0) | |
: (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) | |
: (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) | |
: (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) | |
: (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) | |
: (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) | |
: named.hasOwnProperty(format) ? rgbn(named[format]) | |
: format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) | |
: null; | |
} | |
function rgbn(n) { | |
return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); | |
} | |
function rgba(r, g, b, a) { | |
if (a <= 0) r = g = b = NaN; | |
return new Rgb(r, g, b, a); | |
} | |
function rgbConvert(o) { | |
if (!(o instanceof Color)) o = color(o); | |
if (!o) return new Rgb; | |
o = o.rgb(); | |
return new Rgb(o.r, o.g, o.b, o.opacity); | |
} | |
function colorRgb(r, g, b, opacity) { | |
return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity); | |
} | |
function Rgb(r, g, b, opacity) { | |
this.r = +r; | |
this.g = +g; | |
this.b = +b; | |
this.opacity = +opacity; | |
} | |
define(Rgb, colorRgb, extend(Color, { | |
brighter: function(k) { | |
k = k == null ? brighter : Math.pow(brighter, k); | |
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); | |
}, | |
darker: function(k) { | |
k = k == null ? darker : Math.pow(darker, k); | |
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); | |
}, | |
rgb: function() { | |
return this; | |
}, | |
displayable: function() { | |
return (0 <= this.r && this.r <= 255) | |
&& (0 <= this.g && this.g <= 255) | |
&& (0 <= this.b && this.b <= 255) | |
&& (0 <= this.opacity && this.opacity <= 1); | |
}, | |
toString: function() { | |
var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); | |
return (a === 1 ? "rgb(" : "rgba(") | |
+ Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " | |
+ Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " | |
+ Math.max(0, Math.min(255, Math.round(this.b) || 0)) | |
+ (a === 1 ? ")" : ", " + a + ")"); | |
} | |
})); | |
function hsla(h, s, l, a) { | |
if (a <= 0) h = s = l = NaN; | |
else if (l <= 0 || l >= 1) h = s = NaN; | |
else if (s <= 0) h = NaN; | |
return new Hsl(h, s, l, a); | |
} | |
function hslConvert(o) { | |
if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); | |
if (!(o instanceof Color)) o = color(o); | |
if (!o) return new Hsl; | |
if (o instanceof Hsl) return o; | |
o = o.rgb(); | |
var r = o.r / 255, | |
g = o.g / 255, | |
b = o.b / 255, | |
min = Math.min(r, g, b), | |
max = Math.max(r, g, b), | |
h = NaN, | |
s = max - min, | |
l = (max + min) / 2; | |
if (s) { | |
if (r === max) h = (g - b) / s + (g < b) * 6; | |
else if (g === max) h = (b - r) / s + 2; | |
else h = (r - g) / s + 4; | |
s /= l < 0.5 ? max + min : 2 - max - min; | |
h *= 60; | |
} else { | |
s = l > 0 && l < 1 ? 0 : h; | |
} | |
return new Hsl(h, s, l, o.opacity); | |
} | |
function colorHsl(h, s, l, opacity) { | |
return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity); | |
} | |
function Hsl(h, s, l, opacity) { | |
this.h = +h; | |
this.s = +s; | |
this.l = +l; | |
this.opacity = +opacity; | |
} | |
define(Hsl, colorHsl, extend(Color, { | |
brighter: function(k) { | |
k = k == null ? brighter : Math.pow(brighter, k); | |
return new Hsl(this.h, this.s, this.l * k, this.opacity); | |
}, | |
darker: function(k) { | |
k = k == null ? darker : Math.pow(darker, k); | |
return new Hsl(this.h, this.s, this.l * k, this.opacity); | |
}, | |
rgb: function() { | |
var h = this.h % 360 + (this.h < 0) * 360, | |
s = isNaN(h) || isNaN(this.s) ? 0 : this.s, | |
l = this.l, | |
m2 = l + (l < 0.5 ? l : 1 - l) * s, | |
m1 = 2 * l - m2; | |
return new Rgb( | |
hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), | |
hsl2rgb(h, m1, m2), | |
hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), | |
this.opacity | |
); | |
}, | |
displayable: function() { | |
return (0 <= this.s && this.s <= 1 || isNaN(this.s)) | |
&& (0 <= this.l && this.l <= 1) | |
&& (0 <= this.opacity && this.opacity <= 1); | |
} | |
})); | |
/* From FvD 13.37, CSS Color Module Level 3 */ | |
function hsl2rgb(h, m1, m2) { | |
return (h < 60 ? m1 + (m2 - m1) * h / 60 | |
: h < 180 ? m2 | |
: h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 | |
: m1) * 255; | |
} | |
var deg2rad = Math.PI / 180; | |
var rad2deg = 180 / Math.PI; | |
var Kn = 18; | |
var Xn = 0.950470; | |
var Yn = 1; | |
var Zn = 1.088830; | |
var t0 = 4 / 29; | |
var t1 = 6 / 29; | |
var t2 = 3 * t1 * t1; | |
var t3 = t1 * t1 * t1; | |
function labConvert(o) { | |
if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); | |
if (o instanceof Hcl) { | |
var h = o.h * deg2rad; | |
return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); | |
} | |
if (!(o instanceof Rgb)) o = rgbConvert(o); | |
var b = rgb2xyz(o.r), | |
a = rgb2xyz(o.g), | |
l = rgb2xyz(o.b), | |
x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn), | |
y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn), | |
z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn); | |
return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); | |
} | |
function lab(l, a, b, opacity) { | |
return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity); | |
} | |
function Lab(l, a, b, opacity) { | |
this.l = +l; | |
this.a = +a; | |
this.b = +b; | |
this.opacity = +opacity; | |
} | |
define(Lab, lab, extend(Color, { | |
brighter: function(k) { | |
return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
}, | |
darker: function(k) { | |
return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
}, | |
rgb: function() { | |
var y = (this.l + 16) / 116, | |
x = isNaN(this.a) ? y : y + this.a / 500, | |
z = isNaN(this.b) ? y : y - this.b / 200; | |
y = Yn * lab2xyz(y); | |
x = Xn * lab2xyz(x); | |
z = Zn * lab2xyz(z); | |
return new Rgb( | |
xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB | |
xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z), | |
xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z), | |
this.opacity | |
); | |
} | |
})); | |
function xyz2lab(t) { | |
return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0; | |
} | |
function lab2xyz(t) { | |
return t > t1 ? t * t * t : t2 * (t - t0); | |
} | |
function xyz2rgb(x) { | |
return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); | |
} | |
function rgb2xyz(x) { | |
return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); | |
} | |
function hclConvert(o) { | |
if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); | |
if (!(o instanceof Lab)) o = labConvert(o); | |
var h = Math.atan2(o.b, o.a) * rad2deg; | |
return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); | |
} | |
function colorHcl(h, c, l, opacity) { | |
return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity); | |
} | |
function Hcl(h, c, l, opacity) { | |
this.h = +h; | |
this.c = +c; | |
this.l = +l; | |
this.opacity = +opacity; | |
} | |
define(Hcl, colorHcl, extend(Color, { | |
brighter: function(k) { | |
return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity); | |
}, | |
darker: function(k) { | |
return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity); | |
}, | |
rgb: function() { | |
return labConvert(this).rgb(); | |
} | |
})); | |
var A = -0.14861; | |
var B = +1.78277; | |
var C = -0.29227; | |
var D = -0.90649; | |
var E = +1.97294; | |
var ED = E * D; | |
var EB = E * B; | |
var BC_DA = B * C - D * A; | |
function cubehelixConvert(o) { | |
if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity); | |
if (!(o instanceof Rgb)) o = rgbConvert(o); | |
var r = o.r / 255, | |
g = o.g / 255, | |
b = o.b / 255, | |
l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), | |
bl = b - l, | |
k = (E * (g - l) - C * bl) / D, | |
s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1 | |
h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN; | |
return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); | |
} | |
function cubehelix(h, s, l, opacity) { | |
return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); | |
} | |
function Cubehelix(h, s, l, opacity) { | |
this.h = +h; | |
this.s = +s; | |
this.l = +l; | |
this.opacity = +opacity; | |
} | |
define(Cubehelix, cubehelix, extend(Color, { | |
brighter: function(k) { | |
k = k == null ? brighter : Math.pow(brighter, k); | |
return new Cubehelix(this.h, this.s, this.l * k, this.opacity); | |
}, | |
darker: function(k) { | |
k = k == null ? darker : Math.pow(darker, k); | |
return new Cubehelix(this.h, this.s, this.l * k, this.opacity); | |
}, | |
rgb: function() { | |
var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad, | |
l = +this.l, | |
a = isNaN(this.s) ? 0 : this.s * l * (1 - l), | |
cosh = Math.cos(h), | |
sinh = Math.sin(h); | |
return new Rgb( | |
255 * (l + a * (A * cosh + B * sinh)), | |
255 * (l + a * (C * cosh + D * sinh)), | |
255 * (l + a * (E * cosh)), | |
this.opacity | |
); | |
} | |
})); | |
function basis$1(t1, v0, v1, v2, v3) { | |
var t2 = t1 * t1, t3 = t2 * t1; | |
return ((1 - 3 * t1 + 3 * t2 - t3) * v0 | |
+ (4 - 6 * t2 + 3 * t3) * v1 | |
+ (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 | |
+ t3 * v3) / 6; | |
} | |
function basis$2(values) { | |
var n = values.length - 1; | |
return function(t) { | |
var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), | |
v1 = values[i], | |
v2 = values[i + 1], | |
v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, | |
v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1; | |
return basis$1((t - i / n) * n, v0, v1, v2, v3); | |
}; | |
} | |
function basisClosed$1(values) { | |
var n = values.length; | |
return function(t) { | |
var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), | |
v0 = values[(i + n - 1) % n], | |
v1 = values[i % n], | |
v2 = values[(i + 1) % n], | |
v3 = values[(i + 2) % n]; | |
return basis$1((t - i / n) * n, v0, v1, v2, v3); | |
}; | |
} | |
function constant$2(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function linear$1(a, d) { | |
return function(t) { | |
return a + t * d; | |
}; | |
} | |
function exponential$1(a, b, y) { | |
return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { | |
return Math.pow(a + t * b, y); | |
}; | |
} | |
function hue(a, b) { | |
var d = b - a; | |
return d ? linear$1(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$2(isNaN(a) ? b : a); | |
} | |
function gamma(y) { | |
return (y = +y) === 1 ? nogamma : function(a, b) { | |
return b - a ? exponential$1(a, b, y) : constant$2(isNaN(a) ? b : a); | |
}; | |
} | |
function nogamma(a, b) { | |
var d = b - a; | |
return d ? linear$1(a, d) : constant$2(isNaN(a) ? b : a); | |
} | |
var interpolateRgb = (function rgbGamma(y) { | |
var color = gamma(y); | |
function rgb(start, end) { | |
var r = color((start = colorRgb(start)).r, (end = colorRgb(end)).r), | |
g = color(start.g, end.g), | |
b = color(start.b, end.b), | |
opacity = color(start.opacity, end.opacity); | |
return function(t) { | |
start.r = r(t); | |
start.g = g(t); | |
start.b = b(t); | |
start.opacity = opacity(t); | |
return start + ""; | |
}; | |
} | |
rgb.gamma = rgbGamma; | |
return rgb; | |
})(1); | |
function rgbSpline(spline) { | |
return function(colors) { | |
var n = colors.length, | |
r = new Array(n), | |
g = new Array(n), | |
b = new Array(n), | |
i, color; | |
for (i = 0; i < n; ++i) { | |
color = colorRgb(colors[i]); | |
r[i] = color.r || 0; | |
g[i] = color.g || 0; | |
b[i] = color.b || 0; | |
} | |
r = spline(r); | |
g = spline(g); | |
b = spline(b); | |
color.opacity = 1; | |
return function(t) { | |
color.r = r(t); | |
color.g = g(t); | |
color.b = b(t); | |
return color + ""; | |
}; | |
}; | |
} | |
var rgbBasis = rgbSpline(basis$2); | |
var rgbBasisClosed = rgbSpline(basisClosed$1); | |
function array$1(a, b) { | |
var nb = b ? b.length : 0, | |
na = a ? Math.min(nb, a.length) : 0, | |
x = new Array(nb), | |
c = new Array(nb), | |
i; | |
for (i = 0; i < na; ++i) x[i] = interpolate(a[i], b[i]); | |
for (; i < nb; ++i) c[i] = b[i]; | |
return function(t) { | |
for (i = 0; i < na; ++i) c[i] = x[i](t); | |
return c; | |
}; | |
} | |
function date(a, b) { | |
var d = new Date; | |
return a = +a, b -= a, function(t) { | |
return d.setTime(a + b * t), d; | |
}; | |
} | |
function interpolateNumber(a, b) { | |
return a = +a, b -= a, function(t) { | |
return a + b * t; | |
}; | |
} | |
function object(a, b) { | |
var i = {}, | |
c = {}, | |
k; | |
if (a === null || typeof a !== "object") a = {}; | |
if (b === null || typeof b !== "object") b = {}; | |
for (k in b) { | |
if (k in a) { | |
i[k] = interpolate(a[k], b[k]); | |
} else { | |
c[k] = b[k]; | |
} | |
} | |
return function(t) { | |
for (k in i) c[k] = i[k](t); | |
return c; | |
}; | |
} | |
var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g; | |
var reB = new RegExp(reA.source, "g"); | |
function zero(b) { | |
return function() { | |
return b; | |
}; | |
} | |
function one(b) { | |
return function(t) { | |
return b(t) + ""; | |
}; | |
} | |
function interpolateString(a, b) { | |
var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b | |
am, // current match in a | |
bm, // current match in b | |
bs, // string preceding current number in b, if any | |
i = -1, // index in s | |
s = [], // string constants and placeholders | |
q = []; // number interpolators | |
// Coerce inputs to strings. | |
a = a + "", b = b + ""; | |
// Interpolate pairs of numbers in a & b. | |
while ((am = reA.exec(a)) | |
&& (bm = reB.exec(b))) { | |
if ((bs = bm.index) > bi) { // a string precedes the next number in b | |
bs = b.slice(bi, bs); | |
if (s[i]) s[i] += bs; // coalesce with previous string | |
else s[++i] = bs; | |
} | |
if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match | |
if (s[i]) s[i] += bm; // coalesce with previous string | |
else s[++i] = bm; | |
} else { // interpolate non-matching numbers | |
s[++i] = null; | |
q.push({i: i, x: interpolateNumber(am, bm)}); | |
} | |
bi = reB.lastIndex; | |
} | |
// Add remains of b. | |
if (bi < b.length) { | |
bs = b.slice(bi); | |
if (s[i]) s[i] += bs; // coalesce with previous string | |
else s[++i] = bs; | |
} | |
// Special optimization for only a single match. | |
// Otherwise, interpolate each of the numbers and rejoin the string. | |
return s.length < 2 ? (q[0] | |
? one(q[0].x) | |
: zero(b)) | |
: (b = q.length, function(t) { | |
for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); | |
return s.join(""); | |
}); | |
} | |
function interpolate(a, b) { | |
var t = typeof b, c; | |
return b == null || t === "boolean" ? constant$2(b) | |
: (t === "number" ? interpolateNumber | |
: t === "string" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString) | |
: b instanceof color ? interpolateRgb | |
: b instanceof Date ? date | |
: Array.isArray(b) ? array$1 | |
: isNaN(b) ? object | |
: interpolateNumber)(a, b); | |
} | |
function interpolateRound(a, b) { | |
return a = +a, b -= a, function(t) { | |
return Math.round(a + b * t); | |
}; | |
} | |
var degrees = 180 / Math.PI; | |
var identity$2 = { | |
translateX: 0, | |
translateY: 0, | |
rotate: 0, | |
skewX: 0, | |
scaleX: 1, | |
scaleY: 1 | |
}; | |
function decompose(a, b, c, d, e, f) { | |
var scaleX, scaleY, skewX; | |
if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX; | |
if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX; | |
if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY; | |
if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX; | |
return { | |
translateX: e, | |
translateY: f, | |
rotate: Math.atan2(b, a) * degrees, | |
skewX: Math.atan(skewX) * degrees, | |
scaleX: scaleX, | |
scaleY: scaleY | |
}; | |
} | |
var cssNode; | |
var cssRoot; | |
var cssView; | |
var svgNode; | |
function parseCss(value) { | |
if (value === "none") return identity$2; | |
if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView; | |
cssNode.style.transform = value; | |
value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform"); | |
cssRoot.removeChild(cssNode); | |
value = value.slice(7, -1).split(","); | |
return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]); | |
} | |
function parseSvg(value) { | |
if (value == null) return identity$2; | |
if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g"); | |
svgNode.setAttribute("transform", value); | |
if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2; | |
value = value.matrix; | |
return decompose(value.a, value.b, value.c, value.d, value.e, value.f); | |
} | |
function interpolateTransform(parse, pxComma, pxParen, degParen) { | |
function pop(s) { | |
return s.length ? s.pop() + " " : ""; | |
} | |
function translate(xa, ya, xb, yb, s, q) { | |
if (xa !== xb || ya !== yb) { | |
var i = s.push("translate(", null, pxComma, null, pxParen); | |
q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)}); | |
} else if (xb || yb) { | |
s.push("translate(" + xb + pxComma + yb + pxParen); | |
} | |
} | |
function rotate(a, b, s, q) { | |
if (a !== b) { | |
if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path | |
q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: interpolateNumber(a, b)}); | |
} else if (b) { | |
s.push(pop(s) + "rotate(" + b + degParen); | |
} | |
} | |
function skewX(a, b, s, q) { | |
if (a !== b) { | |
q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: interpolateNumber(a, b)}); | |
} else if (b) { | |
s.push(pop(s) + "skewX(" + b + degParen); | |
} | |
} | |
function scale(xa, ya, xb, yb, s, q) { | |
if (xa !== xb || ya !== yb) { | |
var i = s.push(pop(s) + "scale(", null, ",", null, ")"); | |
q.push({i: i - 4, x: interpolateNumber(xa, xb)}, {i: i - 2, x: interpolateNumber(ya, yb)}); | |
} else if (xb !== 1 || yb !== 1) { | |
s.push(pop(s) + "scale(" + xb + "," + yb + ")"); | |
} | |
} | |
return function(a, b) { | |
var s = [], // string constants and placeholders | |
q = []; // number interpolators | |
a = parse(a), b = parse(b); | |
translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q); | |
rotate(a.rotate, b.rotate, s, q); | |
skewX(a.skewX, b.skewX, s, q); | |
scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); | |
a = b = null; // gc | |
return function(t) { | |
var i = -1, n = q.length, o; | |
while (++i < n) s[(o = q[i]).i] = o.x(t); | |
return s.join(""); | |
}; | |
}; | |
} | |
var interpolateTransform$1 = interpolateTransform(parseCss, "px, ", "px)", "deg)"); | |
var interpolateTransform$2 = interpolateTransform(parseSvg, ", ", ")", ")"); | |
var rho = Math.SQRT2; | |
var rho2 = 2; | |
var rho4 = 4; | |
var epsilon2 = 1e-12; | |
function cosh(x) { | |
return ((x = Math.exp(x)) + 1 / x) / 2; | |
} | |
function sinh(x) { | |
return ((x = Math.exp(x)) - 1 / x) / 2; | |
} | |
function tanh(x) { | |
return ((x = Math.exp(2 * x)) - 1) / (x + 1); | |
} | |
// p0 = [ux0, uy0, w0] | |
// p1 = [ux1, uy1, w1] | |
function interpolateZoom(p0, p1) { | |
var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], | |
ux1 = p1[0], uy1 = p1[1], w1 = p1[2], | |
dx = ux1 - ux0, | |
dy = uy1 - uy0, | |
d2 = dx * dx + dy * dy, | |
i, | |
S; | |
// Special case for u0 ≅ u1. | |
if (d2 < epsilon2) { | |
S = Math.log(w1 / w0) / rho; | |
i = function(t) { | |
return [ | |
ux0 + t * dx, | |
uy0 + t * dy, | |
w0 * Math.exp(rho * t * S) | |
]; | |
} | |
} | |
// General case. | |
else { | |
var d1 = Math.sqrt(d2), | |
b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), | |
b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), | |
r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), | |
r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); | |
S = (r1 - r0) / rho; | |
i = function(t) { | |
var s = t * S, | |
coshr0 = cosh(r0), | |
u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0)); | |
return [ | |
ux0 + u * dx, | |
uy0 + u * dy, | |
w0 * coshr0 / cosh(rho * s + r0) | |
]; | |
} | |
} | |
i.duration = S * 1000; | |
return i; | |
} | |
function hsl(hue) { | |
return function(start, end) { | |
var h = hue((start = colorHsl(start)).h, (end = colorHsl(end)).h), | |
s = nogamma(start.s, end.s), | |
l = nogamma(start.l, end.l), | |
opacity = nogamma(start.opacity, end.opacity); | |
return function(t) { | |
start.h = h(t); | |
start.s = s(t); | |
start.l = l(t); | |
start.opacity = opacity(t); | |
return start + ""; | |
}; | |
} | |
} | |
var hsl$1 = hsl(hue); | |
var hslLong = hsl(nogamma); | |
function lab$1(start, end) { | |
var l = nogamma((start = lab(start)).l, (end = lab(end)).l), | |
a = nogamma(start.a, end.a), | |
b = nogamma(start.b, end.b), | |
opacity = nogamma(start.opacity, end.opacity); | |
return function(t) { | |
start.l = l(t); | |
start.a = a(t); | |
start.b = b(t); | |
start.opacity = opacity(t); | |
return start + ""; | |
}; | |
} | |
function hcl(hue) { | |
return function(start, end) { | |
var h = hue((start = colorHcl(start)).h, (end = colorHcl(end)).h), | |
c = nogamma(start.c, end.c), | |
l = nogamma(start.l, end.l), | |
opacity = nogamma(start.opacity, end.opacity); | |
return function(t) { | |
start.h = h(t); | |
start.c = c(t); | |
start.l = l(t); | |
start.opacity = opacity(t); | |
return start + ""; | |
}; | |
} | |
} | |
var hcl$1 = hcl(hue); | |
var hclLong = hcl(nogamma); | |
function cubehelix$1(hue) { | |
return (function cubehelixGamma(y) { | |
y = +y; | |
function cubehelix$$(start, end) { | |
var h = hue((start = cubehelix(start)).h, (end = cubehelix(end)).h), | |
s = nogamma(start.s, end.s), | |
l = nogamma(start.l, end.l), | |
opacity = nogamma(start.opacity, end.opacity); | |
return function(t) { | |
start.h = h(t); | |
start.s = s(t); | |
start.l = l(Math.pow(t, y)); | |
start.opacity = opacity(t); | |
return start + ""; | |
}; | |
} | |
cubehelix$$.gamma = cubehelixGamma; | |
return cubehelix$$; | |
})(1); | |
} | |
var cubehelix$2 = cubehelix$1(hue); | |
var interpolateCubehelixLong = cubehelix$1(nogamma); | |
function quantize(interpolator, n) { | |
var samples = new Array(n); | |
for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1)); | |
return samples; | |
} | |
var noop$1 = {value: function() {}}; | |
function dispatch() { | |
for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) { | |
if (!(t = arguments[i] + "") || (t in _)) throw new Error("illegal type: " + t); | |
_[t] = []; | |
} | |
return new Dispatch(_); | |
} | |
function Dispatch(_) { | |
this._ = _; | |
} | |
function parseTypenames(typenames, types) { | |
return typenames.trim().split(/^|\s+/).map(function(t) { | |
var name = "", i = t.indexOf("."); | |
if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); | |
if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t); | |
return {type: t, name: name}; | |
}); | |
} | |
Dispatch.prototype = dispatch.prototype = { | |
constructor: Dispatch, | |
on: function(typename, callback) { | |
var _ = this._, | |
T = parseTypenames(typename + "", _), | |
t, | |
i = -1, | |
n = T.length; | |
// If no callback was specified, return the callback of the given type and name. | |
if (arguments.length < 2) { | |
while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t; | |
return; | |
} | |
// If a type was specified, set the callback for the given type and name. | |
// Otherwise, if a null callback was specified, remove callbacks of the given name. | |
if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback); | |
while (++i < n) { | |
if (t = (typename = T[i]).type) _[t] = set$1(_[t], typename.name, callback); | |
else if (callback == null) for (t in _) _[t] = set$1(_[t], typename.name, null); | |
} | |
return this; | |
}, | |
copy: function() { | |
var copy = {}, _ = this._; | |
for (var t in _) copy[t] = _[t].slice(); | |
return new Dispatch(copy); | |
}, | |
call: function(type, that) { | |
if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2]; | |
if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); | |
for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); | |
}, | |
apply: function(type, that, args) { | |
if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); | |
for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); | |
} | |
}; | |
function get(type, name) { | |
for (var i = 0, n = type.length, c; i < n; ++i) { | |
if ((c = type[i]).name === name) { | |
return c.value; | |
} | |
} | |
} | |
function set$1(type, name, callback) { | |
for (var i = 0, n = type.length; i < n; ++i) { | |
if (type[i].name === name) { | |
type[i] = noop$1, type = type.slice(0, i).concat(type.slice(i + 1)); | |
break; | |
} | |
} | |
if (callback != null) type.push({name: name, value: callback}); | |
return type; | |
} | |
function objectConverter(columns) { | |
return new Function("d", "return {" + columns.map(function(name, i) { | |
return JSON.stringify(name) + ": d[" + i + "]"; | |
}).join(",") + "}"); | |
} | |
function customConverter(columns, f) { | |
var object = objectConverter(columns); | |
return function(row, i) { | |
return f(object(row), i, columns); | |
}; | |
} | |
// Compute unique columns in order of discovery. | |
function inferColumns(rows) { | |
var columnSet = Object.create(null), | |
columns = []; | |
rows.forEach(function(row) { | |
for (var column in row) { | |
if (!(column in columnSet)) { | |
columns.push(columnSet[column] = column); | |
} | |
} | |
}); | |
return columns; | |
} | |
function dsv(delimiter) { | |
var reFormat = new RegExp("[\"" + delimiter + "\n]"), | |
delimiterCode = delimiter.charCodeAt(0); | |
function parse(text, f) { | |
var convert, columns, rows = parseRows(text, function(row, i) { | |
if (convert) return convert(row, i - 1); | |
columns = row, convert = f ? customConverter(row, f) : objectConverter(row); | |
}); | |
rows.columns = columns; | |
return rows; | |
} | |
function parseRows(text, f) { | |
var EOL = {}, // sentinel value for end-of-line | |
EOF = {}, // sentinel value for end-of-file | |
rows = [], // output rows | |
N = text.length, | |
I = 0, // current character index | |
n = 0, // the current line number | |
t, // the current token | |
eol; // is the current token followed by EOL? | |
function token() { | |
if (I >= N) return EOF; // special case: end of file | |
if (eol) return eol = false, EOL; // special case: end of line | |
// special case: quotes | |
var j = I, c; | |
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; | |
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, "\""); | |
} | |
// common case: find next delimiter or newline | |
while (I < N) { | |
var k = 1; | |
c = text.charCodeAt(I++); | |
if (c === 10) eol = true; // \n | |
else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \r|\r\n | |
else if (c !== delimiterCode) continue; | |
return text.slice(j, I - k); | |
} | |
// special case: last token before EOF | |
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; | |
} | |
function format(rows, columns) { | |
if (columns == null) columns = inferColumns(rows); | |
return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) { | |
return columns.map(function(column) { | |
return formatValue(row[column]); | |
}).join(delimiter); | |
})).join("\n"); | |
} | |
function formatRows(rows) { | |
return rows.map(formatRow).join("\n"); | |
} | |
function formatRow(row) { | |
return row.map(formatValue).join(delimiter); | |
} | |
function formatValue(text) { | |
return text == null ? "" | |
: reFormat.test(text += "") ? "\"" + text.replace(/\"/g, "\"\"") + "\"" | |
: text; | |
} | |
return { | |
parse: parse, | |
parseRows: parseRows, | |
format: format, | |
formatRows: formatRows | |
}; | |
} | |
var csv = dsv(","); | |
var csvParse = csv.parse; | |
var csvParseRows = csv.parseRows; | |
var csvFormat = csv.format; | |
var csvFormatRows = csv.formatRows; | |
var tsv = dsv("\t"); | |
var tsvParse = tsv.parse; | |
var tsvParseRows = tsv.parseRows; | |
var tsvFormat = tsv.format; | |
var tsvFormatRows = tsv.formatRows; | |
function request(url, callback) { | |
var request, | |
event = dispatch("beforesend", "progress", "load", "error"), | |
mimeType, | |
headers = map$1(), | |
xhr = new XMLHttpRequest, | |
user = null, | |
password = null, | |
response, | |
responseType, | |
timeout = 0; | |
// If IE does not support CORS, use XDomainRequest. | |
if (typeof XDomainRequest !== "undefined" | |
&& !("withCredentials" in xhr) | |
&& /^(http(s)?:)?\/\//.test(url)) xhr = new XDomainRequest; | |
"onload" in xhr | |
? xhr.onload = xhr.onerror = xhr.ontimeout = respond | |
: xhr.onreadystatechange = function(o) { xhr.readyState > 3 && respond(o); }; | |
function respond(o) { | |
var status = xhr.status, result; | |
if (!status && hasResponse(xhr) | |
|| status >= 200 && status < 300 | |
|| status === 304) { | |
if (response) { | |
try { | |
result = response.call(request, xhr); | |
} catch (e) { | |
event.call("error", request, e); | |
return; | |
} | |
} else { | |
result = xhr; | |
} | |
event.call("load", request, result); | |
} else { | |
event.call("error", request, o); | |
} | |
} | |
xhr.onprogress = function(e) { | |
event.call("progress", request, e); | |
}; | |
request = { | |
header: function(name, value) { | |
name = (name + "").toLowerCase(); | |
if (arguments.length < 2) return headers.get(name); | |
if (value == null) headers.remove(name); | |
else headers.set(name, value + ""); | |
return request; | |
}, | |
// If mimeType is non-null and no Accept header is set, a default is used. | |
mimeType: function(value) { | |
if (!arguments.length) return mimeType; | |
mimeType = value == null ? null : value + ""; | |
return request; | |
}, | |
// Specifies what type the response value should take; | |
// for instance, arraybuffer, blob, document, or text. | |
responseType: function(value) { | |
if (!arguments.length) return responseType; | |
responseType = value; | |
return request; | |
}, | |
timeout: function(value) { | |
if (!arguments.length) return timeout; | |
timeout = +value; | |
return request; | |
}, | |
user: function(value) { | |
return arguments.length < 1 ? user : (user = value == null ? null : value + "", request); | |
}, | |
password: function(value) { | |
return arguments.length < 1 ? password : (password = value == null ? null : value + "", request); | |
}, | |
// Specify how to convert the response content to a specific type; | |
// changes the callback value on "load" events. | |
response: function(value) { | |
response = value; | |
return request; | |
}, | |
// Alias for send("GET", …). | |
get: function(data, callback) { | |
return request.send("GET", data, callback); | |
}, | |
// Alias for send("POST", …). | |
post: function(data, callback) { | |
return request.send("POST", data, callback); | |
}, | |
// If callback is non-null, it will be used for error and load events. | |
send: function(method, data, callback) { | |
xhr.open(method, url, true, user, password); | |
if (mimeType != null && !headers.has("accept")) headers.set("accept", mimeType + ",*/*"); | |
if (xhr.setRequestHeader) headers.each(function(value, name) { xhr.setRequestHeader(name, value); }); | |
if (mimeType != null && xhr.overrideMimeType) xhr.overrideMimeType(mimeType); | |
if (responseType != null) xhr.responseType = responseType; | |
if (timeout > 0) xhr.timeout = timeout; | |
if (callback == null && typeof data === "function") callback = data, data = null; | |
if (callback != null && callback.length === 1) callback = fixCallback(callback); | |
if (callback != null) request.on("error", callback).on("load", function(xhr) { callback(null, xhr); }); | |
event.call("beforesend", request, xhr); | |
xhr.send(data == null ? null : data); | |
return request; | |
}, | |
abort: function() { | |
xhr.abort(); | |
return request; | |
}, | |
on: function() { | |
var value = event.on.apply(event, arguments); | |
return value === event ? request : value; | |
} | |
}; | |
if (callback != null) { | |
if (typeof callback !== "function") throw new Error("invalid callback: " + callback); | |
return request.get(callback); | |
} | |
return request; | |
} | |
function fixCallback(callback) { | |
return function(error, xhr) { | |
callback(error == null ? xhr : null); | |
}; | |
} | |
function hasResponse(xhr) { | |
var type = xhr.responseType; | |
return type && type !== "text" | |
? xhr.response // null on error | |
: xhr.responseText; // "" on error | |
} | |
function type(defaultMimeType, response) { | |
return function(url, callback) { | |
var r = request(url).mimeType(defaultMimeType).response(response); | |
if (callback != null) { | |
if (typeof callback !== "function") throw new Error("invalid callback: " + callback); | |
return r.get(callback); | |
} | |
return r; | |
}; | |
} | |
var html = type("text/html", function(xhr) { | |
return document.createRange().createContextualFragment(xhr.responseText); | |
}); | |
var json = type("application/json", function(xhr) { | |
return JSON.parse(xhr.responseText); | |
}); | |
var text = type("text/plain", function(xhr) { | |
return xhr.responseText; | |
}); | |
var xml = type("application/xml", function(xhr) { | |
var xml = xhr.responseXML; | |
if (!xml) throw new Error("parse error"); | |
return xml; | |
}); | |
function dsv$1(defaultMimeType, parse) { | |
return function(url, row, callback) { | |
if (arguments.length < 3) callback = row, row = null; | |
var r = request(url).mimeType(defaultMimeType); | |
r.row = function(_) { return arguments.length ? r.response(responseOf(parse, row = _)) : row; }; | |
r.row(row); | |
return callback ? r.get(callback) : r; | |
}; | |
} | |
function responseOf(parse, row) { | |
return function(request) { | |
return parse(request.responseText, row); | |
}; | |
} | |
var csv$1 = dsv$1("text/csv", csvParse); | |
var tsv$1 = dsv$1("text/tab-separated-values", tsvParse); | |
var frame = 0; | |
var timeout = 0; | |
var interval = 0; | |
var pokeDelay = 1000; | |
var taskHead; | |
var taskTail; | |
var clockLast = 0; | |
var clockNow = 0; | |
var clockSkew = 0; | |
var clock = typeof performance === "object" && performance.now ? performance : Date; | |
var setFrame = typeof requestAnimationFrame === "function" ? requestAnimationFrame : function(f) { setTimeout(f, 17); }; | |
function now() { | |
return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew); | |
} | |
function clearNow() { | |
clockNow = 0; | |
} | |
function Timer() { | |
this._call = | |
this._time = | |
this._next = null; | |
} | |
Timer.prototype = timer.prototype = { | |
constructor: Timer, | |
restart: function(callback, delay, time) { | |
if (typeof callback !== "function") throw new TypeError("callback is not a function"); | |
time = (time == null ? now() : +time) + (delay == null ? 0 : +delay); | |
if (!this._next && taskTail !== this) { | |
if (taskTail) taskTail._next = this; | |
else taskHead = this; | |
taskTail = this; | |
} | |
this._call = callback; | |
this._time = time; | |
sleep(); | |
}, | |
stop: function() { | |
if (this._call) { | |
this._call = null; | |
this._time = Infinity; | |
sleep(); | |
} | |
} | |
}; | |
function timer(callback, delay, time) { | |
var t = new Timer; | |
t.restart(callback, delay, time); | |
return t; | |
} | |
function timerFlush() { | |
now(); // Get the current time, if not already set. | |
++frame; // Pretend we’ve set an alarm, if we haven’t already. | |
var t = taskHead, e; | |
while (t) { | |
if ((e = clockNow - t._time) >= 0) t._call.call(null, e); | |
t = t._next; | |
} | |
--frame; | |
} | |
function wake() { | |
clockNow = (clockLast = clock.now()) + clockSkew; | |
frame = timeout = 0; | |
try { | |
timerFlush(); | |
} finally { | |
frame = 0; | |
nap(); | |
clockNow = 0; | |
} | |
} | |
function poke$1() { | |
var now = clock.now(), delay = now - clockLast; | |
if (delay > pokeDelay) clockSkew -= delay, clockLast = now; | |
} | |
function nap() { | |
var t0, t1 = taskHead, t2, time = Infinity; | |
while (t1) { | |
if (t1._call) { | |
if (time > t1._time) time = t1._time; | |
t0 = t1, t1 = t1._next; | |
} else { | |
t2 = t1._next, t1._next = null; | |
t1 = t0 ? t0._next = t2 : taskHead = t2; | |
} | |
} | |
taskTail = t0; | |
sleep(time); | |
} | |
function sleep(time) { | |
if (frame) return; // Soonest alarm already set, or will be. | |
if (timeout) timeout = clearTimeout(timeout); | |
var delay = time - clockNow; | |
if (delay > 24) { | |
if (time < Infinity) timeout = setTimeout(wake, delay); | |
if (interval) interval = clearInterval(interval); | |
} else { | |
if (!interval) interval = setInterval(poke$1, pokeDelay); | |
frame = 1, setFrame(wake); | |
} | |
} | |
function timeout$1(callback, delay, time) { | |
var t = new Timer; | |
delay = delay == null ? 0 : +delay; | |
t.restart(function(elapsed) { | |
t.stop(); | |
callback(elapsed + delay); | |
}, delay, time); | |
return t; | |
} | |
function interval$1(callback, delay, time) { | |
var t = new Timer, total = delay; | |
if (delay == null) return t.restart(callback, delay, time), t; | |
delay = +delay, time = time == null ? now() : +time; | |
t.restart(function tick(elapsed) { | |
elapsed += total; | |
t.restart(tick, total += delay, time); | |
callback(elapsed); | |
}, delay, time); | |
return t; | |
} | |
var t0$1 = new Date; | |
var t1$1 = new Date; | |
function newInterval(floori, offseti, count, field) { | |
function interval(date) { | |
return floori(date = new Date(+date)), date; | |
} | |
interval.floor = interval; | |
interval.ceil = function(date) { | |
return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date; | |
}; | |
interval.round = function(date) { | |
var d0 = interval(date), | |
d1 = interval.ceil(date); | |
return date - d0 < d1 - date ? d0 : d1; | |
}; | |
interval.offset = function(date, step) { | |
return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date; | |
}; | |
interval.range = function(start, stop, step) { | |
var range = []; | |
start = interval.ceil(start); | |
step = step == null ? 1 : Math.floor(step); | |
if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date | |
do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop) | |
return range; | |
}; | |
interval.filter = function(test) { | |
return newInterval(function(date) { | |
if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1); | |
}, function(date, step) { | |
if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty | |
}); | |
}; | |
if (count) { | |
interval.count = function(start, end) { | |
t0$1.setTime(+start), t1$1.setTime(+end); | |
floori(t0$1), floori(t1$1); | |
return Math.floor(count(t0$1, t1$1)); | |
}; | |
interval.every = function(step) { | |
step = Math.floor(step); | |
return !isFinite(step) || !(step > 0) ? null | |
: !(step > 1) ? interval | |
: interval.filter(field | |
? function(d) { return field(d) % step === 0; } | |
: function(d) { return interval.count(0, d) % step === 0; }); | |
}; | |
} | |
return interval; | |
} | |
var millisecond = newInterval(function() { | |
// noop | |
}, function(date, step) { | |
date.setTime(+date + step); | |
}, function(start, end) { | |
return end - start; | |
}); | |
// An optimized implementation for this simple case. | |
millisecond.every = function(k) { | |
k = Math.floor(k); | |
if (!isFinite(k) || !(k > 0)) return null; | |
if (!(k > 1)) return millisecond; | |
return newInterval(function(date) { | |
date.setTime(Math.floor(date / k) * k); | |
}, function(date, step) { | |
date.setTime(+date + step * k); | |
}, function(start, end) { | |
return (end - start) / k; | |
}); | |
}; | |
var milliseconds = millisecond.range; | |
var durationSecond = 1e3; | |
var durationMinute = 6e4; | |
var durationHour = 36e5; | |
var durationDay = 864e5; | |
var durationWeek = 6048e5; | |
var second = newInterval(function(date) { | |
date.setTime(Math.floor(date / durationSecond) * durationSecond); | |
}, function(date, step) { | |
date.setTime(+date + step * durationSecond); | |
}, function(start, end) { | |
return (end - start) / durationSecond; | |
}, function(date) { | |
return date.getUTCSeconds(); | |
}); | |
var seconds = second.range; | |
var minute = newInterval(function(date) { | |
date.setTime(Math.floor(date / durationMinute) * durationMinute); | |
}, function(date, step) { | |
date.setTime(+date + step * durationMinute); | |
}, function(start, end) { | |
return (end - start) / durationMinute; | |
}, function(date) { | |
return date.getMinutes(); | |
}); | |
var minutes = minute.range; | |
var hour = newInterval(function(date) { | |
var offset = date.getTimezoneOffset() * durationMinute % durationHour; | |
if (offset < 0) offset += durationHour; | |
date.setTime(Math.floor((+date - offset) / durationHour) * durationHour + offset); | |
}, function(date, step) { | |
date.setTime(+date + step * durationHour); | |
}, function(start, end) { | |
return (end - start) / durationHour; | |
}, function(date) { | |
return date.getHours(); | |
}); | |
var hours = hour.range; | |
var day = newInterval(function(date) { | |
date.setHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setDate(date.getDate() + step); | |
}, function(start, end) { | |
return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay; | |
}, function(date) { | |
return date.getDate() - 1; | |
}); | |
var days = day.range; | |
function weekday(i) { | |
return newInterval(function(date) { | |
date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7); | |
date.setHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setDate(date.getDate() + step * 7); | |
}, function(start, end) { | |
return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek; | |
}); | |
} | |
var timeWeek = weekday(0); | |
var timeMonday = weekday(1); | |
var tuesday = weekday(2); | |
var wednesday = weekday(3); | |
var thursday = weekday(4); | |
var friday = weekday(5); | |
var saturday = weekday(6); | |
var sundays = timeWeek.range; | |
var mondays = timeMonday.range; | |
var tuesdays = tuesday.range; | |
var wednesdays = wednesday.range; | |
var thursdays = thursday.range; | |
var fridays = friday.range; | |
var saturdays = saturday.range; | |
var month = newInterval(function(date) { | |
date.setDate(1); | |
date.setHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setMonth(date.getMonth() + step); | |
}, function(start, end) { | |
return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12; | |
}, function(date) { | |
return date.getMonth(); | |
}); | |
var months = month.range; | |
var year = newInterval(function(date) { | |
date.setMonth(0, 1); | |
date.setHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setFullYear(date.getFullYear() + step); | |
}, function(start, end) { | |
return end.getFullYear() - start.getFullYear(); | |
}, function(date) { | |
return date.getFullYear(); | |
}); | |
// An optimized implementation for this simple case. | |
year.every = function(k) { | |
return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) { | |
date.setFullYear(Math.floor(date.getFullYear() / k) * k); | |
date.setMonth(0, 1); | |
date.setHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setFullYear(date.getFullYear() + step * k); | |
}); | |
}; | |
var years = year.range; | |
var utcMinute = newInterval(function(date) { | |
date.setUTCSeconds(0, 0); | |
}, function(date, step) { | |
date.setTime(+date + step * durationMinute); | |
}, function(start, end) { | |
return (end - start) / durationMinute; | |
}, function(date) { | |
return date.getUTCMinutes(); | |
}); | |
var utcMinutes = utcMinute.range; | |
var utcHour = newInterval(function(date) { | |
date.setUTCMinutes(0, 0, 0); | |
}, function(date, step) { | |
date.setTime(+date + step * durationHour); | |
}, function(start, end) { | |
return (end - start) / durationHour; | |
}, function(date) { | |
return date.getUTCHours(); | |
}); | |
var utcHours = utcHour.range; | |
var utcDay = newInterval(function(date) { | |
date.setUTCHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setUTCDate(date.getUTCDate() + step); | |
}, function(start, end) { | |
return (end - start) / durationDay; | |
}, function(date) { | |
return date.getUTCDate() - 1; | |
}); | |
var utcDays = utcDay.range; | |
function utcWeekday(i) { | |
return newInterval(function(date) { | |
date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7); | |
date.setUTCHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setUTCDate(date.getUTCDate() + step * 7); | |
}, function(start, end) { | |
return (end - start) / durationWeek; | |
}); | |
} | |
var utcWeek = utcWeekday(0); | |
var utcMonday = utcWeekday(1); | |
var utcTuesday = utcWeekday(2); | |
var utcWednesday = utcWeekday(3); | |
var utcThursday = utcWeekday(4); | |
var utcFriday = utcWeekday(5); | |
var utcSaturday = utcWeekday(6); | |
var utcSundays = utcWeek.range; | |
var utcMondays = utcMonday.range; | |
var utcTuesdays = utcTuesday.range; | |
var utcWednesdays = utcWednesday.range; | |
var utcThursdays = utcThursday.range; | |
var utcFridays = utcFriday.range; | |
var utcSaturdays = utcSaturday.range; | |
var utcMonth = newInterval(function(date) { | |
date.setUTCDate(1); | |
date.setUTCHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setUTCMonth(date.getUTCMonth() + step); | |
}, function(start, end) { | |
return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12; | |
}, function(date) { | |
return date.getUTCMonth(); | |
}); | |
var utcMonths = utcMonth.range; | |
var utcYear = newInterval(function(date) { | |
date.setUTCMonth(0, 1); | |
date.setUTCHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setUTCFullYear(date.getUTCFullYear() + step); | |
}, function(start, end) { | |
return end.getUTCFullYear() - start.getUTCFullYear(); | |
}, function(date) { | |
return date.getUTCFullYear(); | |
}); | |
// An optimized implementation for this simple case. | |
utcYear.every = function(k) { | |
return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) { | |
date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k); | |
date.setUTCMonth(0, 1); | |
date.setUTCHours(0, 0, 0, 0); | |
}, function(date, step) { | |
date.setUTCFullYear(date.getUTCFullYear() + step * k); | |
}); | |
}; | |
var utcYears = utcYear.range; | |
// Computes the decimal coefficient and exponent of the specified number x with | |
// significant digits p, where x is positive and p is in [1, 21] or undefined. | |
// For example, formatDecimal(1.23) returns ["123", 0]. | |
function formatDecimal(x, p) { | |
if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity | |
var i, coefficient = x.slice(0, i); | |
// The string returned by toExponential either has the form \d\.\d+e[-+]\d+ | |
// (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3). | |
return [ | |
coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, | |
+x.slice(i + 1) | |
]; | |
} | |
function exponent$1(x) { | |
return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN; | |
} | |
function formatGroup(grouping, thousands) { | |
return function(value, width) { | |
var i = value.length, | |
t = [], | |
j = 0, | |
g = grouping[0], | |
length = 0; | |
while (i > 0 && g > 0) { | |
if (length + g + 1 > width) g = Math.max(1, width - length); | |
t.push(value.substring(i -= g, i + g)); | |
if ((length += g + 1) > width) break; | |
g = grouping[j = (j + 1) % grouping.length]; | |
} | |
return t.reverse().join(thousands); | |
}; | |
} | |
function formatDefault(x, p) { | |
x = x.toPrecision(p); | |
out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) { | |
switch (x[i]) { | |
case ".": i0 = i1 = i; break; | |
case "0": if (i0 === 0) i0 = i; i1 = i; break; | |
case "e": break out; | |
default: if (i0 > 0) i0 = 0; break; | |
} | |
} | |
return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x; | |
} | |
var prefixExponent; | |
function formatPrefixAuto(x, p) { | |
var d = formatDecimal(x, p); | |
if (!d) return x + ""; | |
var coefficient = d[0], | |
exponent = d[1], | |
i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, | |
n = coefficient.length; | |
return i === n ? coefficient | |
: i > n ? coefficient + new Array(i - n + 1).join("0") | |
: i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) | |
: "0." + new Array(1 - i).join("0") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y! | |
} | |
function formatRounded(x, p) { | |
var d = formatDecimal(x, p); | |
if (!d) return x + ""; | |
var coefficient = d[0], | |
exponent = d[1]; | |
return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient | |
: coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) | |
: coefficient + new Array(exponent - coefficient.length + 2).join("0"); | |
} | |
var formatTypes = { | |
"": formatDefault, | |
"%": function(x, p) { return (x * 100).toFixed(p); }, | |
"b": function(x) { return Math.round(x).toString(2); }, | |
"c": function(x) { return x + ""; }, | |
"d": function(x) { return Math.round(x).toString(10); }, | |
"e": function(x, p) { return x.toExponential(p); }, | |
"f": function(x, p) { return x.toFixed(p); }, | |
"g": function(x, p) { return x.toPrecision(p); }, | |
"o": function(x) { return Math.round(x).toString(8); }, | |
"p": function(x, p) { return formatRounded(x * 100, p); }, | |
"r": formatRounded, | |
"s": formatPrefixAuto, | |
"X": function(x) { return Math.round(x).toString(16).toUpperCase(); }, | |
"x": function(x) { return Math.round(x).toString(16); } | |
}; | |
// [[fill]align][sign][symbol][0][width][,][.precision][type] | |
var re = /^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i; | |
function formatSpecifier(specifier) { | |
return new FormatSpecifier(specifier); | |
} | |
function FormatSpecifier(specifier) { | |
if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier); | |
var match, | |
fill = match[1] || " ", | |
align = match[2] || ">", | |
sign = match[3] || "-", | |
symbol = match[4] || "", | |
zero = !!match[5], | |
width = match[6] && +match[6], | |
comma = !!match[7], | |
precision = match[8] && +match[8].slice(1), | |
type = match[9] || ""; | |
// The "n" type is an alias for ",g". | |
if (type === "n") comma = true, type = "g"; | |
// Map invalid types to the default format. | |
else if (!formatTypes[type]) type = ""; | |
// If zero fill is specified, padding goes after sign and before digits. | |
if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "="; | |
this.fill = fill; | |
this.align = align; | |
this.sign = sign; | |
this.symbol = symbol; | |
this.zero = zero; | |
this.width = width; | |
this.comma = comma; | |
this.precision = precision; | |
this.type = type; | |
} | |
FormatSpecifier.prototype.toString = function() { | |
return this.fill | |
+ this.align | |
+ this.sign | |
+ this.symbol | |
+ (this.zero ? "0" : "") | |
+ (this.width == null ? "" : Math.max(1, this.width | 0)) | |
+ (this.comma ? "," : "") | |
+ (this.precision == null ? "" : "." + Math.max(0, this.precision | 0)) | |
+ this.type; | |
}; | |
var prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"]; | |
function identity$3(x) { | |
return x; | |
} | |
function formatLocale(locale) { | |
var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity$3, | |
currency = locale.currency, | |
decimal = locale.decimal; | |
function newFormat(specifier) { | |
specifier = formatSpecifier(specifier); | |
var fill = specifier.fill, | |
align = specifier.align, | |
sign = specifier.sign, | |
symbol = specifier.symbol, | |
zero = specifier.zero, | |
width = specifier.width, | |
comma = specifier.comma, | |
precision = specifier.precision, | |
type = specifier.type; | |
// Compute the prefix and suffix. | |
// For SI-prefix, the suffix is lazily computed. | |
var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", | |
suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? "%" : ""; | |
// What format function should we use? | |
// Is this an integer type? | |
// Can this type generate exponential notation? | |
var formatType = formatTypes[type], | |
maybeSuffix = !type || /[defgprs%]/.test(type); | |
// Set the default precision if not specified, | |
// or clamp the specified precision to the supported range. | |
// For significant precision, it must be in [1, 21]. | |
// For fixed precision, it must be in [0, 20]. | |
precision = precision == null ? (type ? 6 : 12) | |
: /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) | |
: Math.max(0, Math.min(20, precision)); | |
function format(value) { | |
var valuePrefix = prefix, | |
valueSuffix = suffix, | |
i, n, c; | |
if (type === "c") { | |
valueSuffix = formatType(value) + valueSuffix; | |
value = ""; | |
} else { | |
value = +value; | |
// Convert negative to positive, and compute the prefix. | |
// Note that -0 is not less than 0, but 1 / -0 is! | |
var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true); | |
// Perform the initial formatting. | |
value = formatType(value, precision); | |
// If the original value was negative, it may be rounded to zero during | |
// formatting; treat this as (positive) zero. | |
if (valueNegative) { | |
i = -1, n = value.length; | |
valueNegative = false; | |
while (++i < n) { | |
if (c = value.charCodeAt(i), (48 < c && c < 58) | |
|| (type === "x" && 96 < c && c < 103) | |
|| (type === "X" && 64 < c && c < 71)) { | |
valueNegative = true; | |
break; | |
} | |
} | |
} | |
// Compute the prefix and suffix. | |
valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix; | |
valueSuffix = valueSuffix + (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + (valueNegative && sign === "(" ? ")" : ""); | |
// Break the formatted value into the integer “value” part that can be | |
// grouped, and fractional or exponential “suffix” part that is not. | |
if (maybeSuffix) { | |
i = -1, n = value.length; | |
while (++i < n) { | |
if (c = value.charCodeAt(i), 48 > c || c > 57) { | |
valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix; | |
value = value.slice(0, i); | |
break; | |
} | |
} | |
} | |
} | |
// If the fill character is not "0", grouping is applied before padding. | |
if (comma && !zero) value = group(value, Infinity); | |
// Compute the padding. | |
var length = valuePrefix.length + value.length + valueSuffix.length, | |
padding = length < width ? new Array(width - length + 1).join(fill) : ""; | |
// If the fill character is "0", grouping is applied after padding. | |
if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = ""; | |
// Reconstruct the final output based on the desired alignment. | |
switch (align) { | |
case "<": return valuePrefix + value + valueSuffix + padding; | |
case "=": return valuePrefix + padding + value + valueSuffix; | |
case "^": return padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); | |
} | |
return padding + valuePrefix + value + valueSuffix; | |
} | |
format.toString = function() { | |
return specifier + ""; | |
}; | |
return format; | |
} | |
function formatPrefix(specifier, value) { | |
var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)), | |
e = Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3, | |
k = Math.pow(10, -e), | |
prefix = prefixes[8 + e / 3]; | |
return function(value) { | |
return f(k * value) + prefix; | |
}; | |
} | |
return { | |
format: newFormat, | |
formatPrefix: formatPrefix | |
}; | |
} | |
var locale; | |
defaultLocale({ | |
decimal: ".", | |
thousands: ",", | |
grouping: [3], | |
currency: ["$", ""] | |
}); | |
function defaultLocale(definition) { | |
locale = formatLocale(definition); | |
exports.format = locale.format; | |
exports.formatPrefix = locale.formatPrefix; | |
return locale; | |
} | |
function precisionFixed(step) { | |
return Math.max(0, -exponent$1(Math.abs(step))); | |
} | |
function precisionPrefix(step, value) { | |
return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3 - exponent$1(Math.abs(step))); | |
} | |
function precisionRound(step, max) { | |
step = Math.abs(step), max = Math.abs(max) - step; | |
return Math.max(0, exponent$1(max) - exponent$1(step)) + 1; | |
} | |
function localDate(d) { | |
if (0 <= d.y && d.y < 100) { | |
var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L); | |
date.setFullYear(d.y); | |
return date; | |
} | |
return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L); | |
} | |
function utcDate(d) { | |
if (0 <= d.y && d.y < 100) { | |
var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L)); | |
date.setUTCFullYear(d.y); | |
return date; | |
} | |
return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L)); | |
} | |
function newYear(y) { | |
return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0}; | |
} | |
function formatLocale$1(locale) { | |
var locale_dateTime = locale.dateTime, | |
locale_date = locale.date, | |
locale_time = locale.time, | |
locale_periods = locale.periods, | |
locale_weekdays = locale.days, | |
locale_shortWeekdays = locale.shortDays, | |
locale_months = locale.months, | |
locale_shortMonths = locale.shortMonths; | |
var periodRe = formatRe(locale_periods), | |
periodLookup = formatLookup(locale_periods), | |
weekdayRe = formatRe(locale_weekdays), | |
weekdayLookup = formatLookup(locale_weekdays), | |
shortWeekdayRe = formatRe(locale_shortWeekdays), | |
shortWeekdayLookup = formatLookup(locale_shortWeekdays), | |
monthRe = formatRe(locale_months), | |
monthLookup = formatLookup(locale_months), | |
shortMonthRe = formatRe(locale_shortMonths), | |
shortMonthLookup = formatLookup(locale_shortMonths); | |
var formats = { | |
"a": formatShortWeekday, | |
"A": formatWeekday, | |
"b": formatShortMonth, | |
"B": formatMonth, | |
"c": null, | |
"d": formatDayOfMonth, | |
"e": formatDayOfMonth, | |
"H": formatHour24, | |
"I": formatHour12, | |
"j": formatDayOfYear, | |
"L": formatMilliseconds, | |
"m": formatMonthNumber, | |
"M": formatMinutes, | |
"p": formatPeriod, | |
"S": formatSeconds, | |
"U": formatWeekNumberSunday, | |
"w": formatWeekdayNumber, | |
"W": formatWeekNumberMonday, | |
"x": null, | |
"X": null, | |
"y": formatYear, | |
"Y": formatFullYear, | |
"Z": formatZone, | |
"%": formatLiteralPercent | |
}; | |
var utcFormats = { | |
"a": formatUTCShortWeekday, | |
"A": formatUTCWeekday, | |
"b": formatUTCShortMonth, | |
"B": formatUTCMonth, | |
"c": null, | |
"d": formatUTCDayOfMonth, | |
"e": formatUTCDayOfMonth, | |
"H": formatUTCHour24, | |
"I": formatUTCHour12, | |
"j": formatUTCDayOfYear, | |
"L": formatUTCMilliseconds, | |
"m": formatUTCMonthNumber, | |
"M": formatUTCMinutes, | |
"p": formatUTCPeriod, | |
"S": formatUTCSeconds, | |
"U": formatUTCWeekNumberSunday, | |
"w": formatUTCWeekdayNumber, | |
"W": formatUTCWeekNumberMonday, | |
"x": null, | |
"X": null, | |
"y": formatUTCYear, | |
"Y": formatUTCFullYear, | |
"Z": formatUTCZone, | |
"%": formatLiteralPercent | |
}; | |
var parses = { | |
"a": parseShortWeekday, | |
"A": parseWeekday, | |
"b": parseShortMonth, | |
"B": parseMonth, | |
"c": parseLocaleDateTime, | |
"d": parseDayOfMonth, | |
"e": parseDayOfMonth, | |
"H": parseHour24, | |
"I": parseHour24, | |
"j": parseDayOfYear, | |
"L": parseMilliseconds, | |
"m": parseMonthNumber, | |
"M": parseMinutes, | |
"p": parsePeriod, | |
"S": parseSeconds, | |
"U": parseWeekNumberSunday, | |
"w": parseWeekdayNumber, | |
"W": parseWeekNumberMonday, | |
"x": parseLocaleDate, | |
"X": parseLocaleTime, | |
"y": parseYear, | |
"Y": parseFullYear, | |
"Z": parseZone, | |
"%": parseLiteralPercent | |
}; | |
// These recursive directive definitions must be deferred. | |
formats.x = newFormat(locale_date, formats); | |
formats.X = newFormat(locale_time, formats); | |
formats.c = newFormat(locale_dateTime, formats); | |
utcFormats.x = newFormat(locale_date, utcFormats); | |
utcFormats.X = newFormat(locale_time, utcFormats); | |
utcFormats.c = newFormat(locale_dateTime, utcFormats); | |
function newFormat(specifier, formats) { | |
return function(date) { | |
var string = [], | |
i = -1, | |
j = 0, | |
n = specifier.length, | |
c, | |
pad, | |
format; | |
if (!(date instanceof Date)) date = new Date(+date); | |
while (++i < n) { | |
if (specifier.charCodeAt(i) === 37) { | |
string.push(specifier.slice(j, i)); | |
if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i); | |
else pad = c === "e" ? " " : "0"; | |
if (format = formats[c]) c = format(date, pad); | |
string.push(c); | |
j = i + 1; | |
} | |
} | |
string.push(specifier.slice(j, i)); | |
return string.join(""); | |
}; | |
} | |
function newParse(specifier, newDate) { | |
return function(string) { | |
var d = newYear(1900), | |
i = parseSpecifier(d, specifier, string += "", 0); | |
if (i != string.length) return null; | |
// The am-pm flag is 0 for AM, and 1 for PM. | |
if ("p" in d) d.H = d.H % 12 + d.p * 12; | |
// Convert day-of-week and week-of-year to day-of-year. | |
if ("W" in d || "U" in d) { | |
if (!("w" in d)) d.w = "W" in d ? 1 : 0; | |
var day = "Z" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay(); | |
d.m = 0; | |
d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7; | |
} | |
// If a time zone is specified, all fields are interpreted as UTC and then | |
// offset according to the specified time zone. | |
if ("Z" in d) { | |
d.H += d.Z / 100 | 0; | |
d.M += d.Z % 100; | |
return utcDate(d); | |
} | |
// Otherwise, all fields are in local time. | |
return newDate(d); | |
}; | |
} | |
function parseSpecifier(d, specifier, string, j) { | |
var i = 0, | |
n = specifier.length, | |
m = string.length, | |
c, | |
parse; | |
while (i < n) { | |
if (j >= m) return -1; | |
c = specifier.charCodeAt(i++); | |
if (c === 37) { | |
c = specifier.charAt(i++); | |
parse = parses[c in pads ? specifier.charAt(i++) : c]; | |
if (!parse || ((j = parse(d, string, j)) < 0)) return -1; | |
} else if (c != string.charCodeAt(j++)) { | |
return -1; | |
} | |
} | |
return j; | |
} | |
function parsePeriod(d, string, i) { | |
var n = periodRe.exec(string.slice(i)); | |
return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
} | |
function parseShortWeekday(d, string, i) { | |
var n = shortWeekdayRe.exec(string.slice(i)); | |
return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
} | |
function parseWeekday(d, string, i) { | |
var n = weekdayRe.exec(string.slice(i)); | |
return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
} | |
function parseShortMonth(d, string, i) { | |
var n = shortMonthRe.exec(string.slice(i)); | |
return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
} | |
function parseMonth(d, string, i) { | |
var n = monthRe.exec(string.slice(i)); | |
return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
} | |
function parseLocaleDateTime(d, string, i) { | |
return parseSpecifier(d, locale_dateTime, string, i); | |
} | |
function parseLocaleDate(d, string, i) { | |
return parseSpecifier(d, locale_date, string, i); | |
} | |
function parseLocaleTime(d, string, i) { | |
return parseSpecifier(d, locale_time, string, i); | |
} | |
function formatShortWeekday(d) { | |
return locale_shortWeekdays[d.getDay()]; | |
} | |
function formatWeekday(d) { | |
return locale_weekdays[d.getDay()]; | |
} | |
function formatShortMonth(d) { | |
return locale_shortMonths[d.getMonth()]; | |
} | |
function formatMonth(d) { | |
return locale_months[d.getMonth()]; | |
} | |
function formatPeriod(d) { | |
return locale_periods[+(d.getHours() >= 12)]; | |
} | |
function formatUTCShortWeekday(d) { | |
return locale_shortWeekdays[d.getUTCDay()]; | |
} | |
function formatUTCWeekday(d) { | |
return locale_weekdays[d.getUTCDay()]; | |
} | |
function formatUTCShortMonth(d) { | |
return locale_shortMonths[d.getUTCMonth()]; | |
} | |
function formatUTCMonth(d) { | |
return locale_months[d.getUTCMonth()]; | |
} | |
function formatUTCPeriod(d) { | |
return locale_periods[+(d.getUTCHours() >= 12)]; | |
} | |
return { | |
format: function(specifier) { | |
var f = newFormat(specifier += "", formats); | |
f.toString = function() { return specifier; }; | |
return f; | |
}, | |
parse: function(specifier) { | |
var p = newParse(specifier += "", localDate); | |
p.toString = function() { return specifier; }; | |
return p; | |
}, | |
utcFormat: function(specifier) { | |
var f = newFormat(specifier += "", utcFormats); | |
f.toString = function() { return specifier; }; | |
return f; | |
}, | |
utcParse: function(specifier) { | |
var p = newParse(specifier, utcDate); | |
p.toString = function() { return specifier; }; | |
return p; | |
} | |
}; | |
} | |
var pads = {"-": "", "_": " ", "0": "0"}; | |
var numberRe = /^\s*\d+/; | |
var percentRe = /^%/; | |
var requoteRe = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; | |
function pad(value, fill, width) { | |
var sign = value < 0 ? "-" : "", | |
string = (sign ? -value : value) + "", | |
length = string.length; | |
return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string); | |
} | |
function requote(s) { | |
return s.replace(requoteRe, "\\$&"); | |
} | |
function formatRe(names) { | |
return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i"); | |
} | |
function formatLookup(names) { | |
var map = {}, i = -1, n = names.length; | |
while (++i < n) map[names[i].toLowerCase()] = i; | |
return map; | |
} | |
function parseWeekdayNumber(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 1)); | |
return n ? (d.w = +n[0], i + n[0].length) : -1; | |
} | |
function parseWeekNumberSunday(d, string, i) { | |
var n = numberRe.exec(string.slice(i)); | |
return n ? (d.U = +n[0], i + n[0].length) : -1; | |
} | |
function parseWeekNumberMonday(d, string, i) { | |
var n = numberRe.exec(string.slice(i)); | |
return n ? (d.W = +n[0], i + n[0].length) : -1; | |
} | |
function parseFullYear(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 4)); | |
return n ? (d.y = +n[0], i + n[0].length) : -1; | |
} | |
function parseYear(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 2)); | |
return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1; | |
} | |
function parseZone(d, string, i) { | |
var n = /^(Z)|([+-]\d\d)(?:\:?(\d\d))?/.exec(string.slice(i, i + 6)); | |
return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1; | |
} | |
function parseMonthNumber(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 2)); | |
return n ? (d.m = n[0] - 1, i + n[0].length) : -1; | |
} | |
function parseDayOfMonth(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 2)); | |
return n ? (d.d = +n[0], i + n[0].length) : -1; | |
} | |
function parseDayOfYear(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 3)); | |
return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1; | |
} | |
function parseHour24(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 2)); | |
return n ? (d.H = +n[0], i + n[0].length) : -1; | |
} | |
function parseMinutes(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 2)); | |
return n ? (d.M = +n[0], i + n[0].length) : -1; | |
} | |
function parseSeconds(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 2)); | |
return n ? (d.S = +n[0], i + n[0].length) : -1; | |
} | |
function parseMilliseconds(d, string, i) { | |
var n = numberRe.exec(string.slice(i, i + 3)); | |
return n ? (d.L = +n[0], i + n[0].length) : -1; | |
} | |
function parseLiteralPercent(d, string, i) { | |
var n = percentRe.exec(string.slice(i, i + 1)); | |
return n ? i + n[0].length : -1; | |
} | |
function formatDayOfMonth(d, p) { | |
return pad(d.getDate(), p, 2); | |
} | |
function formatHour24(d, p) { | |
return pad(d.getHours(), p, 2); | |
} | |
function formatHour12(d, p) { | |
return pad(d.getHours() % 12 || 12, p, 2); | |
} | |
function formatDayOfYear(d, p) { | |
return pad(1 + day.count(year(d), d), p, 3); | |
} | |
function formatMilliseconds(d, p) { | |
return pad(d.getMilliseconds(), p, 3); | |
} | |
function formatMonthNumber(d, p) { | |
return pad(d.getMonth() + 1, p, 2); | |
} | |
function formatMinutes(d, p) { | |
return pad(d.getMinutes(), p, 2); | |
} | |
function formatSeconds(d, p) { | |
return pad(d.getSeconds(), p, 2); | |
} | |
function formatWeekNumberSunday(d, p) { | |
return pad(timeWeek.count(year(d), d), p, 2); | |
} | |
function formatWeekdayNumber(d) { | |
return d.getDay(); | |
} | |
function formatWeekNumberMonday(d, p) { | |
return pad(timeMonday.count(year(d), d), p, 2); | |
} | |
function formatYear(d, p) { | |
return pad(d.getFullYear() % 100, p, 2); | |
} | |
function formatFullYear(d, p) { | |
return pad(d.getFullYear() % 10000, p, 4); | |
} | |
function formatZone(d) { | |
var z = d.getTimezoneOffset(); | |
return (z > 0 ? "-" : (z *= -1, "+")) | |
+ pad(z / 60 | 0, "0", 2) | |
+ pad(z % 60, "0", 2); | |
} | |
function formatUTCDayOfMonth(d, p) { | |
return pad(d.getUTCDate(), p, 2); | |
} | |
function formatUTCHour24(d, p) { | |
return pad(d.getUTCHours(), p, 2); | |
} | |
function formatUTCHour12(d, p) { | |
return pad(d.getUTCHours() % 12 || 12, p, 2); | |
} | |
function formatUTCDayOfYear(d, p) { | |
return pad(1 + utcDay.count(utcYear(d), d), p, 3); | |
} | |
function formatUTCMilliseconds(d, p) { | |
return pad(d.getUTCMilliseconds(), p, 3); | |
} | |
function formatUTCMonthNumber(d, p) { | |
return pad(d.getUTCMonth() + 1, p, 2); | |
} | |
function formatUTCMinutes(d, p) { | |
return pad(d.getUTCMinutes(), p, 2); | |
} | |
function formatUTCSeconds(d, p) { | |
return pad(d.getUTCSeconds(), p, 2); | |
} | |
function formatUTCWeekNumberSunday(d, p) { | |
return pad(utcWeek.count(utcYear(d), d), p, 2); | |
} | |
function formatUTCWeekdayNumber(d) { | |
return d.getUTCDay(); | |
} | |
function formatUTCWeekNumberMonday(d, p) { | |
return pad(utcMonday.count(utcYear(d), d), p, 2); | |
} | |
function formatUTCYear(d, p) { | |
return pad(d.getUTCFullYear() % 100, p, 2); | |
} | |
function formatUTCFullYear(d, p) { | |
return pad(d.getUTCFullYear() % 10000, p, 4); | |
} | |
function formatUTCZone() { | |
return "+0000"; | |
} | |
function formatLiteralPercent() { | |
return "%"; | |
} | |
var locale$1; | |
defaultLocale$1({ | |
dateTime: "%x, %X", | |
date: "%-m/%-d/%Y", | |
time: "%-I:%M:%S %p", | |
periods: ["AM", "PM"], | |
days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], | |
shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], | |
months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], | |
shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] | |
}); | |
function defaultLocale$1(definition) { | |
locale$1 = formatLocale$1(definition); | |
exports.timeFormat = locale$1.format; | |
exports.timeParse = locale$1.parse; | |
exports.utcFormat = locale$1.utcFormat; | |
exports.utcParse = locale$1.utcParse; | |
return locale$1; | |
} | |
var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ"; | |
function formatIsoNative(date) { | |
return date.toISOString(); | |
} | |
var formatIso = Date.prototype.toISOString | |
? formatIsoNative | |
: exports.utcFormat(isoSpecifier); | |
function parseIsoNative(string) { | |
var date = new Date(string); | |
return isNaN(date) ? null : date; | |
} | |
var parseIso = +new Date("2000-01-01T00:00:00.000Z") | |
? parseIsoNative | |
: exports.utcParse(isoSpecifier); | |
var array$2 = Array.prototype; | |
var map$2 = array$2.map; | |
var slice$3 = array$2.slice; | |
var implicit = {name: "implicit"}; | |
function ordinal(range) { | |
var index = map$1(), | |
domain = [], | |
unknown = implicit; | |
range = range == null ? [] : slice$3.call(range); | |
function scale(d) { | |
var key = d + "", i = index.get(key); | |
if (!i) { | |
if (unknown !== implicit) return unknown; | |
index.set(key, i = domain.push(d)); | |
} | |
return range[(i - 1) % range.length]; | |
} | |
scale.domain = function(_) { | |
if (!arguments.length) return domain.slice(); | |
domain = [], index = map$1(); | |
var i = -1, n = _.length, d, key; | |
while (++i < n) if (!index.has(key = (d = _[i]) + "")) index.set(key, domain.push(d)); | |
return scale; | |
}; | |
scale.range = function(_) { | |
return arguments.length ? (range = slice$3.call(_), scale) : range.slice(); | |
}; | |
scale.unknown = function(_) { | |
return arguments.length ? (unknown = _, scale) : unknown; | |
}; | |
scale.copy = function() { | |
return ordinal() | |
.domain(domain) | |
.range(range) | |
.unknown(unknown); | |
}; | |
return scale; | |
} | |
function band() { | |
var scale = ordinal().unknown(undefined), | |
domain = scale.domain, | |
ordinalRange = scale.range, | |
range$$ = [0, 1], | |
step, | |
bandwidth, | |
round = false, | |
paddingInner = 0, | |
paddingOuter = 0, | |
align = 0.5; | |
delete scale.unknown; | |
function rescale() { | |
var n = domain().length, | |
reverse = range$$[1] < range$$[0], | |
start = range$$[reverse - 0], | |
stop = range$$[1 - reverse]; | |
step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2); | |
if (round) step = Math.floor(step); | |
start += (stop - start - step * (n - paddingInner)) * align; | |
bandwidth = step * (1 - paddingInner); | |
if (round) start = Math.round(start), bandwidth = Math.round(bandwidth); | |
var values = range(n).map(function(i) { return start + step * i; }); | |
return ordinalRange(reverse ? values.reverse() : values); | |
} | |
scale.domain = function(_) { | |
return arguments.length ? (domain(_), rescale()) : domain(); | |
}; | |
scale.range = function(_) { | |
return arguments.length ? (range$$ = [+_[0], +_[1]], rescale()) : range$$.slice(); | |
}; | |
scale.rangeRound = function(_) { | |
return range$$ = [+_[0], +_[1]], round = true, rescale(); | |
}; | |
scale.bandwidth = function() { | |
return bandwidth; | |
}; | |
scale.step = function() { | |
return step; | |
}; | |
scale.round = function(_) { | |
return arguments.length ? (round = !!_, rescale()) : round; | |
}; | |
scale.padding = function(_) { | |
return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner; | |
}; | |
scale.paddingInner = function(_) { | |
return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner; | |
}; | |
scale.paddingOuter = function(_) { | |
return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter; | |
}; | |
scale.align = function(_) { | |
return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align; | |
}; | |
scale.copy = function() { | |
return band() | |
.domain(domain()) | |
.range(range$$) | |
.round(round) | |
.paddingInner(paddingInner) | |
.paddingOuter(paddingOuter) | |
.align(align); | |
}; | |
return rescale(); | |
} | |
function pointish(scale) { | |
var copy = scale.copy; | |
scale.padding = scale.paddingOuter; | |
delete scale.paddingInner; | |
delete scale.paddingOuter; | |
scale.copy = function() { | |
return pointish(copy()); | |
}; | |
return scale; | |
} | |
function point$4() { | |
return pointish(band().paddingInner(1)); | |
} | |
function constant$3(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function number$1(x) { | |
return +x; | |
} | |
var unit = [0, 1]; | |
function deinterpolate(a, b) { | |
return (b -= (a = +a)) | |
? function(x) { return (x - a) / b; } | |
: constant$3(b); | |
} | |
function deinterpolateClamp(deinterpolate) { | |
return function(a, b) { | |
var d = deinterpolate(a = +a, b = +b); | |
return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); }; | |
}; | |
} | |
function reinterpolateClamp(reinterpolate) { | |
return function(a, b) { | |
var r = reinterpolate(a = +a, b = +b); | |
return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); }; | |
}; | |
} | |
function bimap(domain, range, deinterpolate, reinterpolate) { | |
var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1]; | |
if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0); | |
else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1); | |
return function(x) { return r0(d0(x)); }; | |
} | |
function polymap(domain, range, deinterpolate, reinterpolate) { | |
var j = Math.min(domain.length, range.length) - 1, | |
d = new Array(j), | |
r = new Array(j), | |
i = -1; | |
// Reverse descending domains. | |
if (domain[j] < domain[0]) { | |
domain = domain.slice().reverse(); | |
range = range.slice().reverse(); | |
} | |
while (++i < j) { | |
d[i] = deinterpolate(domain[i], domain[i + 1]); | |
r[i] = reinterpolate(range[i], range[i + 1]); | |
} | |
return function(x) { | |
var i = bisectRight(domain, x, 1, j) - 1; | |
return r[i](d[i](x)); | |
}; | |
} | |
function copy(source, target) { | |
return target | |
.domain(source.domain()) | |
.range(source.range()) | |
.interpolate(source.interpolate()) | |
.clamp(source.clamp()); | |
} | |
// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1]. | |
// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b]. | |
function continuous(deinterpolate$$, reinterpolate) { | |
var domain = unit, | |
range = unit, | |
interpolate$$ = interpolate, | |
clamp = false, | |
piecewise, | |
output, | |
input; | |
function rescale() { | |
piecewise = Math.min(domain.length, range.length) > 2 ? polymap : bimap; | |
output = input = null; | |
return scale; | |
} | |
function scale(x) { | |
return (output || (output = piecewise(domain, range, clamp ? deinterpolateClamp(deinterpolate$$) : deinterpolate$$, interpolate$$)))(+x); | |
} | |
scale.invert = function(y) { | |
return (input || (input = piecewise(range, domain, deinterpolate, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y); | |
}; | |
scale.domain = function(_) { | |
return arguments.length ? (domain = map$2.call(_, number$1), rescale()) : domain.slice(); | |
}; | |
scale.range = function(_) { | |
return arguments.length ? (range = slice$3.call(_), rescale()) : range.slice(); | |
}; | |
scale.rangeRound = function(_) { | |
return range = slice$3.call(_), interpolate$$ = interpolateRound, rescale(); | |
}; | |
scale.clamp = function(_) { | |
return arguments.length ? (clamp = !!_, rescale()) : clamp; | |
}; | |
scale.interpolate = function(_) { | |
return arguments.length ? (interpolate$$ = _, rescale()) : interpolate$$; | |
}; | |
return rescale(); | |
} | |
function tickFormat(domain, count, specifier) { | |
var start = domain[0], | |
stop = domain[domain.length - 1], | |
step = tickStep(start, stop, count == null ? 10 : count), | |
precision; | |
specifier = formatSpecifier(specifier == null ? ",f" : specifier); | |
switch (specifier.type) { | |
case "s": { | |
var value = Math.max(Math.abs(start), Math.abs(stop)); | |
if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision; | |
return exports.formatPrefix(specifier, value); | |
} | |
case "": | |
case "e": | |
case "g": | |
case "p": | |
case "r": { | |
if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e"); | |
break; | |
} | |
case "f": | |
case "%": { | |
if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === "%") * 2; | |
break; | |
} | |
} | |
return exports.format(specifier); | |
} | |
function linearish(scale) { | |
var domain = scale.domain; | |
scale.ticks = function(count) { | |
var d = domain(); | |
return ticks(d[0], d[d.length - 1], count == null ? 10 : count); | |
}; | |
scale.tickFormat = function(count, specifier) { | |
return tickFormat(domain(), count, specifier); | |
}; | |
scale.nice = function(count) { | |
var d = domain(), | |
i = d.length - 1, | |
n = count == null ? 10 : count, | |
start = d[0], | |
stop = d[i], | |
step = tickStep(start, stop, n); | |
if (step) { | |
step = tickStep(Math.floor(start / step) * step, Math.ceil(stop / step) * step, n); | |
d[0] = Math.floor(start / step) * step; | |
d[i] = Math.ceil(stop / step) * step; | |
domain(d); | |
} | |
return scale; | |
}; | |
return scale; | |
} | |
function linear$2() { | |
var scale = continuous(deinterpolate, interpolateNumber); | |
scale.copy = function() { | |
return copy(scale, linear$2()); | |
}; | |
return linearish(scale); | |
} | |
function identity$4() { | |
var domain = [0, 1]; | |
function scale(x) { | |
return +x; | |
} | |
scale.invert = scale; | |
scale.domain = scale.range = function(_) { | |
return arguments.length ? (domain = map$2.call(_, number$1), scale) : domain.slice(); | |
}; | |
scale.copy = function() { | |
return identity$4().domain(domain); | |
}; | |
return linearish(scale); | |
} | |
function nice(domain, interval) { | |
domain = domain.slice(); | |
var i0 = 0, | |
i1 = domain.length - 1, | |
x0 = domain[i0], | |
x1 = domain[i1], | |
t; | |
if (x1 < x0) { | |
t = i0, i0 = i1, i1 = t; | |
t = x0, x0 = x1, x1 = t; | |
} | |
domain[i0] = interval.floor(x0); | |
domain[i1] = interval.ceil(x1); | |
return domain; | |
} | |
function deinterpolate$1(a, b) { | |
return (b = Math.log(b / a)) | |
? function(x) { return Math.log(x / a) / b; } | |
: constant$3(b); | |
} | |
function reinterpolate(a, b) { | |
return a < 0 | |
? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); } | |
: function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); }; | |
} | |
function pow10(x) { | |
return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x; | |
} | |
function powp(base) { | |
return base === 10 ? pow10 | |
: base === Math.E ? Math.exp | |
: function(x) { return Math.pow(base, x); }; | |
} | |
function logp(base) { | |
return base === Math.E ? Math.log | |
: base === 10 && Math.log10 | |
|| base === 2 && Math.log2 | |
|| (base = Math.log(base), function(x) { return Math.log(x) / base; }); | |
} | |
function reflect(f) { | |
return function(x) { | |
return -f(-x); | |
}; | |
} | |
function log() { | |
var scale = continuous(deinterpolate$1, reinterpolate).domain([1, 10]), | |
domain = scale.domain, | |
base = 10, | |
logs = logp(10), | |
pows = powp(10); | |
function rescale() { | |
logs = logp(base), pows = powp(base); | |
if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows); | |
return scale; | |
} | |
scale.base = function(_) { | |
return arguments.length ? (base = +_, rescale()) : base; | |
}; | |
scale.domain = function(_) { | |
return arguments.length ? (domain(_), rescale()) : domain(); | |
}; | |
scale.ticks = function(count) { | |
var d = domain(), | |
u = d[0], | |
v = d[d.length - 1], | |
r; | |
if (r = v < u) i = u, u = v, v = i; | |
var i = logs(u), | |
j = logs(v), | |
p, | |
k, | |
t, | |
n = count == null ? 10 : +count, | |
z = []; | |
if (!(base % 1) && j - i < n) { | |
i = Math.round(i) - 1, j = Math.round(j) + 1; | |
if (u > 0) for (; i < j; ++i) { | |
for (k = 1, p = pows(i); k < base; ++k) { | |
t = p * k; | |
if (t < u) continue; | |
if (t > v) break; | |
z.push(t); | |
} | |
} else for (; i < j; ++i) { | |
for (k = base - 1, p = pows(i); k >= 1; --k) { | |
t = p * k; | |
if (t < u) continue; | |
if (t > v) break; | |
z.push(t); | |
} | |
} | |
} else { | |
z = ticks(i, j, Math.min(j - i, n)).map(pows); | |
} | |
return r ? z.reverse() : z; | |
}; | |
scale.tickFormat = function(count, specifier) { | |
if (specifier == null) specifier = base === 10 ? ".0e" : ","; | |
if (typeof specifier !== "function") specifier = exports.format(specifier); | |
if (count === Infinity) return specifier; | |
if (count == null) count = 10; | |
var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate? | |
return function(d) { | |
var i = d / pows(Math.round(logs(d))); | |
if (i * base < base - 0.5) i *= base; | |
return i <= k ? specifier(d) : ""; | |
}; | |
}; | |
scale.nice = function() { | |
return domain(nice(domain(), { | |
floor: function(x) { return pows(Math.floor(logs(x))); }, | |
ceil: function(x) { return pows(Math.ceil(logs(x))); } | |
})); | |
}; | |
scale.copy = function() { | |
return copy(scale, log().base(base)); | |
}; | |
return scale; | |
} | |
function raise(x, exponent) { | |
return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent); | |
} | |
function pow() { | |
var exponent = 1, | |
scale = continuous(deinterpolate, reinterpolate), | |
domain = scale.domain; | |
function deinterpolate(a, b) { | |
return (b = raise(b, exponent) - (a = raise(a, exponent))) | |
? function(x) { return (raise(x, exponent) - a) / b; } | |
: constant$3(b); | |
} | |
function reinterpolate(a, b) { | |
b = raise(b, exponent) - (a = raise(a, exponent)); | |
return function(t) { return raise(a + b * t, 1 / exponent); }; | |
} | |
scale.exponent = function(_) { | |
return arguments.length ? (exponent = +_, domain(domain())) : exponent; | |
}; | |
scale.copy = function() { | |
return copy(scale, pow().exponent(exponent)); | |
}; | |
return linearish(scale); | |
} | |
function sqrt() { | |
return pow().exponent(0.5); | |
} | |
function quantile() { | |
var domain = [], | |
range = [], | |
thresholds = []; | |
function rescale() { | |
var i = 0, n = Math.max(1, range.length); | |
thresholds = new Array(n - 1); | |
while (++i < n) thresholds[i - 1] = threshold(domain, i / n); | |
return scale; | |
} | |
function scale(x) { | |
if (!isNaN(x = +x)) return range[bisectRight(thresholds, x)]; | |
} | |
scale.invertExtent = function(y) { | |
var i = range.indexOf(y); | |
return i < 0 ? [NaN, NaN] : [ | |
i > 0 ? thresholds[i - 1] : domain[0], | |
i < thresholds.length ? thresholds[i] : domain[domain.length - 1] | |
]; | |
}; | |
scale.domain = function(_) { | |
if (!arguments.length) return domain.slice(); | |
domain = []; | |
for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d); | |
domain.sort(ascending); | |
return rescale(); | |
}; | |
scale.range = function(_) { | |
return arguments.length ? (range = slice$3.call(_), rescale()) : range.slice(); | |
}; | |
scale.quantiles = function() { | |
return thresholds.slice(); | |
}; | |
scale.copy = function() { | |
return quantile() | |
.domain(domain) | |
.range(range); | |
}; | |
return scale; | |
} | |
function quantize$1() { | |
var x0 = 0, | |
x1 = 1, | |
n = 1, | |
domain = [0.5], | |
range = [0, 1]; | |
function scale(x) { | |
if (x <= x) return range[bisectRight(domain, x, 0, n)]; | |
} | |
function rescale() { | |
var i = -1; | |
domain = new Array(n); | |
while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1); | |
return scale; | |
} | |
scale.domain = function(_) { | |
return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1]; | |
}; | |
scale.range = function(_) { | |
return arguments.length ? (n = (range = slice$3.call(_)).length - 1, rescale()) : range.slice(); | |
}; | |
scale.invertExtent = function(y) { | |
var i = range.indexOf(y); | |
return i < 0 ? [NaN, NaN] | |
: i < 1 ? [x0, domain[0]] | |
: i >= n ? [domain[n - 1], x1] | |
: [domain[i - 1], domain[i]]; | |
}; | |
scale.copy = function() { | |
return quantize$1() | |
.domain([x0, x1]) | |
.range(range); | |
}; | |
return linearish(scale); | |
} | |
function threshold$1() { | |
var domain = [0.5], | |
range = [0, 1], | |
n = 1; | |
function scale(x) { | |
if (x <= x) return range[bisectRight(domain, x, 0, n)]; | |
} | |
scale.domain = function(_) { | |
return arguments.length ? (domain = slice$3.call(_), n = Math.min(domain.length, range.length - 1), scale) : domain.slice(); | |
}; | |
scale.range = function(_) { | |
return arguments.length ? (range = slice$3.call(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice(); | |
}; | |
scale.invertExtent = function(y) { | |
var i = range.indexOf(y); | |
return [domain[i - 1], domain[i]]; | |
}; | |
scale.copy = function() { | |
return threshold$1() | |
.domain(domain) | |
.range(range); | |
}; | |
return scale; | |
} | |
var durationSecond$1 = 1000; | |
var durationMinute$1 = durationSecond$1 * 60; | |
var durationHour$1 = durationMinute$1 * 60; | |
var durationDay$1 = durationHour$1 * 24; | |
var durationWeek$1 = durationDay$1 * 7; | |
var durationMonth = durationDay$1 * 30; | |
var durationYear = durationDay$1 * 365; | |
function date$1(t) { | |
return new Date(t); | |
} | |
function number$2(t) { | |
return t instanceof Date ? +t : +new Date(+t); | |
} | |
function calendar(year, month, week, day, hour, minute, second, millisecond, format) { | |
var scale = continuous(deinterpolate, interpolateNumber), | |
invert = scale.invert, | |
domain = scale.domain; | |
var formatMillisecond = format(".%L"), | |
formatSecond = format(":%S"), | |
formatMinute = format("%I:%M"), | |
formatHour = format("%I %p"), | |
formatDay = format("%a %d"), | |
formatWeek = format("%b %d"), | |
formatMonth = format("%B"), | |
formatYear = format("%Y"); | |
var tickIntervals = [ | |
[second, 1, durationSecond$1], | |
[second, 5, 5 * durationSecond$1], | |
[second, 15, 15 * durationSecond$1], | |
[second, 30, 30 * durationSecond$1], | |
[minute, 1, durationMinute$1], | |
[minute, 5, 5 * durationMinute$1], | |
[minute, 15, 15 * durationMinute$1], | |
[minute, 30, 30 * durationMinute$1], | |
[ hour, 1, durationHour$1 ], | |
[ hour, 3, 3 * durationHour$1 ], | |
[ hour, 6, 6 * durationHour$1 ], | |
[ hour, 12, 12 * durationHour$1 ], | |
[ day, 1, durationDay$1 ], | |
[ day, 2, 2 * durationDay$1 ], | |
[ week, 1, durationWeek$1 ], | |
[ month, 1, durationMonth ], | |
[ month, 3, 3 * durationMonth ], | |
[ year, 1, durationYear ] | |
]; | |
function tickFormat(date) { | |
return (second(date) < date ? formatMillisecond | |
: minute(date) < date ? formatSecond | |
: hour(date) < date ? formatMinute | |
: day(date) < date ? formatHour | |
: month(date) < date ? (week(date) < date ? formatDay : formatWeek) | |
: year(date) < date ? formatMonth | |
: formatYear)(date); | |
} | |
function tickInterval(interval, start, stop, step) { | |
if (interval == null) interval = 10; | |
// If a desired tick count is specified, pick a reasonable tick interval | |
// based on the extent of the domain and a rough estimate of tick size. | |
// Otherwise, assume interval is already a time interval and use it. | |
if (typeof interval === "number") { | |
var target = Math.abs(stop - start) / interval, | |
i = bisector(function(i) { return i[2]; }).right(tickIntervals, target); | |
if (i === tickIntervals.length) { | |
step = tickStep(start / durationYear, stop / durationYear, interval); | |
interval = year; | |
} else if (i) { | |
i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i]; | |
step = i[1]; | |
interval = i[0]; | |
} else { | |
step = tickStep(start, stop, interval); | |
interval = millisecond; | |
} | |
} | |
return step == null ? interval : interval.every(step); | |
} | |
scale.invert = function(y) { | |
return new Date(invert(y)); | |
}; | |
scale.domain = function(_) { | |
return arguments.length ? domain(map$2.call(_, number$2)) : domain().map(date$1); | |
}; | |
scale.ticks = function(interval, step) { | |
var d = domain(), | |
t0 = d[0], | |
t1 = d[d.length - 1], | |
r = t1 < t0, | |
t; | |
if (r) t = t0, t0 = t1, t1 = t; | |
t = tickInterval(interval, t0, t1, step); | |
t = t ? t.range(t0, t1 + 1) : []; // inclusive stop | |
return r ? t.reverse() : t; | |
}; | |
scale.tickFormat = function(count, specifier) { | |
return specifier == null ? tickFormat : format(specifier); | |
}; | |
scale.nice = function(interval, step) { | |
var d = domain(); | |
return (interval = tickInterval(interval, d[0], d[d.length - 1], step)) | |
? domain(nice(d, interval)) | |
: scale; | |
}; | |
scale.copy = function() { | |
return copy(scale, calendar(year, month, week, day, hour, minute, second, millisecond, format)); | |
}; | |
return scale; | |
} | |
function time() { | |
return calendar(year, month, timeWeek, day, hour, minute, second, millisecond, exports.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]); | |
} | |
function utcTime() { | |
return calendar(utcYear, utcMonth, utcWeek, utcDay, utcHour, utcMinute, second, millisecond, exports.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]); | |
} | |
function colors(s) { | |
return s.match(/.{6}/g).map(function(x) { | |
return "#" + x; | |
}); | |
} | |
var category10 = colors("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"); | |
var category20b = colors("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6"); | |
var category20c = colors("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9"); | |
var category20 = colors("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5"); | |
var cubehelix$3 = interpolateCubehelixLong(cubehelix(300, 0.5, 0.0), cubehelix(-240, 0.5, 1.0)); | |
var warm = interpolateCubehelixLong(cubehelix(-100, 0.75, 0.35), cubehelix(80, 1.50, 0.8)); | |
var cool = interpolateCubehelixLong(cubehelix(260, 0.75, 0.35), cubehelix(80, 1.50, 0.8)); | |
var rainbow = cubehelix(); | |
function rainbow$1(t) { | |
if (t < 0 || t > 1) t -= Math.floor(t); | |
var ts = Math.abs(t - 0.5); | |
rainbow.h = 360 * t - 100; | |
rainbow.s = 1.5 - 1.5 * ts; | |
rainbow.l = 0.8 - 0.9 * ts; | |
return rainbow + ""; | |
} | |
function ramp(range) { | |
var n = range.length; | |
return function(t) { | |
return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))]; | |
}; | |
} | |
var viridis = ramp(colors("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")); | |
var magma = ramp(colors("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")); | |
var inferno = ramp(colors("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")); | |
var plasma = ramp(colors("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921")); | |
function sequential(interpolator) { | |
var x0 = 0, | |
x1 = 1, | |
clamp = false; | |
function scale(x) { | |
var t = (x - x0) / (x1 - x0); | |
return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t); | |
} | |
scale.domain = function(_) { | |
return arguments.length ? (x0 = +_[0], x1 = +_[1], scale) : [x0, x1]; | |
}; | |
scale.clamp = function(_) { | |
return arguments.length ? (clamp = !!_, scale) : clamp; | |
}; | |
scale.interpolator = function(_) { | |
return arguments.length ? (interpolator = _, scale) : interpolator; | |
}; | |
scale.copy = function() { | |
return sequential(interpolator).domain([x0, x1]).clamp(clamp); | |
}; | |
return linearish(scale); | |
} | |
var xhtml = "http://www.w3.org/1999/xhtml"; | |
var namespaces = { | |
svg: "http://www.w3.org/2000/svg", | |
xhtml: xhtml, | |
xlink: "http://www.w3.org/1999/xlink", | |
xml: "http://www.w3.org/XML/1998/namespace", | |
xmlns: "http://www.w3.org/2000/xmlns/" | |
}; | |
function namespace(name) { | |
var prefix = name += "", i = prefix.indexOf(":"); | |
if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); | |
return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name; | |
} | |
function creatorInherit(name) { | |
return function() { | |
var document = this.ownerDocument, | |
uri = this.namespaceURI; | |
return uri === xhtml && document.documentElement.namespaceURI === xhtml | |
? document.createElement(name) | |
: document.createElementNS(uri, name); | |
}; | |
} | |
function creatorFixed(fullname) { | |
return function() { | |
return this.ownerDocument.createElementNS(fullname.space, fullname.local); | |
}; | |
} | |
function creator(name) { | |
var fullname = namespace(name); | |
return (fullname.local | |
? creatorFixed | |
: creatorInherit)(fullname); | |
} | |
var nextId = 0; | |
function local() { | |
return new Local; | |
} | |
function Local() { | |
this._ = "@" + (++nextId).toString(36); | |
} | |
Local.prototype = local.prototype = { | |
constructor: Local, | |
get: function(node) { | |
var id = this._; | |
while (!(id in node)) if (!(node = node.parentNode)) return; | |
return node[id]; | |
}, | |
set: function(node, value) { | |
return node[this._] = value; | |
}, | |
remove: function(node) { | |
return this._ in node && delete node[this._]; | |
}, | |
toString: function() { | |
return this._; | |
} | |
}; | |
var matcher = function(selector) { | |
return function() { | |
return this.matches(selector); | |
}; | |
}; | |
if (typeof document !== "undefined") { | |
var element = document.documentElement; | |
if (!element.matches) { | |
var vendorMatches = element.webkitMatchesSelector | |
|| element.msMatchesSelector | |
|| element.mozMatchesSelector | |
|| element.oMatchesSelector; | |
matcher = function(selector) { | |
return function() { | |
return vendorMatches.call(this, selector); | |
}; | |
}; | |
} | |
} | |
var matcher$1 = matcher; | |
var filterEvents = {}; | |
exports.event = null; | |
if (typeof document !== "undefined") { | |
var element$1 = document.documentElement; | |
if (!("onmouseenter" in element$1)) { | |
filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"}; | |
} | |
} | |
function filterContextListener(listener, index, group) { | |
listener = contextListener(listener, index, group); | |
return function(event) { | |
var related = event.relatedTarget; | |
if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) { | |
listener.call(this, event); | |
} | |
}; | |
} | |
function contextListener(listener, index, group) { | |
return function(event1) { | |
var event0 = exports.event; // Events can be reentrant (e.g., focus). | |
exports.event = event1; | |
try { | |
listener.call(this, this.__data__, index, group); | |
} finally { | |
exports.event = event0; | |
} | |
}; | |
} | |
function parseTypenames$1(typenames) { | |
return typenames.trim().split(/^|\s+/).map(function(t) { | |
var name = "", i = t.indexOf("."); | |
if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); | |
return {type: t, name: name}; | |
}); | |
} | |
function onRemove(typename) { | |
return function() { | |
var on = this.__on; | |
if (!on) return; | |
for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { | |
if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) { | |
this.removeEventListener(o.type, o.listener, o.capture); | |
} else { | |
on[++i] = o; | |
} | |
} | |
if (++i) on.length = i; | |
else delete this.__on; | |
}; | |
} | |
function onAdd(typename, value, capture) { | |
var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener; | |
return function(d, i, group) { | |
var on = this.__on, o, listener = wrap(value, i, group); | |
if (on) for (var j = 0, m = on.length; j < m; ++j) { | |
if ((o = on[j]).type === typename.type && o.name === typename.name) { | |
this.removeEventListener(o.type, o.listener, o.capture); | |
this.addEventListener(o.type, o.listener = listener, o.capture = capture); | |
o.value = value; | |
return; | |
} | |
} | |
this.addEventListener(typename.type, listener, capture); | |
o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture}; | |
if (!on) this.__on = [o]; | |
else on.push(o); | |
}; | |
} | |
function selection_on(typename, value, capture) { | |
var typenames = parseTypenames$1(typename + ""), i, n = typenames.length, t; | |
if (arguments.length < 2) { | |
var on = this.node().__on; | |
if (on) for (var j = 0, m = on.length, o; j < m; ++j) { | |
for (i = 0, o = on[j]; i < n; ++i) { | |
if ((t = typenames[i]).type === o.type && t.name === o.name) { | |
return o.value; | |
} | |
} | |
} | |
return; | |
} | |
on = value ? onAdd : onRemove; | |
if (capture == null) capture = false; | |
for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture)); | |
return this; | |
} | |
function customEvent(event1, listener, that, args) { | |
var event0 = exports.event; | |
event1.sourceEvent = exports.event; | |
exports.event = event1; | |
try { | |
return listener.apply(that, args); | |
} finally { | |
exports.event = event0; | |
} | |
} | |
function sourceEvent() { | |
var current = exports.event, source; | |
while (source = current.sourceEvent) current = source; | |
return current; | |
} | |
function point$5(node, event) { | |
var svg = node.ownerSVGElement || node; | |
if (svg.createSVGPoint) { | |
var point = svg.createSVGPoint(); | |
point.x = event.clientX, point.y = event.clientY; | |
point = point.matrixTransform(node.getScreenCTM().inverse()); | |
return [point.x, point.y]; | |
} | |
var rect = node.getBoundingClientRect(); | |
return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop]; | |
} | |
function mouse(node) { | |
var event = sourceEvent(); | |
if (event.changedTouches) event = event.changedTouches[0]; | |
return point$5(node, event); | |
} | |
function none$2() {} | |
function selector(selector) { | |
return selector == null ? none$2 : function() { | |
return this.querySelector(selector); | |
}; | |
} | |
function selection_select(select) { | |
if (typeof select !== "function") select = selector(select); | |
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { | |
if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { | |
if ("__data__" in node) subnode.__data__ = node.__data__; | |
subgroup[i] = subnode; | |
} | |
} | |
} | |
return new Selection(subgroups, this._parents); | |
} | |
function empty() { | |
return []; | |
} | |
function selectorAll(selector) { | |
return selector == null ? empty : function() { | |
return this.querySelectorAll(selector); | |
}; | |
} | |
function selection_selectAll(select) { | |
if (typeof select !== "function") select = selectorAll(select); | |
for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
if (node = group[i]) { | |
subgroups.push(select.call(node, node.__data__, i, group)); | |
parents.push(node); | |
} | |
} | |
} | |
return new Selection(subgroups, parents); | |
} | |
function selection_filter(match) { | |
if (typeof match !== "function") match = matcher$1(match); | |
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { | |
if ((node = group[i]) && match.call(node, node.__data__, i, group)) { | |
subgroup.push(node); | |
} | |
} | |
} | |
return new Selection(subgroups, this._parents); | |
} | |
function sparse(update) { | |
return new Array(update.length); | |
} | |
function selection_enter() { | |
return new Selection(this._enter || this._groups.map(sparse), this._parents); | |
} | |
function EnterNode(parent, datum) { | |
this.ownerDocument = parent.ownerDocument; | |
this.namespaceURI = parent.namespaceURI; | |
this._next = null; | |
this._parent = parent; | |
this.__data__ = datum; | |
} | |
EnterNode.prototype = { | |
constructor: EnterNode, | |
appendChild: function(child) { return this._parent.insertBefore(child, this._next); }, | |
insertBefore: function(child, next) { return this._parent.insertBefore(child, next); }, | |
querySelector: function(selector) { return this._parent.querySelector(selector); }, | |
querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); } | |
}; | |
function constant$4(x) { | |
return function() { | |
return x; | |
}; | |
} | |
var keyPrefix = "$"; // Protect against keys like “__proto__”. | |
function bindIndex(parent, group, enter, update, exit, data) { | |
var i = 0, | |
node, | |
groupLength = group.length, | |
dataLength = data.length; | |
// Put any non-null nodes that fit into update. | |
// Put any null nodes into enter. | |
// Put any remaining data into enter. | |
for (; i < dataLength; ++i) { | |
if (node = group[i]) { | |
node.__data__ = data[i]; | |
update[i] = node; | |
} else { | |
enter[i] = new EnterNode(parent, data[i]); | |
} | |
} | |
// Put any non-null nodes that don’t fit into exit. | |
for (; i < groupLength; ++i) { | |
if (node = group[i]) { | |
exit[i] = node; | |
} | |
} | |
} | |
function bindKey(parent, group, enter, update, exit, data, key) { | |
var i, | |
node, | |
nodeByKeyValue = {}, | |
groupLength = group.length, | |
dataLength = data.length, | |
keyValues = new Array(groupLength), | |
keyValue; | |
// Compute the key for each node. | |
// If multiple nodes have the same key, the duplicates are added to exit. | |
for (i = 0; i < groupLength; ++i) { | |
if (node = group[i]) { | |
keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group); | |
if (keyValue in nodeByKeyValue) { | |
exit[i] = node; | |
} else { | |
nodeByKeyValue[keyValue] = node; | |
} | |
} | |
} | |
// Compute the key for each datum. | |
// If there a node associated with this key, join and add it to update. | |
// If there is not (or the key is a duplicate), add it to enter. | |
for (i = 0; i < dataLength; ++i) { | |
keyValue = keyPrefix + key.call(parent, data[i], i, data); | |
if (node = nodeByKeyValue[keyValue]) { | |
update[i] = node; | |
node.__data__ = data[i]; | |
nodeByKeyValue[keyValue] = null; | |
} else { | |
enter[i] = new EnterNode(parent, data[i]); | |
} | |
} | |
// Add any remaining nodes that were not bound to data to exit. | |
for (i = 0; i < groupLength; ++i) { | |
if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) { | |
exit[i] = node; | |
} | |
} | |
} | |
function selection_data(value, key) { | |
if (!value) { | |
data = new Array(this.size()), j = -1; | |
this.each(function(d) { data[++j] = d; }); | |
return data; | |
} | |
var bind = key ? bindKey : bindIndex, | |
parents = this._parents, | |
groups = this._groups; | |
if (typeof value !== "function") value = constant$4(value); | |
for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) { | |
var parent = parents[j], | |
group = groups[j], | |
groupLength = group.length, | |
data = value.call(parent, parent && parent.__data__, j, parents), | |
dataLength = data.length, | |
enterGroup = enter[j] = new Array(dataLength), | |
updateGroup = update[j] = new Array(dataLength), | |
exitGroup = exit[j] = new Array(groupLength); | |
bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); | |
// Now connect the enter nodes to their following update node, such that | |
// appendChild can insert the materialized enter node before this node, | |
// rather than at the end of the parent node. | |
for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) { | |
if (previous = enterGroup[i0]) { | |
if (i0 >= i1) i1 = i0 + 1; | |
while (!(next = updateGroup[i1]) && ++i1 < dataLength); | |
previous._next = next || null; | |
} | |
} | |
} | |
update = new Selection(update, parents); | |
update._enter = enter; | |
update._exit = exit; | |
return update; | |
} | |
function selection_exit() { | |
return new Selection(this._exit || this._groups.map(sparse), this._parents); | |
} | |
function selection_merge(selection) { | |
for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { | |
for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { | |
if (node = group0[i] || group1[i]) { | |
merge[i] = node; | |
} | |
} | |
} | |
for (; j < m0; ++j) { | |
merges[j] = groups0[j]; | |
} | |
return new Selection(merges, this._parents); | |
} | |
function selection_order() { | |
for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) { | |
for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) { | |
if (node = group[i]) { | |
if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); | |
next = node; | |
} | |
} | |
} | |
return this; | |
} | |
function selection_sort(compare) { | |
if (!compare) compare = ascending$2; | |
function compareNode(a, b) { | |
return a && b ? compare(a.__data__, b.__data__) : !a - !b; | |
} | |
for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) { | |
if (node = group[i]) { | |
sortgroup[i] = node; | |
} | |
} | |
sortgroup.sort(compareNode); | |
} | |
return new Selection(sortgroups, this._parents).order(); | |
} | |
function ascending$2(a, b) { | |
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
} | |
function selection_call() { | |
var callback = arguments[0]; | |
arguments[0] = this; | |
callback.apply(null, arguments); | |
return this; | |
} | |
function selection_nodes() { | |
var nodes = new Array(this.size()), i = -1; | |
this.each(function() { nodes[++i] = this; }); | |
return nodes; | |
} | |
function selection_node() { | |
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
for (var group = groups[j], i = 0, n = group.length; i < n; ++i) { | |
var node = group[i]; | |
if (node) return node; | |
} | |
} | |
return null; | |
} | |
function selection_size() { | |
var size = 0; | |
this.each(function() { ++size; }); | |
return size; | |
} | |
function selection_empty() { | |
return !this.node(); | |
} | |
function selection_each(callback) { | |
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { | |
if (node = group[i]) callback.call(node, node.__data__, i, group); | |
} | |
} | |
return this; | |
} | |
function attrRemove(name) { | |
return function() { | |
this.removeAttribute(name); | |
}; | |
} | |
function attrRemoveNS(fullname) { | |
return function() { | |
this.removeAttributeNS(fullname.space, fullname.local); | |
}; | |
} | |
function attrConstant(name, value) { | |
return function() { | |
this.setAttribute(name, value); | |
}; | |
} | |
function attrConstantNS(fullname, value) { | |
return function() { | |
this.setAttributeNS(fullname.space, fullname.local, value); | |
}; | |
} | |
function attrFunction(name, value) { | |
return function() { | |
var v = value.apply(this, arguments); | |
if (v == null) this.removeAttribute(name); | |
else this.setAttribute(name, v); | |
}; | |
} | |
function attrFunctionNS(fullname, value) { | |
return function() { | |
var v = value.apply(this, arguments); | |
if (v == null) this.removeAttributeNS(fullname.space, fullname.local); | |
else this.setAttributeNS(fullname.space, fullname.local, v); | |
}; | |
} | |
function selection_attr(name, value) { | |
var fullname = namespace(name); | |
if (arguments.length < 2) { | |
var node = this.node(); | |
return fullname.local | |
? node.getAttributeNS(fullname.space, fullname.local) | |
: node.getAttribute(fullname); | |
} | |
return this.each((value == null | |
? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function" | |
? (fullname.local ? attrFunctionNS : attrFunction) | |
: (fullname.local ? attrConstantNS : attrConstant)))(fullname, value)); | |
} | |
function window$1(node) { | |
return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node | |
|| (node.document && node) // node is a Window | |
|| node.defaultView; // node is a Document | |
} | |
function styleRemove(name) { | |
return function() { | |
this.style.removeProperty(name); | |
}; | |
} | |
function styleConstant(name, value, priority) { | |
return function() { | |
this.style.setProperty(name, value, priority); | |
}; | |
} | |
function styleFunction(name, value, priority) { | |
return function() { | |
var v = value.apply(this, arguments); | |
if (v == null) this.style.removeProperty(name); | |
else this.style.setProperty(name, v, priority); | |
}; | |
} | |
function selection_style(name, value, priority) { | |
var node; | |
return arguments.length > 1 | |
? this.each((value == null | |
? styleRemove : typeof value === "function" | |
? styleFunction | |
: styleConstant)(name, value, priority == null ? "" : priority)) | |
: window$1(node = this.node()) | |
.getComputedStyle(node, null) | |
.getPropertyValue(name); | |
} | |
function propertyRemove(name) { | |
return function() { | |
delete this[name]; | |
}; | |
} | |
function propertyConstant(name, value) { | |
return function() { | |
this[name] = value; | |
}; | |
} | |
function propertyFunction(name, value) { | |
return function() { | |
var v = value.apply(this, arguments); | |
if (v == null) delete this[name]; | |
else this[name] = v; | |
}; | |
} | |
function selection_property(name, value) { | |
return arguments.length > 1 | |
? this.each((value == null | |
? propertyRemove : typeof value === "function" | |
? propertyFunction | |
: propertyConstant)(name, value)) | |
: this.node()[name]; | |
} | |
function classArray(string) { | |
return string.trim().split(/^|\s+/); | |
} | |
function classList(node) { | |
return node.classList || new ClassList(node); | |
} | |
function ClassList(node) { | |
this._node = node; | |
this._names = classArray(node.getAttribute("class") || ""); | |
} | |
ClassList.prototype = { | |
add: function(name) { | |
var i = this._names.indexOf(name); | |
if (i < 0) { | |
this._names.push(name); | |
this._node.setAttribute("class", this._names.join(" ")); | |
} | |
}, | |
remove: function(name) { | |
var i = this._names.indexOf(name); | |
if (i >= 0) { | |
this._names.splice(i, 1); | |
this._node.setAttribute("class", this._names.join(" ")); | |
} | |
}, | |
contains: function(name) { | |
return this._names.indexOf(name) >= 0; | |
} | |
}; | |
function classedAdd(node, names) { | |
var list = classList(node), i = -1, n = names.length; | |
while (++i < n) list.add(names[i]); | |
} | |
function classedRemove(node, names) { | |
var list = classList(node), i = -1, n = names.length; | |
while (++i < n) list.remove(names[i]); | |
} | |
function classedTrue(names) { | |
return function() { | |
classedAdd(this, names); | |
}; | |
} | |
function classedFalse(names) { | |
return function() { | |
classedRemove(this, names); | |
}; | |
} | |
function classedFunction(names, value) { | |
return function() { | |
(value.apply(this, arguments) ? classedAdd : classedRemove)(this, names); | |
}; | |
} | |
function selection_classed(name, value) { | |
var names = classArray(name + ""); | |
if (arguments.length < 2) { | |
var list = classList(this.node()), i = -1, n = names.length; | |
while (++i < n) if (!list.contains(names[i])) return false; | |
return true; | |
} | |
return this.each((typeof value === "function" | |
? classedFunction : value | |
? classedTrue | |
: classedFalse)(names, value)); | |
} | |
function textRemove() { | |
this.textContent = ""; | |
} | |
function textConstant(value) { | |
return function() { | |
this.textContent = value; | |
}; | |
} | |
function textFunction(value) { | |
return function() { | |
var v = value.apply(this, arguments); | |
this.textContent = v == null ? "" : v; | |
}; | |
} | |
function selection_text(value) { | |
return arguments.length | |
? this.each(value == null | |
? textRemove : (typeof value === "function" | |
? textFunction | |
: textConstant)(value)) | |
: this.node().textContent; | |
} | |
function htmlRemove() { | |
this.innerHTML = ""; | |
} | |
function htmlConstant(value) { | |
return function() { | |
this.innerHTML = value; | |
}; | |
} | |
function htmlFunction(value) { | |
return function() { | |
var v = value.apply(this, arguments); | |
this.innerHTML = v == null ? "" : v; | |
}; | |
} | |
function selection_html(value) { | |
return arguments.length | |
? this.each(value == null | |
? htmlRemove : (typeof value === "function" | |
? htmlFunction | |
: htmlConstant)(value)) | |
: this.node().innerHTML; | |
} | |
function raise$1() { | |
if (this.nextSibling) this.parentNode.appendChild(this); | |
} | |
function selection_raise() { | |
return this.each(raise$1); | |
} | |
function lower() { | |
if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild); | |
} | |
function selection_lower() { | |
return this.each(lower); | |
} | |
function selection_append(name) { | |
var create = typeof name === "function" ? name : creator(name); | |
return this.select(function() { | |
return this.appendChild(create.apply(this, arguments)); | |
}); | |
} | |
function constantNull() { | |
return null; | |
} | |
function selection_insert(name, before) { | |
var create = typeof name === "function" ? name : creator(name), | |
select = before == null ? constantNull : typeof before === "function" ? before : selector(before); | |
return this.select(function() { | |
return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null); | |
}); | |
} | |
function remove() { | |
var parent = this.parentNode; | |
if (parent) parent.removeChild(this); | |
} | |
function selection_remove() { | |
return this.each(remove); | |
} | |
function selection_datum(value) { | |
return arguments.length | |
? this.property("__data__", value) | |
: this.node().__data__; | |
} | |
function dispatchEvent(node, type, params) { | |
var window = window$1(node), | |
event = window.CustomEvent; | |
if (event) { | |
event = new event(type, params); | |
} else { | |
event = window.document.createEvent("Event"); | |
if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail; | |
else event.initEvent(type, false, false); | |
} | |
node.dispatchEvent(event); | |
} | |
function dispatchConstant(type, params) { | |
return function() { | |
return dispatchEvent(this, type, params); | |
}; | |
} | |
function dispatchFunction(type, params) { | |
return function() { | |
return dispatchEvent(this, type, params.apply(this, arguments)); | |
}; | |
} | |
function selection_dispatch(type, params) { | |
return this.each((typeof params === "function" | |
? dispatchFunction | |
: dispatchConstant)(type, params)); | |
} | |
var root = [null]; | |
function Selection(groups, parents) { | |
this._groups = groups; | |
this._parents = parents; | |
} | |
function selection() { | |
return new Selection([[document.documentElement]], root); | |
} | |
Selection.prototype = selection.prototype = { | |
constructor: Selection, | |
select: selection_select, | |
selectAll: selection_selectAll, | |
filter: selection_filter, | |
data: selection_data, | |
enter: selection_enter, | |
exit: selection_exit, | |
merge: selection_merge, | |
order: selection_order, | |
sort: selection_sort, | |
call: selection_call, | |
nodes: selection_nodes, | |
node: selection_node, | |
size: selection_size, | |
empty: selection_empty, | |
each: selection_each, | |
attr: selection_attr, | |
style: selection_style, | |
property: selection_property, | |
classed: selection_classed, | |
text: selection_text, | |
html: selection_html, | |
raise: selection_raise, | |
lower: selection_lower, | |
append: selection_append, | |
insert: selection_insert, | |
remove: selection_remove, | |
datum: selection_datum, | |
on: selection_on, | |
dispatch: selection_dispatch | |
}; | |
function select(selector) { | |
return typeof selector === "string" | |
? new Selection([[document.querySelector(selector)]], [document.documentElement]) | |
: new Selection([[selector]], root); | |
} | |
function selectAll(selector) { | |
return typeof selector === "string" | |
? new Selection([document.querySelectorAll(selector)], [document.documentElement]) | |
: new Selection([selector == null ? [] : selector], root); | |
} | |
function touch(node, touches, identifier) { | |
if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches; | |
for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) { | |
if ((touch = touches[i]).identifier === identifier) { | |
return point$5(node, touch); | |
} | |
} | |
return null; | |
} | |
function touches(node, touches) { | |
if (touches == null) touches = sourceEvent().touches; | |
for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) { | |
points[i] = point$5(node, touches[i]); | |
} | |
return points; | |
} | |
var emptyOn = dispatch("start", "end", "interrupt"); | |
var emptyTween = []; | |
var CREATED = 0; | |
var SCHEDULED = 1; | |
var STARTING = 2; | |
var STARTED = 3; | |
var RUNNING = 4; | |
var ENDING = 5; | |
var ENDED = 6; | |
function schedule(node, name, id, index, group, timing) { | |
var schedules = node.__transition; | |
if (!schedules) node.__transition = {}; | |
else if (id in schedules) return; | |
create(node, id, { | |
name: name, | |
index: index, // For context during callback. | |
group: group, // For context during callback. | |
on: emptyOn, | |
tween: emptyTween, | |
time: timing.time, | |
delay: timing.delay, | |
duration: timing.duration, | |
ease: timing.ease, | |
timer: null, | |
state: CREATED | |
}); | |
} | |
function init(node, id) { | |
var schedule = node.__transition; | |
if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error("too late"); | |
return schedule; | |
} | |
function set$2(node, id) { | |
var schedule = node.__transition; | |
if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error("too late"); | |
return schedule; | |
} | |
function get$1(node, id) { | |
var schedule = node.__transition; | |
if (!schedule || !(schedule = schedule[id])) throw new Error("too late"); | |
return schedule; | |
} | |
function create(node, id, self) { | |
var schedules = node.__transition, | |
tween; | |
// Initialize the self timer when the transition is created. | |
// Note the actual delay is not known until the first callback! | |
schedules[id] = self; | |
self.timer = timer(schedule, 0, self.time); | |
function schedule(elapsed) { | |
self.state = SCHEDULED; | |
self.timer.restart(start, self.delay, self.time); | |
// If the elapsed delay is less than our first sleep, start immediately. | |
if (self.delay <= elapsed) start(elapsed - self.delay); | |
} | |
function start(elapsed) { | |
var i, j, n, o; | |
// If the state is not SCHEDULED, then we previously errored on start. | |
if (self.state !== SCHEDULED) return stop(); | |
for (i in schedules) { | |
o = schedules[i]; | |
if (o.name !== self.name) continue; | |
// While this element already has a starting transition during this frame, | |
// defer starting an interrupting transition until that transition has a | |
// chance to tick (and possibly end); see d3/d3-transition#54! | |
if (o.state === STARTED) return timeout$1(start); | |
// Interrupt the active transition, if any. | |
// Dispatch the interrupt event. | |
if (o.state === RUNNING) { | |
o.state = ENDED; | |
o.timer.stop(); | |
o.on.call("interrupt", node, node.__data__, o.index, o.group); | |
delete schedules[i]; | |
} | |
// Cancel any pre-empted transitions. No interrupt event is dispatched | |
// because the cancelled transitions never started. Note that this also | |
// removes this transition from the pending list! | |
else if (+i < id) { | |
o.state = ENDED; | |
o.timer.stop(); | |
delete schedules[i]; | |
} | |
} | |
// Defer the first tick to end of the current frame; see d3/d3#1576. | |
// Note the transition may be canceled after start and before the first tick! | |
// Note this must be scheduled before the start event; see d3/d3-transition#16! | |
// Assuming this is successful, subsequent callbacks go straight to tick. | |
timeout$1(function() { | |
if (self.state === STARTED) { | |
self.state = RUNNING; | |
self.timer.restart(tick, self.delay, self.time); | |
tick(elapsed); | |
} | |
}); | |
// Dispatch the start event. | |
// Note this must be done before the tween are initialized. | |
self.state = STARTING; | |
self.on.call("start", node, node.__data__, self.index, self.group); | |
if (self.state !== STARTING) return; // interrupted | |
self.state = STARTED; | |
// Initialize the tween, deleting null tween. | |
tween = new Array(n = self.tween.length); | |
for (i = 0, j = -1; i < n; ++i) { | |
if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) { | |
tween[++j] = o; | |
} | |
} | |
tween.length = j + 1; | |
} | |
function tick(elapsed) { | |
var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1), | |
i = -1, | |
n = tween.length; | |
while (++i < n) { | |
tween[i].call(null, t); | |
} | |
// Dispatch the end event. | |
if (self.state === ENDING) { | |
self.on.call("end", node, node.__data__, self.index, self.group); | |
stop(); | |
} | |
} | |
function stop() { | |
self.state = ENDED; | |
self.timer.stop(); | |
delete schedules[id]; | |
for (var i in schedules) return; // eslint-disable-line no-unused-vars | |
delete node.__transition; | |
} | |
} | |
function interrupt(node, name) { | |
var schedules = node.__transition, | |
schedule, | |
active, | |
empty = true, | |
i; | |
if (!schedules) return; | |
name = name == null ? null : name + ""; | |
for (i in schedules) { | |
if ((schedule = schedules[i]).name !== name) { empty = false; continue; } | |
active = schedule.state > STARTING && schedule.state < ENDING; | |
schedule.state = ENDED; | |
schedule.timer.stop(); | |
if (active) schedule.on.call("interrupt", node, node.__data__, schedule.index, schedule.group); | |
delete schedules[i]; | |
} | |
if (empty) delete node.__transition; | |
} | |
function selection_interrupt(name) { | |
return this.each(function() { | |
interrupt(this, name); | |
}); | |
} | |
function tweenRemove(id, name) { | |
var tween0, tween1; | |
return function() { | |
var schedule = set$2(this, id), | |
tween = schedule.tween; | |
// If this node shared tween with the previous node, | |
// just assign the updated shared tween and we’re done! | |
// Otherwise, copy-on-write. | |
if (tween !== tween0) { | |
tween1 = tween0 = tween; | |
for (var i = 0, n = tween1.length; i < n; ++i) { | |
if (tween1[i].name === name) { | |
tween1 = tween1.slice(); | |
tween1.splice(i, 1); | |
break; | |
} | |
} | |
} | |
schedule.tween = tween1; | |
}; | |
} | |
function tweenFunction(id, name, value) { | |
var tween0, tween1; | |
if (typeof value !== "function") throw new Error; | |
return function() { | |
var schedule = set$2(this, id), | |
tween = schedule.tween; | |
// If this node shared tween with the previous node, | |
// just assign the updated shared tween and we’re done! | |
// Otherwise, copy-on-write. | |
if (tween !== tween0) { | |
tween1 = (tween0 = tween).slice(); | |
for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) { | |
if (tween1[i].name === name) { | |
tween1[i] = t; | |
break; | |
} | |
} | |
if (i === n) tween1.push(t); | |
} | |
schedule.tween = tween1; | |
}; | |
} | |
function transition_tween(name, value) { | |
var id = this._id; | |
name += ""; | |
if (arguments.length < 2) { | |
var tween = get$1(this.node(), id).tween; | |
for (var i = 0, n = tween.length, t; i < n; ++i) { | |
if ((t = tween[i]).name === name) { | |
return t.value; | |
} | |
} | |
return null; | |
} | |
return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value)); | |
} | |
function tweenValue(transition, name, value) { | |
var id = transition._id; | |
transition.each(function() { | |
var schedule = set$2(this, id); | |
(schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments); | |
}); | |
return function(node) { | |
return get$1(node, id).value[name]; | |
}; | |
} | |
function interpolate$1(a, b) { | |
var c; | |
return (typeof b === "number" ? interpolateNumber | |
: b instanceof color ? interpolateRgb | |
: (c = color(b)) ? (b = c, interpolateRgb) | |
: interpolateString)(a, b); | |
} | |
function attrRemove$1(name) { | |
return function() { | |
this.removeAttribute(name); | |
}; | |
} | |
function attrRemoveNS$1(fullname) { | |
return function() { | |
this.removeAttributeNS(fullname.space, fullname.local); | |
}; | |
} | |
function attrConstant$1(name, interpolate, value1) { | |
var value00, | |
interpolate0; | |
return function() { | |
var value0 = this.getAttribute(name); | |
return value0 === value1 ? null | |
: value0 === value00 ? interpolate0 | |
: interpolate0 = interpolate(value00 = value0, value1); | |
}; | |
} | |
function attrConstantNS$1(fullname, interpolate, value1) { | |
var value00, | |
interpolate0; | |
return function() { | |
var value0 = this.getAttributeNS(fullname.space, fullname.local); | |
return value0 === value1 ? null | |
: value0 === value00 ? interpolate0 | |
: interpolate0 = interpolate(value00 = value0, value1); | |
}; | |
} | |
function attrFunction$1(name, interpolate, value) { | |
var value00, | |
value10, | |
interpolate0; | |
return function() { | |
var value0, value1 = value(this); | |
if (value1 == null) return void this.removeAttribute(name); | |
value0 = this.getAttribute(name); | |
return value0 === value1 ? null | |
: value0 === value00 && value1 === value10 ? interpolate0 | |
: interpolate0 = interpolate(value00 = value0, value10 = value1); | |
}; | |
} | |
function attrFunctionNS$1(fullname, interpolate, value) { | |
var value00, | |
value10, | |
interpolate0; | |
return function() { | |
var value0, value1 = value(this); | |
if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local); | |
value0 = this.getAttributeNS(fullname.space, fullname.local); | |
return value0 === value1 ? null | |
: value0 === value00 && value1 === value10 ? interpolate0 | |
: interpolate0 = interpolate(value00 = value0, value10 = value1); | |
}; | |
} | |
function transition_attr(name, value) { | |
var fullname = namespace(name), i = fullname === "transform" ? interpolateTransform$2 : interpolate$1; | |
return this.attrTween(name, typeof value === "function" | |
? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, "attr." + name, value)) | |
: value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname) | |
: (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value)); | |
} | |
function attrTweenNS(fullname, value) { | |
function tween() { | |
var node = this, i = value.apply(node, arguments); | |
return i && function(t) { | |
node.setAttributeNS(fullname.space, fullname.local, i(t)); | |
}; | |
} | |
tween._value = value; | |
return tween; | |
} | |
function attrTween(name, value) { | |
function tween() { | |
var node = this, i = value.apply(node, arguments); | |
return i && function(t) { | |
node.setAttribute(name, i(t)); | |
}; | |
} | |
tween._value = value; | |
return tween; | |
} | |
function transition_attrTween(name, value) { | |
var key = "attr." + name; | |
if (arguments.length < 2) return (key = this.tween(key)) && key._value; | |
if (value == null) return this.tween(key, null); | |
if (typeof value !== "function") throw new Error; | |
var fullname = namespace(name); | |
return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value)); | |
} | |
function delayFunction(id, value) { | |
return function() { | |
init(this, id).delay = +value.apply(this, arguments); | |
}; | |
} | |
function delayConstant(id, value) { | |
return value = +value, function() { | |
init(this, id).delay = value; | |
}; | |
} | |
function transition_delay(value) { | |
var id = this._id; | |
return arguments.length | |
? this.each((typeof value === "function" | |
? delayFunction | |
: delayConstant)(id, value)) | |
: get$1(this.node(), id).delay; | |
} | |
function durationFunction(id, value) { | |
return function() { | |
set$2(this, id).duration = +value.apply(this, arguments); | |
}; | |
} | |
function durationConstant(id, value) { | |
return value = +value, function() { | |
set$2(this, id).duration = value; | |
}; | |
} | |
function transition_duration(value) { | |
var id = this._id; | |
return arguments.length | |
? this.each((typeof value === "function" | |
? durationFunction | |
: durationConstant)(id, value)) | |
: get$1(this.node(), id).duration; | |
} | |
function easeConstant(id, value) { | |
if (typeof value !== "function") throw new Error; | |
return function() { | |
set$2(this, id).ease = value; | |
}; | |
} | |
function transition_ease(value) { | |
var id = this._id; | |
return arguments.length | |
? this.each(easeConstant(id, value)) | |
: get$1(this.node(), id).ease; | |
} | |
function transition_filter(match) { | |
if (typeof match !== "function") match = matcher$1(match); | |
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { | |
if ((node = group[i]) && match.call(node, node.__data__, i, group)) { | |
subgroup.push(node); | |
} | |
} | |
} | |
return new Transition(subgroups, this._parents, this._name, this._id); | |
} | |
function transition_merge(transition) { | |
if (transition._id !== this._id) throw new Error; | |
for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { | |
for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { | |
if (node = group0[i] || group1[i]) { | |
merge[i] = node; | |
} | |
} | |
} | |
for (; j < m0; ++j) { | |
merges[j] = groups0[j]; | |
} | |
return new Transition(merges, this._parents, this._name, this._id); | |
} | |
function start$1(name) { | |
return (name + "").trim().split(/^|\s+/).every(function(t) { | |
var i = t.indexOf("."); | |
if (i >= 0) t = t.slice(0, i); | |
return !t || t === "start"; | |
}); | |
} | |
function onFunction(id, name, listener) { | |
var on0, on1, sit = start$1(name) ? init : set$2; | |
return function() { | |
var schedule = sit(this, id), | |
on = schedule.on; | |
// If this node shared a dispatch with the previous node, | |
// just assign the updated shared dispatch and we’re done! | |
// Otherwise, copy-on-write. | |
if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener); | |
schedule.on = on1; | |
}; | |
} | |
function transition_on(name, listener) { | |
var id = this._id; | |
return arguments.length < 2 | |
? get$1(this.node(), id).on.on(name) | |
: this.each(onFunction(id, name, listener)); | |
} | |
function removeFunction(id) { | |
return function() { | |
var parent = this.parentNode; | |
for (var i in this.__transition) if (+i !== id) return; | |
if (parent) parent.removeChild(this); | |
}; | |
} | |
function transition_remove() { | |
return this.on("end.remove", removeFunction(this._id)); | |
} | |
function transition_select(select) { | |
var name = this._name, | |
id = this._id; | |
if (typeof select !== "function") select = selector(select); | |
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { | |
if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { | |
if ("__data__" in node) subnode.__data__ = node.__data__; | |
subgroup[i] = subnode; | |
schedule(subgroup[i], name, id, i, subgroup, get$1(node, id)); | |
} | |
} | |
} | |
return new Transition(subgroups, this._parents, name, id); | |
} | |
function transition_selectAll(select) { | |
var name = this._name, | |
id = this._id; | |
if (typeof select !== "function") select = selectorAll(select); | |
for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
if (node = group[i]) { | |
for (var children = select.call(node, node.__data__, i, group), child, inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k) { | |
if (child = children[k]) { | |
schedule(child, name, id, k, children, inherit); | |
} | |
} | |
subgroups.push(children); | |
parents.push(node); | |
} | |
} | |
} | |
return new Transition(subgroups, parents, name, id); | |
} | |
var Selection$1 = selection.prototype.constructor; | |
function transition_selection() { | |
return new Selection$1(this._groups, this._parents); | |
} | |
function styleRemove$1(name, interpolate) { | |
var value00, | |
value10, | |
interpolate0; | |
return function() { | |
var style = window$1(this).getComputedStyle(this, null), | |
value0 = style.getPropertyValue(name), | |
value1 = (this.style.removeProperty(name), style.getPropertyValue(name)); | |
return value0 === value1 ? null | |
: value0 === value00 && value1 === value10 ? interpolate0 | |
: interpolate0 = interpolate(value00 = value0, value10 = value1); | |
}; | |
} | |
function styleRemoveEnd(name) { | |
return function() { | |
this.style.removeProperty(name); | |
}; | |
} | |
function styleConstant$1(name, interpolate, value1) { | |
var value00, | |
interpolate0; | |
return function() { | |
var value0 = window$1(this).getComputedStyle(this, null).getPropertyValue(name); | |
return value0 === value1 ? null | |
: value0 === value00 ? interpolate0 | |
: interpolate0 = interpolate(value00 = value0, value1); | |
}; | |
} | |
function styleFunction$1(name, interpolate, value) { | |
var value00, | |
value10, | |
interpolate0; | |
return function() { | |
var style = window$1(this).getComputedStyle(this, null), | |
value0 = style.getPropertyValue(name), | |
value1 = value(this); | |
if (value1 == null) value1 = (this.style.removeProperty(name), style.getPropertyValue(name)); | |
return value0 === value1 ? null | |
: value0 === value00 && value1 === value10 ? interpolate0 | |
: interpolate0 = interpolate(value00 = value0, value10 = value1); | |
}; | |
} | |
function transition_style(name, value, priority) { | |
var i = (name += "") === "transform" ? interpolateTransform$1 : interpolate$1; | |
return value == null ? this | |
.styleTween(name, styleRemove$1(name, i)) | |
.on("end.style." + name, styleRemoveEnd(name)) | |
: this.styleTween(name, typeof value === "function" | |
? styleFunction$1(name, i, tweenValue(this, "style." + name, value)) | |
: styleConstant$1(name, i, value), priority); | |
} | |
function styleTween(name, value, priority) { | |
function tween() { | |
var node = this, i = value.apply(node, arguments); | |
return i && function(t) { | |
node.style.setProperty(name, i(t), priority); | |
}; | |
} | |
tween._value = value; | |
return tween; | |
} | |
function transition_styleTween(name, value, priority) { | |
var key = "style." + (name += ""); | |
if (arguments.length < 2) return (key = this.tween(key)) && key._value; | |
if (value == null) return this.tween(key, null); | |
if (typeof value !== "function") throw new Error; | |
return this.tween(key, styleTween(name, value, priority == null ? "" : priority)); | |
} | |
function textConstant$1(value) { | |
return function() { | |
this.textContent = value; | |
}; | |
} | |
function textFunction$1(value) { | |
return function() { | |
var value1 = value(this); | |
this.textContent = value1 == null ? "" : value1; | |
}; | |
} | |
function transition_text(value) { | |
return this.tween("text", typeof value === "function" | |
? textFunction$1(tweenValue(this, "text", value)) | |
: textConstant$1(value == null ? "" : value + "")); | |
} | |
function transition_transition() { | |
var name = this._name, | |
id0 = this._id, | |
id1 = newId(); | |
for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
if (node = group[i]) { | |
var inherit = get$1(node, id0); | |
schedule(node, name, id1, i, group, { | |
time: inherit.time + inherit.delay + inherit.duration, | |
delay: 0, | |
duration: inherit.duration, | |
ease: inherit.ease | |
}); | |
} | |
} | |
} | |
return new Transition(groups, this._parents, name, id1); | |
} | |
var id = 0; | |
function Transition(groups, parents, name, id) { | |
this._groups = groups; | |
this._parents = parents; | |
this._name = name; | |
this._id = id; | |
} | |
function transition(name) { | |
return selection().transition(name); | |
} | |
function newId() { | |
return ++id; | |
} | |
var selection_prototype = selection.prototype; | |
Transition.prototype = transition.prototype = { | |
constructor: Transition, | |
select: transition_select, | |
selectAll: transition_selectAll, | |
filter: transition_filter, | |
merge: transition_merge, | |
selection: transition_selection, | |
transition: transition_transition, | |
call: selection_prototype.call, | |
nodes: selection_prototype.nodes, | |
node: selection_prototype.node, | |
size: selection_prototype.size, | |
empty: selection_prototype.empty, | |
each: selection_prototype.each, | |
on: transition_on, | |
attr: transition_attr, | |
attrTween: transition_attrTween, | |
style: transition_style, | |
styleTween: transition_styleTween, | |
text: transition_text, | |
remove: transition_remove, | |
tween: transition_tween, | |
delay: transition_delay, | |
duration: transition_duration, | |
ease: transition_ease | |
}; | |
var defaultTiming = { | |
time: null, // Set on use. | |
delay: 0, | |
duration: 250, | |
ease: easeCubicInOut | |
}; | |
function inherit(node, id) { | |
var timing; | |
while (!(timing = node.__transition) || !(timing = timing[id])) { | |
if (!(node = node.parentNode)) { | |
return defaultTiming.time = now(), defaultTiming; | |
} | |
} | |
return timing; | |
} | |
function selection_transition(name) { | |
var id, | |
timing; | |
if (name instanceof Transition) { | |
id = name._id, name = name._name; | |
} else { | |
id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + ""; | |
} | |
for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { | |
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
if (node = group[i]) { | |
schedule(node, name, id, i, group, timing || inherit(node, id)); | |
} | |
} | |
} | |
return new Transition(groups, this._parents, name, id); | |
} | |
selection.prototype.interrupt = selection_interrupt; | |
selection.prototype.transition = selection_transition; | |
var root$1 = [null]; | |
function active(node, name) { | |
var schedules = node.__transition, | |
schedule, | |
i; | |
if (schedules) { | |
name = name == null ? null : name + ""; | |
for (i in schedules) { | |
if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) { | |
return new Transition([[node]], root$1, name, +i); | |
} | |
} | |
} | |
return null; | |
} | |
var slice$4 = Array.prototype.slice; | |
function identity$5(x) { | |
return x; | |
} | |
var top = 1; | |
var right = 2; | |
var bottom = 3; | |
var left = 4; | |
var epsilon$2 = 1e-6; | |
function translateX(scale0, scale1, d) { | |
var x = scale0(d); | |
return "translate(" + (isFinite(x) ? x : scale1(d)) + ",0)"; | |
} | |
function translateY(scale0, scale1, d) { | |
var y = scale0(d); | |
return "translate(0," + (isFinite(y) ? y : scale1(d)) + ")"; | |
} | |
function center(scale) { | |
var offset = scale.bandwidth() / 2; | |
if (scale.round()) offset = Math.round(offset); | |
return function(d) { | |
return scale(d) + offset; | |
}; | |
} | |
function entering() { | |
return !this.__axis; | |
} | |
function axis(orient, scale) { | |
var tickArguments = [], | |
tickValues = null, | |
tickFormat = null, | |
tickSizeInner = 6, | |
tickSizeOuter = 6, | |
tickPadding = 3; | |
function axis(context) { | |
var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues, | |
format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$5) : tickFormat, | |
spacing = Math.max(tickSizeInner, 0) + tickPadding, | |
transform = orient === top || orient === bottom ? translateX : translateY, | |
range = scale.range(), | |
range0 = range[0] + 0.5, | |
range1 = range[range.length - 1] + 0.5, | |
position = (scale.bandwidth ? center : identity$5)(scale.copy()), | |
selection = context.selection ? context.selection() : context, | |
path = selection.selectAll(".domain").data([null]), | |
tick = selection.selectAll(".tick").data(values, scale).order(), | |
tickExit = tick.exit(), | |
tickEnter = tick.enter().append("g").attr("class", "tick"), | |
line = tick.select("line"), | |
text = tick.select("text"), | |
k = orient === top || orient === left ? -1 : 1, | |
x, y = orient === left || orient === right ? (x = "x", "y") : (x = "y", "x"); | |
path = path.merge(path.enter().insert("path", ".tick") | |
.attr("class", "domain") | |
.attr("stroke", "#000")); | |
tick = tick.merge(tickEnter); | |
line = line.merge(tickEnter.append("line") | |
.attr("stroke", "#000") | |
.attr(x + "2", k * tickSizeInner) | |
.attr(y + "1", 0.5) | |
.attr(y + "2", 0.5)); | |
text = text.merge(tickEnter.append("text") | |
.attr("fill", "#000") | |
.attr(x, k * spacing) | |
.attr(y, 0.5) | |
.attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em")); | |
if (context !== selection) { | |
path = path.transition(context); | |
tick = tick.transition(context); | |
line = line.transition(context); | |
text = text.transition(context); | |
tickExit = tickExit.transition(context) | |
.attr("opacity", epsilon$2) | |
.attr("transform", function(d) { return transform(position, this.parentNode.__axis || position, d); }); | |
tickEnter | |
.attr("opacity", epsilon$2) | |
.attr("transform", function(d) { return transform(this.parentNode.__axis || position, position, d); }); | |
} | |
tickExit.remove(); | |
path | |
.attr("d", orient === left || orient == right | |
? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter | |
: "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter); | |
tick | |
.attr("opacity", 1) | |
.attr("transform", function(d) { return transform(position, position, d); }); | |
line | |
.attr(x + "2", k * tickSizeInner); | |
text | |
.attr(x, k * spacing) | |
.text(format); | |
selection.filter(entering) | |
.attr("fill", "none") | |
.attr("font-size", 10) | |
.attr("font-family", "sans-serif") | |
.attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle"); | |
selection | |
.each(function() { this.__axis = position; }); | |
} | |
axis.scale = function(_) { | |
return arguments.length ? (scale = _, axis) : scale; | |
}; | |
axis.ticks = function() { | |
return tickArguments = slice$4.call(arguments), axis; | |
}; | |
axis.tickArguments = function(_) { | |
return arguments.length ? (tickArguments = _ == null ? [] : slice$4.call(_), axis) : tickArguments.slice(); | |
}; | |
axis.tickValues = function(_) { | |
return arguments.length ? (tickValues = _ == null ? null : slice$4.call(_), axis) : tickValues && tickValues.slice(); | |
}; | |
axis.tickFormat = function(_) { | |
return arguments.length ? (tickFormat = _, axis) : tickFormat; | |
}; | |
axis.tickSize = function(_) { | |
return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner; | |
}; | |
axis.tickSizeInner = function(_) { | |
return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner; | |
}; | |
axis.tickSizeOuter = function(_) { | |
return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter; | |
}; | |
axis.tickPadding = function(_) { | |
return arguments.length ? (tickPadding = +_, axis) : tickPadding; | |
}; | |
return axis; | |
} | |
function axisTop(scale) { | |
return axis(top, scale); | |
} | |
function axisRight(scale) { | |
return axis(right, scale); | |
} | |
function axisBottom(scale) { | |
return axis(bottom, scale); | |
} | |
function axisLeft(scale) { | |
return axis(left, scale); | |
} | |
function defaultSeparation(a, b) { | |
return a.parent === b.parent ? 1 : 2; | |
} | |
function meanX(children) { | |
return children.reduce(meanXReduce, 0) / children.length; | |
} | |
function meanXReduce(x, c) { | |
return x + c.x; | |
} | |
function maxY(children) { | |
return 1 + children.reduce(maxYReduce, 0); | |
} | |
function maxYReduce(y, c) { | |
return Math.max(y, c.y); | |
} | |
function leafLeft(node) { | |
var children; | |
while (children = node.children) node = children[0]; | |
return node; | |
} | |
function leafRight(node) { | |
var children; | |
while (children = node.children) node = children[children.length - 1]; | |
return node; | |
} | |
function cluster() { | |
var separation = defaultSeparation, | |
dx = 1, | |
dy = 1, | |
nodeSize = false; | |
function cluster(root) { | |
var previousNode, | |
x = 0; | |
// First walk, computing the initial x & y values. | |
root.eachAfter(function(node) { | |
var children = node.children; | |
if (children) { | |
node.x = meanX(children); | |
node.y = maxY(children); | |
} else { | |
node.x = previousNode ? x += separation(node, previousNode) : 0; | |
node.y = 0; | |
previousNode = node; | |
} | |
}); | |
var left = leafLeft(root), | |
right = leafRight(root), | |
x0 = left.x - separation(left, right) / 2, | |
x1 = right.x + separation(right, left) / 2; | |
// Second walk, normalizing x & y to the desired size. | |
return root.eachAfter(nodeSize ? function(node) { | |
node.x = (node.x - root.x) * dx; | |
node.y = (root.y - node.y) * dy; | |
} : function(node) { | |
node.x = (node.x - x0) / (x1 - x0) * dx; | |
node.y = (1 - (root.y ? node.y / root.y : 1)) * dy; | |
}); | |
} | |
cluster.separation = function(x) { | |
return arguments.length ? (separation = x, cluster) : separation; | |
}; | |
cluster.size = function(x) { | |
return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]); | |
}; | |
cluster.nodeSize = function(x) { | |
return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null); | |
}; | |
return cluster; | |
} | |
function node_each(callback) { | |
var node = this, current, next = [node], children, i, n; | |
do { | |
current = next.reverse(), next = []; | |
while (node = current.pop()) { | |
callback(node), children = node.children; | |
if (children) for (i = 0, n = children.length; i < n; ++i) { | |
next.push(children[i]); | |
} | |
} | |
} while (next.length); | |
return this; | |
} | |
function node_eachBefore(callback) { | |
var node = this, nodes = [node], children, i; | |
while (node = nodes.pop()) { | |
callback(node), children = node.children; | |
if (children) for (i = children.length - 1; i >= 0; --i) { | |
nodes.push(children[i]); | |
} | |
} | |
return this; | |
} | |
function node_eachAfter(callback) { | |
var node = this, nodes = [node], next = [], children, i, n; | |
while (node = nodes.pop()) { | |
next.push(node), children = node.children; | |
if (children) for (i = 0, n = children.length; i < n; ++i) { | |
nodes.push(children[i]); | |
} | |
} | |
while (node = next.pop()) { | |
callback(node); | |
} | |
return this; | |
} | |
function node_sum(value) { | |
return this.eachAfter(function(node) { | |
var sum = +value(node.data) || 0, | |
children = node.children, | |
i = children && children.length; | |
while (--i >= 0) sum += children[i].value; | |
node.value = sum; | |
}); | |
} | |
function node_sort(compare) { | |
return this.eachBefore(function(node) { | |
if (node.children) { | |
node.children.sort(compare); | |
} | |
}); | |
} | |
function node_path(end) { | |
var start = this, | |
ancestor = leastCommonAncestor(start, end), | |
nodes = [start]; | |
while (start !== ancestor) { | |
start = start.parent; | |
nodes.push(start); | |
} | |
var k = nodes.length; | |
while (end !== ancestor) { | |
nodes.splice(k, 0, end); | |
end = end.parent; | |
} | |
return nodes; | |
} | |
function leastCommonAncestor(a, b) { | |
if (a === b) return a; | |
var aNodes = a.ancestors(), | |
bNodes = b.ancestors(), | |
c = null; | |
a = aNodes.pop(); | |
b = bNodes.pop(); | |
while (a === b) { | |
c = a; | |
a = aNodes.pop(); | |
b = bNodes.pop(); | |
} | |
return c; | |
} | |
function node_ancestors() { | |
var node = this, nodes = [node]; | |
while (node = node.parent) { | |
nodes.push(node); | |
} | |
return nodes; | |
} | |
function node_descendants() { | |
var nodes = []; | |
this.each(function(node) { | |
nodes.push(node); | |
}); | |
return nodes; | |
} | |
function node_leaves() { | |
var leaves = []; | |
this.eachBefore(function(node) { | |
if (!node.children) { | |
leaves.push(node); | |
} | |
}); | |
return leaves; | |
} | |
function node_links() { | |
var root = this, links = []; | |
root.each(function(node) { | |
if (node !== root) { // Don’t include the root’s parent, if any. | |
links.push({source: node.parent, target: node}); | |
} | |
}); | |
return links; | |
} | |
function hierarchy(data, children) { | |
var root = new Node(data), | |
valued = +data.value && (root.value = data.value), | |
node, | |
nodes = [root], | |
child, | |
childs, | |
i, | |
n; | |
if (children == null) children = defaultChildren; | |
while (node = nodes.pop()) { | |
if (valued) node.value = +node.data.value; | |
if ((childs = children(node.data)) && (n = childs.length)) { | |
node.children = new Array(n); | |
for (i = n - 1; i >= 0; --i) { | |
nodes.push(child = node.children[i] = new Node(childs[i])); | |
child.parent = node; | |
child.depth = node.depth + 1; | |
} | |
} | |
} | |
return root.eachBefore(computeHeight); | |
} | |
function node_copy() { | |
return hierarchy(this).eachBefore(copyData); | |
} | |
function defaultChildren(d) { | |
return d.children; | |
} | |
function copyData(node) { | |
node.data = node.data.data; | |
} | |
function computeHeight(node) { | |
var height = 0; | |
do node.height = height; | |
while ((node = node.parent) && (node.height < ++height)); | |
} | |
function Node(data) { | |
this.data = data; | |
this.depth = | |
this.height = 0; | |
this.parent = null; | |
} | |
Node.prototype = hierarchy.prototype = { | |
constructor: Node, | |
each: node_each, | |
eachAfter: node_eachAfter, | |
eachBefore: node_eachBefore, | |
sum: node_sum, | |
sort: node_sort, | |
path: node_path, | |
ancestors: node_ancestors, | |
descendants: node_descendants, | |
leaves: node_leaves, | |
links: node_links, | |
copy: node_copy | |
}; | |
function Node$2(value) { | |
this._ = value; | |
this.next = null; | |
} | |
function shuffle$1(array) { | |
var i, | |
n = (array = array.slice()).length, | |
head = null, | |
node = head; | |
while (n) { | |
var next = new Node$2(array[n - 1]); | |
if (node) node = node.next = next; | |
else node = head = next; | |
array[i] = array[--n]; | |
} | |
return { | |
head: head, | |
tail: node | |
}; | |
} | |
function enclose(circles) { | |
return encloseN(shuffle$1(circles), []); | |
} | |
function encloses(a, b) { | |
var dx = b.x - a.x, | |
dy = b.y - a.y, | |
dr = a.r - b.r; | |
return dr * dr + 1e-6 > dx * dx + dy * dy; | |
} | |
// Returns the smallest circle that contains circles L and intersects circles B. | |
function encloseN(L, B) { | |
var circle, | |
l0 = null, | |
l1 = L.head, | |
l2, | |
p1; | |
switch (B.length) { | |
case 1: circle = enclose1(B[0]); break; | |
case 2: circle = enclose2(B[0], B[1]); break; | |
case 3: circle = enclose3(B[0], B[1], B[2]); break; | |
} | |
while (l1) { | |
p1 = l1._, l2 = l1.next; | |
if (!circle || !encloses(circle, p1)) { | |
// Temporarily truncate L before l1. | |
if (l0) L.tail = l0, l0.next = null; | |
else L.head = L.tail = null; | |
B.push(p1); | |
circle = encloseN(L, B); // Note: reorders L! | |
B.pop(); | |
// Move l1 to the front of L and reconnect the truncated list L. | |
if (L.head) l1.next = L.head, L.head = l1; | |
else l1.next = null, L.head = L.tail = l1; | |
l0 = L.tail, l0.next = l2; | |
} else { | |
l0 = l1; | |
} | |
l1 = l2; | |
} | |
L.tail = l0; | |
return circle; | |
} | |
function enclose1(a) { | |
return { | |
x: a.x, | |
y: a.y, | |
r: a.r | |
}; | |
} | |
function enclose2(a, b) { | |
var x1 = a.x, y1 = a.y, r1 = a.r, | |
x2 = b.x, y2 = b.y, r2 = b.r, | |
x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1, | |
l = Math.sqrt(x21 * x21 + y21 * y21); | |
return { | |
x: (x1 + x2 + x21 / l * r21) / 2, | |
y: (y1 + y2 + y21 / l * r21) / 2, | |
r: (l + r1 + r2) / 2 | |
}; | |
} | |
function enclose3(a, b, c) { | |
var x1 = a.x, y1 = a.y, r1 = a.r, | |
x2 = b.x, y2 = b.y, r2 = b.r, | |
x3 = c.x, y3 = c.y, r3 = c.r, | |
a2 = 2 * (x1 - x2), | |
b2 = 2 * (y1 - y2), | |
c2 = 2 * (r2 - r1), | |
d2 = x1 * x1 + y1 * y1 - r1 * r1 - x2 * x2 - y2 * y2 + r2 * r2, | |
a3 = 2 * (x1 - x3), | |
b3 = 2 * (y1 - y3), | |
c3 = 2 * (r3 - r1), | |
d3 = x1 * x1 + y1 * y1 - r1 * r1 - x3 * x3 - y3 * y3 + r3 * r3, | |
ab = a3 * b2 - a2 * b3, | |
xa = (b2 * d3 - b3 * d2) / ab - x1, | |
xb = (b3 * c2 - b2 * c3) / ab, | |
ya = (a3 * d2 - a2 * d3) / ab - y1, | |
yb = (a2 * c3 - a3 * c2) / ab, | |
A = xb * xb + yb * yb - 1, | |
B = 2 * (xa * xb + ya * yb + r1), | |
C = xa * xa + ya * ya - r1 * r1, | |
r = (-B - Math.sqrt(B * B - 4 * A * C)) / (2 * A); | |
return { | |
x: xa + xb * r + x1, | |
y: ya + yb * r + y1, | |
r: r | |
}; | |
} | |
function place(a, b, c) { | |
var ax = a.x, | |
ay = a.y, | |
da = b.r + c.r, | |
db = a.r + c.r, | |
dx = b.x - ax, | |
dy = b.y - ay, | |
dc = dx * dx + dy * dy; | |
if (dc) { | |
var x = 0.5 + ((db *= db) - (da *= da)) / (2 * dc), | |
y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc); | |
c.x = ax + x * dx + y * dy; | |
c.y = ay + x * dy - y * dx; | |
} else { | |
c.x = ax + db; | |
c.y = ay; | |
} | |
} | |
function intersects(a, b) { | |
var dx = b.x - a.x, | |
dy = b.y - a.y, | |
dr = a.r + b.r; | |
return dr * dr > dx * dx + dy * dy; | |
} | |
function distance2(circle, x, y) { | |
var dx = circle.x - x, | |
dy = circle.y - y; | |
return dx * dx + dy * dy; | |
} | |
function Node$1(circle) { | |
this._ = circle; | |
this.next = null; | |
this.previous = null; | |
} | |
function packEnclose(circles) { | |
if (!(n = circles.length)) return 0; | |
var a, b, c, n; | |
// Place the first circle. | |
a = circles[0], a.x = 0, a.y = 0; | |
if (!(n > 1)) return a.r; | |
// Place the second circle. | |
b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0; | |
if (!(n > 2)) return a.r + b.r; | |
// Place the third circle. | |
place(b, a, c = circles[2]); | |
// Initialize the weighted centroid. | |
var aa = a.r * a.r, | |
ba = b.r * b.r, | |
ca = c.r * c.r, | |
oa = aa + ba + ca, | |
ox = aa * a.x + ba * b.x + ca * c.x, | |
oy = aa * a.y + ba * b.y + ca * c.y, | |
cx, cy, i, j, k, sj, sk; | |
// Initialize the front-chain using the first three circles a, b and c. | |
a = new Node$1(a), b = new Node$1(b), c = new Node$1(c); | |
a.next = c.previous = b; | |
b.next = a.previous = c; | |
c.next = b.previous = a; | |
// Attempt to place each remaining circle… | |
pack: for (i = 3; i < n; ++i) { | |
place(a._, b._, c = circles[i]), c = new Node$1(c); | |
// If there are only three elements in the front-chain… | |
if ((k = a.previous) === (j = b.next)) { | |
// If the new circle intersects the third circle, | |
// rotate the front chain to try the next position. | |
if (intersects(j._, c._)) { | |
a = b, b = j, --i; | |
continue pack; | |
} | |
} | |
// Find the closest intersecting circle on the front-chain, if any. | |
else { | |
sj = j._.r, sk = k._.r; | |
do { | |
if (sj <= sk) { | |
if (intersects(j._, c._)) { | |
b = j, a.next = b, b.previous = a, --i; | |
continue pack; | |
} | |
j = j.next, sj += j._.r; | |
} else { | |
if (intersects(k._, c._)) { | |
a = k, a.next = b, b.previous = a, --i; | |
continue pack; | |
} | |
k = k.previous, sk += k._.r; | |
} | |
} while (j !== k.next); | |
} | |
// Success! Insert the new circle c between a and b. | |
c.previous = a, c.next = b, a.next = b.previous = b = c; | |
// Update the weighted centroid. | |
oa += ca = c._.r * c._.r; | |
ox += ca * c._.x; | |
oy += ca * c._.y; | |
// Compute the new closest circle a to centroid. | |
aa = distance2(a._, cx = ox / oa, cy = oy / oa); | |
while ((c = c.next) !== b) { | |
if ((ca = distance2(c._, cx, cy)) < aa) { | |
a = c, aa = ca; | |
} | |
} | |
b = a.next; | |
} | |
// Compute the enclosing circle of the front chain. | |
a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = enclose(a); | |
// Translate the circles to put the enclosing circle around the origin. | |
for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y; | |
return c.r; | |
} | |
function siblings(circles) { | |
packEnclose(circles); | |
return circles; | |
} | |
function optional(f) { | |
return f == null ? null : required(f); | |
} | |
function required(f) { | |
if (typeof f !== "function") throw new Error; | |
return f; | |
} | |
function constantZero() { | |
return 0; | |
} | |
function constant$5(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function defaultRadius(d) { | |
return Math.sqrt(d.value); | |
} | |
function index() { | |
var radius = null, | |
dx = 1, | |
dy = 1, | |
padding = constantZero; | |
function pack(root) { | |
root.x = dx / 2, root.y = dy / 2; | |
if (radius) { | |
root.eachBefore(radiusLeaf(radius)) | |
.eachAfter(packChildren(padding, 0.5)) | |
.eachBefore(translateChild(1)); | |
} else { | |
root.eachBefore(radiusLeaf(defaultRadius)) | |
.eachAfter(packChildren(constantZero, 1)) | |
.eachAfter(packChildren(padding, root.r / Math.min(dx, dy))) | |
.eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r))); | |
} | |
return root; | |
} | |
pack.radius = function(x) { | |
return arguments.length ? (radius = optional(x), pack) : radius; | |
}; | |
pack.size = function(x) { | |
return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy]; | |
}; | |
pack.padding = function(x) { | |
return arguments.length ? (padding = typeof x === "function" ? x : constant$5(+x), pack) : padding; | |
}; | |
return pack; | |
} | |
function radiusLeaf(radius) { | |
return function(node) { | |
if (!node.children) { | |
node.r = Math.max(0, +radius(node) || 0); | |
} | |
}; | |
} | |
function packChildren(padding, k) { | |
return function(node) { | |
if (children = node.children) { | |
var children, | |
i, | |
n = children.length, | |
r = padding(node) * k || 0, | |
e; | |
if (r) for (i = 0; i < n; ++i) children[i].r += r; | |
e = packEnclose(children); | |
if (r) for (i = 0; i < n; ++i) children[i].r -= r; | |
node.r = e + r; | |
} | |
}; | |
} | |
function translateChild(k) { | |
return function(node) { | |
var parent = node.parent; | |
node.r *= k; | |
if (parent) { | |
node.x = parent.x + k * node.x; | |
node.y = parent.y + k * node.y; | |
} | |
}; | |
} | |
function roundNode(node) { | |
node.x0 = Math.round(node.x0); | |
node.y0 = Math.round(node.y0); | |
node.x1 = Math.round(node.x1); | |
node.y1 = Math.round(node.y1); | |
} | |
function treemapDice(parent, x0, y0, x1, y1) { | |
var nodes = parent.children, | |
node, | |
i = -1, | |
n = nodes.length, | |
k = parent.value && (x1 - x0) / parent.value; | |
while (++i < n) { | |
node = nodes[i], node.y0 = y0, node.y1 = y1; | |
node.x0 = x0, node.x1 = x0 += node.value * k; | |
} | |
} | |
function partition() { | |
var dx = 1, | |
dy = 1, | |
padding = 0, | |
round = false; | |
function partition(root) { | |
var n = root.height + 1; | |
root.x0 = | |
root.y0 = padding; | |
root.x1 = dx; | |
root.y1 = dy / n; | |
root.eachBefore(positionNode(dy, n)); | |
if (round) root.eachBefore(roundNode); | |
return root; | |
} | |
function positionNode(dy, n) { | |
return function(node) { | |
if (node.children) { | |
treemapDice(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n); | |
} | |
var x0 = node.x0, | |
y0 = node.y0, | |
x1 = node.x1 - padding, | |
y1 = node.y1 - padding; | |
if (x1 < x0) x0 = x1 = (x0 + x1) / 2; | |
if (y1 < y0) y0 = y1 = (y0 + y1) / 2; | |
node.x0 = x0; | |
node.y0 = y0; | |
node.x1 = x1; | |
node.y1 = y1; | |
}; | |
} | |
partition.round = function(x) { | |
return arguments.length ? (round = !!x, partition) : round; | |
}; | |
partition.size = function(x) { | |
return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy]; | |
}; | |
partition.padding = function(x) { | |
return arguments.length ? (padding = +x, partition) : padding; | |
}; | |
return partition; | |
} | |
var keyPrefix$1 = "$"; | |
var preroot = {depth: -1}; | |
var ambiguous = {}; | |
function defaultId(d) { | |
return d.id; | |
} | |
function defaultParentId(d) { | |
return d.parentId; | |
} | |
function stratify() { | |
var id = defaultId, | |
parentId = defaultParentId; | |
function stratify(data) { | |
var d, | |
i, | |
n = data.length, | |
root, | |
parent, | |
node, | |
nodes = new Array(n), | |
nodeId, | |
nodeKey, | |
nodeByKey = {}; | |
for (i = 0; i < n; ++i) { | |
d = data[i], node = nodes[i] = new Node(d); | |
if ((nodeId = id(d, i, data)) != null && (nodeId += "")) { | |
nodeKey = keyPrefix$1 + (node.id = nodeId); | |
nodeByKey[nodeKey] = nodeKey in nodeByKey ? ambiguous : node; | |
} | |
} | |
for (i = 0; i < n; ++i) { | |
node = nodes[i], nodeId = parentId(data[i], i, data); | |
if (nodeId == null || !(nodeId += "")) { | |
if (root) throw new Error("multiple roots"); | |
root = node; | |
} else { | |
parent = nodeByKey[keyPrefix$1 + nodeId]; | |
if (!parent) throw new Error("missing: " + nodeId); | |
if (parent === ambiguous) throw new Error("ambiguous: " + nodeId); | |
if (parent.children) parent.children.push(node); | |
else parent.children = [node]; | |
node.parent = parent; | |
} | |
} | |
if (!root) throw new Error("no root"); | |
root.parent = preroot; | |
root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight); | |
root.parent = null; | |
if (n > 0) throw new Error("cycle"); | |
return root; | |
} | |
stratify.id = function(x) { | |
return arguments.length ? (id = required(x), stratify) : id; | |
}; | |
stratify.parentId = function(x) { | |
return arguments.length ? (parentId = required(x), stratify) : parentId; | |
}; | |
return stratify; | |
} | |
function defaultSeparation$1(a, b) { | |
return a.parent === b.parent ? 1 : 2; | |
} | |
// function radialSeparation(a, b) { | |
// return (a.parent === b.parent ? 1 : 2) / a.depth; | |
// } | |
// This function is used to traverse the left contour of a subtree (or | |
// subforest). It returns the successor of v on this contour. This successor is | |
// either given by the leftmost child of v or by the thread of v. The function | |
// returns null if and only if v is on the highest level of its subtree. | |
function nextLeft(v) { | |
var children = v.children; | |
return children ? children[0] : v.t; | |
} | |
// This function works analogously to nextLeft. | |
function nextRight(v) { | |
var children = v.children; | |
return children ? children[children.length - 1] : v.t; | |
} | |
// Shifts the current subtree rooted at w+. This is done by increasing | |
// prelim(w+) and mod(w+) by shift. | |
function moveSubtree(wm, wp, shift) { | |
var change = shift / (wp.i - wm.i); | |
wp.c -= change; | |
wp.s += shift; | |
wm.c += change; | |
wp.z += shift; | |
wp.m += shift; | |
} | |
// All other shifts, applied to the smaller subtrees between w- and w+, are | |
// performed by this function. To prepare the shifts, we have to adjust | |
// change(w+), shift(w+), and change(w-). | |
function executeShifts(v) { | |
var shift = 0, | |
change = 0, | |
children = v.children, | |
i = children.length, | |
w; | |
while (--i >= 0) { | |
w = children[i]; | |
w.z += shift; | |
w.m += shift; | |
shift += w.s + (change += w.c); | |
} | |
} | |
// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise, | |
// returns the specified (default) ancestor. | |
function nextAncestor(vim, v, ancestor) { | |
return vim.a.parent === v.parent ? vim.a : ancestor; | |
} | |
function TreeNode(node, i) { | |
this._ = node; | |
this.parent = null; | |
this.children = null; | |
this.A = null; // default ancestor | |
this.a = this; // ancestor | |
this.z = 0; // prelim | |
this.m = 0; // mod | |
this.c = 0; // change | |
this.s = 0; // shift | |
this.t = null; // thread | |
this.i = i; // number | |
} | |
TreeNode.prototype = Object.create(Node.prototype); | |
function treeRoot(root) { | |
var tree = new TreeNode(root, 0), | |
node, | |
nodes = [tree], | |
child, | |
children, | |
i, | |
n; | |
while (node = nodes.pop()) { | |
if (children = node._.children) { | |
node.children = new Array(n = children.length); | |
for (i = n - 1; i >= 0; --i) { | |
nodes.push(child = node.children[i] = new TreeNode(children[i], i)); | |
child.parent = node; | |
} | |
} | |
} | |
(tree.parent = new TreeNode(null, 0)).children = [tree]; | |
return tree; | |
} | |
// Node-link tree diagram using the Reingold-Tilford "tidy" algorithm | |
function tree() { | |
var separation = defaultSeparation$1, | |
dx = 1, | |
dy = 1, | |
nodeSize = null; | |
function tree(root) { | |
var t = treeRoot(root); | |
// Compute the layout using Buchheim et al.’s algorithm. | |
t.eachAfter(firstWalk), t.parent.m = -t.z; | |
t.eachBefore(secondWalk); | |
// If a fixed node size is specified, scale x and y. | |
if (nodeSize) root.eachBefore(sizeNode); | |
// If a fixed tree size is specified, scale x and y based on the extent. | |
// Compute the left-most, right-most, and depth-most nodes for extents. | |
else { | |
var left = root, | |
right = root, | |
bottom = root; | |
root.eachBefore(function(node) { | |
if (node.x < left.x) left = node; | |
if (node.x > right.x) right = node; | |
if (node.depth > bottom.depth) bottom = node; | |
}); | |
var s = left === right ? 1 : separation(left, right) / 2, | |
tx = s - left.x, | |
kx = dx / (right.x + s + tx), | |
ky = dy / (bottom.depth || 1); | |
root.eachBefore(function(node) { | |
node.x = (node.x + tx) * kx; | |
node.y = node.depth * ky; | |
}); | |
} | |
return root; | |
} | |
// Computes a preliminary x-coordinate for v. Before that, FIRST WALK is | |
// applied recursively to the children of v, as well as the function | |
// APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the | |
// node v is placed to the midpoint of its outermost children. | |
function firstWalk(v) { | |
var children = v.children, | |
siblings = v.parent.children, | |
w = v.i ? siblings[v.i - 1] : null; | |
if (children) { | |
executeShifts(v); | |
var midpoint = (children[0].z + children[children.length - 1].z) / 2; | |
if (w) { | |
v.z = w.z + separation(v._, w._); | |
v.m = v.z - midpoint; | |
} else { | |
v.z = midpoint; | |
} | |
} else if (w) { | |
v.z = w.z + separation(v._, w._); | |
} | |
v.parent.A = apportion(v, w, v.parent.A || siblings[0]); | |
} | |
// Computes all real x-coordinates by summing up the modifiers recursively. | |
function secondWalk(v) { | |
v._.x = v.z + v.parent.m; | |
v.m += v.parent.m; | |
} | |
// The core of the algorithm. Here, a new subtree is combined with the | |
// previous subtrees. Threads are used to traverse the inside and outside | |
// contours of the left and right subtree up to the highest common level. The | |
// vertices used for the traversals are vi+, vi-, vo-, and vo+, where the | |
// superscript o means outside and i means inside, the subscript - means left | |
// subtree and + means right subtree. For summing up the modifiers along the | |
// contour, we use respective variables si+, si-, so-, and so+. Whenever two | |
// nodes of the inside contours conflict, we compute the left one of the | |
// greatest uncommon ancestors using the function ANCESTOR and call MOVE | |
// SUBTREE to shift the subtree and prepare the shifts of smaller subtrees. | |
// Finally, we add a new thread (if necessary). | |
function apportion(v, w, ancestor) { | |
if (w) { | |
var vip = v, | |
vop = v, | |
vim = w, | |
vom = vip.parent.children[0], | |
sip = vip.m, | |
sop = vop.m, | |
sim = vim.m, | |
som = vom.m, | |
shift; | |
while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) { | |
vom = nextLeft(vom); | |
vop = nextRight(vop); | |
vop.a = v; | |
shift = vim.z + sim - vip.z - sip + separation(vim._, vip._); | |
if (shift > 0) { | |
moveSubtree(nextAncestor(vim, v, ancestor), v, shift); | |
sip += shift; | |
sop += shift; | |
} | |
sim += vim.m; | |
sip += vip.m; | |
som += vom.m; | |
sop += vop.m; | |
} | |
if (vim && !nextRight(vop)) { | |
vop.t = vim; | |
vop.m += sim - sop; | |
} | |
if (vip && !nextLeft(vom)) { | |
vom.t = vip; | |
vom.m += sip - som; | |
ancestor = v; | |
} | |
} | |
return ancestor; | |
} | |
function sizeNode(node) { | |
node.x *= dx; | |
node.y = node.depth * dy; | |
} | |
tree.separation = function(x) { | |
return arguments.length ? (separation = x, tree) : separation; | |
}; | |
tree.size = function(x) { | |
return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]); | |
}; | |
tree.nodeSize = function(x) { | |
return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null); | |
}; | |
return tree; | |
} | |
function treemapSlice(parent, x0, y0, x1, y1) { | |
var nodes = parent.children, | |
node, | |
i = -1, | |
n = nodes.length, | |
k = parent.value && (y1 - y0) / parent.value; | |
while (++i < n) { | |
node = nodes[i], node.x0 = x0, node.x1 = x1; | |
node.y0 = y0, node.y1 = y0 += node.value * k; | |
} | |
} | |
var phi = (1 + Math.sqrt(5)) / 2; | |
function squarifyRatio(ratio, parent, x0, y0, x1, y1) { | |
var rows = [], | |
nodes = parent.children, | |
row, | |
nodeValue, | |
i0 = 0, | |
i1 = 0, | |
n = nodes.length, | |
dx, dy, | |
value = parent.value, | |
sumValue, | |
minValue, | |
maxValue, | |
newRatio, | |
minRatio, | |
alpha, | |
beta; | |
while (i0 < n) { | |
dx = x1 - x0, dy = y1 - y0; | |
// Find the next non-empty node. | |
do sumValue = nodes[i1++].value; while (!sumValue && i1 < n); | |
minValue = maxValue = sumValue; | |
alpha = Math.max(dy / dx, dx / dy) / (value * ratio); | |
beta = sumValue * sumValue * alpha; | |
minRatio = Math.max(maxValue / beta, beta / minValue); | |
// Keep adding nodes while the aspect ratio maintains or improves. | |
for (; i1 < n; ++i1) { | |
sumValue += nodeValue = nodes[i1].value; | |
if (nodeValue < minValue) minValue = nodeValue; | |
if (nodeValue > maxValue) maxValue = nodeValue; | |
beta = sumValue * sumValue * alpha; | |
newRatio = Math.max(maxValue / beta, beta / minValue); | |
if (newRatio > minRatio) { sumValue -= nodeValue; break; } | |
minRatio = newRatio; | |
} | |
// Position and record the row orientation. | |
rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)}); | |
if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1); | |
else treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1); | |
value -= sumValue, i0 = i1; | |
} | |
return rows; | |
} | |
var squarify = (function custom(ratio) { | |
function squarify(parent, x0, y0, x1, y1) { | |
squarifyRatio(ratio, parent, x0, y0, x1, y1); | |
} | |
squarify.ratio = function(x) { | |
return custom((x = +x) > 1 ? x : 1); | |
}; | |
return squarify; | |
})(phi); | |
function index$1() { | |
var tile = squarify, | |
round = false, | |
dx = 1, | |
dy = 1, | |
paddingStack = [0], | |
paddingInner = constantZero, | |
paddingTop = constantZero, | |
paddingRight = constantZero, | |
paddingBottom = constantZero, | |
paddingLeft = constantZero; | |
function treemap(root) { | |
root.x0 = | |
root.y0 = 0; | |
root.x1 = dx; | |
root.y1 = dy; | |
root.eachBefore(positionNode); | |
paddingStack = [0]; | |
if (round) root.eachBefore(roundNode); | |
return root; | |
} | |
function positionNode(node) { | |
var p = paddingStack[node.depth], | |
x0 = node.x0 + p, | |
y0 = node.y0 + p, | |
x1 = node.x1 - p, | |
y1 = node.y1 - p; | |
if (x1 < x0) x0 = x1 = (x0 + x1) / 2; | |
if (y1 < y0) y0 = y1 = (y0 + y1) / 2; | |
node.x0 = x0; | |
node.y0 = y0; | |
node.x1 = x1; | |
node.y1 = y1; | |
if (node.children) { | |
p = paddingStack[node.depth + 1] = paddingInner(node) / 2; | |
x0 += paddingLeft(node) - p; | |
y0 += paddingTop(node) - p; | |
x1 -= paddingRight(node) - p; | |
y1 -= paddingBottom(node) - p; | |
if (x1 < x0) x0 = x1 = (x0 + x1) / 2; | |
if (y1 < y0) y0 = y1 = (y0 + y1) / 2; | |
tile(node, x0, y0, x1, y1); | |
} | |
} | |
treemap.round = function(x) { | |
return arguments.length ? (round = !!x, treemap) : round; | |
}; | |
treemap.size = function(x) { | |
return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy]; | |
}; | |
treemap.tile = function(x) { | |
return arguments.length ? (tile = required(x), treemap) : tile; | |
}; | |
treemap.padding = function(x) { | |
return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner(); | |
}; | |
treemap.paddingInner = function(x) { | |
return arguments.length ? (paddingInner = typeof x === "function" ? x : constant$5(+x), treemap) : paddingInner; | |
}; | |
treemap.paddingOuter = function(x) { | |
return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop(); | |
}; | |
treemap.paddingTop = function(x) { | |
return arguments.length ? (paddingTop = typeof x === "function" ? x : constant$5(+x), treemap) : paddingTop; | |
}; | |
treemap.paddingRight = function(x) { | |
return arguments.length ? (paddingRight = typeof x === "function" ? x : constant$5(+x), treemap) : paddingRight; | |
}; | |
treemap.paddingBottom = function(x) { | |
return arguments.length ? (paddingBottom = typeof x === "function" ? x : constant$5(+x), treemap) : paddingBottom; | |
}; | |
treemap.paddingLeft = function(x) { | |
return arguments.length ? (paddingLeft = typeof x === "function" ? x : constant$5(+x), treemap) : paddingLeft; | |
}; | |
return treemap; | |
} | |
function binary(parent, x0, y0, x1, y1) { | |
var nodes = parent.children, | |
i, n = nodes.length, | |
sum, sums = new Array(n + 1); | |
for (sums[0] = sum = i = 0; i < n; ++i) { | |
sums[i + 1] = sum += nodes[i].value; | |
} | |
partition(0, n, parent.value, x0, y0, x1, y1); | |
function partition(i, j, value, x0, y0, x1, y1) { | |
if (i >= j - 1) { | |
var node = nodes[i]; | |
node.x0 = x0, node.y0 = y0; | |
node.x1 = x1, node.y1 = y1; | |
return; | |
} | |
var valueOffset = sums[i], | |
valueTarget = (value / 2) + valueOffset, | |
k = i + 1, | |
hi = j - 1; | |
while (k < hi) { | |
var mid = k + hi >>> 1; | |
if (sums[mid] < valueTarget) k = mid + 1; | |
else hi = mid; | |
} | |
var valueLeft = sums[k] - valueOffset, | |
valueRight = value - valueLeft; | |
if ((y1 - y0) > (x1 - x0)) { | |
var yk = (y0 * valueRight + y1 * valueLeft) / value; | |
partition(i, k, valueLeft, x0, y0, x1, yk); | |
partition(k, j, valueRight, x0, yk, x1, y1); | |
} else { | |
var xk = (x0 * valueRight + x1 * valueLeft) / value; | |
partition(i, k, valueLeft, x0, y0, xk, y1); | |
partition(k, j, valueRight, xk, y0, x1, y1); | |
} | |
} | |
} | |
function sliceDice(parent, x0, y0, x1, y1) { | |
(parent.depth & 1 ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1); | |
} | |
var resquarify = (function custom(ratio) { | |
function resquarify(parent, x0, y0, x1, y1) { | |
if ((rows = parent._squarify) && (rows.ratio === ratio)) { | |
var rows, | |
row, | |
nodes, | |
i, | |
j = -1, | |
n, | |
m = rows.length, | |
value = parent.value; | |
while (++j < m) { | |
row = rows[j], nodes = row.children; | |
for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value; | |
if (row.dice) treemapDice(row, x0, y0, x1, y0 += (y1 - y0) * row.value / value); | |
else treemapSlice(row, x0, y0, x0 += (x1 - x0) * row.value / value, y1); | |
value -= row.value; | |
} | |
} else { | |
parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1); | |
rows.ratio = ratio; | |
} | |
} | |
resquarify.ratio = function(x) { | |
return custom((x = +x) > 1 ? x : 1); | |
}; | |
return resquarify; | |
})(phi); | |
function center$1(x, y) { | |
var nodes; | |
if (x == null) x = 0; | |
if (y == null) y = 0; | |
function force() { | |
var i, | |
n = nodes.length, | |
node, | |
sx = 0, | |
sy = 0; | |
for (i = 0; i < n; ++i) { | |
node = nodes[i], sx += node.x, sy += node.y; | |
} | |
for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) { | |
node = nodes[i], node.x -= sx, node.y -= sy; | |
} | |
} | |
force.initialize = function(_) { | |
nodes = _; | |
}; | |
force.x = function(_) { | |
return arguments.length ? (x = +_, force) : x; | |
}; | |
force.y = function(_) { | |
return arguments.length ? (y = +_, force) : y; | |
}; | |
return force; | |
} | |
function constant$6(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function jiggle() { | |
return (Math.random() - 0.5) * 1e-6; | |
} | |
function x$1(d) { | |
return d.x + d.vx; | |
} | |
function y$1(d) { | |
return d.y + d.vy; | |
} | |
function collide(radius) { | |
var nodes, | |
radii, | |
strength = 1, | |
iterations = 1; | |
if (typeof radius !== "function") radius = constant$6(radius == null ? 1 : +radius); | |
function force() { | |
var i, n = nodes.length, | |
tree, | |
node, | |
xi, | |
yi, | |
ri, | |
ri2; | |
for (var k = 0; k < iterations; ++k) { | |
tree = quadtree(nodes, x$1, y$1).visitAfter(prepare); | |
for (i = 0; i < n; ++i) { | |
node = nodes[i]; | |
ri = radii[node.index], ri2 = ri * ri; | |
xi = node.x + node.vx; | |
yi = node.y + node.vy; | |
tree.visit(apply); | |
} | |
} | |
function apply(quad, x0, y0, x1, y1) { | |
var data = quad.data, rj = quad.r, r = ri + rj; | |
if (data) { | |
if (data.index > node.index) { | |
var x = xi - data.x - data.vx, | |
y = yi - data.y - data.vy, | |
l = x * x + y * y; | |
if (l < r * r) { | |
if (x === 0) x = jiggle(), l += x * x; | |
if (y === 0) y = jiggle(), l += y * y; | |
l = (r - (l = Math.sqrt(l))) / l * strength; | |
node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj)); | |
node.vy += (y *= l) * r; | |
data.vx -= x * (r = 1 - r); | |
data.vy -= y * r; | |
} | |
} | |
return; | |
} | |
return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r; | |
} | |
} | |
function prepare(quad) { | |
if (quad.data) return quad.r = radii[quad.data.index]; | |
for (var i = quad.r = 0; i < 4; ++i) { | |
if (quad[i] && quad[i].r > quad.r) { | |
quad.r = quad[i].r; | |
} | |
} | |
} | |
function initialize() { | |
if (!nodes) return; | |
var i, n = nodes.length, node; | |
radii = new Array(n); | |
for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes); | |
} | |
force.initialize = function(_) { | |
nodes = _; | |
initialize(); | |
}; | |
force.iterations = function(_) { | |
return arguments.length ? (iterations = +_, force) : iterations; | |
}; | |
force.strength = function(_) { | |
return arguments.length ? (strength = +_, force) : strength; | |
}; | |
force.radius = function(_) { | |
return arguments.length ? (radius = typeof _ === "function" ? _ : constant$6(+_), initialize(), force) : radius; | |
}; | |
return force; | |
} | |
function index$2(d) { | |
return d.index; | |
} | |
function find(nodeById, nodeId) { | |
var node = nodeById.get(nodeId); | |
if (!node) throw new Error("missing: " + nodeId); | |
return node; | |
} | |
function link(links) { | |
var id = index$2, | |
strength = defaultStrength, | |
strengths, | |
distance = constant$6(30), | |
distances, | |
nodes, | |
count, | |
bias, | |
iterations = 1; | |
if (links == null) links = []; | |
function defaultStrength(link) { | |
return 1 / Math.min(count[link.source.index], count[link.target.index]); | |
} | |
function force(alpha) { | |
for (var k = 0, n = links.length; k < iterations; ++k) { | |
for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) { | |
link = links[i], source = link.source, target = link.target; | |
x = target.x + target.vx - source.x - source.vx || jiggle(); | |
y = target.y + target.vy - source.y - source.vy || jiggle(); | |
l = Math.sqrt(x * x + y * y); | |
l = (l - distances[i]) / l * alpha * strengths[i]; | |
x *= l, y *= l; | |
target.vx -= x * (b = bias[i]); | |
target.vy -= y * b; | |
source.vx += x * (b = 1 - b); | |
source.vy += y * b; | |
} | |
} | |
} | |
function initialize() { | |
if (!nodes) return; | |
var i, | |
n = nodes.length, | |
m = links.length, | |
nodeById = map$1(nodes, id), | |
link; | |
for (i = 0, count = new Array(n); i < m; ++i) { | |
link = links[i], link.index = i; | |
if (typeof link.source !== "object") link.source = find(nodeById, link.source); | |
if (typeof link.target !== "object") link.target = find(nodeById, link.target); | |
count[link.source.index] = (count[link.source.index] || 0) + 1; | |
count[link.target.index] = (count[link.target.index] || 0) + 1; | |
} | |
for (i = 0, bias = new Array(m); i < m; ++i) { | |
link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]); | |
} | |
strengths = new Array(m), initializeStrength(); | |
distances = new Array(m), initializeDistance(); | |
} | |
function initializeStrength() { | |
if (!nodes) return; | |
for (var i = 0, n = links.length; i < n; ++i) { | |
strengths[i] = +strength(links[i], i, links); | |
} | |
} | |
function initializeDistance() { | |
if (!nodes) return; | |
for (var i = 0, n = links.length; i < n; ++i) { | |
distances[i] = +distance(links[i], i, links); | |
} | |
} | |
force.initialize = function(_) { | |
nodes = _; | |
initialize(); | |
}; | |
force.links = function(_) { | |
return arguments.length ? (links = _, initialize(), force) : links; | |
}; | |
force.id = function(_) { | |
return arguments.length ? (id = _, force) : id; | |
}; | |
force.iterations = function(_) { | |
return arguments.length ? (iterations = +_, force) : iterations; | |
}; | |
force.strength = function(_) { | |
return arguments.length ? (strength = typeof _ === "function" ? _ : constant$6(+_), initializeStrength(), force) : strength; | |
}; | |
force.distance = function(_) { | |
return arguments.length ? (distance = typeof _ === "function" ? _ : constant$6(+_), initializeDistance(), force) : distance; | |
}; | |
return force; | |
} | |
function x$2(d) { | |
return d.x; | |
} | |
function y$2(d) { | |
return d.y; | |
} | |
var initialRadius = 10; | |
var initialAngle = Math.PI * (3 - Math.sqrt(5)); | |
function simulation(nodes) { | |
var simulation, | |
alpha = 1, | |
alphaMin = 0.001, | |
alphaDecay = 1 - Math.pow(alphaMin, 1 / 300), | |
alphaTarget = 0, | |
velocityDecay = 0.6, | |
forces = map$1(), | |
stepper = timer(step), | |
event = dispatch("tick", "end"); | |
if (nodes == null) nodes = []; | |
function step() { | |
tick(); | |
event.call("tick", simulation); | |
if (alpha < alphaMin) { | |
stepper.stop(); | |
event.call("end", simulation); | |
} | |
} | |
function tick() { | |
var i, n = nodes.length, node; | |
alpha += (alphaTarget - alpha) * alphaDecay; | |
forces.each(function(force) { | |
force(alpha); | |
}); | |
for (i = 0; i < n; ++i) { | |
node = nodes[i]; | |
if (node.fx == null) node.x += node.vx *= velocityDecay; | |
else node.x = node.fx, node.vx = 0; | |
if (node.fy == null) node.y += node.vy *= velocityDecay; | |
else node.y = node.fy, node.vy = 0; | |
} | |
} | |
function initializeNodes() { | |
for (var i = 0, n = nodes.length, node; i < n; ++i) { | |
node = nodes[i], node.index = i; | |
if (isNaN(node.x) || isNaN(node.y)) { | |
var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle; | |
node.x = radius * Math.cos(angle); | |
node.y = radius * Math.sin(angle); | |
} | |
if (isNaN(node.vx) || isNaN(node.vy)) { | |
node.vx = node.vy = 0; | |
} | |
} | |
} | |
function initializeForce(force) { | |
if (force.initialize) force.initialize(nodes); | |
return force; | |
} | |
initializeNodes(); | |
return simulation = { | |
tick: tick, | |
restart: function() { | |
return stepper.restart(step), simulation; | |
}, | |
stop: function() { | |
return stepper.stop(), simulation; | |
}, | |
nodes: function(_) { | |
return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes; | |
}, | |
alpha: function(_) { | |
return arguments.length ? (alpha = +_, simulation) : alpha; | |
}, | |
alphaMin: function(_) { | |
return arguments.length ? (alphaMin = +_, simulation) : alphaMin; | |
}, | |
alphaDecay: function(_) { | |
return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay; | |
}, | |
alphaTarget: function(_) { | |
return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget; | |
}, | |
velocityDecay: function(_) { | |
return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay; | |
}, | |
force: function(name, _) { | |
return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name); | |
}, | |
find: function(x, y, radius) { | |
var i = 0, | |
n = nodes.length, | |
dx, | |
dy, | |
d2, | |
node, | |
closest; | |
if (radius == null) radius = Infinity; | |
else radius *= radius; | |
for (i = 0; i < n; ++i) { | |
node = nodes[i]; | |
dx = x - node.x; | |
dy = y - node.y; | |
d2 = dx * dx + dy * dy; | |
if (d2 < radius) closest = node, radius = d2; | |
} | |
return closest; | |
}, | |
on: function(name, _) { | |
return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name); | |
} | |
}; | |
} | |
function manyBody() { | |
var nodes, | |
node, | |
alpha, | |
strength = constant$6(-30), | |
strengths, | |
distanceMin2 = 1, | |
distanceMax2 = Infinity, | |
theta2 = 0.81; | |
function force(_) { | |
var i, n = nodes.length, tree = quadtree(nodes, x$2, y$2).visitAfter(accumulate); | |
for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply); | |
} | |
function initialize() { | |
if (!nodes) return; | |
var i, n = nodes.length, node; | |
strengths = new Array(n); | |
for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes); | |
} | |
function accumulate(quad) { | |
var strength = 0, q, c, x, y, i; | |
// For internal nodes, accumulate forces from child quadrants. | |
if (quad.length) { | |
for (x = y = i = 0; i < 4; ++i) { | |
if ((q = quad[i]) && (c = q.value)) { | |
strength += c, x += c * q.x, y += c * q.y; | |
} | |
} | |
quad.x = x / strength; | |
quad.y = y / strength; | |
} | |
// For leaf nodes, accumulate forces from coincident quadrants. | |
else { | |
q = quad; | |
q.x = q.data.x; | |
q.y = q.data.y; | |
do strength += strengths[q.data.index]; | |
while (q = q.next); | |
} | |
quad.value = strength; | |
} | |
function apply(quad, x1, _, x2) { | |
if (!quad.value) return true; | |
var x = quad.x - node.x, | |
y = quad.y - node.y, | |
w = x2 - x1, | |
l = x * x + y * y; | |
// Apply the Barnes-Hut approximation if possible. | |
// Limit forces for very close nodes; randomize direction if coincident. | |
if (w * w / theta2 < l) { | |
if (l < distanceMax2) { | |
if (x === 0) x = jiggle(), l += x * x; | |
if (y === 0) y = jiggle(), l += y * y; | |
if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); | |
node.vx += x * quad.value * alpha / l; | |
node.vy += y * quad.value * alpha / l; | |
} | |
return true; | |
} | |
// Otherwise, process points directly. | |
else if (quad.length || l >= distanceMax2) return; | |
// Limit forces for very close nodes; randomize direction if coincident. | |
if (quad.data !== node || quad.next) { | |
if (x === 0) x = jiggle(), l += x * x; | |
if (y === 0) y = jiggle(), l += y * y; | |
if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); | |
} | |
do if (quad.data !== node) { | |
w = strengths[quad.data.index] * alpha / l; | |
node.vx += x * w; | |
node.vy += y * w; | |
} while (quad = quad.next); | |
} | |
force.initialize = function(_) { | |
nodes = _; | |
initialize(); | |
}; | |
force.strength = function(_) { | |
return arguments.length ? (strength = typeof _ === "function" ? _ : constant$6(+_), initialize(), force) : strength; | |
}; | |
force.distanceMin = function(_) { | |
return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2); | |
}; | |
force.distanceMax = function(_) { | |
return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2); | |
}; | |
force.theta = function(_) { | |
return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2); | |
}; | |
return force; | |
} | |
function x$3(x) { | |
var strength = constant$6(0.1), | |
nodes, | |
strengths, | |
xz; | |
if (typeof x !== "function") x = constant$6(x == null ? 0 : +x); | |
function force(alpha) { | |
for (var i = 0, n = nodes.length, node; i < n; ++i) { | |
node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha; | |
} | |
} | |
function initialize() { | |
if (!nodes) return; | |
var i, n = nodes.length; | |
strengths = new Array(n); | |
xz = new Array(n); | |
for (i = 0; i < n; ++i) { | |
strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); | |
} | |
} | |
force.initialize = function(_) { | |
nodes = _; | |
initialize(); | |
}; | |
force.strength = function(_) { | |
return arguments.length ? (strength = typeof _ === "function" ? _ : constant$6(+_), initialize(), force) : strength; | |
}; | |
force.x = function(_) { | |
return arguments.length ? (x = typeof _ === "function" ? _ : constant$6(+_), initialize(), force) : x; | |
}; | |
return force; | |
} | |
function y$3(y) { | |
var strength = constant$6(0.1), | |
nodes, | |
strengths, | |
yz; | |
if (typeof y !== "function") y = constant$6(y == null ? 0 : +y); | |
function force(alpha) { | |
for (var i = 0, n = nodes.length, node; i < n; ++i) { | |
node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha; | |
} | |
} | |
function initialize() { | |
if (!nodes) return; | |
var i, n = nodes.length; | |
strengths = new Array(n); | |
yz = new Array(n); | |
for (i = 0; i < n; ++i) { | |
strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); | |
} | |
} | |
force.initialize = function(_) { | |
nodes = _; | |
initialize(); | |
}; | |
force.strength = function(_) { | |
return arguments.length ? (strength = typeof _ === "function" ? _ : constant$6(+_), initialize(), force) : strength; | |
}; | |
force.y = function(_) { | |
return arguments.length ? (y = typeof _ === "function" ? _ : constant$6(+_), initialize(), force) : y; | |
}; | |
return force; | |
} | |
function nopropagation() { | |
exports.event.stopImmediatePropagation(); | |
} | |
function noevent() { | |
exports.event.preventDefault(); | |
exports.event.stopImmediatePropagation(); | |
} | |
function dragDisable(view) { | |
var root = view.document.documentElement, | |
selection = select(view).on("dragstart.drag", noevent, true); | |
if ("onselectstart" in root) { | |
selection.on("selectstart.drag", noevent, true); | |
} else { | |
root.__noselect = root.style.MozUserSelect; | |
root.style.MozUserSelect = "none"; | |
} | |
} | |
function dragEnable(view, noclick) { | |
var root = view.document.documentElement, | |
selection = select(view).on("dragstart.drag", null); | |
if (noclick) { | |
selection.on("click.drag", noevent, true); | |
setTimeout(function() { selection.on("click.drag", null); }, 0); | |
} | |
if ("onselectstart" in root) { | |
selection.on("selectstart.drag", null); | |
} else { | |
root.style.MozUserSelect = root.__noselect; | |
delete root.__noselect; | |
} | |
} | |
function constant$7(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) { | |
this.target = target; | |
this.type = type; | |
this.subject = subject; | |
this.identifier = id; | |
this.active = active; | |
this.x = x; | |
this.y = y; | |
this.dx = dx; | |
this.dy = dy; | |
this._ = dispatch; | |
} | |
DragEvent.prototype.on = function() { | |
var value = this._.on.apply(this._, arguments); | |
return value === this._ ? this : value; | |
}; | |
// Ignore right-click, since that should open the context menu. | |
function defaultFilter() { | |
return !exports.event.button; | |
} | |
function defaultContainer() { | |
return this.parentNode; | |
} | |
function defaultSubject(d) { | |
return d == null ? {x: exports.event.x, y: exports.event.y} : d; | |
} | |
function drag() { | |
var filter = defaultFilter, | |
container = defaultContainer, | |
subject = defaultSubject, | |
gestures = {}, | |
listeners = dispatch("start", "drag", "end"), | |
active = 0, | |
mousemoving, | |
touchending; | |
function drag(selection) { | |
selection | |
.on("mousedown.drag", mousedowned) | |
.on("touchstart.drag", touchstarted) | |
.on("touchmove.drag", touchmoved) | |
.on("touchend.drag touchcancel.drag", touchended) | |
.style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); | |
} | |
function mousedowned() { | |
if (touchending || !filter.apply(this, arguments)) return; | |
var gesture = beforestart("mouse", container.apply(this, arguments), mouse, this, arguments); | |
if (!gesture) return; | |
select(exports.event.view).on("mousemove.drag", mousemoved, true).on("mouseup.drag", mouseupped, true); | |
dragDisable(exports.event.view); | |
nopropagation(); | |
mousemoving = false; | |
gesture("start"); | |
} | |
function mousemoved() { | |
noevent(); | |
mousemoving = true; | |
gestures.mouse("drag"); | |
} | |
function mouseupped() { | |
select(exports.event.view).on("mousemove.drag mouseup.drag", null); | |
dragEnable(exports.event.view, mousemoving); | |
noevent(); | |
gestures.mouse("end"); | |
} | |
function touchstarted() { | |
if (!filter.apply(this, arguments)) return; | |
var touches = exports.event.changedTouches, | |
c = container.apply(this, arguments), | |
n = touches.length, i, gesture; | |
for (i = 0; i < n; ++i) { | |
if (gesture = beforestart(touches[i].identifier, c, touch, this, arguments)) { | |
nopropagation(); | |
gesture("start"); | |
} | |
} | |
} | |
function touchmoved() { | |
var touches = exports.event.changedTouches, | |
n = touches.length, i, gesture; | |
for (i = 0; i < n; ++i) { | |
if (gesture = gestures[touches[i].identifier]) { | |
noevent(); | |
gesture("drag"); | |
} | |
} | |
} | |
function touchended() { | |
var touches = exports.event.changedTouches, | |
n = touches.length, i, gesture; | |
if (touchending) clearTimeout(touchending); | |
touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! | |
for (i = 0; i < n; ++i) { | |
if (gesture = gestures[touches[i].identifier]) { | |
nopropagation(); | |
gesture("end"); | |
} | |
} | |
} | |
function beforestart(id, container, point, that, args) { | |
var p = point(container, id), s, dx, dy, | |
sublisteners = listeners.copy(); | |
if (!customEvent(new DragEvent(drag, "beforestart", s, id, active, p[0], p[1], 0, 0, sublisteners), function() { | |
if ((exports.event.subject = s = subject.apply(that, args)) == null) return false; | |
dx = s.x - p[0] || 0; | |
dy = s.y - p[1] || 0; | |
return true; | |
})) return; | |
return function gesture(type) { | |
var p0 = p, n; | |
switch (type) { | |
case "start": gestures[id] = gesture, n = active++; break; | |
case "end": delete gestures[id], --active; // nobreak | |
case "drag": p = point(container, id), n = active; break; | |
} | |
customEvent(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]); | |
}; | |
} | |
drag.filter = function(_) { | |
return arguments.length ? (filter = typeof _ === "function" ? _ : constant$7(!!_), drag) : filter; | |
}; | |
drag.container = function(_) { | |
return arguments.length ? (container = typeof _ === "function" ? _ : constant$7(_), drag) : container; | |
}; | |
drag.subject = function(_) { | |
return arguments.length ? (subject = typeof _ === "function" ? _ : constant$7(_), drag) : subject; | |
}; | |
drag.on = function() { | |
var value = listeners.on.apply(listeners, arguments); | |
return value === listeners ? drag : value; | |
}; | |
return drag; | |
} | |
function constant$8(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function x$4(d) { | |
return d[0]; | |
} | |
function y$4(d) { | |
return d[1]; | |
} | |
function RedBlackTree() { | |
this._ = null; // root node | |
} | |
function RedBlackNode(node) { | |
node.U = // parent node | |
node.C = // color - true for red, false for black | |
node.L = // left node | |
node.R = // right node | |
node.P = // previous node | |
node.N = null; // next node | |
} | |
RedBlackTree.prototype = { | |
constructor: RedBlackTree, | |
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 = RedBlackFirst(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) { | |
RedBlackRotateLeft(this, parent); | |
after = parent; | |
parent = after.U; | |
} | |
parent.C = false; | |
grandpa.C = true; | |
RedBlackRotateRight(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) { | |
RedBlackRotateRight(this, parent); | |
after = parent; | |
parent = after.U; | |
} | |
parent.C = false; | |
grandpa.C = true; | |
RedBlackRotateLeft(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 = RedBlackFirst(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; | |
RedBlackRotateLeft(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; | |
RedBlackRotateRight(this, sibling); | |
sibling = parent.R; | |
} | |
sibling.C = parent.C; | |
parent.C = sibling.R.C = false; | |
RedBlackRotateLeft(this, parent); | |
node = this._; | |
break; | |
} | |
} else { | |
sibling = parent.L; | |
if (sibling.C) { | |
sibling.C = false; | |
parent.C = true; | |
RedBlackRotateRight(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; | |
RedBlackRotateLeft(this, sibling); | |
sibling = parent.L; | |
} | |
sibling.C = parent.C; | |
parent.C = sibling.L.C = false; | |
RedBlackRotateRight(this, parent); | |
node = this._; | |
break; | |
} | |
} | |
sibling.C = true; | |
node = parent; | |
parent = parent.U; | |
} while (!node.C); | |
if (node) node.C = false; | |
} | |
}; | |
function RedBlackRotateLeft(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 RedBlackRotateRight(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 RedBlackFirst(node) { | |
while (node.L) node = node.L; | |
return node; | |
} | |
function createEdge(left, right, v0, v1) { | |
var edge = [null, null], | |
index = edges.push(edge) - 1; | |
edge.left = left; | |
edge.right = right; | |
if (v0) setEdgeEnd(edge, left, right, v0); | |
if (v1) setEdgeEnd(edge, right, left, v1); | |
cells[left.index].halfedges.push(index); | |
cells[right.index].halfedges.push(index); | |
return edge; | |
} | |
function createBorderEdge(left, v0, v1) { | |
var edge = [v0, v1]; | |
edge.left = left; | |
return edge; | |
} | |
function setEdgeEnd(edge, left, right, vertex) { | |
if (!edge[0] && !edge[1]) { | |
edge[0] = vertex; | |
edge.left = left; | |
edge.right = right; | |
} else if (edge.left === right) { | |
edge[1] = vertex; | |
} else { | |
edge[0] = vertex; | |
} | |
} | |
// Liang–Barsky line clipping. | |
function clipEdge(edge, x0, y0, x1, y1) { | |
var a = edge[0], | |
b = edge[1], | |
ax = a[0], | |
ay = a[1], | |
bx = b[0], | |
by = b[1], | |
t0 = 0, | |
t1 = 1, | |
dx = bx - ax, | |
dy = by - ay, | |
r; | |
r = x0 - ax; | |
if (!dx && r > 0) return; | |
r /= dx; | |
if (dx < 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} else if (dx > 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} | |
r = x1 - ax; | |
if (!dx && r < 0) return; | |
r /= dx; | |
if (dx < 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} else if (dx > 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} | |
r = y0 - ay; | |
if (!dy && r > 0) return; | |
r /= dy; | |
if (dy < 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} else if (dy > 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} | |
r = y1 - ay; | |
if (!dy && r < 0) return; | |
r /= dy; | |
if (dy < 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} else if (dy > 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} | |
if (!(t0 > 0) && !(t1 < 1)) return true; // TODO Better check? | |
if (t0 > 0) edge[0] = [ax + t0 * dx, ay + t0 * dy]; | |
if (t1 < 1) edge[1] = [ax + t1 * dx, ay + t1 * dy]; | |
return true; | |
} | |
function connectEdge(edge, x0, y0, x1, y1) { | |
var v1 = edge[1]; | |
if (v1) return true; | |
var v0 = edge[0], | |
left = edge.left, | |
right = edge.right, | |
lx = left[0], | |
ly = left[1], | |
rx = right[0], | |
ry = right[1], | |
fx = (lx + rx) / 2, | |
fy = (ly + ry) / 2, | |
fm, | |
fb; | |
if (ry === ly) { | |
if (fx < x0 || fx >= x1) return; | |
if (lx > rx) { | |
if (!v0) v0 = [fx, y0]; | |
else if (v0[1] >= y1) return; | |
v1 = [fx, y1]; | |
} else { | |
if (!v0) v0 = [fx, y1]; | |
else if (v0[1] < y0) return; | |
v1 = [fx, y0]; | |
} | |
} else { | |
fm = (lx - rx) / (ry - ly); | |
fb = fy - fm * fx; | |
if (fm < -1 || fm > 1) { | |
if (lx > rx) { | |
if (!v0) v0 = [(y0 - fb) / fm, y0]; | |
else if (v0[1] >= y1) return; | |
v1 = [(y1 - fb) / fm, y1]; | |
} else { | |
if (!v0) v0 = [(y1 - fb) / fm, y1]; | |
else if (v0[1] < y0) return; | |
v1 = [(y0 - fb) / fm, y0]; | |
} | |
} else { | |
if (ly < ry) { | |
if (!v0) v0 = [x0, fm * x0 + fb]; | |
else if (v0[0] >= x1) return; | |
v1 = [x1, fm * x1 + fb]; | |
} else { | |
if (!v0) v0 = [x1, fm * x1 + fb]; | |
else if (v0[0] < x0) return; | |
v1 = [x0, fm * x0 + fb]; | |
} | |
} | |
} | |
edge[0] = v0; | |
edge[1] = v1; | |
return true; | |
} | |
function clipEdges(x0, y0, x1, y1) { | |
var i = edges.length, | |
edge; | |
while (i--) { | |
if (!connectEdge(edge = edges[i], x0, y0, x1, y1) | |
|| !clipEdge(edge, x0, y0, x1, y1) | |
|| !(Math.abs(edge[0][0] - edge[1][0]) > epsilon$3 | |
|| Math.abs(edge[0][1] - edge[1][1]) > epsilon$3)) { | |
delete edges[i]; | |
} | |
} | |
} | |
function createCell(site) { | |
return cells[site.index] = { | |
site: site, | |
halfedges: [] | |
}; | |
} | |
function cellHalfedgeAngle(cell, edge) { | |
var site = cell.site, | |
va = edge.left, | |
vb = edge.right; | |
if (site === vb) vb = va, va = site; | |
if (vb) return Math.atan2(vb[1] - va[1], vb[0] - va[0]); | |
if (site === va) va = edge[1], vb = edge[0]; | |
else va = edge[0], vb = edge[1]; | |
return Math.atan2(va[0] - vb[0], vb[1] - va[1]); | |
} | |
function cellHalfedgeStart(cell, edge) { | |
return edge[+(edge.left !== cell.site)]; | |
} | |
function cellHalfedgeEnd(cell, edge) { | |
return edge[+(edge.left === cell.site)]; | |
} | |
function sortCellHalfedges() { | |
for (var i = 0, n = cells.length, cell, halfedges, j, m; i < n; ++i) { | |
if ((cell = cells[i]) && (m = (halfedges = cell.halfedges).length)) { | |
var index = new Array(m), | |
array = new Array(m); | |
for (j = 0; j < m; ++j) index[j] = j, array[j] = cellHalfedgeAngle(cell, edges[halfedges[j]]); | |
index.sort(function(i, j) { return array[j] - array[i]; }); | |
for (j = 0; j < m; ++j) array[j] = halfedges[index[j]]; | |
for (j = 0; j < m; ++j) halfedges[j] = array[j]; | |
} | |
} | |
} | |
function clipCells(x0, y0, x1, y1) { | |
var nCells = cells.length, | |
iCell, | |
cell, | |
site, | |
iHalfedge, | |
halfedges, | |
nHalfedges, | |
start, | |
startX, | |
startY, | |
end, | |
endX, | |
endY, | |
cover = true; | |
for (iCell = 0; iCell < nCells; ++iCell) { | |
if (cell = cells[iCell]) { | |
site = cell.site; | |
halfedges = cell.halfedges; | |
iHalfedge = halfedges.length; | |
// Remove any dangling clipped edges. | |
while (iHalfedge--) { | |
if (!edges[halfedges[iHalfedge]]) { | |
halfedges.splice(iHalfedge, 1); | |
} | |
} | |
// Insert any border edges as necessary. | |
iHalfedge = 0, nHalfedges = halfedges.length; | |
while (iHalfedge < nHalfedges) { | |
end = cellHalfedgeEnd(cell, edges[halfedges[iHalfedge]]), endX = end[0], endY = end[1]; | |
start = cellHalfedgeStart(cell, edges[halfedges[++iHalfedge % nHalfedges]]), startX = start[0], startY = start[1]; | |
if (Math.abs(endX - startX) > epsilon$3 || Math.abs(endY - startY) > epsilon$3) { | |
halfedges.splice(iHalfedge, 0, edges.push(createBorderEdge(site, end, | |
Math.abs(endX - x0) < epsilon$3 && y1 - endY > epsilon$3 ? [x0, Math.abs(startX - x0) < epsilon$3 ? startY : y1] | |
: Math.abs(endY - y1) < epsilon$3 && x1 - endX > epsilon$3 ? [Math.abs(startY - y1) < epsilon$3 ? startX : x1, y1] | |
: Math.abs(endX - x1) < epsilon$3 && endY - y0 > epsilon$3 ? [x1, Math.abs(startX - x1) < epsilon$3 ? startY : y0] | |
: Math.abs(endY - y0) < epsilon$3 && endX - x0 > epsilon$3 ? [Math.abs(startY - y0) < epsilon$3 ? startX : x0, y0] | |
: null)) - 1); | |
++nHalfedges; | |
} | |
} | |
if (nHalfedges) cover = false; | |
} | |
} | |
// If there weren’t any edges, have the closest site cover the extent. | |
// It doesn’t matter which corner of the extent we measure! | |
if (cover) { | |
var dx, dy, d2, dc = Infinity; | |
for (iCell = 0, cover = null; iCell < nCells; ++iCell) { | |
if (cell = cells[iCell]) { | |
site = cell.site; | |
dx = site[0] - x0; | |
dy = site[1] - y0; | |
d2 = dx * dx + dy * dy; | |
if (d2 < dc) dc = d2, cover = cell; | |
} | |
} | |
if (cover) { | |
var v00 = [x0, y0], v01 = [x0, y1], v11 = [x1, y1], v10 = [x1, y0]; | |
cover.halfedges.push( | |
edges.push(createBorderEdge(site = cover.site, v00, v01)) - 1, | |
edges.push(createBorderEdge(site, v01, v11)) - 1, | |
edges.push(createBorderEdge(site, v11, v10)) - 1, | |
edges.push(createBorderEdge(site, v10, v00)) - 1 | |
); | |
} | |
} | |
// Lastly delete any cells with no edges; these were entirely clipped. | |
for (iCell = 0; iCell < nCells; ++iCell) { | |
if (cell = cells[iCell]) { | |
if (!cell.halfedges.length) { | |
delete cells[iCell]; | |
} | |
} | |
} | |
} | |
var circlePool = []; | |
var firstCircle; | |
function Circle() { | |
RedBlackNode(this); | |
this.x = | |
this.y = | |
this.arc = | |
this.site = | |
this.cy = null; | |
} | |
function attachCircle(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[0], | |
by = cSite[1], | |
ax = lSite[0] - bx, | |
ay = lSite[1] - by, | |
cx = rSite[0] - bx, | |
cy = rSite[1] - by; | |
var d = 2 * (ax * cy - ay * cx); | |
if (d >= -epsilon2$1) return; | |
var ha = ax * ax + ay * ay, | |
hc = cx * cx + cy * cy, | |
x = (cy * ha - ay * hc) / d, | |
y = (ax * hc - cx * ha) / d; | |
var circle = circlePool.pop() || new Circle; | |
circle.arc = arc; | |
circle.site = cSite; | |
circle.x = x + bx; | |
circle.y = (circle.cy = y + by) + Math.sqrt(x * x + y * y); // y bottom | |
arc.circle = circle; | |
var before = null, | |
node = circles._; | |
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; } | |
} | |
} | |
circles.insert(before, circle); | |
if (!before) firstCircle = circle; | |
} | |
function detachCircle(arc) { | |
var circle = arc.circle; | |
if (circle) { | |
if (!circle.P) firstCircle = circle.N; | |
circles.remove(circle); | |
circlePool.push(circle); | |
RedBlackNode(circle); | |
arc.circle = null; | |
} | |
} | |
var beachPool = []; | |
function Beach() { | |
RedBlackNode(this); | |
this.edge = | |
this.site = | |
this.circle = null; | |
} | |
function createBeach(site) { | |
var beach = beachPool.pop() || new Beach; | |
beach.site = site; | |
return beach; | |
} | |
function detachBeach(beach) { | |
detachCircle(beach); | |
beaches.remove(beach); | |
beachPool.push(beach); | |
RedBlackNode(beach); | |
} | |
function removeBeach(beach) { | |
var circle = beach.circle, | |
x = circle.x, | |
y = circle.cy, | |
vertex = [x, y], | |
previous = beach.P, | |
next = beach.N, | |
disappearing = [beach]; | |
detachBeach(beach); | |
var lArc = previous; | |
while (lArc.circle | |
&& Math.abs(x - lArc.circle.x) < epsilon$3 | |
&& Math.abs(y - lArc.circle.cy) < epsilon$3) { | |
previous = lArc.P; | |
disappearing.unshift(lArc); | |
detachBeach(lArc); | |
lArc = previous; | |
} | |
disappearing.unshift(lArc); | |
detachCircle(lArc); | |
var rArc = next; | |
while (rArc.circle | |
&& Math.abs(x - rArc.circle.x) < epsilon$3 | |
&& Math.abs(y - rArc.circle.cy) < epsilon$3) { | |
next = rArc.N; | |
disappearing.push(rArc); | |
detachBeach(rArc); | |
rArc = next; | |
} | |
disappearing.push(rArc); | |
detachCircle(rArc); | |
var nArcs = disappearing.length, | |
iArc; | |
for (iArc = 1; iArc < nArcs; ++iArc) { | |
rArc = disappearing[iArc]; | |
lArc = disappearing[iArc - 1]; | |
setEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex); | |
} | |
lArc = disappearing[0]; | |
rArc = disappearing[nArcs - 1]; | |
rArc.edge = createEdge(lArc.site, rArc.site, null, vertex); | |
attachCircle(lArc); | |
attachCircle(rArc); | |
} | |
function addBeach(site) { | |
var x = site[0], | |
directrix = site[1], | |
lArc, | |
rArc, | |
dxl, | |
dxr, | |
node = beaches._; | |
while (node) { | |
dxl = leftBreakPoint(node, directrix) - x; | |
if (dxl > epsilon$3) node = node.L; else { | |
dxr = x - rightBreakPoint(node, directrix); | |
if (dxr > epsilon$3) { | |
if (!node.R) { | |
lArc = node; | |
break; | |
} | |
node = node.R; | |
} else { | |
if (dxl > -epsilon$3) { | |
lArc = node.P; | |
rArc = node; | |
} else if (dxr > -epsilon$3) { | |
lArc = node; | |
rArc = node.N; | |
} else { | |
lArc = rArc = node; | |
} | |
break; | |
} | |
} | |
} | |
createCell(site); | |
var newArc = createBeach(site); | |
beaches.insert(lArc, newArc); | |
if (!lArc && !rArc) return; | |
if (lArc === rArc) { | |
detachCircle(lArc); | |
rArc = createBeach(lArc.site); | |
beaches.insert(newArc, rArc); | |
newArc.edge = rArc.edge = createEdge(lArc.site, newArc.site); | |
attachCircle(lArc); | |
attachCircle(rArc); | |
return; | |
} | |
if (!rArc) { // && lArc | |
newArc.edge = createEdge(lArc.site, newArc.site); | |
return; | |
} | |
// else lArc !== rArc | |
detachCircle(lArc); | |
detachCircle(rArc); | |
var lSite = lArc.site, | |
ax = lSite[0], | |
ay = lSite[1], | |
bx = site[0] - ax, | |
by = site[1] - ay, | |
rSite = rArc.site, | |
cx = rSite[0] - ax, | |
cy = rSite[1] - ay, | |
d = 2 * (bx * cy - by * cx), | |
hb = bx * bx + by * by, | |
hc = cx * cx + cy * cy, | |
vertex = [(cy * hb - by * hc) / d + ax, (bx * hc - cx * hb) / d + ay]; | |
setEdgeEnd(rArc.edge, lSite, rSite, vertex); | |
newArc.edge = createEdge(lSite, site, null, vertex); | |
rArc.edge = createEdge(site, rSite, null, vertex); | |
attachCircle(lArc); | |
attachCircle(rArc); | |
} | |
function leftBreakPoint(arc, directrix) { | |
var site = arc.site, | |
rfocx = site[0], | |
rfocy = site[1], | |
pby2 = rfocy - directrix; | |
if (!pby2) return rfocx; | |
var lArc = arc.P; | |
if (!lArc) return -Infinity; | |
site = lArc.site; | |
var lfocx = site[0], | |
lfocy = site[1], | |
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 rightBreakPoint(arc, directrix) { | |
var rArc = arc.N; | |
if (rArc) return leftBreakPoint(rArc, directrix); | |
var site = arc.site; | |
return site[1] === directrix ? site[0] : Infinity; | |
} | |
var epsilon$3 = 1e-6; | |
var epsilon2$1 = 1e-12; | |
var beaches; | |
var cells; | |
var circles; | |
var edges; | |
function triangleArea(a, b, c) { | |
return (a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]); | |
} | |
function lexicographic(a, b) { | |
return b[1] - a[1] | |
|| b[0] - a[0]; | |
} | |
function Diagram(sites, extent) { | |
var site = sites.sort(lexicographic).pop(), | |
x, | |
y, | |
circle; | |
edges = []; | |
cells = new Array(sites.length); | |
beaches = new RedBlackTree; | |
circles = new RedBlackTree; | |
while (true) { | |
circle = firstCircle; | |
if (site && (!circle || site[1] < circle.y || (site[1] === circle.y && site[0] < circle.x))) { | |
if (site[0] !== x || site[1] !== y) { | |
addBeach(site); | |
x = site[0], y = site[1]; | |
} | |
site = sites.pop(); | |
} else if (circle) { | |
removeBeach(circle.arc); | |
} else { | |
break; | |
} | |
} | |
sortCellHalfedges(); | |
if (extent) { | |
var x0 = +extent[0][0], | |
y0 = +extent[0][1], | |
x1 = +extent[1][0], | |
y1 = +extent[1][1]; | |
clipEdges(x0, y0, x1, y1); | |
clipCells(x0, y0, x1, y1); | |
} | |
this.edges = edges; | |
this.cells = cells; | |
beaches = | |
circles = | |
edges = | |
cells = null; | |
} | |
Diagram.prototype = { | |
constructor: Diagram, | |
polygons: function() { | |
var edges = this.edges; | |
return this.cells.map(function(cell) { | |
var polygon = cell.halfedges.map(function(i) { return cellHalfedgeStart(cell, edges[i]); }); | |
polygon.data = cell.site.data; | |
return polygon; | |
}); | |
}, | |
triangles: function() { | |
var triangles = [], | |
edges = this.edges; | |
this.cells.forEach(function(cell, i) { | |
var site = cell.site, | |
halfedges = cell.halfedges, | |
j = -1, | |
m = halfedges.length, | |
s0, | |
e1 = edges[halfedges[m - 1]], | |
s1 = e1.left === site ? e1.right : e1.left; | |
while (++j < m) { | |
s0 = s1; | |
e1 = edges[halfedges[j]]; | |
s1 = e1.left === site ? e1.right : e1.left; | |
if (s0 && s1 && i < s0.index && i < s1.index && triangleArea(site, s0, s1) < 0) { | |
triangles.push([site.data, s0.data, s1.data]); | |
} | |
} | |
}); | |
return triangles; | |
}, | |
links: function() { | |
return this.edges.filter(function(edge) { | |
return edge.right; | |
}).map(function(edge) { | |
return { | |
source: edge.left.data, | |
target: edge.right.data | |
}; | |
}); | |
}, | |
find: function(x, y, radius) { | |
var that = this, | |
i0, i1 = that._found || 0, | |
cell = that.cells[i1] || that.cells[i1 = 0], | |
dx = x - cell.site[0], | |
dy = y - cell.site[1], | |
d2 = dx * dx + dy * dy; | |
do { | |
cell = that.cells[i0 = i1], i1 = null; | |
cell.halfedges.forEach(function(e) { | |
var edge = that.edges[e], v = edge.left; | |
if ((v === cell.site || !v) && !(v = edge.right)) return; | |
var vx = x - v[0], | |
vy = y - v[1], | |
v2 = vx * vx + vy * vy; | |
if (v2 < d2) d2 = v2, i1 = v.index; | |
}); | |
} while (i1 !== null); | |
that._found = i0; | |
return radius == null || d2 <= radius * radius ? cell.site : null; | |
} | |
} | |
function voronoi() { | |
var x = x$4, | |
y = y$4, | |
extent = null; | |
function voronoi(data) { | |
return new Diagram(data.map(function(d, i) { | |
var s = [Math.round(x(d, i, data) / epsilon$3) * epsilon$3, Math.round(y(d, i, data) / epsilon$3) * epsilon$3]; | |
s.index = i; | |
s.data = d; | |
return s; | |
}), extent); | |
} | |
voronoi.polygons = function(data) { | |
return voronoi(data).polygons(); | |
}; | |
voronoi.links = function(data) { | |
return voronoi(data).links(); | |
}; | |
voronoi.triangles = function(data) { | |
return voronoi(data).triangles(); | |
}; | |
voronoi.x = function(_) { | |
return arguments.length ? (x = typeof _ === "function" ? _ : constant$8(+_), voronoi) : x; | |
}; | |
voronoi.y = function(_) { | |
return arguments.length ? (y = typeof _ === "function" ? _ : constant$8(+_), voronoi) : y; | |
}; | |
voronoi.extent = function(_) { | |
return arguments.length ? (extent = _ == null ? null : [[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]], voronoi) : extent && [[extent[0][0], extent[0][1]], [extent[1][0], extent[1][1]]]; | |
}; | |
voronoi.size = function(_) { | |
return arguments.length ? (extent = _ == null ? null : [[0, 0], [+_[0], +_[1]]], voronoi) : extent && [extent[1][0] - extent[0][0], extent[1][1] - extent[0][1]]; | |
}; | |
return voronoi; | |
} | |
function constant$9(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function ZoomEvent(target, type, transform) { | |
this.target = target; | |
this.type = type; | |
this.transform = transform; | |
} | |
function Transform(k, x, y) { | |
this.k = k; | |
this.x = x; | |
this.y = y; | |
} | |
Transform.prototype = { | |
constructor: Transform, | |
scale: function(k) { | |
return k === 1 ? this : new Transform(this.k * k, this.x, this.y); | |
}, | |
translate: function(x, y) { | |
return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y); | |
}, | |
apply: function(point) { | |
return [point[0] * this.k + this.x, point[1] * this.k + this.y]; | |
}, | |
applyX: function(x) { | |
return x * this.k + this.x; | |
}, | |
applyY: function(y) { | |
return y * this.k + this.y; | |
}, | |
invert: function(location) { | |
return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k]; | |
}, | |
invertX: function(x) { | |
return (x - this.x) / this.k; | |
}, | |
invertY: function(y) { | |
return (y - this.y) / this.k; | |
}, | |
rescaleX: function(x) { | |
return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x)); | |
}, | |
rescaleY: function(y) { | |
return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y)); | |
}, | |
toString: function() { | |
return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")"; | |
} | |
}; | |
var identity$6 = new Transform(1, 0, 0); | |
transform.prototype = Transform.prototype; | |
function transform(node) { | |
return node.__zoom || identity$6; | |
} | |
function nopropagation$1() { | |
exports.event.stopImmediatePropagation(); | |
} | |
function noevent$1() { | |
exports.event.preventDefault(); | |
exports.event.stopImmediatePropagation(); | |
} | |
// Ignore right-click, since that should open the context menu. | |
function defaultFilter$1() { | |
return !exports.event.button; | |
} | |
function defaultExtent() { | |
var e = this, w, h; | |
if (e instanceof SVGElement) { | |
e = e.ownerSVGElement || e; | |
w = e.width.baseVal.value; | |
h = e.height.baseVal.value; | |
} else { | |
w = e.clientWidth; | |
h = e.clientHeight; | |
} | |
return [[0, 0], [w, h]]; | |
} | |
function defaultTransform() { | |
return this.__zoom || identity$6; | |
} | |
function zoom() { | |
var filter = defaultFilter$1, | |
extent = defaultExtent, | |
k0 = 0, | |
k1 = Infinity, | |
x0 = -k1, | |
x1 = k1, | |
y0 = x0, | |
y1 = x1, | |
duration = 250, | |
interpolate = interpolateZoom, | |
gestures = [], | |
listeners = dispatch("start", "zoom", "end"), | |
touchstarting, | |
touchending, | |
touchDelay = 500, | |
wheelDelay = 150; | |
function zoom(selection) { | |
selection | |
.on("wheel.zoom", wheeled) | |
.on("mousedown.zoom", mousedowned) | |
.on("dblclick.zoom", dblclicked) | |
.on("touchstart.zoom", touchstarted) | |
.on("touchmove.zoom", touchmoved) | |
.on("touchend.zoom touchcancel.zoom", touchended) | |
.style("-webkit-tap-highlight-color", "rgba(0,0,0,0)") | |
.property("__zoom", defaultTransform); | |
} | |
zoom.transform = function(collection, transform) { | |
var selection = collection.selection ? collection.selection() : collection; | |
selection.property("__zoom", defaultTransform); | |
if (collection !== selection) { | |
schedule(collection, transform); | |
} else { | |
selection.interrupt().each(function() { | |
gesture(this, arguments) | |
.start() | |
.zoom(null, typeof transform === "function" ? transform.apply(this, arguments) : transform) | |
.end(); | |
}); | |
} | |
}; | |
zoom.scaleBy = function(selection, k) { | |
zoom.scaleTo(selection, function() { | |
var k0 = this.__zoom.k, | |
k1 = typeof k === "function" ? k.apply(this, arguments) : k; | |
return k0 * k1; | |
}); | |
}; | |
zoom.scaleTo = function(selection, k) { | |
zoom.transform(selection, function() { | |
var e = extent.apply(this, arguments), | |
t0 = this.__zoom, | |
p0 = centroid(e), | |
p1 = t0.invert(p0), | |
k1 = typeof k === "function" ? k.apply(this, arguments) : k; | |
return constrain(translate(scale(t0, k1), p0, p1), e); | |
}); | |
}; | |
zoom.translateBy = function(selection, x, y) { | |
zoom.transform(selection, function() { | |
return constrain(this.__zoom.translate( | |
typeof x === "function" ? x.apply(this, arguments) : x, | |
typeof y === "function" ? y.apply(this, arguments) : y | |
), extent.apply(this, arguments)); | |
}); | |
}; | |
function scale(transform, k) { | |
k = Math.max(k0, Math.min(k1, k)); | |
return k === transform.k ? transform : new Transform(k, transform.x, transform.y); | |
} | |
function translate(transform, p0, p1) { | |
var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k; | |
return x === transform.x && y === transform.y ? transform : new Transform(transform.k, x, y); | |
} | |
function constrain(transform, extent) { | |
var dx0 = transform.invertX(extent[0][0]) - x0, | |
dx1 = transform.invertX(extent[1][0]) - x1, | |
dy0 = transform.invertY(extent[0][1]) - y0, | |
dy1 = transform.invertY(extent[1][1]) - y1; | |
return transform.translate( | |
dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1), | |
dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1) | |
); | |
} | |
function centroid(extent) { | |
return [(+extent[0][0] + +extent[1][0]) / 2, (+extent[0][1] + +extent[1][1]) / 2]; | |
} | |
function schedule(transition, transform, center) { | |
transition | |
.on("start.zoom", function() { gesture(this, arguments).start(); }) | |
.on("interrupt.zoom end.zoom", function() { gesture(this, arguments).end(); }) | |
.tween("zoom", function() { | |
var that = this, | |
args = arguments, | |
g = gesture(that, args), | |
e = extent.apply(that, args), | |
p = center || centroid(e), | |
w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]), | |
a = that.__zoom, | |
b = typeof transform === "function" ? transform.apply(that, args) : transform, | |
i = interpolate(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k)); | |
return function(t) { | |
if (t === 1) t = b; // Avoid rounding error on end. | |
else { var l = i(t), k = w / l[2]; t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); } | |
g.zoom(null, t); | |
}; | |
}); | |
} | |
function gesture(that, args) { | |
for (var i = 0, n = gestures.length, g; i < n; ++i) { | |
if ((g = gestures[i]).that === that) { | |
return g; | |
} | |
} | |
return new Gesture(that, args); | |
} | |
function Gesture(that, args) { | |
this.that = that; | |
this.args = args; | |
this.index = -1; | |
this.active = 0; | |
this.extent = extent.apply(that, args); | |
} | |
Gesture.prototype = { | |
start: function() { | |
if (++this.active === 1) { | |
this.index = gestures.push(this) - 1; | |
this.emit("start"); | |
} | |
return this; | |
}, | |
zoom: function(key, transform) { | |
if (this.mouse && key !== "mouse") this.mouse[1] = transform.invert(this.mouse[0]); | |
if (this.touch0 && key !== "touch") this.touch0[1] = transform.invert(this.touch0[0]); | |
if (this.touch1 && key !== "touch") this.touch1[1] = transform.invert(this.touch1[0]); | |
this.that.__zoom = transform; | |
this.emit("zoom"); | |
return this; | |
}, | |
end: function() { | |
if (--this.active === 0) { | |
gestures.splice(this.index, 1); | |
this.index = -1; | |
this.emit("end"); | |
} | |
return this; | |
}, | |
emit: function(type) { | |
customEvent(new ZoomEvent(zoom, type, this.that.__zoom), listeners.apply, listeners, [type, this.that, this.args]); | |
} | |
}; | |
function wheeled() { | |
if (!filter.apply(this, arguments)) return; | |
var g = gesture(this, arguments), | |
t = this.__zoom, | |
k = Math.max(k0, Math.min(k1, t.k * Math.pow(2, -exports.event.deltaY * (exports.event.deltaMode ? 120 : 1) / 500))), | |
p = mouse(this); | |
// If the mouse is in the same location as before, reuse it. | |
// If there were recent wheel events, reset the wheel idle timeout. | |
if (g.wheel) { | |
if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) { | |
g.mouse[1] = t.invert(g.mouse[0] = p); | |
} | |
clearTimeout(g.wheel); | |
} | |
// If this wheel event won’t trigger a transform change, ignore it. | |
else if (t.k === k) return; | |
// Otherwise, capture the mouse point and location at the start. | |
else { | |
g.mouse = [p, t.invert(p)]; | |
interrupt(this); | |
g.start(); | |
} | |
noevent$1(); | |
g.wheel = setTimeout(wheelidled, wheelDelay); | |
g.zoom("mouse", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent)); | |
function wheelidled() { | |
g.wheel = null; | |
g.end(); | |
} | |
} | |
function mousedowned() { | |
if (touchending || !filter.apply(this, arguments)) return; | |
var g = gesture(this, arguments), | |
v = select(exports.event.view).on("mousemove.zoom", mousemoved, true).on("mouseup.zoom", mouseupped, true), | |
p = mouse(this); | |
dragDisable(exports.event.view); | |
nopropagation$1(); | |
g.mouse = [p, this.__zoom.invert(p)]; | |
interrupt(this); | |
g.start(); | |
function mousemoved() { | |
noevent$1(); | |
g.moved = true; | |
g.zoom("mouse", constrain(translate(g.that.__zoom, g.mouse[0] = mouse(g.that), g.mouse[1]), g.extent)); | |
} | |
function mouseupped() { | |
v.on("mousemove.zoom mouseup.zoom", null); | |
dragEnable(exports.event.view, g.moved); | |
noevent$1(); | |
g.end(); | |
} | |
} | |
function dblclicked() { | |
if (!filter.apply(this, arguments)) return; | |
var t0 = this.__zoom, | |
p0 = mouse(this), | |
p1 = t0.invert(p0), | |
k1 = t0.k * (exports.event.shiftKey ? 0.5 : 2), | |
t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, arguments)); | |
noevent$1(); | |
if (duration > 0) select(this).transition().duration(duration).call(schedule, t1, p0); | |
else select(this).call(zoom.transform, t1); | |
} | |
function touchstarted() { | |
if (!filter.apply(this, arguments)) return; | |
var g = gesture(this, arguments), | |
touches = exports.event.changedTouches, | |
n = touches.length, i, t, p; | |
nopropagation$1(); | |
for (i = 0; i < n; ++i) { | |
t = touches[i], p = touch(this, touches, t.identifier); | |
p = [p, this.__zoom.invert(p), t.identifier]; | |
if (!g.touch0) g.touch0 = p; | |
else if (!g.touch1) g.touch1 = p; | |
} | |
// If this is a dbltap, reroute to the (optional) dblclick.zoom handler. | |
if (touchstarting) { | |
touchstarting = clearTimeout(touchstarting); | |
if (!g.touch1) { | |
g.end(); | |
p = select(this).on("dblclick.zoom"); | |
if (p) p.apply(this, arguments); | |
return; | |
} | |
} | |
if (exports.event.touches.length === n) { | |
touchstarting = setTimeout(function() { touchstarting = null; }, touchDelay); | |
interrupt(this); | |
g.start(); | |
} | |
} | |
function touchmoved() { | |
var g = gesture(this, arguments), | |
touches = exports.event.changedTouches, | |
n = touches.length, i, t, p, l; | |
noevent$1(); | |
if (touchstarting) touchstarting = clearTimeout(touchstarting); | |
for (i = 0; i < n; ++i) { | |
t = touches[i], p = touch(this, touches, t.identifier); | |
if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p; | |
else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p; | |
} | |
t = g.that.__zoom; | |
if (g.touch1) { | |
var p0 = g.touch0[0], l0 = g.touch0[1], | |
p1 = g.touch1[0], l1 = g.touch1[1], | |
dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp, | |
dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl; | |
t = scale(t, Math.sqrt(dp / dl)); | |
p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2]; | |
l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2]; | |
} | |
else if (g.touch0) p = g.touch0[0], l = g.touch0[1]; | |
else return; | |
g.zoom("touch", constrain(translate(t, p, l), g.extent)); | |
} | |
function touchended() { | |
var g = gesture(this, arguments), | |
touches = exports.event.changedTouches, | |
n = touches.length, i, t; | |
nopropagation$1(); | |
if (touchending) clearTimeout(touchending); | |
touchending = setTimeout(function() { touchending = null; }, touchDelay); | |
for (i = 0; i < n; ++i) { | |
t = touches[i]; | |
if (g.touch0 && g.touch0[2] === t.identifier) delete g.touch0; | |
else if (g.touch1 && g.touch1[2] === t.identifier) delete g.touch1; | |
} | |
if (g.touch1 && !g.touch0) g.touch0 = g.touch1, delete g.touch1; | |
if (!g.touch0) g.end(); | |
} | |
zoom.filter = function(_) { | |
return arguments.length ? (filter = typeof _ === "function" ? _ : constant$9(!!_), zoom) : filter; | |
}; | |
zoom.extent = function(_) { | |
return arguments.length ? (extent = typeof _ === "function" ? _ : constant$9([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent; | |
}; | |
zoom.scaleExtent = function(_) { | |
return arguments.length ? (k0 = +_[0], k1 = +_[1], zoom) : [k0, k1]; | |
}; | |
zoom.translateExtent = function(_) { | |
return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], zoom) : [[x0, y0], [x1, y1]]; | |
}; | |
zoom.duration = function(_) { | |
return arguments.length ? (duration = +_, zoom) : duration; | |
}; | |
zoom.interpolate = function(_) { | |
return arguments.length ? (interpolate = _, zoom) : interpolate; | |
}; | |
zoom.on = function() { | |
var value = listeners.on.apply(listeners, arguments); | |
return value === listeners ? zoom : value; | |
}; | |
return zoom; | |
} | |
function constant$10(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function BrushEvent(target, type, selection) { | |
this.target = target; | |
this.type = type; | |
this.selection = selection; | |
} | |
function nopropagation$2() { | |
exports.event.stopImmediatePropagation(); | |
} | |
function noevent$2() { | |
exports.event.preventDefault(); | |
exports.event.stopImmediatePropagation(); | |
} | |
var MODE_DRAG = {name: "drag"}; | |
var MODE_SPACE = {name: "space"}; | |
var MODE_HANDLE = {name: "handle"}; | |
var MODE_CENTER = {name: "center"}; | |
var X = { | |
name: "x", | |
handles: ["e", "w"].map(type$1), | |
input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; }, | |
output: function(xy) { return xy && [xy[0][0], xy[1][0]]; } | |
}; | |
var Y = { | |
name: "y", | |
handles: ["n", "s"].map(type$1), | |
input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; }, | |
output: function(xy) { return xy && [xy[0][1], xy[1][1]]; } | |
}; | |
var XY = { | |
name: "xy", | |
handles: ["n", "e", "s", "w", "nw", "ne", "se", "sw"].map(type$1), | |
input: function(xy) { return xy; }, | |
output: function(xy) { return xy; } | |
}; | |
var cursors = { | |
overlay: "crosshair", | |
selection: "move", | |
n: "ns-resize", | |
e: "ew-resize", | |
s: "ns-resize", | |
w: "ew-resize", | |
nw: "nwse-resize", | |
ne: "nesw-resize", | |
se: "nwse-resize", | |
sw: "nesw-resize" | |
}; | |
var flipX = { | |
e: "w", | |
w: "e", | |
nw: "ne", | |
ne: "nw", | |
se: "sw", | |
sw: "se" | |
}; | |
var flipY = { | |
n: "s", | |
s: "n", | |
nw: "sw", | |
ne: "se", | |
se: "ne", | |
sw: "nw" | |
}; | |
var signsX = { | |
overlay: +1, | |
selection: +1, | |
n: null, | |
e: +1, | |
s: null, | |
w: -1, | |
nw: -1, | |
ne: +1, | |
se: +1, | |
sw: -1 | |
}; | |
var signsY = { | |
overlay: +1, | |
selection: +1, | |
n: -1, | |
e: null, | |
s: +1, | |
w: null, | |
nw: -1, | |
ne: -1, | |
se: +1, | |
sw: +1 | |
}; | |
function type$1(t) { | |
return {type: t}; | |
} | |
// Ignore right-click, since that should open the context menu. | |
function defaultFilter$2() { | |
return !exports.event.button; | |
} | |
function defaultExtent$1() { | |
var svg = this.ownerSVGElement || this; | |
return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]]; | |
} | |
// Like d3.local, but with the name “__brush” rather than auto-generated. | |
function local$1(node) { | |
while (!node.__brush) if (!(node = node.parentNode)) return; | |
return node.__brush; | |
} | |
function empty$1(extent) { | |
return extent[0][0] === extent[1][0] | |
|| extent[0][1] === extent[1][1]; | |
} | |
function brushSelection(node) { | |
var state = node.__brush; | |
return state ? state.dim.output(state.selection) : null; | |
} | |
function brushX() { | |
return brush$1(X); | |
} | |
function brushY() { | |
return brush$1(Y); | |
} | |
function brush() { | |
return brush$1(XY); | |
} | |
function brush$1(dim) { | |
var extent = defaultExtent$1, | |
filter = defaultFilter$2, | |
listeners = dispatch(brush, "start", "brush", "end"), | |
handleSize = 6, | |
touchending; | |
function brush(group) { | |
var overlay = group | |
.property("__brush", initialize) | |
.selectAll(".overlay") | |
.data([type$1("overlay")]); | |
overlay.enter().append("rect") | |
.attr("class", "overlay") | |
.attr("pointer-events", "all") | |
.attr("cursor", cursors.overlay) | |
.merge(overlay) | |
.each(function() { | |
var extent = local$1(this).extent; | |
select(this) | |
.attr("x", extent[0][0]) | |
.attr("y", extent[0][1]) | |
.attr("width", extent[1][0] - extent[0][0]) | |
.attr("height", extent[1][1] - extent[0][1]); | |
}); | |
group.selectAll(".selection") | |
.data([type$1("selection")]) | |
.enter().append("rect") | |
.attr("class", "selection") | |
.attr("cursor", cursors.selection) | |
.attr("fill", "#777") | |
.attr("fill-opacity", 0.3) | |
.attr("stroke", "#fff") | |
.attr("shape-rendering", "crispEdges"); | |
var handle = group.selectAll(".handle") | |
.data(dim.handles, function(d) { return d.type; }); | |
handle.exit().remove(); | |
handle.enter().append("rect") | |
.attr("class", function(d) { return "handle handle--" + d.type; }) | |
.attr("cursor", function(d) { return cursors[d.type]; }); | |
group | |
.each(redraw) | |
.attr("fill", "none") | |
.attr("pointer-events", "all") | |
.style("-webkit-tap-highlight-color", "rgba(0,0,0,0)") | |
.on("mousedown.brush touchstart.brush", started); | |
} | |
brush.move = function(group, selection) { | |
if (group.selection) { | |
group | |
.on("start.brush", function() { emitter(this, arguments).beforestart().start(); }) | |
.on("interrupt.brush end.brush", function() { emitter(this, arguments).end(); }) | |
.tween("brush", function() { | |
var that = this, | |
state = that.__brush, | |
emit = emitter(that, arguments), | |
selection0 = state.selection, | |
selection1 = dim.input(typeof selection === "function" ? selection.apply(this, arguments) : selection, state.extent), | |
i = interpolate(selection0, selection1); | |
function tween(t) { | |
state.selection = t === 1 && empty$1(selection1) ? null : i(t); | |
redraw.call(that); | |
emit.brush(); | |
} | |
return selection0 && selection1 ? tween : tween(1); | |
}); | |
} else { | |
group | |
.each(function() { | |
var that = this, | |
args = arguments, | |
state = that.__brush, | |
selection1 = dim.input(typeof selection === "function" ? selection.apply(that, args) : selection, state.extent), | |
emit = emitter(that, args).beforestart(); | |
interrupt(that); | |
state.selection = selection1 == null || empty$1(selection1) ? null : selection1; | |
redraw.call(that); | |
emit.start().brush().end(); | |
}); | |
} | |
}; | |
function redraw() { | |
var group = select(this), | |
selection = local$1(this).selection; | |
if (selection) { | |
group.selectAll(".selection") | |
.style("display", null) | |
.attr("x", selection[0][0]) | |
.attr("y", selection[0][1]) | |
.attr("width", selection[1][0] - selection[0][0]) | |
.attr("height", selection[1][1] - selection[0][1]); | |
group.selectAll(".handle") | |
.style("display", null) | |
.attr("x", function(d) { return d.type[d.type.length - 1] === "e" ? selection[1][0] - handleSize / 2 : selection[0][0] - handleSize / 2; }) | |
.attr("y", function(d) { return d.type[0] === "s" ? selection[1][1] - handleSize / 2 : selection[0][1] - handleSize / 2; }) | |
.attr("width", function(d) { return d.type === "n" || d.type === "s" ? selection[1][0] - selection[0][0] + handleSize : handleSize; }) | |
.attr("height", function(d) { return d.type === "e" || d.type === "w" ? selection[1][1] - selection[0][1] + handleSize : handleSize; }); | |
} | |
else { | |
group.selectAll(".selection,.handle") | |
.style("display", "none") | |
.attr("x", null) | |
.attr("y", null) | |
.attr("width", null) | |
.attr("height", null); | |
} | |
} | |
function emitter(that, args) { | |
return that.__brush.emitter || new Emitter(that, args); | |
} | |
function Emitter(that, args) { | |
this.that = that; | |
this.args = args; | |
this.state = that.__brush; | |
this.active = 0; | |
} | |
Emitter.prototype = { | |
beforestart: function() { | |
if (++this.active === 1) this.state.emitter = this, this.starting = true; | |
return this; | |
}, | |
start: function() { | |
if (this.starting) this.starting = false, this.emit("start"); | |
return this; | |
}, | |
brush: function() { | |
this.emit("brush"); | |
return this; | |
}, | |
end: function() { | |
if (--this.active === 0) delete this.state.emitter, this.emit("end"); | |
return this; | |
}, | |
emit: function(type) { | |
customEvent(new BrushEvent(brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]); | |
} | |
}; | |
function started() { | |
if (exports.event.touches) { if (exports.event.changedTouches.length < exports.event.touches.length) return noevent$2(); } | |
else if (touchending) return; | |
if (!filter.apply(this, arguments)) return; | |
var that = this, | |
type = exports.event.target.__data__.type, | |
mode = (exports.event.metaKey ? type = "overlay" : type) === "selection" ? MODE_DRAG : (exports.event.altKey ? MODE_CENTER : MODE_HANDLE), | |
signX = dim === Y ? null : signsX[type], | |
signY = dim === X ? null : signsY[type], | |
state = local$1(that), | |
extent = state.extent, | |
selection = state.selection, | |
W = extent[0][0], w0, w1, | |
N = extent[0][1], n0, n1, | |
E = extent[1][0], e0, e1, | |
S = extent[1][1], s0, s1, | |
dx, | |
dy, | |
moving, | |
shifting = signX && signY && exports.event.shiftKey, | |
lockX, | |
lockY, | |
point0 = mouse(that), | |
point = point0, | |
emit = emitter(that, arguments).beforestart(); | |
if (type === "overlay") { | |
state.selection = selection = [ | |
[w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]], | |
[e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0] | |
]; | |
} else { | |
w0 = selection[0][0]; | |
n0 = selection[0][1]; | |
e0 = selection[1][0]; | |
s0 = selection[1][1]; | |
} | |
w1 = w0; | |
n1 = n0; | |
e1 = e0; | |
s1 = s0; | |
var group = select(that) | |
.attr("pointer-events", "none"); | |
var overlay = group.selectAll(".overlay") | |
.attr("cursor", cursors[type]); | |
if (exports.event.touches) { | |
group | |
.on("touchmove.brush", moved, true) | |
.on("touchend.brush touchcancel.brush", ended, true); | |
} else { | |
var view = select(exports.event.view) | |
.on("keydown.brush", keydowned, true) | |
.on("keyup.brush", keyupped, true) | |
.on("mousemove.brush", moved, true) | |
.on("mouseup.brush", ended, true); | |
dragDisable(exports.event.view); | |
} | |
nopropagation$2(); | |
interrupt(that); | |
redraw.call(that); | |
emit.start(); | |
function moved() { | |
var point1 = mouse(that); | |
if (shifting && !lockX && !lockY) { | |
if (Math.abs(point1[0] - point[0]) > Math.abs(point1[1] - point[1])) lockY = true; | |
else lockX = true; | |
} | |
point = point1; | |
moving = true; | |
noevent$2(); | |
move(); | |
} | |
function move() { | |
var t; | |
dx = point[0] - point0[0]; | |
dy = point[1] - point0[1]; | |
switch (mode) { | |
case MODE_SPACE: | |
case MODE_DRAG: { | |
if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx; | |
if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy; | |
break; | |
} | |
case MODE_HANDLE: { | |
if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0; | |
else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx; | |
if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0; | |
else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy; | |
break; | |
} | |
case MODE_CENTER: { | |
if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX)); | |
if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY)); | |
break; | |
} | |
} | |
if (e1 < w1) { | |
signX *= -1; | |
t = w0, w0 = e0, e0 = t; | |
t = w1, w1 = e1, e1 = t; | |
if (type in flipX) overlay.attr("cursor", cursors[type = flipX[type]]); | |
} | |
if (s1 < n1) { | |
signY *= -1; | |
t = n0, n0 = s0, s0 = t; | |
t = n1, n1 = s1, s1 = t; | |
if (type in flipY) overlay.attr("cursor", cursors[type = flipY[type]]); | |
} | |
if (state.selection) selection = state.selection; // May be set by brush.move! | |
if (lockX) w1 = selection[0][0], e1 = selection[1][0]; | |
if (lockY) n1 = selection[0][1], s1 = selection[1][1]; | |
if (selection[0][0] !== w1 | |
|| selection[0][1] !== n1 | |
|| selection[1][0] !== e1 | |
|| selection[1][1] !== s1) { | |
state.selection = [[w1, n1], [e1, s1]]; | |
redraw.call(that); | |
emit.brush(); | |
} | |
} | |
function ended() { | |
nopropagation$2(); | |
if (exports.event.touches) { | |
if (exports.event.touches.length) return; | |
if (touchending) clearTimeout(touchending); | |
touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! | |
group.on("touchmove.brush touchend.brush touchcancel.brush", null); | |
} else { | |
dragEnable(exports.event.view, moving); | |
view.on("keydown.brush keyup.brush mousemove.brush mouseup.brush", null); | |
} | |
group.attr("pointer-events", "all"); | |
overlay.attr("cursor", cursors.overlay); | |
if (state.selection) selection = state.selection; // May be set by brush.move (on start)! | |
if (empty$1(selection)) state.selection = null, redraw.call(that); | |
emit.end(); | |
} | |
function keydowned() { | |
switch (exports.event.keyCode) { | |
case 16: { // SHIFT | |
shifting = signX && signY; | |
break; | |
} | |
case 18: { // ALT | |
if (mode === MODE_HANDLE) { | |
if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX; | |
if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY; | |
mode = MODE_CENTER; | |
move(); | |
} | |
break; | |
} | |
case 32: { // SPACE; takes priority over ALT | |
if (mode === MODE_HANDLE || mode === MODE_CENTER) { | |
if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx; | |
if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy; | |
mode = MODE_SPACE; | |
overlay.attr("cursor", cursors.selection); | |
move(); | |
} | |
break; | |
} | |
default: return; | |
} | |
noevent$2(); | |
} | |
function keyupped() { | |
switch (exports.event.keyCode) { | |
case 16: { // SHIFT | |
if (shifting) { | |
lockX = lockY = shifting = false; | |
move(); | |
} | |
break; | |
} | |
case 18: { // ALT | |
if (mode === MODE_CENTER) { | |
if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1; | |
if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1; | |
mode = MODE_HANDLE; | |
move(); | |
} | |
break; | |
} | |
case 32: { // SPACE | |
if (mode === MODE_SPACE) { | |
if (exports.event.altKey) { | |
if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX; | |
if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY; | |
mode = MODE_CENTER; | |
} else { | |
if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1; | |
if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1; | |
mode = MODE_HANDLE; | |
} | |
overlay.attr("cursor", cursors[type]); | |
move(); | |
} | |
break; | |
} | |
default: return; | |
} | |
noevent$2(); | |
} | |
} | |
function initialize() { | |
var state = this.__brush || {selection: null}; | |
state.extent = extent.apply(this, arguments); | |
state.dim = dim; | |
return state; | |
} | |
brush.extent = function(_) { | |
return arguments.length ? (extent = typeof _ === "function" ? _ : constant$10([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent; | |
}; | |
brush.filter = function(_) { | |
return arguments.length ? (filter = typeof _ === "function" ? _ : constant$10(!!_), brush) : filter; | |
}; | |
brush.handleSize = function(_) { | |
return arguments.length ? (handleSize = +_, brush) : handleSize; | |
}; | |
brush.on = function() { | |
var value = listeners.on.apply(listeners, arguments); | |
return value === listeners ? brush : value; | |
}; | |
return brush; | |
} | |
var cos = Math.cos; | |
var sin = Math.sin; | |
var pi$3 = Math.PI; | |
var halfPi$2 = pi$3 / 2; | |
var tau$3 = pi$3 * 2; | |
var max$1 = Math.max; | |
function compareValue(compare) { | |
return function(a, b) { | |
return compare( | |
a.source.value + a.target.value, | |
b.source.value + b.target.value | |
); | |
}; | |
} | |
function chord() { | |
var padAngle = 0, | |
sortGroups = null, | |
sortSubgroups = null, | |
sortChords = null; | |
function chord(matrix) { | |
var n = matrix.length, | |
groupSums = [], | |
groupIndex = range(n), | |
subgroupIndex = [], | |
chords = [], | |
groups = chords.groups = new Array(n), | |
subgroups = new Array(n * n), | |
k, | |
x, | |
x0, | |
dx, | |
i, | |
j; | |
// Compute the sum. | |
k = 0, i = -1; while (++i < n) { | |
x = 0, j = -1; while (++j < n) { | |
x += matrix[i][j]; | |
} | |
groupSums.push(x); | |
subgroupIndex.push(range(n)); | |
k += x; | |
} | |
// Sort groups… | |
if (sortGroups) groupIndex.sort(function(a, b) { | |
return sortGroups(groupSums[a], groupSums[b]); | |
}); | |
// Sort subgroups… | |
if (sortSubgroups) subgroupIndex.forEach(function(d, i) { | |
d.sort(function(a, b) { | |
return sortSubgroups(matrix[i][a], matrix[i][b]); | |
}); | |
}); | |
// Convert the sum to scaling factor for [0, 2pi]. | |
// TODO Allow start and end angle to be specified? | |
// TODO Allow padding to be specified as percentage? | |
k = max$1(0, tau$3 - padAngle * n) / k; | |
dx = k ? padAngle : tau$3 / n; | |
// Compute the start and end angle for each group and subgroup. | |
// Note: Opera has a bug reordering object literal properties! | |
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[dj * n + di] = { | |
index: di, | |
subindex: dj, | |
startAngle: a0, | |
endAngle: a1, | |
value: v | |
}; | |
} | |
groups[di] = { | |
index: di, | |
startAngle: x0, | |
endAngle: x, | |
value: groupSums[di] | |
}; | |
x += dx; | |
} | |
// Generate chords for each (non-empty) subgroup-subgroup link. | |
i = -1; while (++i < n) { | |
j = i - 1; while (++j < n) { | |
var source = subgroups[j * n + i], | |
target = subgroups[i * n + j]; | |
if (source.value || target.value) { | |
chords.push(source.value < target.value | |
? {source: target, target: source} | |
: {source: source, target: target}); | |
} | |
} | |
} | |
return sortChords ? chords.sort(sortChords) : chords; | |
} | |
chord.padAngle = function(_) { | |
return arguments.length ? (padAngle = max$1(0, _), chord) : padAngle; | |
}; | |
chord.sortGroups = function(_) { | |
return arguments.length ? (sortGroups = _, chord) : sortGroups; | |
}; | |
chord.sortSubgroups = function(_) { | |
return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups; | |
}; | |
chord.sortChords = function(_) { | |
return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._; | |
}; | |
return chord; | |
} | |
var slice$5 = Array.prototype.slice; | |
function constant$11(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function defaultSource(d) { | |
return d.source; | |
} | |
function defaultTarget(d) { | |
return d.target; | |
} | |
function defaultRadius$1(d) { | |
return d.radius; | |
} | |
function defaultStartAngle(d) { | |
return d.startAngle; | |
} | |
function defaultEndAngle(d) { | |
return d.endAngle; | |
} | |
function ribbon() { | |
var source = defaultSource, | |
target = defaultTarget, | |
radius = defaultRadius$1, | |
startAngle = defaultStartAngle, | |
endAngle = defaultEndAngle, | |
context = null; | |
function ribbon() { | |
var buffer, | |
argv = slice$5.call(arguments), | |
s = source.apply(this, argv), | |
t = target.apply(this, argv), | |
sr = +radius.apply(this, (argv[0] = s, argv)), | |
sa0 = startAngle.apply(this, argv) - halfPi$2, | |
sa1 = endAngle.apply(this, argv) - halfPi$2, | |
sx0 = sr * cos(sa0), | |
sy0 = sr * sin(sa0), | |
tr = +radius.apply(this, (argv[0] = t, argv)), | |
ta0 = startAngle.apply(this, argv) - halfPi$2, | |
ta1 = endAngle.apply(this, argv) - halfPi$2; | |
if (!context) context = buffer = path(); | |
context.moveTo(sx0, sy0); | |
context.arc(0, 0, sr, sa0, sa1); | |
if (sa0 !== ta0 || sa1 !== ta1) { // TODO sr !== tr? | |
context.quadraticCurveTo(0, 0, tr * cos(ta0), tr * sin(ta0)); | |
context.arc(0, 0, tr, ta0, ta1); | |
} | |
context.quadraticCurveTo(0, 0, sx0, sy0); | |
context.closePath(); | |
if (buffer) return context = null, buffer + "" || null; | |
} | |
ribbon.radius = function(_) { | |
return arguments.length ? (radius = typeof _ === "function" ? _ : constant$11(+_), ribbon) : radius; | |
}; | |
ribbon.startAngle = function(_) { | |
return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant$11(+_), ribbon) : startAngle; | |
}; | |
ribbon.endAngle = function(_) { | |
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$11(+_), ribbon) : endAngle; | |
}; | |
ribbon.source = function(_) { | |
return arguments.length ? (source = _, ribbon) : source; | |
}; | |
ribbon.target = function(_) { | |
return arguments.length ? (target = _, ribbon) : target; | |
}; | |
ribbon.context = function(_) { | |
return arguments.length ? ((context = _ == null ? null : _), ribbon) : context; | |
}; | |
return ribbon; | |
} | |
// Adds floating point numbers with twice the normal precision. | |
// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and | |
// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3) | |
// 305–363 (1997). | |
// Code adapted from GeographicLib by Charles F. F. Karney, | |
// http://geographiclib.sourceforge.net/ | |
function adder() { | |
return new Adder; | |
} | |
function Adder() { | |
this.reset(); | |
} | |
Adder.prototype = { | |
constructor: Adder, | |
reset: function() { | |
this.s = // rounded value | |
this.t = 0; // exact error | |
}, | |
add: function(y) { | |
add$1(temp, y, this.t); | |
add$1(this, temp.s, this.s); | |
if (this.s) this.t += temp.t; | |
else this.s = temp.t; | |
}, | |
valueOf: function() { | |
return this.s; | |
} | |
}; | |
var temp = new Adder; | |
function add$1(adder, a, b) { | |
var x = adder.s = a + b, | |
bv = x - a, | |
av = x - bv; | |
adder.t = (a - av) + (b - bv); | |
} | |
var epsilon$4 = 1e-6; | |
var epsilon2$2 = 1e-12; | |
var pi$4 = Math.PI; | |
var halfPi$3 = pi$4 / 2; | |
var quarterPi = pi$4 / 4; | |
var tau$4 = pi$4 * 2; | |
var degrees$1 = 180 / pi$4; | |
var radians = pi$4 / 180; | |
var abs = Math.abs; | |
var atan = Math.atan; | |
var atan2 = Math.atan2; | |
var cos$1 = Math.cos; | |
var ceil = Math.ceil; | |
var exp = Math.exp; | |
var log$1 = Math.log; | |
var pow$1 = Math.pow; | |
var sin$1 = Math.sin; | |
var sign$1 = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }; | |
var sqrt$1 = Math.sqrt; | |
var tan = Math.tan; | |
function acos(x) { | |
return x > 1 ? 0 : x < -1 ? pi$4 : Math.acos(x); | |
} | |
function asin$1(x) { | |
return x > 1 ? halfPi$3 : x < -1 ? -halfPi$3 : Math.asin(x); | |
} | |
function haversin(x) { | |
return (x = sin$1(x / 2)) * x; | |
} | |
function noop$2() {} | |
function streamGeometry(geometry, stream) { | |
if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) { | |
streamGeometryType[geometry.type](geometry, stream); | |
} | |
} | |
var streamObjectType = { | |
Feature: function(feature, stream) { | |
streamGeometry(feature.geometry, stream); | |
}, | |
FeatureCollection: function(object, stream) { | |
var features = object.features, i = -1, n = features.length; | |
while (++i < n) streamGeometry(features[i].geometry, stream); | |
} | |
}; | |
var streamGeometryType = { | |
Sphere: function(object, stream) { | |
stream.sphere(); | |
}, | |
Point: function(object, stream) { | |
object = object.coordinates; | |
stream.point(object[0], object[1], object[2]); | |
}, | |
MultiPoint: function(object, stream) { | |
var coordinates = object.coordinates, i = -1, n = coordinates.length; | |
while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]); | |
}, | |
LineString: function(object, stream) { | |
streamLine(object.coordinates, stream, 0); | |
}, | |
MultiLineString: function(object, stream) { | |
var coordinates = object.coordinates, i = -1, n = coordinates.length; | |
while (++i < n) streamLine(coordinates[i], stream, 0); | |
}, | |
Polygon: function(object, stream) { | |
streamPolygon(object.coordinates, stream); | |
}, | |
MultiPolygon: function(object, stream) { | |
var coordinates = object.coordinates, i = -1, n = coordinates.length; | |
while (++i < n) streamPolygon(coordinates[i], stream); | |
}, | |
GeometryCollection: function(object, stream) { | |
var geometries = object.geometries, i = -1, n = geometries.length; | |
while (++i < n) streamGeometry(geometries[i], stream); | |
} | |
}; | |
function streamLine(coordinates, stream, closed) { | |
var i = -1, n = coordinates.length - closed, coordinate; | |
stream.lineStart(); | |
while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]); | |
stream.lineEnd(); | |
} | |
function streamPolygon(coordinates, stream) { | |
var i = -1, n = coordinates.length; | |
stream.polygonStart(); | |
while (++i < n) streamLine(coordinates[i], stream, 1); | |
stream.polygonEnd(); | |
} | |
function geoStream(object, stream) { | |
if (object && streamObjectType.hasOwnProperty(object.type)) { | |
streamObjectType[object.type](object, stream); | |
} else { | |
streamGeometry(object, stream); | |
} | |
} | |
var areaRingSum = adder(); | |
var areaSum = adder(); | |
var lambda00; | |
var phi00; | |
var lambda0; | |
var cosPhi0; | |
var sinPhi0; | |
var areaStream = { | |
point: noop$2, | |
lineStart: noop$2, | |
lineEnd: noop$2, | |
polygonStart: function() { | |
areaRingSum.reset(); | |
areaStream.lineStart = areaRingStart; | |
areaStream.lineEnd = areaRingEnd; | |
}, | |
polygonEnd: function() { | |
var areaRing = +areaRingSum; | |
areaSum.add(areaRing < 0 ? tau$4 + areaRing : areaRing); | |
this.lineStart = this.lineEnd = this.point = noop$2; | |
}, | |
sphere: function() { | |
areaSum.add(tau$4); | |
} | |
}; | |
function areaRingStart() { | |
areaStream.point = areaPointFirst; | |
} | |
function areaRingEnd() { | |
areaPoint(lambda00, phi00); | |
} | |
function areaPointFirst(lambda, phi) { | |
areaStream.point = areaPoint; | |
lambda00 = lambda, phi00 = phi; | |
lambda *= radians, phi *= radians; | |
lambda0 = lambda, cosPhi0 = cos$1(phi = phi / 2 + quarterPi), sinPhi0 = sin$1(phi); | |
} | |
function areaPoint(lambda, phi) { | |
lambda *= radians, phi *= radians; | |
phi = phi / 2 + quarterPi; // half the angular distance from south pole | |
// Spherical excess E for a spherical triangle with vertices: south pole, | |
// previous point, current point. Uses a formula derived from Cagnoli’s | |
// theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2). | |
var dLambda = lambda - lambda0, | |
sdLambda = dLambda >= 0 ? 1 : -1, | |
adLambda = sdLambda * dLambda, | |
cosPhi = cos$1(phi), | |
sinPhi = sin$1(phi), | |
k = sinPhi0 * sinPhi, | |
u = cosPhi0 * cosPhi + k * cos$1(adLambda), | |
v = k * sdLambda * sin$1(adLambda); | |
areaRingSum.add(atan2(v, u)); | |
// Advance the previous points. | |
lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi; | |
} | |
function area$2(object) { | |
areaSum.reset(); | |
geoStream(object, areaStream); | |
return areaSum * 2; | |
} | |
function spherical(cartesian) { | |
return [atan2(cartesian[1], cartesian[0]), asin$1(cartesian[2])]; | |
} | |
function cartesian(spherical) { | |
var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi); | |
return [cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)]; | |
} | |
function cartesianDot(a, b) { | |
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; | |
} | |
function cartesianCross(a, b) { | |
return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]; | |
} | |
// TODO return a | |
function cartesianAddInPlace(a, b) { | |
a[0] += b[0], a[1] += b[1], a[2] += b[2]; | |
} | |
function cartesianScale(vector, k) { | |
return [vector[0] * k, vector[1] * k, vector[2] * k]; | |
} | |
// TODO return d | |
function cartesianNormalizeInPlace(d) { | |
var l = sqrt$1(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]); | |
d[0] /= l, d[1] /= l, d[2] /= l; | |
} | |
var lambda0$1; | |
var phi0; | |
var lambda1; | |
var phi1; | |
var lambda2; | |
var lambda00$1; | |
var phi00$1; | |
var p0; | |
var deltaSum = adder(); | |
var ranges; | |
var range$1; | |
var boundsStream = { | |
point: boundsPoint, | |
lineStart: boundsLineStart, | |
lineEnd: boundsLineEnd, | |
polygonStart: function() { | |
boundsStream.point = boundsRingPoint; | |
boundsStream.lineStart = boundsRingStart; | |
boundsStream.lineEnd = boundsRingEnd; | |
deltaSum.reset(); | |
areaStream.polygonStart(); | |
}, | |
polygonEnd: function() { | |
areaStream.polygonEnd(); | |
boundsStream.point = boundsPoint; | |
boundsStream.lineStart = boundsLineStart; | |
boundsStream.lineEnd = boundsLineEnd; | |
if (areaRingSum < 0) lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90); | |
else if (deltaSum > epsilon$4) phi1 = 90; | |
else if (deltaSum < -epsilon$4) phi0 = -90; | |
range$1[0] = lambda0$1, range$1[1] = lambda1; | |
} | |
}; | |
function boundsPoint(lambda, phi) { | |
ranges.push(range$1 = [lambda0$1 = lambda, lambda1 = lambda]); | |
if (phi < phi0) phi0 = phi; | |
if (phi > phi1) phi1 = phi; | |
} | |
function linePoint(lambda, phi) { | |
var p = cartesian([lambda * radians, phi * radians]); | |
if (p0) { | |
var normal = cartesianCross(p0, p), | |
equatorial = [normal[1], -normal[0], 0], | |
inflection = cartesianCross(equatorial, normal); | |
cartesianNormalizeInPlace(inflection); | |
inflection = spherical(inflection); | |
var delta = lambda - lambda2, | |
sign = delta > 0 ? 1 : -1, | |
lambdai = inflection[0] * degrees$1 * sign, | |
phii, | |
antimeridian = abs(delta) > 180; | |
if (antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) { | |
phii = inflection[1] * degrees$1; | |
if (phii > phi1) phi1 = phii; | |
} else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) { | |
phii = -inflection[1] * degrees$1; | |
if (phii < phi0) phi0 = phii; | |
} else { | |
if (phi < phi0) phi0 = phi; | |
if (phi > phi1) phi1 = phi; | |
} | |
if (antimeridian) { | |
if (lambda < lambda2) { | |
if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda; | |
} else { | |
if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda; | |
} | |
} else { | |
if (lambda1 >= lambda0$1) { | |
if (lambda < lambda0$1) lambda0$1 = lambda; | |
if (lambda > lambda1) lambda1 = lambda; | |
} else { | |
if (lambda > lambda2) { | |
if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda; | |
} else { | |
if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda; | |
} | |
} | |
} | |
} else { | |
boundsPoint(lambda, phi); | |
} | |
p0 = p, lambda2 = lambda; | |
} | |
function boundsLineStart() { | |
boundsStream.point = linePoint; | |
} | |
function boundsLineEnd() { | |
range$1[0] = lambda0$1, range$1[1] = lambda1; | |
boundsStream.point = boundsPoint; | |
p0 = null; | |
} | |
function boundsRingPoint(lambda, phi) { | |
if (p0) { | |
var delta = lambda - lambda2; | |
deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta); | |
} else { | |
lambda00$1 = lambda, phi00$1 = phi; | |
} | |
areaStream.point(lambda, phi); | |
linePoint(lambda, phi); | |
} | |
function boundsRingStart() { | |
areaStream.lineStart(); | |
} | |
function boundsRingEnd() { | |
boundsRingPoint(lambda00$1, phi00$1); | |
areaStream.lineEnd(); | |
if (abs(deltaSum) > epsilon$4) lambda0$1 = -(lambda1 = 180); | |
range$1[0] = lambda0$1, range$1[1] = lambda1; | |
p0 = null; | |
} | |
// Finds the left-right distance between two longitudes. | |
// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want | |
// the distance between ±180° to be 360°. | |
function angle(lambda0, lambda1) { | |
return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1; | |
} | |
function rangeCompare(a, b) { | |
return a[0] - b[0]; | |
} | |
function rangeContains(range, x) { | |
return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x; | |
} | |
function bounds(feature) { | |
var i, n, a, b, merged, deltaMax, delta; | |
phi1 = lambda1 = -(lambda0$1 = phi0 = Infinity); | |
ranges = []; | |
geoStream(feature, boundsStream); | |
// First, sort ranges by their minimum longitudes. | |
if (n = ranges.length) { | |
ranges.sort(rangeCompare); | |
// Then, merge any ranges that overlap. | |
for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) { | |
b = ranges[i]; | |
if (rangeContains(a, b[0]) || rangeContains(a, b[1])) { | |
if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1]; | |
if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0]; | |
} else { | |
merged.push(a = b); | |
} | |
} | |
// Finally, find the largest gap between the merged ranges. | |
// The final bounding box will be the inverse of this gap. | |
for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) { | |
b = merged[i]; | |
if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0$1 = b[0], lambda1 = a[1]; | |
} | |
} | |
ranges = range$1 = null; | |
return lambda0$1 === Infinity || phi0 === Infinity | |
? [[NaN, NaN], [NaN, NaN]] | |
: [[lambda0$1, phi0], [lambda1, phi1]]; | |
} | |
var W0; | |
var W1; | |
var X0; | |
var Y0; | |
var Z0; | |
var X1; | |
var Y1; | |
var Z1; | |
var X2; | |
var Y2; | |
var Z2; | |
var lambda00$2; | |
var phi00$2; | |
var x0; | |
var y0; | |
var z0; | |
// previous point | |
var centroidStream = { | |
sphere: noop$2, | |
point: centroidPoint, | |
lineStart: centroidLineStart, | |
lineEnd: centroidLineEnd, | |
polygonStart: function() { | |
centroidStream.lineStart = centroidRingStart; | |
centroidStream.lineEnd = centroidRingEnd; | |
}, | |
polygonEnd: function() { | |
centroidStream.lineStart = centroidLineStart; | |
centroidStream.lineEnd = centroidLineEnd; | |
} | |
}; | |
// Arithmetic mean of Cartesian vectors. | |
function centroidPoint(lambda, phi) { | |
lambda *= radians, phi *= radians; | |
var cosPhi = cos$1(phi); | |
centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)); | |
} | |
function centroidPointCartesian(x, y, z) { | |
++W0; | |
X0 += (x - X0) / W0; | |
Y0 += (y - Y0) / W0; | |
Z0 += (z - Z0) / W0; | |
} | |
function centroidLineStart() { | |
centroidStream.point = centroidLinePointFirst; | |
} | |
function centroidLinePointFirst(lambda, phi) { | |
lambda *= radians, phi *= radians; | |
var cosPhi = cos$1(phi); | |
x0 = cosPhi * cos$1(lambda); | |
y0 = cosPhi * sin$1(lambda); | |
z0 = sin$1(phi); | |
centroidStream.point = centroidLinePoint; | |
centroidPointCartesian(x0, y0, z0); | |
} | |
function centroidLinePoint(lambda, phi) { | |
lambda *= radians, phi *= radians; | |
var cosPhi = cos$1(phi), | |
x = cosPhi * cos$1(lambda), | |
y = cosPhi * sin$1(lambda), | |
z = sin$1(phi), | |
w = atan2(sqrt$1((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z); | |
W1 += w; | |
X1 += w * (x0 + (x0 = x)); | |
Y1 += w * (y0 + (y0 = y)); | |
Z1 += w * (z0 + (z0 = z)); | |
centroidPointCartesian(x0, y0, z0); | |
} | |
function centroidLineEnd() { | |
centroidStream.point = centroidPoint; | |
} | |
// See J. E. Brock, The Inertia Tensor for a Spherical Triangle, | |
// J. Applied Mechanics 42, 239 (1975). | |
function centroidRingStart() { | |
centroidStream.point = centroidRingPointFirst; | |
} | |
function centroidRingEnd() { | |
centroidRingPoint(lambda00$2, phi00$2); | |
centroidStream.point = centroidPoint; | |
} | |
function centroidRingPointFirst(lambda, phi) { | |
lambda00$2 = lambda, phi00$2 = phi; | |
lambda *= radians, phi *= radians; | |
centroidStream.point = centroidRingPoint; | |
var cosPhi = cos$1(phi); | |
x0 = cosPhi * cos$1(lambda); | |
y0 = cosPhi * sin$1(lambda); | |
z0 = sin$1(phi); | |
centroidPointCartesian(x0, y0, z0); | |
} | |
function centroidRingPoint(lambda, phi) { | |
lambda *= radians, phi *= radians; | |
var cosPhi = cos$1(phi), | |
x = cosPhi * cos$1(lambda), | |
y = cosPhi * sin$1(lambda), | |
z = sin$1(phi), | |
cx = y0 * z - z0 * y, | |
cy = z0 * x - x0 * z, | |
cz = x0 * y - y0 * x, | |
m = sqrt$1(cx * cx + cy * cy + cz * cz), | |
u = x0 * x + y0 * y + z0 * z, | |
v = m && -acos(u) / m, // area weight | |
w = atan2(m, u); // line weight | |
X2 += v * cx; | |
Y2 += v * cy; | |
Z2 += v * cz; | |
W1 += w; | |
X1 += w * (x0 + (x0 = x)); | |
Y1 += w * (y0 + (y0 = y)); | |
Z1 += w * (z0 + (z0 = z)); | |
centroidPointCartesian(x0, y0, z0); | |
} | |
function centroid$1(object) { | |
W0 = W1 = | |
X0 = Y0 = Z0 = | |
X1 = Y1 = Z1 = | |
X2 = Y2 = Z2 = 0; | |
geoStream(object, centroidStream); | |
var x = X2, | |
y = Y2, | |
z = Z2, | |
m = x * x + y * y + z * z; | |
// If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid. | |
if (m < epsilon2$2) { | |
x = X1, y = Y1, z = Z1; | |
// If the feature has zero length, fall back to arithmetic mean of point vectors. | |
if (W1 < epsilon$4) x = X0, y = Y0, z = Z0; | |
m = x * x + y * y + z * z; | |
// If the feature still has an undefined ccentroid, then return. | |
if (m < epsilon2$2) return [NaN, NaN]; | |
} | |
return [atan2(y, x) * degrees$1, asin$1(z / sqrt$1(m)) * degrees$1]; | |
} | |
function constant$12(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function compose(a, b) { | |
function compose(x, y) { | |
return x = a(x, y), b(x[0], x[1]); | |
} | |
if (a.invert && b.invert) compose.invert = function(x, y) { | |
return x = b.invert(x, y), x && a.invert(x[0], x[1]); | |
}; | |
return compose; | |
} | |
function rotationIdentity(lambda, phi) { | |
return [lambda > pi$4 ? lambda - tau$4 : lambda < -pi$4 ? lambda + tau$4 : lambda, phi]; | |
} | |
rotationIdentity.invert = rotationIdentity; | |
function rotateRadians(deltaLambda, deltaPhi, deltaGamma) { | |
return (deltaLambda %= tau$4) ? (deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) | |
: rotationLambda(deltaLambda)) | |
: (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) | |
: rotationIdentity); | |
} | |
function forwardRotationLambda(deltaLambda) { | |
return function(lambda, phi) { | |
return lambda += deltaLambda, [lambda > pi$4 ? lambda - tau$4 : lambda < -pi$4 ? lambda + tau$4 : lambda, phi]; | |
}; | |
} | |
function rotationLambda(deltaLambda) { | |
var rotation = forwardRotationLambda(deltaLambda); | |
rotation.invert = forwardRotationLambda(-deltaLambda); | |
return rotation; | |
} | |
function rotationPhiGamma(deltaPhi, deltaGamma) { | |
var cosDeltaPhi = cos$1(deltaPhi), | |
sinDeltaPhi = sin$1(deltaPhi), | |
cosDeltaGamma = cos$1(deltaGamma), | |
sinDeltaGamma = sin$1(deltaGamma); | |
function rotation(lambda, phi) { | |
var cosPhi = cos$1(phi), | |
x = cos$1(lambda) * cosPhi, | |
y = sin$1(lambda) * cosPhi, | |
z = sin$1(phi), | |
k = z * cosDeltaPhi + x * sinDeltaPhi; | |
return [ | |
atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi), | |
asin$1(k * cosDeltaGamma + y * sinDeltaGamma) | |
]; | |
} | |
rotation.invert = function(lambda, phi) { | |
var cosPhi = cos$1(phi), | |
x = cos$1(lambda) * cosPhi, | |
y = sin$1(lambda) * cosPhi, | |
z = sin$1(phi), | |
k = z * cosDeltaGamma - y * sinDeltaGamma; | |
return [ | |
atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi), | |
asin$1(k * cosDeltaPhi - x * sinDeltaPhi) | |
]; | |
}; | |
return rotation; | |
} | |
function rotation(rotate) { | |
rotate = rotateRadians(rotate[0] * radians, rotate[1] * radians, rotate.length > 2 ? rotate[2] * radians : 0); | |
function forward(coordinates) { | |
coordinates = rotate(coordinates[0] * radians, coordinates[1] * radians); | |
return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates; | |
} | |
forward.invert = function(coordinates) { | |
coordinates = rotate.invert(coordinates[0] * radians, coordinates[1] * radians); | |
return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates; | |
}; | |
return forward; | |
} | |
// Generates a circle centered at [0°, 0°], with a given radius and precision. | |
function circleStream(stream, radius, delta, direction, t0, t1) { | |
if (!delta) return; | |
var cosRadius = cos$1(radius), | |
sinRadius = sin$1(radius), | |
step = direction * delta; | |
if (t0 == null) { | |
t0 = radius + direction * tau$4; | |
t1 = radius - step / 2; | |
} else { | |
t0 = circleRadius(cosRadius, t0); | |
t1 = circleRadius(cosRadius, t1); | |
if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * tau$4; | |
} | |
for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) { | |
point = spherical([cosRadius, -sinRadius * cos$1(t), -sinRadius * sin$1(t)]); | |
stream.point(point[0], point[1]); | |
} | |
} | |
// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0]. | |
function circleRadius(cosRadius, point) { | |
point = cartesian(point), point[0] -= cosRadius; | |
cartesianNormalizeInPlace(point); | |
var radius = acos(-point[1]); | |
return ((-point[2] < 0 ? -radius : radius) + tau$4 - epsilon$4) % tau$4; | |
} | |
function geoCircle() { | |
var center = constant$12([0, 0]), | |
radius = constant$12(90), | |
precision = constant$12(6), | |
ring, | |
rotate, | |
stream = {point: point}; | |
function point(x, y) { | |
ring.push(x = rotate(x, y)); | |
x[0] *= degrees$1, x[1] *= degrees$1; | |
} | |
function circle() { | |
var c = center.apply(this, arguments), | |
r = radius.apply(this, arguments) * radians, | |
p = precision.apply(this, arguments) * radians; | |
ring = []; | |
rotate = rotateRadians(-c[0] * radians, -c[1] * radians, 0).invert; | |
circleStream(stream, r, p, 1); | |
c = {type: "Polygon", coordinates: [ring]}; | |
ring = rotate = null; | |
return c; | |
} | |
circle.center = function(_) { | |
return arguments.length ? (center = typeof _ === "function" ? _ : constant$12([+_[0], +_[1]]), circle) : center; | |
}; | |
circle.radius = function(_) { | |
return arguments.length ? (radius = typeof _ === "function" ? _ : constant$12(+_), circle) : radius; | |
}; | |
circle.precision = function(_) { | |
return arguments.length ? (precision = typeof _ === "function" ? _ : constant$12(+_), circle) : precision; | |
}; | |
return circle; | |
} | |
function clipBuffer() { | |
var lines = [], | |
line; | |
return { | |
point: function(x, y) { | |
line.push([x, y]); | |
}, | |
lineStart: function() { | |
lines.push(line = []); | |
}, | |
lineEnd: noop$2, | |
rejoin: function() { | |
if (lines.length > 1) lines.push(lines.pop().concat(lines.shift())); | |
}, | |
result: function() { | |
var result = lines; | |
lines = []; | |
line = null; | |
return result; | |
} | |
}; | |
} | |
function clipLine(a, b, x0, y0, x1, y1) { | |
var ax = a[0], | |
ay = a[1], | |
bx = b[0], | |
by = b[1], | |
t0 = 0, | |
t1 = 1, | |
dx = bx - ax, | |
dy = by - ay, | |
r; | |
r = x0 - ax; | |
if (!dx && r > 0) return; | |
r /= dx; | |
if (dx < 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} else if (dx > 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} | |
r = x1 - ax; | |
if (!dx && r < 0) return; | |
r /= dx; | |
if (dx < 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} else if (dx > 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} | |
r = y0 - ay; | |
if (!dy && r > 0) return; | |
r /= dy; | |
if (dy < 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} else if (dy > 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} | |
r = y1 - ay; | |
if (!dy && r < 0) return; | |
r /= dy; | |
if (dy < 0) { | |
if (r > t1) return; | |
if (r > t0) t0 = r; | |
} else if (dy > 0) { | |
if (r < t0) return; | |
if (r < t1) t1 = r; | |
} | |
if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy; | |
if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy; | |
return true; | |
} | |
function pointEqual(a, b) { | |
return abs(a[0] - b[0]) < epsilon$4 && abs(a[1] - b[1]) < epsilon$4; | |
} | |
function Intersection(point, points, other, entry) { | |
this.x = point; | |
this.z = points; | |
this.o = other; // another intersection | |
this.e = entry; // is an entry? | |
this.v = false; // visited | |
this.n = this.p = null; // next & previous | |
} | |
// A generalized polygon clipping algorithm: given a polygon that has been cut | |
// into its visible line segments, and rejoins the segments by interpolating | |
// along the clip edge. | |
function clipPolygon(segments, compareIntersection, startInside, interpolate, stream) { | |
var subject = [], | |
clip = [], | |
i, | |
n; | |
segments.forEach(function(segment) { | |
if ((n = segment.length - 1) <= 0) return; | |
var n, p0 = segment[0], p1 = segment[n], x; | |
// If the first and last points of a segment are coincident, then treat as a | |
// closed ring. TODO if all rings are closed, then the winding order of the | |
// exterior ring should be checked. | |
if (pointEqual(p0, p1)) { | |
stream.lineStart(); | |
for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]); | |
stream.lineEnd(); | |
return; | |
} | |
subject.push(x = new Intersection(p0, segment, null, true)); | |
clip.push(x.o = new Intersection(p0, null, x, false)); | |
subject.push(x = new Intersection(p1, segment, null, false)); | |
clip.push(x.o = new Intersection(p1, null, x, true)); | |
}); | |
if (!subject.length) return; | |
clip.sort(compareIntersection); | |
link$1(subject); | |
link$1(clip); | |
for (i = 0, n = clip.length; i < n; ++i) { | |
clip[i].e = startInside = !startInside; | |
} | |
var start = subject[0], | |
points, | |
point; | |
while (1) { | |
// Find first unvisited intersection. | |
var current = start, | |
isSubject = true; | |
while (current.v) if ((current = current.n) === start) return; | |
points = current.z; | |
stream.lineStart(); | |
do { | |
current.v = current.o.v = true; | |
if (current.e) { | |
if (isSubject) { | |
for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]); | |
} else { | |
interpolate(current.x, current.n.x, 1, stream); | |
} | |
current = current.n; | |
} else { | |
if (isSubject) { | |
points = current.p.z; | |
for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]); | |
} else { | |
interpolate(current.x, current.p.x, -1, stream); | |
} | |
current = current.p; | |
} | |
current = current.o; | |
points = current.z; | |
isSubject = !isSubject; | |
} while (!current.v); | |
stream.lineEnd(); | |
} | |
} | |
function link$1(array) { | |
if (!(n = array.length)) return; | |
var n, | |
i = 0, | |
a = array[0], | |
b; | |
while (++i < n) { | |
a.n = b = array[i]; | |
b.p = a; | |
a = b; | |
} | |
a.n = b = array[0]; | |
b.p = a; | |
} | |
var clipMax = 1e9; | |
var clipMin = -clipMax; | |
// TODO Use d3-polygon’s polygonContains here for the ring check? | |
// TODO Eliminate duplicate buffering in clipBuffer and polygon.push? | |
function clipExtent(x0, y0, x1, y1) { | |
function visible(x, y) { | |
return x0 <= x && x <= x1 && y0 <= y && y <= y1; | |
} | |
function interpolate(from, to, direction, stream) { | |
var a = 0, a1 = 0; | |
if (from == null | |
|| (a = corner(from, direction)) !== (a1 = corner(to, direction)) | |
|| comparePoint(from, to) < 0 ^ direction > 0) { | |
do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0); | |
while ((a = (a + direction + 4) % 4) !== a1); | |
} else { | |
stream.point(to[0], to[1]); | |
} | |
} | |
function corner(p, direction) { | |
return abs(p[0] - x0) < epsilon$4 ? direction > 0 ? 0 : 3 | |
: abs(p[0] - x1) < epsilon$4 ? direction > 0 ? 2 : 1 | |
: abs(p[1] - y0) < epsilon$4 ? direction > 0 ? 1 : 0 | |
: direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon | |
} | |
function compareIntersection(a, b) { | |
return comparePoint(a.x, b.x); | |
} | |
function comparePoint(a, b) { | |
var ca = corner(a, 1), | |
cb = corner(b, 1); | |
return ca !== cb ? ca - cb | |
: ca === 0 ? b[1] - a[1] | |
: ca === 1 ? a[0] - b[0] | |
: ca === 2 ? a[1] - b[1] | |
: b[0] - a[0]; | |
} | |
return function(stream) { | |
var activeStream = stream, | |
bufferStream = clipBuffer(), | |
segments, | |
polygon, | |
ring, | |
x__, y__, v__, // first point | |
x_, y_, v_, // previous point | |
first, | |
clean; | |
var clipStream = { | |
point: point, | |
lineStart: lineStart, | |
lineEnd: lineEnd, | |
polygonStart: polygonStart, | |
polygonEnd: polygonEnd | |
}; | |
function point(x, y) { | |
if (visible(x, y)) activeStream.point(x, y); | |
} | |
function polygonInside() { | |
var winding = 0; | |
for (var i = 0, n = polygon.length; i < n; ++i) { | |
for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) { | |
a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1]; | |
if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; } | |
else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; } | |
} | |
} | |
return winding; | |
} | |
// Buffer geometry within a polygon and then clip it en masse. | |
function polygonStart() { | |
activeStream = bufferStream, segments = [], polygon = [], clean = true; | |
} | |
function polygonEnd() { | |
var startInside = polygonInside(), | |
cleanInside = clean && startInside, | |
visible = (segments = merge(segments)).length; | |
if (cleanInside || visible) { | |
stream.polygonStart(); | |
if (cleanInside) { | |
stream.lineStart(); | |
interpolate(null, null, 1, stream); | |
stream.lineEnd(); | |
} | |
if (visible) { | |
clipPolygon(segments, compareIntersection, startInside, interpolate, stream); | |
} | |
stream.polygonEnd(); | |
} | |
activeStream = stream, segments = polygon = ring = null; | |
} | |
function lineStart() { | |
clipStream.point = linePoint; | |
if (polygon) polygon.push(ring = []); | |
first = true; | |
v_ = false; | |
x_ = y_ = NaN; | |
} | |
// TODO rather than special-case polygons, simply handle them separately. | |
// Ideally, coincident intersection points should be jittered to avoid | |
// clipping issues. | |
function lineEnd() { | |
if (segments) { | |
linePoint(x__, y__); | |
if (v__ && v_) bufferStream.rejoin(); | |
segments.push(bufferStream.result()); | |
} | |
clipStream.point = point; | |
if (v_) activeStream.lineEnd(); | |
} | |
function linePoint(x, y) { | |
var v = visible(x, y); | |
if (polygon) ring.push([x, y]); | |
if (first) { | |
x__ = x, y__ = y, v__ = v; | |
first = false; | |
if (v) { | |
activeStream.lineStart(); | |
activeStream.point(x, y); | |
} | |
} else { | |
if (v && v_) activeStream.point(x, y); | |
else { | |
var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))], | |
b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))]; | |
if (clipLine(a, b, x0, y0, x1, y1)) { | |
if (!v_) { | |
activeStream.lineStart(); | |
activeStream.point(a[0], a[1]); | |
} | |
activeStream.point(b[0], b[1]); | |
if (!v) activeStream.lineEnd(); | |
clean = false; | |
} else if (v) { | |
activeStream.lineStart(); | |
activeStream.point(x, y); | |
clean = false; | |
} | |
} | |
} | |
x_ = x, y_ = y, v_ = v; | |
} | |
return clipStream; | |
}; | |
} | |
function extent$1() { | |
var x0 = 0, | |
y0 = 0, | |
x1 = 960, | |
y1 = 500, | |
cache, | |
cacheStream, | |
clip; | |
return clip = { | |
stream: function(stream) { | |
return cache && cacheStream === stream ? cache : cache = clipExtent(x0, y0, x1, y1)(cacheStream = stream); | |
}, | |
extent: function(_) { | |
return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]]; | |
} | |
}; | |
} | |
var lengthSum = adder(); | |
var lambda0$2; | |
var sinPhi0$1; | |
var cosPhi0$1; | |
var lengthStream = { | |
sphere: noop$2, | |
point: noop$2, | |
lineStart: lengthLineStart, | |
lineEnd: noop$2, | |
polygonStart: noop$2, | |
polygonEnd: noop$2 | |
}; | |
function lengthLineStart() { | |
lengthStream.point = lengthPointFirst; | |
lengthStream.lineEnd = lengthLineEnd; | |
} | |
function lengthLineEnd() { | |
lengthStream.point = lengthStream.lineEnd = noop$2; | |
} | |
function lengthPointFirst(lambda, phi) { | |
lambda *= radians, phi *= radians; | |
lambda0$2 = lambda, sinPhi0$1 = sin$1(phi), cosPhi0$1 = cos$1(phi); | |
lengthStream.point = lengthPoint; | |
} | |
function lengthPoint(lambda, phi) { | |
lambda *= radians, phi *= radians; | |
var sinPhi = sin$1(phi), | |
cosPhi = cos$1(phi), | |
delta = abs(lambda - lambda0$2), | |
cosDelta = cos$1(delta), | |
sinDelta = sin$1(delta), | |
x = cosPhi * sinDelta, | |
y = cosPhi0$1 * sinPhi - sinPhi0$1 * cosPhi * cosDelta, | |
z = sinPhi0$1 * sinPhi + cosPhi0$1 * cosPhi * cosDelta; | |
lengthSum.add(atan2(sqrt$1(x * x + y * y), z)); | |
lambda0$2 = lambda, sinPhi0$1 = sinPhi, cosPhi0$1 = cosPhi; | |
} | |
function length$2(object) { | |
lengthSum.reset(); | |
geoStream(object, lengthStream); | |
return +lengthSum; | |
} | |
var coordinates = [null, null]; | |
var object$1 = {type: "LineString", coordinates: coordinates}; | |
function distance(a, b) { | |
coordinates[0] = a; | |
coordinates[1] = b; | |
return length$2(object$1); | |
} | |
function graticuleX(y0, y1, dy) { | |
var y = range(y0, y1 - epsilon$4, dy).concat(y1); | |
return function(x) { return y.map(function(y) { return [x, y]; }); }; | |
} | |
function graticuleY(x0, x1, dx) { | |
var x = range(x0, x1 - epsilon$4, dx).concat(x1); | |
return function(y) { return x.map(function(x) { return [x, y]; }); }; | |
} | |
function graticule() { | |
var x1, x0, X1, X0, | |
y1, y0, Y1, Y0, | |
dx = 10, dy = dx, DX = 90, DY = 360, | |
x, y, X, Y, | |
precision = 2.5; | |
function graticule() { | |
return {type: "MultiLineString", coordinates: lines()}; | |
} | |
function lines() { | |
return range(ceil(X0 / DX) * DX, X1, DX).map(X) | |
.concat(range(ceil(Y0 / DY) * DY, Y1, DY).map(Y)) | |
.concat(range(ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return abs(x % DX) > epsilon$4; }).map(x)) | |
.concat(range(ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return abs(y % DY) > epsilon$4; }).map(y)); | |
} | |
graticule.lines = function() { | |
return lines().map(function(coordinates) { return {type: "LineString", coordinates: coordinates}; }); | |
}; | |
graticule.outline = function() { | |
return { | |
type: "Polygon", | |
coordinates: [ | |
X(X0).concat( | |
Y(Y1).slice(1), | |
X(X1).reverse().slice(1), | |
Y(Y0).reverse().slice(1)) | |
] | |
}; | |
}; | |
graticule.extent = function(_) { | |
if (!arguments.length) return graticule.extentMinor(); | |
return graticule.extentMajor(_).extentMinor(_); | |
}; | |
graticule.extentMajor = function(_) { | |
if (!arguments.length) return [[X0, Y0], [X1, Y1]]; | |
X0 = +_[0][0], X1 = +_[1][0]; | |
Y0 = +_[0][1], Y1 = +_[1][1]; | |
if (X0 > X1) _ = X0, X0 = X1, X1 = _; | |
if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _; | |
return graticule.precision(precision); | |
}; | |
graticule.extentMinor = function(_) { | |
if (!arguments.length) return [[x0, y0], [x1, y1]]; | |
x0 = +_[0][0], x1 = +_[1][0]; | |
y0 = +_[0][1], y1 = +_[1][1]; | |
if (x0 > x1) _ = x0, x0 = x1, x1 = _; | |
if (y0 > y1) _ = y0, y0 = y1, y1 = _; | |
return graticule.precision(precision); | |
}; | |
graticule.step = function(_) { | |
if (!arguments.length) return graticule.stepMinor(); | |
return graticule.stepMajor(_).stepMinor(_); | |
}; | |
graticule.stepMajor = function(_) { | |
if (!arguments.length) return [DX, DY]; | |
DX = +_[0], DY = +_[1]; | |
return graticule; | |
}; | |
graticule.stepMinor = function(_) { | |
if (!arguments.length) return [dx, dy]; | |
dx = +_[0], dy = +_[1]; | |
return graticule; | |
}; | |
graticule.precision = function(_) { | |
if (!arguments.length) return precision; | |
precision = +_; | |
x = graticuleX(y0, y1, 90); | |
y = graticuleY(x0, x1, precision); | |
X = graticuleX(Y0, Y1, 90); | |
Y = graticuleY(X0, X1, precision); | |
return graticule; | |
}; | |
return graticule | |
.extentMajor([[-180, -90 + epsilon$4], [180, 90 - epsilon$4]]) | |
.extentMinor([[-180, -80 - epsilon$4], [180, 80 + epsilon$4]]); | |
} | |
function graticule10() { | |
return graticule()(); | |
} | |
function interpolate$2(a, b) { | |
var x0 = a[0] * radians, | |
y0 = a[1] * radians, | |
x1 = b[0] * radians, | |
y1 = b[1] * radians, | |
cy0 = cos$1(y0), | |
sy0 = sin$1(y0), | |
cy1 = cos$1(y1), | |
sy1 = sin$1(y1), | |
kx0 = cy0 * cos$1(x0), | |
ky0 = cy0 * sin$1(x0), | |
kx1 = cy1 * cos$1(x1), | |
ky1 = cy1 * sin$1(x1), | |
d = 2 * asin$1(sqrt$1(haversin(y1 - y0) + cy0 * cy1 * haversin(x1 - x0))), | |
k = sin$1(d); | |
var interpolate = d ? function(t) { | |
var B = sin$1(t *= d) / k, | |
A = sin$1(d - t) / k, | |
x = A * kx0 + B * kx1, | |
y = A * ky0 + B * ky1, | |
z = A * sy0 + B * sy1; | |
return [ | |
atan2(y, x) * degrees$1, | |
atan2(z, sqrt$1(x * x + y * y)) * degrees$1 | |
]; | |
} : function() { | |
return [x0 * degrees$1, y0 * degrees$1]; | |
}; | |
interpolate.distance = d; | |
return interpolate; | |
} | |
function identity$7(x) { | |
return x; | |
} | |
var areaSum$1 = adder(); | |
var areaRingSum$1 = adder(); | |
var x00; | |
var y00; | |
var x0$1; | |
var y0$1; | |
var areaStream$1 = { | |
point: noop$2, | |
lineStart: noop$2, | |
lineEnd: noop$2, | |
polygonStart: function() { | |
areaStream$1.lineStart = areaRingStart$1; | |
areaStream$1.lineEnd = areaRingEnd$1; | |
}, | |
polygonEnd: function() { | |
areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$2; | |
areaSum$1.add(abs(areaRingSum$1)); | |
areaRingSum$1.reset(); | |
}, | |
result: function() { | |
var area = areaSum$1 / 2; | |
areaSum$1.reset(); | |
return area; | |
} | |
}; | |
function areaRingStart$1() { | |
areaStream$1.point = areaPointFirst$1; | |
} | |
function areaPointFirst$1(x, y) { | |
areaStream$1.point = areaPoint$1; | |
x00 = x0$1 = x, y00 = y0$1 = y; | |
} | |
function areaPoint$1(x, y) { | |
areaRingSum$1.add(y0$1 * x - x0$1 * y); | |
x0$1 = x, y0$1 = y; | |
} | |
function areaRingEnd$1() { | |
areaPoint$1(x00, y00); | |
} | |
var x0$2 = Infinity; | |
var y0$2 = x0$2; | |
var x1 = -x0$2; | |
var y1 = x1; | |
var boundsStream$1 = { | |
point: boundsPoint$1, | |
lineStart: noop$2, | |
lineEnd: noop$2, | |
polygonStart: noop$2, | |
polygonEnd: noop$2, | |
result: function() { | |
var bounds = [[x0$2, y0$2], [x1, y1]]; | |
x1 = y1 = -(y0$2 = x0$2 = Infinity); | |
return bounds; | |
} | |
}; | |
function boundsPoint$1(x, y) { | |
if (x < x0$2) x0$2 = x; | |
if (x > x1) x1 = x; | |
if (y < y0$2) y0$2 = y; | |
if (y > y1) y1 = y; | |
} | |
var X0$1 = 0; | |
var Y0$1 = 0; | |
var Z0$1 = 0; | |
var X1$1 = 0; | |
var Y1$1 = 0; | |
var Z1$1 = 0; | |
var X2$1 = 0; | |
var Y2$1 = 0; | |
var Z2$1 = 0; | |
var x00$1; | |
var y00$1; | |
var x0$3; | |
var y0$3; | |
var centroidStream$1 = { | |
point: centroidPoint$1, | |
lineStart: centroidLineStart$1, | |
lineEnd: centroidLineEnd$1, | |
polygonStart: function() { | |
centroidStream$1.lineStart = centroidRingStart$1; | |
centroidStream$1.lineEnd = centroidRingEnd$1; | |
}, | |
polygonEnd: function() { | |
centroidStream$1.point = centroidPoint$1; | |
centroidStream$1.lineStart = centroidLineStart$1; | |
centroidStream$1.lineEnd = centroidLineEnd$1; | |
}, | |
result: function() { | |
var centroid = Z2$1 ? [X2$1 / Z2$1, Y2$1 / Z2$1] | |
: Z1$1 ? [X1$1 / Z1$1, Y1$1 / Z1$1] | |
: Z0$1 ? [X0$1 / Z0$1, Y0$1 / Z0$1] | |
: [NaN, NaN]; | |
X0$1 = Y0$1 = Z0$1 = | |
X1$1 = Y1$1 = Z1$1 = | |
X2$1 = Y2$1 = Z2$1 = 0; | |
return centroid; | |
} | |
}; | |
function centroidPoint$1(x, y) { | |
X0$1 += x; | |
Y0$1 += y; | |
++Z0$1; | |
} | |
function centroidLineStart$1() { | |
centroidStream$1.point = centroidPointFirstLine; | |
} | |
function centroidPointFirstLine(x, y) { | |
centroidStream$1.point = centroidPointLine; | |
centroidPoint$1(x0$3 = x, y0$3 = y); | |
} | |
function centroidPointLine(x, y) { | |
var dx = x - x0$3, dy = y - y0$3, z = sqrt$1(dx * dx + dy * dy); | |
X1$1 += z * (x0$3 + x) / 2; | |
Y1$1 += z * (y0$3 + y) / 2; | |
Z1$1 += z; | |
centroidPoint$1(x0$3 = x, y0$3 = y); | |
} | |
function centroidLineEnd$1() { | |
centroidStream$1.point = centroidPoint$1; | |
} | |
function centroidRingStart$1() { | |
centroidStream$1.point = centroidPointFirstRing; | |
} | |
function centroidRingEnd$1() { | |
centroidPointRing(x00$1, y00$1); | |
} | |
function centroidPointFirstRing(x, y) { | |
centroidStream$1.point = centroidPointRing; | |
centroidPoint$1(x00$1 = x0$3 = x, y00$1 = y0$3 = y); | |
} | |
function centroidPointRing(x, y) { | |
var dx = x - x0$3, | |
dy = y - y0$3, | |
z = sqrt$1(dx * dx + dy * dy); | |
X1$1 += z * (x0$3 + x) / 2; | |
Y1$1 += z * (y0$3 + y) / 2; | |
Z1$1 += z; | |
z = y0$3 * x - x0$3 * y; | |
X2$1 += z * (x0$3 + x); | |
Y2$1 += z * (y0$3 + y); | |
Z2$1 += z * 3; | |
centroidPoint$1(x0$3 = x, y0$3 = y); | |
} | |
function PathContext(context) { | |
this._context = context; | |
} | |
PathContext.prototype = { | |
_radius: 4.5, | |
pointRadius: function(_) { | |
return this._radius = _, this; | |
}, | |
polygonStart: function() { | |
this._line = 0; | |
}, | |
polygonEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (this._line === 0) this._context.closePath(); | |
this._point = NaN; | |
}, | |
point: function(x, y) { | |
switch (this._point) { | |
case 0: { | |
this._context.moveTo(x, y); | |
this._point = 1; | |
break; | |
} | |
case 1: { | |
this._context.lineTo(x, y); | |
break; | |
} | |
default: { | |
this._context.moveTo(x + this._radius, y); | |
this._context.arc(x, y, this._radius, 0, tau$4); | |
break; | |
} | |
} | |
}, | |
result: noop$2 | |
}; | |
function PathString() { | |
this._string = []; | |
} | |
PathString.prototype = { | |
_circle: circle$1(4.5), | |
pointRadius: function(_) { | |
return this._circle = circle$1(_), this; | |
}, | |
polygonStart: function() { | |
this._line = 0; | |
}, | |
polygonEnd: function() { | |
this._line = NaN; | |
}, | |
lineStart: function() { | |
this._point = 0; | |
}, | |
lineEnd: function() { | |
if (this._line === 0) this._string.push("Z"); | |
this._point = NaN; | |
}, | |
point: function(x, y) { | |
switch (this._point) { | |
case 0: { | |
this._string.push("M", x, ",", y); | |
this._point = 1; | |
break; | |
} | |
case 1: { | |
this._string.push("L", x, ",", y); | |
break; | |
} | |
default: { | |
this._string.push("M", x, ",", y, this._circle); | |
break; | |
} | |
} | |
}, | |
result: function() { | |
if (this._string.length) { | |
var result = this._string.join(""); | |
this._string = []; | |
return result; | |
} | |
} | |
}; | |
function circle$1(radius) { | |
return "m0," + radius | |
+ "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius | |
+ "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius | |
+ "z"; | |
} | |
function index$3(projection, context) { | |
var pointRadius = 4.5, | |
projectionStream, | |
contextStream; | |
function path(object) { | |
if (object) { | |
if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments)); | |
geoStream(object, projectionStream(contextStream)); | |
} | |
return contextStream.result(); | |
} | |
path.area = function(object) { | |
geoStream(object, projectionStream(areaStream$1)); | |
return areaStream$1.result(); | |
}; | |
path.bounds = function(object) { | |
geoStream(object, projectionStream(boundsStream$1)); | |
return boundsStream$1.result(); | |
}; | |
path.centroid = function(object) { | |
geoStream(object, projectionStream(centroidStream$1)); | |
return centroidStream$1.result(); | |
}; | |
path.projection = function(_) { | |
return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$7) : (projection = _).stream, path) : projection; | |
}; | |
path.context = function(_) { | |
if (!arguments.length) return context; | |
contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _); | |
if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius); | |
return path; | |
}; | |
path.pointRadius = function(_) { | |
if (!arguments.length) return pointRadius; | |
pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_); | |
return path; | |
}; | |
return path.projection(projection).context(context); | |
} | |
var sum$2 = adder(); | |
function polygonContains(polygon, point) { | |
var lambda = point[0], | |
phi = point[1], | |
normal = [sin$1(lambda), -cos$1(lambda), 0], | |
angle = 0, | |
winding = 0; | |
sum$2.reset(); | |
for (var i = 0, n = polygon.length; i < n; ++i) { | |
if (!(m = (ring = polygon[i]).length)) continue; | |
var ring, | |
m, | |
point0 = ring[m - 1], | |
lambda0 = point0[0], | |
phi0 = point0[1] / 2 + quarterPi, | |
sinPhi0 = sin$1(phi0), | |
cosPhi0 = cos$1(phi0); | |
for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) { | |
var point1 = ring[j], | |
lambda1 = point1[0], | |
phi1 = point1[1] / 2 + quarterPi, | |
sinPhi1 = sin$1(phi1), | |
cosPhi1 = cos$1(phi1), | |
delta = lambda1 - lambda0, | |
sign = delta >= 0 ? 1 : -1, | |
absDelta = sign * delta, | |
antimeridian = absDelta > pi$4, | |
k = sinPhi0 * sinPhi1; | |
sum$2.add(atan2(k * sign * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta))); | |
angle += antimeridian ? delta + sign * tau$4 : delta; | |
// Are the longitudes either side of the point’s meridian (lambda), | |
// and are the latitudes smaller than the parallel (phi)? | |
if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) { | |
var arc = cartesianCross(cartesian(point0), cartesian(point1)); | |
cartesianNormalizeInPlace(arc); | |
var intersection = cartesianCross(normal, arc); | |
cartesianNormalizeInPlace(intersection); | |
var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin$1(intersection[2]); | |
if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) { | |
winding += antimeridian ^ delta >= 0 ? 1 : -1; | |
} | |
} | |
} | |
} | |
// First, determine whether the South pole is inside or outside: | |
// | |
// It is inside if: | |
// * the polygon winds around it in a clockwise direction. | |
// * the polygon does not (cumulatively) wind around it, but has a negative | |
// (counter-clockwise) area. | |
// | |
// Second, count the (signed) number of times a segment crosses a lambda | |
// from the point to the South pole. If it is zero, then the point is the | |
// same side as the South pole. | |
return (angle < -epsilon$4 || angle < epsilon$4 && sum$2 < -epsilon$4) ^ (winding & 1); | |
} | |
function clip(pointVisible, clipLine, interpolate, start) { | |
return function(rotate, sink) { | |
var line = clipLine(sink), | |
rotatedStart = rotate.invert(start[0], start[1]), | |
ringBuffer = clipBuffer(), | |
ringSink = clipLine(ringBuffer), | |
polygonStarted = false, | |
polygon, | |
segments, | |
ring; | |
var clip = { | |
point: point, | |
lineStart: lineStart, | |
lineEnd: lineEnd, | |
polygonStart: function() { | |
clip.point = pointRing; | |
clip.lineStart = ringStart; | |
clip.lineEnd = ringEnd; | |
segments = []; | |
polygon = []; | |
}, | |
polygonEnd: function() { | |
clip.point = point; | |
clip.lineStart = lineStart; | |
clip.lineEnd = lineEnd; | |
segments = merge(segments); | |
var startInside = polygonContains(polygon, rotatedStart); | |
if (segments.length) { | |
if (!polygonStarted) sink.polygonStart(), polygonStarted = true; | |
clipPolygon(segments, compareIntersection, startInside, interpolate, sink); | |
} else if (startInside) { | |
if (!polygonStarted) sink.polygonStart(), polygonStarted = true; | |
sink.lineStart(); | |
interpolate(null, null, 1, sink); | |
sink.lineEnd(); | |
} | |
if (polygonStarted) sink.polygonEnd(), polygonStarted = false; | |
segments = polygon = null; | |
}, | |
sphere: function() { | |
sink.polygonStart(); | |
sink.lineStart(); | |
interpolate(null, null, 1, sink); | |
sink.lineEnd(); | |
sink.polygonEnd(); | |
} | |
}; | |
function point(lambda, phi) { | |
var point = rotate(lambda, phi); | |
if (pointVisible(lambda = point[0], phi = point[1])) sink.point(lambda, phi); | |
} | |
function pointLine(lambda, phi) { | |
var point = rotate(lambda, phi); | |
line.point(point[0], point[1]); | |
} | |
function lineStart() { | |
clip.point = pointLine; | |
line.lineStart(); | |
} | |
function lineEnd() { | |
clip.point = point; | |
line.lineEnd(); | |
} | |
function pointRing(lambda, phi) { | |
ring.push([lambda, phi]); | |
var point = rotate(lambda, phi); | |
ringSink.point(point[0], point[1]); | |
} | |
function ringStart() { | |
ringSink.lineStart(); | |
ring = []; | |
} | |
function ringEnd() { | |
pointRing(ring[0][0], ring[0][1]); | |
ringSink.lineEnd(); | |
var clean = ringSink.clean(), | |
ringSegments = ringBuffer.result(), | |
i, n = ringSegments.length, m, | |
segment, | |
point; | |
ring.pop(); | |
polygon.push(ring); | |
ring = null; | |
if (!n) return; | |
// No intersections. | |
if (clean & 1) { | |
segment = ringSegments[0]; | |
if ((m = segment.length - 1) > 0) { | |
if (!polygonStarted) sink.polygonStart(), polygonStarted = true; | |
sink.lineStart(); | |
for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]); | |
sink.lineEnd(); | |
} | |
return; | |
} | |
// Rejoin connected segments. | |
// TODO reuse ringBuffer.rejoin()? | |
if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift())); | |
segments.push(ringSegments.filter(validSegment)); | |
} | |
return clip; | |
}; | |
} | |
function validSegment(segment) { | |
return segment.length > 1; | |
} | |
// Intersections are sorted along the clip edge. For both antimeridian cutting | |
// and circle clipping, the same comparison is used. | |
function compareIntersection(a, b) { | |
return ((a = a.x)[0] < 0 ? a[1] - halfPi$3 - epsilon$4 : halfPi$3 - a[1]) | |
- ((b = b.x)[0] < 0 ? b[1] - halfPi$3 - epsilon$4 : halfPi$3 - b[1]); | |
} | |
var clipAntimeridian = clip( | |
function() { return true; }, | |
clipAntimeridianLine, | |
clipAntimeridianInterpolate, | |
[-pi$4, -halfPi$3] | |
); | |
// Takes a line and cuts into visible segments. Return values: 0 - there were | |
// intersections or the line was empty; 1 - no intersections; 2 - there were | |
// intersections, and the first and last segments should be rejoined. | |
function clipAntimeridianLine(stream) { | |
var lambda0 = NaN, | |
phi0 = NaN, | |
sign0 = NaN, | |
clean; // no intersections | |
return { | |
lineStart: function() { | |
stream.lineStart(); | |
clean = 1; | |
}, | |
point: function(lambda1, phi1) { | |
var sign1 = lambda1 > 0 ? pi$4 : -pi$4, | |
delta = abs(lambda1 - lambda0); | |
if (abs(delta - pi$4) < epsilon$4) { // line crosses a pole | |
stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$3 : -halfPi$3); | |
stream.point(sign0, phi0); | |
stream.lineEnd(); | |
stream.lineStart(); | |
stream.point(sign1, phi0); | |
stream.point(lambda1, phi0); | |
clean = 0; | |
} else if (sign0 !== sign1 && delta >= pi$4) { // line crosses antimeridian | |
if (abs(lambda0 - sign0) < epsilon$4) lambda0 -= sign0 * epsilon$4; // handle degeneracies | |
if (abs(lambda1 - sign1) < epsilon$4) lambda1 -= sign1 * epsilon$4; | |
phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1); | |
stream.point(sign0, phi0); | |
stream.lineEnd(); | |
stream.lineStart(); | |
stream.point(sign1, phi0); | |
clean = 0; | |
} | |
stream.point(lambda0 = lambda1, phi0 = phi1); | |
sign0 = sign1; | |
}, | |
lineEnd: function() { | |
stream.lineEnd(); | |
lambda0 = phi0 = NaN; | |
}, | |
clean: function() { | |
return 2 - clean; // if intersections, rejoin first and last segments | |
} | |
}; | |
} | |
function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) { | |
var cosPhi0, | |
cosPhi1, | |
sinLambda0Lambda1 = sin$1(lambda0 - lambda1); | |
return abs(sinLambda0Lambda1) > epsilon$4 | |
? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1) | |
- sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0)) | |
/ (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) | |
: (phi0 + phi1) / 2; | |
} | |
function clipAntimeridianInterpolate(from, to, direction, stream) { | |
var phi; | |
if (from == null) { | |
phi = direction * halfPi$3; | |
stream.point(-pi$4, phi); | |
stream.point(0, phi); | |
stream.point(pi$4, phi); | |
stream.point(pi$4, 0); | |
stream.point(pi$4, -phi); | |
stream.point(0, -phi); | |
stream.point(-pi$4, -phi); | |
stream.point(-pi$4, 0); | |
stream.point(-pi$4, phi); | |
} else if (abs(from[0] - to[0]) > epsilon$4) { | |
var lambda = from[0] < to[0] ? pi$4 : -pi$4; | |
phi = direction * lambda / 2; | |
stream.point(-lambda, phi); | |
stream.point(0, phi); | |
stream.point(lambda, phi); | |
} else { | |
stream.point(to[0], to[1]); | |
} | |
} | |
function clipCircle(radius, delta) { | |
var cr = cos$1(radius), | |
smallRadius = cr > 0, | |
notHemisphere = abs(cr) > epsilon$4; // TODO optimise for this common case | |
function interpolate(from, to, direction, stream) { | |
circleStream(stream, radius, delta, direction, from, to); | |
} | |
function visible(lambda, phi) { | |
return cos$1(lambda) * cos$1(phi) > cr; | |
} | |
// Takes a line and cuts into visible segments. Return values used for polygon | |
// clipping: 0 - there were intersections or the line was empty; 1 - no | |
// intersections 2 - there were intersections, and the first and last segments | |
// should be rejoined. | |
function clipLine(stream) { | |
var point0, // previous point | |
c0, // code for previous point | |
v0, // visibility of previous point | |
v00, // visibility of first point | |
clean; // no intersections | |
return { | |
lineStart: function() { | |
v00 = v0 = false; | |
clean = 1; | |
}, | |
point: function(lambda, phi) { | |
var point1 = [lambda, phi], | |
point2, | |
v = visible(lambda, phi), | |
c = smallRadius | |
? v ? 0 : code(lambda, phi) | |
: v ? code(lambda + (lambda < 0 ? pi$4 : -pi$4), phi) : 0; | |
if (!point0 && (v00 = v0 = v)) stream.lineStart(); | |
// Handle degeneracies. | |
// TODO ignore if not clipping polygons. | |
if (v !== v0) { | |
point2 = intersect(point0, point1); | |
if (pointEqual(point0, point2) || pointEqual(point1, point2)) { | |
point1[0] += epsilon$4; | |
point1[1] += epsilon$4; | |
v = visible(point1[0], point1[1]); | |
} | |
} | |
if (v !== v0) { | |
clean = 0; | |
if (v) { | |
// outside going in | |
stream.lineStart(); | |
point2 = intersect(point1, point0); | |
stream.point(point2[0], point2[1]); | |
} else { | |
// inside going out | |
point2 = intersect(point0, point1); | |
stream.point(point2[0], point2[1]); | |
stream.lineEnd(); | |
} | |
point0 = point2; | |
} else if (notHemisphere && point0 && smallRadius ^ v) { | |
var t; | |
// If the codes for two points are different, or are both zero, | |
// and there this segment intersects with the small circle. | |
if (!(c & c0) && (t = intersect(point1, point0, true))) { | |
clean = 0; | |
if (smallRadius) { | |
stream.lineStart(); | |
stream.point(t[0][0], t[0][1]); | |
stream.point(t[1][0], t[1][1]); | |
stream.lineEnd(); | |
} else { | |
stream.point(t[1][0], t[1][1]); | |
stream.lineEnd(); | |
stream.lineStart(); | |
stream.point(t[0][0], t[0][1]); | |
} | |
} | |
} | |
if (v && (!point0 || !pointEqual(point0, point1))) { | |
stream.point(point1[0], point1[1]); | |
} | |
point0 = point1, v0 = v, c0 = c; | |
}, | |
lineEnd: function() { | |
if (v0) stream.lineEnd(); | |
point0 = null; | |
}, | |
// Rejoin first and last segments if there were intersections and the first | |
// and last points were visible. | |
clean: function() { | |
return clean | ((v00 && v0) << 1); | |
} | |
}; | |
} | |
// Intersects the great circle between a and b with the clip circle. | |
function intersect(a, b, two) { | |
var pa = cartesian(a), | |
pb = cartesian(b); | |
// We have two planes, n1.p = d1 and n2.p = d2. | |
// Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2). | |
var n1 = [1, 0, 0], // normal | |
n2 = cartesianCross(pa, pb), | |
n2n2 = cartesianDot(n2, n2), | |
n1n2 = n2[0], // cartesianDot(n1, n2), | |
determinant = n2n2 - n1n2 * n1n2; | |
// Two polar points. | |
if (!determinant) return !two && a; | |
var c1 = cr * n2n2 / determinant, | |
c2 = -cr * n1n2 / determinant, | |
n1xn2 = cartesianCross(n1, n2), | |
A = cartesianScale(n1, c1), | |
B = cartesianScale(n2, c2); | |
cartesianAddInPlace(A, B); | |
// Solve |p(t)|^2 = 1. | |
var u = n1xn2, | |
w = cartesianDot(A, u), | |
uu = cartesianDot(u, u), | |
t2 = w * w - uu * (cartesianDot(A, A) - 1); | |
if (t2 < 0) return; | |
var t = sqrt$1(t2), | |
q = cartesianScale(u, (-w - t) / uu); | |
cartesianAddInPlace(q, A); | |
q = spherical(q); | |
if (!two) return q; | |
// Two intersection points. | |
var lambda0 = a[0], | |
lambda1 = b[0], | |
phi0 = a[1], | |
phi1 = b[1], | |
z; | |
if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z; | |
var delta = lambda1 - lambda0, | |
polar = abs(delta - pi$4) < epsilon$4, | |
meridian = polar || delta < epsilon$4; | |
if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z; | |
// Check that the first point is between a and b. | |
if (meridian | |
? polar | |
? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < epsilon$4 ? phi0 : phi1) | |
: phi0 <= q[1] && q[1] <= phi1 | |
: delta > pi$4 ^ (lambda0 <= q[0] && q[0] <= lambda1)) { | |
var q1 = cartesianScale(u, (-w + t) / uu); | |
cartesianAddInPlace(q1, A); | |
return [q, spherical(q1)]; | |
} | |
} | |
// Generates a 4-bit vector representing the location of a point relative to | |
// the small circle's bounding box. | |
function code(lambda, phi) { | |
var r = smallRadius ? radius : pi$4 - radius, | |
code = 0; | |
if (lambda < -r) code |= 1; // left | |
else if (lambda > r) code |= 2; // right | |
if (phi < -r) code |= 4; // below | |
else if (phi > r) code |= 8; // above | |
return code; | |
} | |
return clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi$4, radius - pi$4]); | |
} | |
function transform$1(methods) { | |
return { | |
stream: transformer(methods) | |
}; | |
} | |
function transformer(methods) { | |
return function(stream) { | |
var s = new TransformStream; | |
for (var key in methods) s[key] = methods[key]; | |
s.stream = stream; | |
return s; | |
}; | |
} | |
function TransformStream() {} | |
TransformStream.prototype = { | |
constructor: TransformStream, | |
point: function(x, y) { this.stream.point(x, y); }, | |
sphere: function() { this.stream.sphere(); }, | |
lineStart: function() { this.stream.lineStart(); }, | |
lineEnd: function() { this.stream.lineEnd(); }, | |
polygonStart: function() { this.stream.polygonStart(); }, | |
polygonEnd: function() { this.stream.polygonEnd(); } | |
}; | |
function fitExtent(projection, extent, object) { | |
var w = extent[1][0] - extent[0][0], | |
h = extent[1][1] - extent[0][1], | |
clip = projection.clipExtent && projection.clipExtent(); | |
projection | |
.scale(150) | |
.translate([0, 0]); | |
if (clip != null) projection.clipExtent(null); | |
geoStream(object, projection.stream(boundsStream$1)); | |
var b = boundsStream$1.result(), | |
k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])), | |
x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2, | |
y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2; | |
if (clip != null) projection.clipExtent(clip); | |
return projection | |
.scale(k * 150) | |
.translate([x, y]); | |
} | |
function fitSize(projection, size, object) { | |
return fitExtent(projection, [[0, 0], size], object); | |
} | |
var maxDepth = 16; | |
var cosMinDistance = cos$1(30 * radians); | |
// cos(minimum angular distance) | |
function resample(project, delta2) { | |
return +delta2 ? resample$1(project, delta2) : resampleNone(project); | |
} | |
function resampleNone(project) { | |
return transformer({ | |
point: function(x, y) { | |
x = project(x, y); | |
this.stream.point(x[0], x[1]); | |
} | |
}); | |
} | |
function resample$1(project, delta2) { | |
function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) { | |
var dx = x1 - x0, | |
dy = y1 - y0, | |
d2 = dx * dx + dy * dy; | |
if (d2 > 4 * delta2 && depth--) { | |
var a = a0 + a1, | |
b = b0 + b1, | |
c = c0 + c1, | |
m = sqrt$1(a * a + b * b + c * c), | |
phi2 = asin$1(c /= m), | |
lambda2 = abs(abs(c) - 1) < epsilon$4 || abs(lambda0 - lambda1) < epsilon$4 ? (lambda0 + lambda1) / 2 : atan2(b, a), | |
p = project(lambda2, phi2), | |
x2 = p[0], | |
y2 = p[1], | |
dx2 = x2 - x0, | |
dy2 = y2 - y0, | |
dz = dy * dx2 - dx * dy2; | |
if (dz * dz / d2 > delta2 // perpendicular projected distance | |
|| abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end | |
|| a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance | |
resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream); | |
stream.point(x2, y2); | |
resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream); | |
} | |
} | |
} | |
return function(stream) { | |
var lambda00, x00, y00, a00, b00, c00, // first point | |
lambda0, x0, y0, a0, b0, c0; // previous point | |
var resampleStream = { | |
point: point, | |
lineStart: lineStart, | |
lineEnd: lineEnd, | |
polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; }, | |
polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; } | |
}; | |
function point(x, y) { | |
x = project(x, y); | |
stream.point(x[0], x[1]); | |
} | |
function lineStart() { | |
x0 = NaN; | |
resampleStream.point = linePoint; | |
stream.lineStart(); | |
} | |
function linePoint(lambda, phi) { | |
var c = cartesian([lambda, phi]), p = project(lambda, phi); | |
resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream); | |
stream.point(x0, y0); | |
} | |
function lineEnd() { | |
resampleStream.point = point; | |
stream.lineEnd(); | |
} | |
function ringStart() { | |
lineStart(); | |
resampleStream.point = ringPoint; | |
resampleStream.lineEnd = ringEnd; | |
} | |
function ringPoint(lambda, phi) { | |
linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0; | |
resampleStream.point = linePoint; | |
} | |
function ringEnd() { | |
resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream); | |
resampleStream.lineEnd = lineEnd; | |
lineEnd(); | |
} | |
return resampleStream; | |
}; | |
} | |
var transformRadians = transformer({ | |
point: function(x, y) { | |
this.stream.point(x * radians, y * radians); | |
} | |
}); | |
function projection(project) { | |
return projectionMutator(function() { return project; })(); | |
} | |
function projectionMutator(projectAt) { | |
var project, | |
k = 150, // scale | |
x = 480, y = 250, // translate | |
dx, dy, lambda = 0, phi = 0, // center | |
deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, projectRotate, // rotate | |
theta = null, preclip = clipAntimeridian, // clip angle | |
x0 = null, y0, x1, y1, postclip = identity$7, // clip extent | |
delta2 = 0.5, projectResample = resample(projectTransform, delta2), // precision | |
cache, | |
cacheStream; | |
function projection(point) { | |
point = projectRotate(point[0] * radians, point[1] * radians); | |
return [point[0] * k + dx, dy - point[1] * k]; | |
} | |
function invert(point) { | |
point = projectRotate.invert((point[0] - dx) / k, (dy - point[1]) / k); | |
return point && [point[0] * degrees$1, point[1] * degrees$1]; | |
} | |
function projectTransform(x, y) { | |
return x = project(x, y), [x[0] * k + dx, dy - x[1] * k]; | |
} | |
projection.stream = function(stream) { | |
return cache && cacheStream === stream ? cache : cache = transformRadians(preclip(rotate, projectResample(postclip(cacheStream = stream)))); | |
}; | |
projection.clipAngle = function(_) { | |
return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians, 6 * radians) : (theta = null, clipAntimeridian), reset()) : theta * degrees$1; | |
}; | |
projection.clipExtent = function(_) { | |
return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$7) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]]; | |
}; | |
projection.scale = function(_) { | |
return arguments.length ? (k = +_, recenter()) : k; | |
}; | |
projection.translate = function(_) { | |
return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y]; | |
}; | |
projection.center = function(_) { | |
return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees$1, phi * degrees$1]; | |
}; | |
projection.rotate = function(_) { | |
return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees$1, deltaPhi * degrees$1, deltaGamma * degrees$1]; | |
}; | |
projection.precision = function(_) { | |
return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt$1(delta2); | |
}; | |
projection.fitExtent = function(extent, object) { | |
return fitExtent(projection, extent, object); | |
}; | |
projection.fitSize = function(size, object) { | |
return fitSize(projection, size, object); | |
}; | |
function recenter() { | |
projectRotate = compose(rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma), project); | |
var center = project(lambda, phi); | |
dx = x - center[0] * k; | |
dy = y + center[1] * k; | |
return reset(); | |
} | |
function reset() { | |
cache = cacheStream = null; | |
return projection; | |
} | |
return function() { | |
project = projectAt.apply(this, arguments); | |
projection.invert = project.invert && invert; | |
return recenter(); | |
}; | |
} | |
function conicProjection(projectAt) { | |
var phi0 = 0, | |
phi1 = pi$4 / 3, | |
m = projectionMutator(projectAt), | |
p = m(phi0, phi1); | |
p.parallels = function(_) { | |
return arguments.length ? m(phi0 = _[0] * radians, phi1 = _[1] * radians) : [phi0 * degrees$1, phi1 * degrees$1]; | |
}; | |
return p; | |
} | |
function cylindricalEqualAreaRaw(phi0) { | |
var cosPhi0 = cos$1(phi0); | |
function forward(lambda, phi) { | |
return [lambda * cosPhi0, sin$1(phi) / cosPhi0]; | |
} | |
forward.invert = function(x, y) { | |
return [x / cosPhi0, asin$1(y * cosPhi0)]; | |
}; | |
return forward; | |
} | |
function conicEqualAreaRaw(y0, y1) { | |
var sy0 = sin$1(y0), n = (sy0 + sin$1(y1)) / 2; | |
// Are the parallels symmetrical around the Equator? | |
if (abs(n) < epsilon$4) return cylindricalEqualAreaRaw(y0); | |
var c = 1 + sy0 * (2 * n - sy0), r0 = sqrt$1(c) / n; | |
function project(x, y) { | |
var r = sqrt$1(c - 2 * n * sin$1(y)) / n; | |
return [r * sin$1(x *= n), r0 - r * cos$1(x)]; | |
} | |
project.invert = function(x, y) { | |
var r0y = r0 - y; | |
return [atan2(x, abs(r0y)) / n * sign$1(r0y), asin$1((c - (x * x + r0y * r0y) * n * n) / (2 * n))]; | |
}; | |
return project; | |
} | |
function conicEqualArea() { | |
return conicProjection(conicEqualAreaRaw) | |
.scale(155.424) | |
.center([0, 33.6442]); | |
} | |
function albers() { | |
return conicEqualArea() | |
.parallels([29.5, 45.5]) | |
.scale(1070) | |
.translate([480, 250]) | |
.rotate([96, 0]) | |
.center([-0.6, 38.7]); | |
} | |
// The projections must have mutually exclusive clip regions on the sphere, | |
// as this will avoid emitting interleaving lines and polygons. | |
function multiplex(streams) { | |
var n = streams.length; | |
return { | |
point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); }, | |
sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); }, | |
lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); }, | |
lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); }, | |
polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); }, | |
polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); } | |
}; | |
} | |
// A composite projection for the United States, configured by default for | |
// 960×500. The projection also works quite well at 960×600 if you change the | |
// scale to 1285 and adjust the translate accordingly. The set of standard | |
// parallels for each region comes from USGS, which is published here: | |
// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers | |
function albersUsa() { | |
var cache, | |
cacheStream, | |
lower48 = albers(), lower48Point, | |
alaska = conicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338 | |
hawaii = conicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007 | |
point, pointStream = {point: function(x, y) { point = [x, y]; }}; | |
function albersUsa(coordinates) { | |
var x = coordinates[0], y = coordinates[1]; | |
return point = null, | |
(lower48Point.point(x, y), point) | |
|| (alaskaPoint.point(x, y), point) | |
|| (hawaiiPoint.point(x, y), point); | |
} | |
albersUsa.invert = function(coordinates) { | |
var k = lower48.scale(), | |
t = lower48.translate(), | |
x = (coordinates[0] - t[0]) / k, | |
y = (coordinates[1] - t[1]) / k; | |
return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska | |
: y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii | |
: lower48).invert(coordinates); | |
}; | |
albersUsa.stream = function(stream) { | |
return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]); | |
}; | |
albersUsa.precision = function(_) { | |
if (!arguments.length) return lower48.precision(); | |
lower48.precision(_), alaska.precision(_), hawaii.precision(_); | |
return reset(); | |
}; | |
albersUsa.scale = function(_) { | |
if (!arguments.length) return lower48.scale(); | |
lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_); | |
return albersUsa.translate(lower48.translate()); | |
}; | |
albersUsa.translate = function(_) { | |
if (!arguments.length) return lower48.translate(); | |
var k = lower48.scale(), x = +_[0], y = +_[1]; | |
lower48Point = lower48 | |
.translate(_) | |
.clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]]) | |
.stream(pointStream); | |
alaskaPoint = alaska | |
.translate([x - 0.307 * k, y + 0.201 * k]) | |
.clipExtent([[x - 0.425 * k + epsilon$4, y + 0.120 * k + epsilon$4], [x - 0.214 * k - epsilon$4, y + 0.234 * k - epsilon$4]]) | |
.stream(pointStream); | |
hawaiiPoint = hawaii | |
.translate([x - 0.205 * k, y + 0.212 * k]) | |
.clipExtent([[x - 0.214 * k + epsilon$4, y + 0.166 * k + epsilon$4], [x - 0.115 * k - epsilon$4, y + 0.234 * k - epsilon$4]]) | |
.stream(pointStream); | |
return reset(); | |
}; | |
albersUsa.fitExtent = function(extent, object) { | |
return fitExtent(albersUsa, extent, object); | |
}; | |
albersUsa.fitSize = function(size, object) { | |
return fitSize(albersUsa, size, object); | |
}; | |
function reset() { | |
cache = cacheStream = null; | |
return albersUsa; | |
} | |
return albersUsa.scale(1070); | |
} | |
function azimuthalRaw(scale) { | |
return function(x, y) { | |
var cx = cos$1(x), | |
cy = cos$1(y), | |
k = scale(cx * cy); | |
return [ | |
k * cy * sin$1(x), | |
k * sin$1(y) | |
]; | |
} | |
} | |
function azimuthalInvert(angle) { | |
return function(x, y) { | |
var z = sqrt$1(x * x + y * y), | |
c = angle(z), | |
sc = sin$1(c), | |
cc = cos$1(c); | |
return [ | |
atan2(x * sc, z * cc), | |
asin$1(z && y * sc / z) | |
]; | |
} | |
} | |
var azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) { | |
return sqrt$1(2 / (1 + cxcy)); | |
}); | |
azimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) { | |
return 2 * asin$1(z / 2); | |
}); | |
function azimuthalEqualArea() { | |
return projection(azimuthalEqualAreaRaw) | |
.scale(124.75) | |
.clipAngle(180 - 1e-3); | |
} | |
var azimuthalEquidistantRaw = azimuthalRaw(function(c) { | |
return (c = acos(c)) && c / sin$1(c); | |
}); | |
azimuthalEquidistantRaw.invert = azimuthalInvert(function(z) { | |
return z; | |
}); | |
function azimuthalEquidistant() { | |
return projection(azimuthalEquidistantRaw) | |
.scale(79.4188) | |
.clipAngle(180 - 1e-3); | |
} | |
function mercatorRaw(lambda, phi) { | |
return [lambda, log$1(tan((halfPi$3 + phi) / 2))]; | |
} | |
mercatorRaw.invert = function(x, y) { | |
return [x, 2 * atan(exp(y)) - halfPi$3]; | |
}; | |
function mercator() { | |
return mercatorProjection(mercatorRaw) | |
.scale(961 / tau$4); | |
} | |
function mercatorProjection(project) { | |
var m = projection(project), | |
scale = m.scale, | |
translate = m.translate, | |
clipExtent = m.clipExtent, | |
clipAuto; | |
m.scale = function(_) { | |
return arguments.length ? (scale(_), clipAuto && m.clipExtent(null), m) : scale(); | |
}; | |
m.translate = function(_) { | |
return arguments.length ? (translate(_), clipAuto && m.clipExtent(null), m) : translate(); | |
}; | |
m.clipExtent = function(_) { | |
if (!arguments.length) return clipAuto ? null : clipExtent(); | |
if (clipAuto = _ == null) { | |
var k = pi$4 * scale(), | |
t = translate(); | |
_ = [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]]; | |
} | |
clipExtent(_); | |
return m; | |
}; | |
return m.clipExtent(null); | |
} | |
function tany(y) { | |
return tan((halfPi$3 + y) / 2); | |
} | |
function conicConformalRaw(y0, y1) { | |
var cy0 = cos$1(y0), | |
n = y0 === y1 ? sin$1(y0) : log$1(cy0 / cos$1(y1)) / log$1(tany(y1) / tany(y0)), | |
f = cy0 * pow$1(tany(y0), n) / n; | |
if (!n) return mercatorRaw; | |
function project(x, y) { | |
if (f > 0) { if (y < -halfPi$3 + epsilon$4) y = -halfPi$3 + epsilon$4; } | |
else { if (y > halfPi$3 - epsilon$4) y = halfPi$3 - epsilon$4; } | |
var r = f / pow$1(tany(y), n); | |
return [r * sin$1(n * x), f - r * cos$1(n * x)]; | |
} | |
project.invert = function(x, y) { | |
var fy = f - y, r = sign$1(n) * sqrt$1(x * x + fy * fy); | |
return [atan2(x, abs(fy)) / n * sign$1(fy), 2 * atan(pow$1(f / r, 1 / n)) - halfPi$3]; | |
}; | |
return project; | |
} | |
function conicConformal() { | |
return conicProjection(conicConformalRaw) | |
.scale(109.5) | |
.parallels([30, 30]); | |
} | |
function equirectangularRaw(lambda, phi) { | |
return [lambda, phi]; | |
} | |
equirectangularRaw.invert = equirectangularRaw; | |
function geoEquirectangular() { | |
return projection(equirectangularRaw) | |
.scale(152.63); | |
} | |
function conicEquidistantRaw(y0, y1) { | |
var cy0 = cos$1(y0), | |
n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0), | |
g = cy0 / n + y0; | |
if (abs(n) < epsilon$4) return equirectangularRaw; | |
function project(x, y) { | |
var gy = g - y, nx = n * x; | |
return [gy * sin$1(nx), g - gy * cos$1(nx)]; | |
} | |
project.invert = function(x, y) { | |
var gy = g - y; | |
return [atan2(x, abs(gy)) / n * sign$1(gy), g - sign$1(n) * sqrt$1(x * x + gy * gy)]; | |
}; | |
return project; | |
} | |
function conicEquidistant() { | |
return conicProjection(conicEquidistantRaw) | |
.scale(131.154) | |
.center([0, 13.9389]); | |
} | |
function gnomonicRaw(x, y) { | |
var cy = cos$1(y), k = cos$1(x) * cy; | |
return [cy * sin$1(x) / k, sin$1(y) / k]; | |
} | |
gnomonicRaw.invert = azimuthalInvert(atan); | |
function gnomonic() { | |
return projection(gnomonicRaw) | |
.scale(144.049) | |
.clipAngle(60); | |
} | |
function scaleTranslate(kx, ky, tx, ty) { | |
return kx === 1 && ky === 1 && tx === 0 && ty === 0 ? identity$7 : transformer({ | |
point: function(x, y) { | |
this.stream.point(x * kx + tx, y * ky + ty); | |
} | |
}); | |
} | |
function identity$8() { | |
var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, transform = identity$7, // scale, translate and reflect | |
x0 = null, y0, x1, y1, clip = identity$7, // clip extent | |
cache, | |
cacheStream, | |
projection; | |
function reset() { | |
cache = cacheStream = null; | |
return projection; | |
} | |
return projection = { | |
stream: function(stream) { | |
return cache && cacheStream === stream ? cache : cache = transform(clip(cacheStream = stream)); | |
}, | |
clipExtent: function(_) { | |
return arguments.length ? (clip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$7) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]]; | |
}, | |
scale: function(_) { | |
return arguments.length ? (transform = scaleTranslate((k = +_) * sx, k * sy, tx, ty), reset()) : k; | |
}, | |
translate: function(_) { | |
return arguments.length ? (transform = scaleTranslate(k * sx, k * sy, tx = +_[0], ty = +_[1]), reset()) : [tx, ty]; | |
}, | |
reflectX: function(_) { | |
return arguments.length ? (transform = scaleTranslate(k * (sx = _ ? -1 : 1), k * sy, tx, ty), reset()) : sx < 0; | |
}, | |
reflectY: function(_) { | |
return arguments.length ? (transform = scaleTranslate(k * sx, k * (sy = _ ? -1 : 1), tx, ty), reset()) : sy < 0; | |
}, | |
fitExtent: function(extent, object) { | |
return fitExtent(projection, extent, object); | |
}, | |
fitSize: function(size, object) { | |
return fitSize(projection, size, object); | |
} | |
}; | |
} | |
function orthographicRaw(x, y) { | |
return [cos$1(y) * sin$1(x), sin$1(y)]; | |
} | |
orthographicRaw.invert = azimuthalInvert(asin$1); | |
function geoOrthographic() { | |
return projection(orthographicRaw) | |
.scale(249.5) | |
.clipAngle(90 + epsilon$4); | |
} | |
function stereographicRaw(x, y) { | |
var cy = cos$1(y), k = 1 + cos$1(x) * cy; | |
return [cy * sin$1(x) / k, sin$1(y) / k]; | |
} | |
stereographicRaw.invert = azimuthalInvert(function(z) { | |
return 2 * atan(z); | |
}); | |
function stereographic() { | |
return projection(stereographicRaw) | |
.scale(250) | |
.clipAngle(142); | |
} | |
function transverseMercatorRaw(lambda, phi) { | |
return [log$1(tan((halfPi$3 + phi) / 2)), -lambda]; | |
} | |
transverseMercatorRaw.invert = function(x, y) { | |
return [-y, 2 * atan(exp(x)) - halfPi$3]; | |
}; | |
function transverseMercator() { | |
var m = mercatorProjection(transverseMercatorRaw), | |
center = m.center, | |
rotate = m.rotate; | |
m.center = function(_) { | |
return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]); | |
}; | |
m.rotate = function(_) { | |
return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]); | |
}; | |
return rotate([0, 0, 90]) | |
.scale(159.155); | |
} | |
function translateSelection(xy) { | |
return this.attr('transform', function(d,i) { | |
return 'translate('+[typeof xy == 'function' ? xy.call(this, d,i) : xy]+')'; | |
}); | |
}; | |
function parseAttributes(name) { | |
if (typeof name === "string") { | |
var attr = {}, | |
parts = name.split(/([\.#])/g), p; | |
name = parts.shift(); | |
while ((p = parts.shift())) { | |
if (p == '.') attr['class'] = attr['class'] ? attr['class'] + ' ' + parts.shift() : parts.shift(); | |
else if (p == '#') attr.id = parts.shift(); | |
} | |
return {tag: name, attr: attr}; | |
} | |
return name; | |
} | |
function append(name) { | |
var n = parseAttributes(name), s; | |
name = creator(n.tag); | |
s = this.select(function() { | |
return this.appendChild(name.apply(this, arguments)); | |
}); | |
//attrs not provided by default in v4 | |
for (var key in n.attr) { s.attr(key, n.attr[key]) } | |
return s; | |
}; | |
function selectAppend(name) { | |
var select = selector(name), | |
n = parseAttributes(name), s; | |
name = creator(n.tag); | |
s = this.select(function() { | |
return select.apply(this, arguments) | |
|| this.appendChild(name.apply(this, arguments)); | |
}); | |
//attrs not provided by default in v4 | |
for (var key in n.attr) { s.attr(key, n.attr[key]) } | |
return s; | |
}; | |
function tspans(lines, lh) { | |
return this.selectAll('tspan') | |
.data(lines).enter() | |
.append('tspan') | |
.text(function(d) { return d; }) | |
.attr('x', 0) | |
.attr('dy', function(d, i) { return i ? lh || 15 : 0; }); | |
}; | |
function appendMany(data, name){ | |
return this.selectAll(null).data(data).enter().append(name); | |
}; | |
function at(name, value) { | |
if (typeof(name) == 'object'){ | |
for (var key in name){ | |
this.attr(key.replace(/([a-z\d])([A-Z])/g, '$1-$2').toLowerCase(), name[key]) | |
} | |
return this | |
} else{ | |
return arguments.length == 1 ? this.attr(name) : this.attr(name, value) | |
} | |
}; | |
function f(){ | |
var functions = arguments | |
//convert all string arguments into field accessors | |
var i = 0, l = functions.length | |
while (i < l) { | |
if (typeof(functions[i]) === 'string' || typeof(functions[i]) === 'number'){ | |
functions[i] = (function(str){ return function(d){ return d[str] } })(functions[i]) | |
} | |
i++ | |
} | |
//return composition of functions | |
return function(d) { | |
var i=0, l = functions.length | |
while (i++ < l) d = functions[i-1].call(this, d) | |
return d | |
} | |
} | |
f.not = function(d){ return !d } | |
f.run = function(d){ return d() } | |
f.objToFn = function(obj, defaultVal){ | |
if (arguments.length == 1) defaultVal = undefined | |
return function(str){ | |
return typeof(obj[str]) !== undefined ? obj[str] : defaultVal } | |
} | |
function st(name, value) { | |
if (typeof(name) == 'object'){ | |
for (var key in name){ | |
addStyle(this, key, name[key]) | |
} | |
return this | |
} else{ | |
return arguments.length == 1 ? this.style(name) : addStyle(this, name, value) | |
} | |
function addStyle(sel, style, value){ | |
var style = style.replace(/([a-z\d])([A-Z])/g, '$1-$2').toLowerCase() | |
var pxStyles = 'top left bottom right padding-top padding-left padding-bottom padding-right border-top b-width border-left-width border-botto-width m border-right-width margin-top margin-left margin-bottom margin-right font-size width height stroke-width line-height margin padding border max-width min-width' | |
if (~pxStyles.indexOf(style) ){ | |
sel.style(style, typeof value == 'function' ? f(value, addPx) : addPx(value)) | |
} else{ | |
sel.style(style, value) | |
} | |
return sel | |
} | |
function addPx(d){ return d.match ? d : d + 'px' } | |
}; | |
function wordwrap(line, maxCharactersPerLine) { | |
var w = line.split(' '), | |
lines = [], | |
words = [], | |
maxChars = maxCharactersPerLine || 40, | |
l = 0; | |
w.forEach(function(d) { | |
if (l+d.length > maxChars) { | |
lines.push(words.join(' ')); | |
words.length = 0; | |
l = 0; | |
} | |
l += d.length; | |
words.push(d); | |
}); | |
if (words.length) { | |
lines.push(words.join(' ')); | |
} | |
return lines.filter(function(d){ return d != '' }); | |
}; | |
function ascendingKey(key) { | |
return typeof key == 'function' ? function (a, b) { | |
return key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : key(a) >= key(b) ? 0 : NaN; | |
} : function (a, b) { | |
return a[key] < b[key] ? -1 : a[key] > b[key] ? 1 : a[key] >= b[key] ? 0 : NaN; | |
}; | |
}; | |
function descendingKey(key) { | |
return typeof key == 'function' ? function (a, b) { | |
return key(b) < key(a) ? -1 : key(b) > key(a) ? 1 : key(b) >= key(a) ? 0 : NaN; | |
} : function (a, b) { | |
return b[key] < a[key] ? -1 : b[key] > a[key] ? 1 : b[key] >= a[key] ? 0 : NaN; | |
}; | |
}; | |
function conventions(c){ | |
c = c || {} | |
c.margin = c.margin || {top: 20, right: 20, bottom: 20, left: 20} | |
;['top', 'right', 'bottom', 'left'].forEach(function(d){ | |
if (!c.margin[d] && c.margin[d] != 0) c.margin[d] = 20 | |
}) | |
c.width = c.width || c.totalWidth - c.margin.left - c.margin.right || 900 | |
c.height = c.height || c.totalHeight - c.margin.top - c.margin.bottom || 460 | |
c.totalWidth = c.width + c.margin.left + c.margin.right | |
c.totalHeight = c.height + c.margin.top + c.margin.bottom | |
c.parentSel = c.parentSel || select('body') | |
c.rootsvg = c.parentSel.append('svg') | |
c.svg = c.rootsvg | |
.attr('width', c.totalWidth) | |
.attr('height', c.totalHeight) | |
.append('g') | |
.attr('transform', 'translate(' + c.margin.left + ',' + c.margin.top + ')') | |
c.x = c.x || linear$2().range([0, c.width]) | |
c.y = c.y || linear$2().range([c.height, 0]) | |
c.xAxis = c.xAxis || axisBottom().scale(c.x) | |
c.yAxis = c.yAxis || axisLeft().scale(c.y) | |
c.drawAxis = function(){ | |
c.svg.append('g') | |
.attr('class', 'x axis') | |
.attr('transform', 'translate(0,' + c.height + ')') | |
.call(c.xAxis); | |
c.svg.append('g') | |
.attr('class', 'y axis') | |
.call(c.yAxis); | |
} | |
return c | |
} | |
function attachTooltip(sel, tooltipSel, fieldFns){ | |
if (!sel.size()) return | |
tooltipSel = tooltipSel || select('.tooltip') | |
sel | |
.on('mouseover.attachTooltip', ttDisplay) | |
.on('mousemove.attachTooltip', ttMove) | |
.on('mouseout.attachTooltip', ttHide) | |
.on('click.attachTooltip', function(d){ console.log(d) }) | |
var d = sel.datum() | |
fieldFns = fieldFns || d3keys(d) | |
.filter(function(str){ | |
return (typeof d[str] != 'object') && (d[str] != 'array') | |
}) | |
.map(function(str){ | |
return function(d){ return str + ': <b>' + d[str] + '</b>'} }) | |
function ttDisplay(d){ | |
tooltipSel | |
.classed('tooltip-hidden', false) | |
.html('') | |
.appendMany(fieldFns, 'div') | |
.html(function(fn){ return fn(d) }) | |
select(this).classed('tooltipped', true) | |
} | |
function ttMove(d){ | |
var tt = tooltipSel | |
if (!tt.size()) return | |
var e = exports.event, | |
x = e.clientX, | |
y = e.clientY, | |
n = tt.node(), | |
nBB = n.getBoundingClientRect(), | |
doctop = (window.scrollY)? window.scrollY : (document.documentElement && document.documentElement.scrollTop)? document.documentElement.scrollTop : document.body.scrollTop, | |
topPos = y+doctop-nBB.height-18; | |
tt.style('top', (topPos < 0 ? 18 + y : topPos)+'px'); | |
tt.style('left', Math.min(Math.max(20, (x-nBB.width/2)), window.innerWidth - nBB.width - 20)+'px'); | |
} | |
function ttHide(d){ | |
tooltipSel.classed('tooltip-hidden', true); | |
selectAll('.tooltipped').classed('tooltipped', false) | |
} | |
} | |
function loadData(files, cb){ | |
var q = queue() | |
files.forEach(function(d){ | |
var type = d.split('.').reverse()[0] | |
var loadFn = {csv: csv$1, tsv: tsv$1, json: json}[type] | |
if (!loadFn) return cb(new Error('Invalid type', d)) | |
q.defer(loadFn, d) | |
}) | |
q.awaitAll(cb) | |
} | |
function nestBy(array, key){ | |
return nest().key(key).entries(array).map(function(d){ | |
d.values.key = d.key | |
return d.values | |
}) | |
} | |
function round(n, p) { | |
return p ? Math.round(n * (p = Math.pow(10, p))) / p : Math.round(n); | |
}; | |
selection.prototype.translate = translateSelection | |
transition.prototype.translate = translateSelection | |
selection.prototype.append = append | |
selection.prototype.selectAppend = selectAppend | |
selection.prototype.tspans = tspans | |
selection.prototype.appendMany = appendMany | |
selection.prototype.at = at | |
selection.prototype.st = st | |
transition.prototype.at = at | |
transition.prototype.st = st | |
selection.prototype.prop = selection.prototype.property | |
function graphScroll(){ | |
var windowHeight, | |
dispatch$$ = dispatch("scroll", "active"), | |
sections = select('null'), | |
i = NaN, | |
sectionPos = [], | |
n, | |
graph = select('null'), | |
isFixed = null, | |
isBelow = null, | |
container = select('body'), | |
containerStart = 0, | |
belowStart, | |
eventId = Math.random(), | |
offset = 200 | |
function reposition(){ | |
var i1 = 0 | |
sectionPos.forEach(function(d, i){ | |
if (d < pageYOffset - containerStart + offset) i1 = i | |
}) | |
i1 = Math.min(n - 1, i1) | |
if (i != i1){ | |
sections.classed('graph-scroll-active', function(d, i){ return i === i1 }) | |
dispatch$$.call('active', null, i1) | |
i = i1 | |
} | |
var isBelow1 = pageYOffset > belowStart | |
if (isBelow != isBelow1){ | |
isBelow = isBelow1 | |
graph.classed('graph-scroll-below', isBelow) | |
} | |
var isFixed1 = !isBelow && pageYOffset > containerStart | |
if (isFixed != isFixed1){ | |
isFixed = isFixed1 | |
graph.classed('graph-scroll-fixed', isFixed) | |
} | |
} | |
function resize(){ | |
sectionPos = [] | |
var startPos | |
sections.each(function(d, i){ | |
if (!i) startPos = this.getBoundingClientRect().top | |
sectionPos.push(this.getBoundingClientRect().top - startPos) }) | |
var containerBB = container.node().getBoundingClientRect() | |
var graphBB = graph.node().getBoundingClientRect() | |
containerStart = containerBB.top + pageYOffset | |
belowStart = containerBB.bottom - graphBB.height + pageYOffset | |
} | |
function keydown() { | |
if (!isFixed) return | |
var delta | |
switch (exports.event.keyCode) { | |
case 39: // right arrow | |
if (exports.event.metaKey) return | |
case 40: // down arrow | |
case 34: // page down | |
delta = exports.event.metaKey ? Infinity : 1 ;break | |
case 37: // left arrow | |
if (exports.event.metaKey) return | |
case 38: // up arrow | |
case 33: // page up | |
delta = exports.event.metaKey ? -Infinity : -1 ;break | |
case 32: // space | |
delta = exports.event.shiftKey ? -1 : 1 | |
;break | |
default: return | |
} | |
var i1 = Math.max(0, Math.min(i + delta, n - 1)) | |
select(document.documentElement) | |
.interrupt() | |
.transition() | |
.duration(500) | |
.tween("scroll", function() { | |
var i = interpolateNumber(pageYOffset, sectionPos[i1] + containerStart) | |
return function(t) { scrollTo(0, i(t)) } | |
}) | |
exports.event.preventDefault() | |
} | |
var rv ={} | |
rv.container = function(_x){ | |
if (!_x) return container | |
container = _x | |
return rv | |
} | |
rv.graph = function(_x){ | |
if (!_x) return graph | |
graph = _x | |
return rv | |
} | |
rv.eventId = function(_x){ | |
if (!_x) return eventId | |
eventId = _x | |
return rv | |
} | |
rv.sections = function (_x){ | |
if (!_x) return sections | |
sections = _x | |
n = sections.size() | |
select(window) | |
.on('scroll.gscroll' + eventId, reposition) | |
.on('resize.gscroll' + eventId, resize) | |
.on('keydown.gscroll' + eventId, keydown) | |
resize() | |
timer(function() { | |
reposition() | |
return true | |
}) | |
return rv | |
} | |
rv.on = function() { | |
var value = dispatch$$.on.apply(dispatch$$, arguments); | |
return value === dispatch$$ ? rv : value; | |
} | |
rv.offset = function(_x) { | |
if(!_x) return rv | |
offset = _x | |
return rv | |
} | |
return rv | |
} | |
var abs$1 = Math.abs; | |
var atan2$1 = Math.atan2; | |
var cos$2 = Math.cos; | |
var log$2 = Math.log; | |
var sin$2 = Math.sin; | |
var epsilon$5 = 1e-6; | |
var pi$5 = Math.PI; | |
var halfPi$4 = pi$5 / 2; | |
var sqrt2 = sqrt$2(2); | |
var degrees$2 = 180 / pi$5; | |
var radians$1 = pi$5 / 180; | |
function asin$2(x) { | |
return x > 1 ? halfPi$4 : x < -1 ? -halfPi$4 : Math.asin(x); | |
} | |
function acos$1(x) { | |
return x > 1 ? 0 : x < -1 ? pi$5 : Math.acos(x); | |
} | |
function sqrt$2(x) { | |
return x > 0 ? Math.sqrt(x) : 0; | |
} | |
var sqrt8 = sqrt$2(8); | |
var phi0$1 = log$2(1 + sqrt2); | |
var sqrt3$1 = sqrt$2(3); | |
function cylindricalEqualAreaRaw$1(phi0) { | |
var cosPhi0 = cos$2(phi0); | |
function forward(lambda, phi) { | |
return [lambda * cosPhi0, sin$2(phi) / cosPhi0]; | |
} | |
forward.invert = function(x, y) { | |
return [x / cosPhi0, asin$2(y * cosPhi0)]; | |
}; | |
return forward; | |
} | |
var eisenlohrK = 3 + 2 * sqrt2; | |
var faheyK = cos$2(35 * radians$1); | |
function ginzburgPolyconicRaw(a, b, c, d, e, f, g, h) { | |
if (arguments.length < 8) h = 0; | |
function forward(lambda, phi) { | |
if (!phi) return [a * lambda / pi$5, 0]; | |
var phi2 = phi * phi, | |
xB = a + phi2 * (b + phi2 * (c + phi2 * d)), | |
yB = phi * (e - 1 + phi2 * (f - h + phi2 * g)), | |
m = (xB * xB + yB * yB) / (2 * yB), | |
alpha = lambda * asin$2(xB / m) / pi$5; | |
return [m * sin$2(alpha), phi * (1 + phi2 * h) + m * (1 - cos$2(alpha))]; | |
} | |
forward.invert = function(x, y) { | |
var lambda = pi$5 * x / a, | |
phi = y, | |
deltaLambda, deltaPhi, i = 50; | |
do { | |
var phi2 = phi * phi, | |
xB = a + phi2 * (b + phi2 * (c + phi2 * d)), | |
yB = phi * (e - 1 + phi2 * (f - h + phi2 * g)), | |
p = xB * xB + yB * yB, | |
q = 2 * yB, | |
m = p / q, | |
m2 = m * m, | |
dAlphadLambda = asin$2(xB / m) / pi$5, | |
alpha = lambda * dAlphadLambda, | |
xB2 = xB * xB, | |
dxBdPhi = (2 * b + phi2 * (4 * c + phi2 * 6 * d)) * phi, | |
dyBdPhi = e + phi2 * (3 * f + phi2 * 5 * g), | |
dpdPhi = 2 * (xB * dxBdPhi + yB * (dyBdPhi - 1)), | |
dqdPhi = 2 * (dyBdPhi - 1), | |
dmdPhi = (dpdPhi * q - p * dqdPhi) / (q * q), | |
cosAlpha = cos$2(alpha), | |
sinAlpha = sin$2(alpha), | |
mcosAlpha = m * cosAlpha, | |
msinAlpha = m * sinAlpha, | |
dAlphadPhi = ((lambda / pi$5) * (1 / sqrt$2(1 - xB2 / m2)) * (dxBdPhi * m - xB * dmdPhi)) / m2, | |
fx = msinAlpha - x, | |
fy = phi * (1 + phi2 * h) + m - mcosAlpha - y, | |
deltaxDeltaPhi = dmdPhi * sinAlpha + mcosAlpha * dAlphadPhi, | |
deltaxDeltaLambda = mcosAlpha * dAlphadLambda, | |
deltayDeltaPhi = 1 + dmdPhi - (dmdPhi * cosAlpha - msinAlpha * dAlphadPhi), | |
deltayDeltaLambda = msinAlpha * dAlphadLambda, | |
denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda; | |
if (!denominator) break; | |
lambda -= deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator; | |
phi -= deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator; | |
} while ((abs$1(deltaLambda) > epsilon$5 || abs$1(deltaPhi) > epsilon$5) && --i > 0); | |
return [lambda, phi]; | |
}; | |
return forward; | |
} | |
var ginzburg4Raw = ginzburgPolyconicRaw(2.8284, -1.6988, 0.75432, -0.18071, 1.76003, -0.38914, 0.042555); | |
var ginzburg5Raw = ginzburgPolyconicRaw(2.583819, -0.835827, 0.170354, -0.038094, 1.543313, -0.411435,0.082742); | |
var ginzburg6Raw = ginzburgPolyconicRaw(5 / 6 * pi$5, -0.62636, -0.0344, 0, 1.3493, -0.05524, 0, 0.045); | |
var ginzburg9Raw = ginzburgPolyconicRaw(2.6516, -0.76534, 0.19123, -0.047094, 1.36289, -0.13965,0.031762); | |
var healpixLambert = cylindricalEqualAreaRaw$1(0); | |
var pi_sqrt2 = pi$5 / sqrt2; | |
var sqrt6 = sqrt$2(6); | |
var sqrt7 = sqrt$2(7); | |
function naturalEarthRaw(lambda, phi) { | |
var phi2 = phi * phi, phi4 = phi2 * phi2; | |
return [ | |
lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (0.003971 * phi2 - 0.001529 * phi4))), | |
phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) | |
]; | |
} | |
naturalEarthRaw.invert = function(x, y) { | |
var phi = y, i = 25, delta; | |
do { | |
var phi2 = phi * phi, phi4 = phi2 * phi2; | |
phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) - y) / | |
(1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 0.005916 * 11 * phi4))); | |
} while (abs$1(delta) > epsilon$5 && --i > 0); | |
return [ | |
x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (0.003971 - 0.001529 * phi2)))), | |
phi | |
]; | |
}; | |
function naturalEarth() { | |
return projection(naturalEarthRaw) | |
.scale(175.295); | |
} | |
// TODO generate on-the-fly to avoid external modification. | |
var octahedron = [ | |
[0, 90], | |
[-90, 0], [0, 0], [90, 0], [180, 0], | |
[0, -90] | |
]; | |
[ | |
[0, 2, 1], | |
[0, 3, 2], | |
[5, 1, 2], | |
[5, 2, 3], | |
[0, 1, 4], | |
[0, 4, 3], | |
[5, 4, 1], | |
[5, 3, 4] | |
].map(function(face) { | |
return face.map(function(i) { | |
return octahedron[i]; | |
}); | |
}); | |
var kx$1 = 2 / sqrt$2(3); | |
var K = [ | |
[0.9986, -0.062], | |
[1.0000, 0.0000], | |
[0.9986, 0.0620], | |
[0.9954, 0.1240], | |
[0.9900, 0.1860], | |
[0.9822, 0.2480], | |
[0.9730, 0.3100], | |
[0.9600, 0.3720], | |
[0.9427, 0.4340], | |
[0.9216, 0.4958], | |
[0.8962, 0.5571], | |
[0.8679, 0.6176], | |
[0.8350, 0.6769], | |
[0.7986, 0.7346], | |
[0.7597, 0.7903], | |
[0.7186, 0.8435], | |
[0.6732, 0.8936], | |
[0.6213, 0.9394], | |
[0.5722, 0.9761], | |
[0.5322, 1.0000] | |
]; | |
K.forEach(function(d) { | |
d[1] *= 1.0144; | |
}); | |
function satelliteVerticalRaw(P) { | |
function forward(lambda, phi) { | |
var cosPhi = cos$2(phi), | |
k = (P - 1) / (P - cosPhi * cos$2(lambda)); | |
return [ | |
k * cosPhi * sin$2(lambda), | |
k * sin$2(phi) | |
]; | |
} | |
forward.invert = function(x, y) { | |
var rho2 = x * x + y * y, | |
rho = sqrt$2(rho2), | |
sinc = (P - sqrt$2(1 - rho2 * (P + 1) / (P - 1))) / ((P - 1) / rho + rho / (P - 1)); | |
return [ | |
atan2$1(x * sinc, rho * sqrt$2(1 - sinc * sinc)), | |
rho ? asin$2(y * sinc / rho) : 0 | |
]; | |
}; | |
return forward; | |
} | |
function satelliteRaw(P, omega) { | |
var vertical = satelliteVerticalRaw(P); | |
if (!omega) return vertical; | |
var cosOmega = cos$2(omega), | |
sinOmega = sin$2(omega); | |
function forward(lambda, phi) { | |
var coordinates = vertical(lambda, phi), | |
y = coordinates[1], | |
A = y * sinOmega / (P - 1) + cosOmega; | |
return [ | |
coordinates[0] * cosOmega / A, | |
y / A | |
]; | |
} | |
forward.invert = function(x, y) { | |
var k = (P - 1) / (P - 1 - y * sinOmega); | |
return vertical.invert(k * x, k * y * cosOmega); | |
}; | |
return forward; | |
} | |
function satellite() { | |
var distance = 2, | |
omega = 0, | |
m = projectionMutator(satelliteRaw), | |
p = m(distance, omega); | |
// As a multiple of radius. | |
p.distance = function(_) { | |
if (!arguments.length) return distance; | |
return m(distance = +_, omega); | |
}; | |
p.tilt = function(_) { | |
if (!arguments.length) return omega * degrees$2; | |
return m(distance, omega = _ * radians$1); | |
}; | |
return p | |
.scale(432.147) | |
.clipAngle(acos$1(1 / distance) * degrees$2 - 1e-6); | |
} | |
var A$1 = 4 * pi$5 + 3 * sqrt$2(3); | |
var B$1 = 2 * sqrt$2(2 * pi$5 * sqrt$2(3) / A$1); | |
exports.geoNaturalEarth = naturalEarth; | |
exports.geoSatellite = satellite; | |
exports.version = version; | |
exports.bisect = bisectRight; | |
exports.bisectRight = bisectRight; | |
exports.bisectLeft = bisectLeft; | |
exports.ascending = ascending; | |
exports.bisector = bisector; | |
exports.descending = descending; | |
exports.deviation = deviation; | |
exports.extent = extent; | |
exports.histogram = histogram; | |
exports.thresholdFreedmanDiaconis = freedmanDiaconis; | |
exports.thresholdScott = scott; | |
exports.thresholdSturges = sturges; | |
exports.max = max; | |
exports.mean = mean; | |
exports.median = median; | |
exports.merge = merge; | |
exports.min = min; | |
exports.pairs = pairs; | |
exports.permute = permute; | |
exports.quantile = threshold; | |
exports.range = range; | |
exports.scan = scan; | |
exports.shuffle = shuffle; | |
exports.sum = sum; | |
exports.ticks = ticks; | |
exports.tickStep = tickStep; | |
exports.transpose = transpose; | |
exports.variance = variance; | |
exports.zip = zip; | |
exports.entries = entries; | |
exports.keys = d3keys; | |
exports.values = values; | |
exports.map = map$1; | |
exports.set = set; | |
exports.nest = nest; | |
exports.randomUniform = uniform; | |
exports.randomNormal = normal; | |
exports.randomLogNormal = logNormal; | |
exports.randomBates = bates; | |
exports.randomIrwinHall = irwinHall; | |
exports.randomExponential = exponential; | |
exports.easeLinear = linear; | |
exports.easeQuad = quadInOut; | |
exports.easeQuadIn = quadIn; | |
exports.easeQuadOut = quadOut; | |
exports.easeQuadInOut = quadInOut; | |
exports.easeCubic = easeCubicInOut; | |
exports.easeCubicIn = cubicIn; | |
exports.easeCubicOut = cubicOut; | |
exports.easeCubicInOut = easeCubicInOut; | |
exports.easePoly = polyInOut; | |
exports.easePolyIn = polyIn; | |
exports.easePolyOut = polyOut; | |
exports.easePolyInOut = polyInOut; | |
exports.easeSin = sinInOut; | |
exports.easeSinIn = sinIn; | |
exports.easeSinOut = sinOut; | |
exports.easeSinInOut = sinInOut; | |
exports.easeExp = expInOut; | |
exports.easeExpIn = expIn; | |
exports.easeExpOut = expOut; | |
exports.easeExpInOut = expInOut; | |
exports.easeCircle = circleInOut; | |
exports.easeCircleIn = circleIn; | |
exports.easeCircleOut = circleOut; | |
exports.easeCircleInOut = circleInOut; | |
exports.easeBounce = bounceOut; | |
exports.easeBounceIn = bounceIn; | |
exports.easeBounceOut = bounceOut; | |
exports.easeBounceInOut = bounceInOut; | |
exports.easeBack = backInOut; | |
exports.easeBackIn = backIn; | |
exports.easeBackOut = backOut; | |
exports.easeBackInOut = backInOut; | |
exports.easeElastic = elasticOut; | |
exports.easeElasticIn = elasticIn; | |
exports.easeElasticOut = elasticOut; | |
exports.easeElasticInOut = elasticInOut; | |
exports.polygonArea = area; | |
exports.polygonCentroid = centroid; | |
exports.polygonHull = hull; | |
exports.polygonContains = contains; | |
exports.polygonLength = length$1; | |
exports.path = path; | |
exports.quadtree = quadtree; | |
exports.queue = queue; | |
exports.arc = arc; | |
exports.area = area$1; | |
exports.line = line; | |
exports.pie = pie; | |
exports.radialArea = radialArea; | |
exports.radialLine = radialLine$1; | |
exports.symbol = symbol; | |
exports.symbols = symbols; | |
exports.symbolCircle = circle; | |
exports.symbolCross = cross$1; | |
exports.symbolDiamond = diamond; | |
exports.symbolSquare = square; | |
exports.symbolStar = star; | |
exports.symbolTriangle = triangle; | |
exports.symbolWye = wye; | |
exports.curveBasisClosed = basisClosed; | |
exports.curveBasisOpen = basisOpen; | |
exports.curveBasis = basis; | |
exports.curveBundle = bundle; | |
exports.curveCardinalClosed = cardinalClosed; | |
exports.curveCardinalOpen = cardinalOpen; | |
exports.curveCardinal = cardinal; | |
exports.curveCatmullRomClosed = catmullRomClosed; | |
exports.curveCatmullRomOpen = catmullRomOpen; | |
exports.curveCatmullRom = catmullRom; | |
exports.curveLinearClosed = linearClosed; | |
exports.curveLinear = curveLinear; | |
exports.curveMonotoneX = monotoneX; | |
exports.curveMonotoneY = monotoneY; | |
exports.curveNatural = natural; | |
exports.curveStep = step; | |
exports.curveStepAfter = stepAfter; | |
exports.curveStepBefore = stepBefore; | |
exports.stack = stack; | |
exports.stackOffsetExpand = expand; | |
exports.stackOffsetNone = none; | |
exports.stackOffsetSilhouette = silhouette; | |
exports.stackOffsetWiggle = wiggle; | |
exports.stackOrderAscending = ascending$1; | |
exports.stackOrderDescending = descending$2; | |
exports.stackOrderInsideOut = insideOut; | |
exports.stackOrderNone = none$1; | |
exports.stackOrderReverse = reverse; | |
exports.color = color; | |
exports.rgb = colorRgb; | |
exports.hsl = colorHsl; | |
exports.lab = lab; | |
exports.hcl = colorHcl; | |
exports.cubehelix = cubehelix; | |
exports.interpolate = interpolate; | |
exports.interpolateArray = array$1; | |
exports.interpolateDate = date; | |
exports.interpolateNumber = interpolateNumber; | |
exports.interpolateObject = object; | |
exports.interpolateRound = interpolateRound; | |
exports.interpolateString = interpolateString; | |
exports.interpolateTransformCss = interpolateTransform$1; | |
exports.interpolateTransformSvg = interpolateTransform$2; | |
exports.interpolateZoom = interpolateZoom; | |
exports.interpolateRgb = interpolateRgb; | |
exports.interpolateRgbBasis = rgbBasis; | |
exports.interpolateRgbBasisClosed = rgbBasisClosed; | |
exports.interpolateHsl = hsl$1; | |
exports.interpolateHslLong = hslLong; | |
exports.interpolateLab = lab$1; | |
exports.interpolateHcl = hcl$1; | |
exports.interpolateHclLong = hclLong; | |
exports.interpolateCubehelix = cubehelix$2; | |
exports.interpolateCubehelixLong = interpolateCubehelixLong; | |
exports.interpolateBasis = basis$2; | |
exports.interpolateBasisClosed = basisClosed$1; | |
exports.quantize = quantize; | |
exports.dispatch = dispatch; | |
exports.dsvFormat = dsv; | |
exports.csvParse = csvParse; | |
exports.csvParseRows = csvParseRows; | |
exports.csvFormat = csvFormat; | |
exports.csvFormatRows = csvFormatRows; | |
exports.tsvParse = tsvParse; | |
exports.tsvParseRows = tsvParseRows; | |
exports.tsvFormat = tsvFormat; | |
exports.tsvFormatRows = tsvFormatRows; | |
exports.request = request; | |
exports.html = html; | |
exports.json = json; | |
exports.text = text; | |
exports.xml = xml; | |
exports.csv = csv$1; | |
exports.tsv = tsv$1; | |
exports.now = now; | |
exports.timer = timer; | |
exports.timerFlush = timerFlush; | |
exports.timeout = timeout$1; | |
exports.interval = interval$1; | |
exports.timeInterval = newInterval; | |
exports.timeMillisecond = millisecond; | |
exports.timeMilliseconds = milliseconds; | |
exports.timeSecond = second; | |
exports.timeSeconds = seconds; | |
exports.timeMinute = minute; | |
exports.timeMinutes = minutes; | |
exports.timeHour = hour; | |
exports.timeHours = hours; | |
exports.timeDay = day; | |
exports.timeDays = days; | |
exports.timeWeek = timeWeek; | |
exports.timeWeeks = sundays; | |
exports.timeSunday = timeWeek; | |
exports.timeSundays = sundays; | |
exports.timeMonday = timeMonday; | |
exports.timeMondays = mondays; | |
exports.timeTuesday = tuesday; | |
exports.timeTuesdays = tuesdays; | |
exports.timeWednesday = wednesday; | |
exports.timeWednesdays = wednesdays; | |
exports.timeThursday = thursday; | |
exports.timeThursdays = thursdays; | |
exports.timeFriday = friday; | |
exports.timeFridays = fridays; | |
exports.timeSaturday = saturday; | |
exports.timeSaturdays = saturdays; | |
exports.timeMonth = month; | |
exports.timeMonths = months; | |
exports.timeYear = year; | |
exports.timeYears = years; | |
exports.utcMillisecond = millisecond; | |
exports.utcMilliseconds = milliseconds; | |
exports.utcSecond = second; | |
exports.utcSeconds = seconds; | |
exports.utcMinute = utcMinute; | |
exports.utcMinutes = utcMinutes; | |
exports.utcHour = utcHour; | |
exports.utcHours = utcHours; | |
exports.utcDay = utcDay; | |
exports.utcDays = utcDays; | |
exports.utcWeek = utcWeek; | |
exports.utcWeeks = utcSundays; | |
exports.utcSunday = utcWeek; | |
exports.utcSundays = utcSundays; | |
exports.utcMonday = utcMonday; | |
exports.utcMondays = utcMondays; | |
exports.utcTuesday = utcTuesday; | |
exports.utcTuesdays = utcTuesdays; | |
exports.utcWednesday = utcWednesday; | |
exports.utcWednesdays = utcWednesdays; | |
exports.utcThursday = utcThursday; | |
exports.utcThursdays = utcThursdays; | |
exports.utcFriday = utcFriday; | |
exports.utcFridays = utcFridays; | |
exports.utcSaturday = utcSaturday; | |
exports.utcSaturdays = utcSaturdays; | |
exports.utcMonth = utcMonth; | |
exports.utcMonths = utcMonths; | |
exports.utcYear = utcYear; | |
exports.utcYears = utcYears; | |
exports.formatLocale = formatLocale; | |
exports.formatDefaultLocale = defaultLocale; | |
exports.formatSpecifier = formatSpecifier; | |
exports.precisionFixed = precisionFixed; | |
exports.precisionPrefix = precisionPrefix; | |
exports.precisionRound = precisionRound; | |
exports.isoFormat = formatIso; | |
exports.isoParse = parseIso; | |
exports.timeFormatLocale = formatLocale$1; | |
exports.timeFormatDefaultLocale = defaultLocale$1; | |
exports.scaleBand = band; | |
exports.scalePoint = point$4; | |
exports.scaleIdentity = identity$4; | |
exports.scaleLinear = linear$2; | |
exports.scaleLog = log; | |
exports.scaleOrdinal = ordinal; | |
exports.scaleImplicit = implicit; | |
exports.scalePow = pow; | |
exports.scaleSqrt = sqrt; | |
exports.scaleQuantile = quantile; | |
exports.scaleQuantize = quantize$1; | |
exports.scaleThreshold = threshold$1; | |
exports.scaleTime = time; | |
exports.scaleUtc = utcTime; | |
exports.schemeCategory10 = category10; | |
exports.schemeCategory20b = category20b; | |
exports.schemeCategory20c = category20c; | |
exports.schemeCategory20 = category20; | |
exports.scaleSequential = sequential; | |
exports.interpolateCubehelixDefault = cubehelix$3; | |
exports.interpolateRainbow = rainbow$1; | |
exports.interpolateWarm = warm; | |
exports.interpolateCool = cool; | |
exports.interpolateViridis = viridis; | |
exports.interpolateMagma = magma; | |
exports.interpolateInferno = inferno; | |
exports.interpolatePlasma = plasma; | |
exports.creator = creator; | |
exports.customEvent = customEvent; | |
exports.local = local; | |
exports.matcher = matcher$1; | |
exports.mouse = mouse; | |
exports.namespace = namespace; | |
exports.namespaces = namespaces; | |
exports.select = select; | |
exports.selectAll = selectAll; | |
exports.selection = selection; | |
exports.selector = selector; | |
exports.selectorAll = selectorAll; | |
exports.touch = touch; | |
exports.touches = touches; | |
exports.window = window$1; | |
exports.active = active; | |
exports.interrupt = interrupt; | |
exports.transition = transition; | |
exports.axisTop = axisTop; | |
exports.axisRight = axisRight; | |
exports.axisBottom = axisBottom; | |
exports.axisLeft = axisLeft; | |
exports.cluster = cluster; | |
exports.hierarchy = hierarchy; | |
exports.pack = index; | |
exports.packSiblings = siblings; | |
exports.packEnclose = enclose; | |
exports.partition = partition; | |
exports.stratify = stratify; | |
exports.tree = tree; | |
exports.treemap = index$1; | |
exports.treemapBinary = binary; | |
exports.treemapDice = treemapDice; | |
exports.treemapSlice = treemapSlice; | |
exports.treemapSliceDice = sliceDice; | |
exports.treemapSquarify = squarify; | |
exports.treemapResquarify = resquarify; | |
exports.forceCenter = center$1; | |
exports.forceCollide = collide; | |
exports.forceLink = link; | |
exports.forceManyBody = manyBody; | |
exports.forceSimulation = simulation; | |
exports.forceX = x$3; | |
exports.forceY = y$3; | |
exports.drag = drag; | |
exports.dragDisable = dragDisable; | |
exports.dragEnable = dragEnable; | |
exports.voronoi = voronoi; | |
exports.zoom = zoom; | |
exports.zoomIdentity = identity$6; | |
exports.zoomTransform = transform; | |
exports.brush = brush; | |
exports.brushX = brushX; | |
exports.brushY = brushY; | |
exports.brushSelection = brushSelection; | |
exports.chord = chord; | |
exports.ribbon = ribbon; | |
exports.geoAlbers = albers; | |
exports.geoAlbersUsa = albersUsa; | |
exports.geoArea = area$2; | |
exports.geoAzimuthalEqualArea = azimuthalEqualArea; | |
exports.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw; | |
exports.geoAzimuthalEquidistant = azimuthalEquidistant; | |
exports.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw; | |
exports.geoBounds = bounds; | |
exports.geoCentroid = centroid$1; | |
exports.geoCircle = geoCircle; | |
exports.geoClipExtent = extent$1; | |
exports.geoConicConformal = conicConformal; | |
exports.geoConicConformalRaw = conicConformalRaw; | |
exports.geoConicEqualArea = conicEqualArea; | |
exports.geoConicEqualAreaRaw = conicEqualAreaRaw; | |
exports.geoConicEquidistant = conicEquidistant; | |
exports.geoConicEquidistantRaw = conicEquidistantRaw; | |
exports.geoDistance = distance; | |
exports.geoEquirectangular = geoEquirectangular; | |
exports.geoEquirectangularRaw = equirectangularRaw; | |
exports.geoGnomonic = gnomonic; | |
exports.geoGnomonicRaw = gnomonicRaw; | |
exports.geoGraticule = graticule; | |
exports.geoGraticule10 = graticule10; | |
exports.geoIdentity = identity$8; | |
exports.geoInterpolate = interpolate$2; | |
exports.geoLength = length$2; | |
exports.geoMercator = mercator; | |
exports.geoMercatorRaw = mercatorRaw; | |
exports.geoOrthographic = geoOrthographic; | |
exports.geoOrthographicRaw = orthographicRaw; | |
exports.geoPath = index$3; | |
exports.geoProjection = projection; | |
exports.geoProjectionMutator = projectionMutator; | |
exports.geoRotation = rotation; | |
exports.geoStereographic = stereographic; | |
exports.geoStereographicRaw = stereographicRaw; | |
exports.geoStream = geoStream; | |
exports.geoTransform = transform$1; | |
exports.geoTransverseMercator = transverseMercator; | |
exports.geoTransverseMercatorRaw = transverseMercatorRaw; | |
exports.wordwrap = wordwrap; | |
exports.parseAttributes = parseAttributes; | |
exports.f = f; | |
exports.ascendingKey = ascendingKey; | |
exports.descendingKey = descendingKey; | |
exports.conventions = conventions; | |
exports.attachTooltip = attachTooltip; | |
exports.loadData = loadData; | |
exports.nestBy = nestBy; | |
exports.round = round; | |
exports.graphScroll = graphScroll; | |
Object.defineProperty(exports, '__esModule', { value: true }); | |
}))); |
!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n(t.d3=t.d3||{})}(this,function(t){"use strict";function n(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function e(t){return 1===t.length&&(t=r(t)),{left:function(n,e,r,i){for(null==r&&(r=0),null==i&&(i=n.length);r<i;){var o=r+i>>>1;t(n[o],e)<0?r=o+1:i=o}return r},right:function(n,e,r,i){for(null==r&&(r=0),null==i&&(i=n.length);r<i;){var o=r+i>>>1;t(n[o],e)>0?i=o:r=o+1}return r}}}function r(t){return function(e,r){return n(t(e),r)}}function i(t,n){return n<t?-1:n>t?1:n>=t?0:NaN}function o(t){return null===t?NaN:+t}function u(t,n){var e,r,i=t.length,u=0,a=0,c=-1,s=0;if(null==n)for(;++c<i;)isNaN(e=o(t[c]))||(r=e-u,u+=r/++s,a+=r*(e-u));else for(;++c<i;)isNaN(e=o(n(t[c],c,t)))||(r=e-u,u+=r/++s,a+=r*(e-u));if(s>1)return a/(s-1)}function a(t,n){var e=u(t,n);return e?Math.sqrt(e):e}function c(t,n){var e,r,i,o=-1,u=t.length;if(null==n){for(;++o<u;)if(null!=(r=t[o])&&r>=r){e=i=r;break}for(;++o<u;)null!=(r=t[o])&&(e>r&&(e=r),i<r&&(i=r))}else{for(;++o<u;)if(null!=(r=n(t[o],o,t))&&r>=r){e=i=r;break}for(;++o<u;)null!=(r=n(t[o],o,t))&&(e>r&&(e=r),i<r&&(i=r))}return[e,i]}function s(t){return function(){return t}}function f(t){return t}function l(t,n,e){t=+t,n=+n,e=(i=arguments.length)<2?(n=t,t=0,1):i<3?1:+e;for(var r=-1,i=0|Math.max(0,Math.ceil((n-t)/e)),o=new Array(i);++r<i;)o[r]=t+r*e;return o}function h(t,n,e){var r=p(t,n,e);return l(Math.ceil(t/r)*r,Math.floor(n/r)*r+r/2,r)}function p(t,n,e){var r=Math.abs(n-t)/Math.max(0,e),i=Math.pow(10,Math.floor(Math.log(r)/Math.LN10)),o=r/i;return o>=pv?i*=10:o>=dv?i*=5:o>=vv&&(i*=2),n<t?-i:i}function d(t){return Math.ceil(Math.log(t.length)/Math.LN2)+1}function v(){function t(t){var i,o,u=t.length,a=new Array(u);for(i=0;i<u;++i)a[i]=n(t[i],i,t);var c=e(a),s=c[0],f=c[1],l=r(a,s,f);Array.isArray(l)||(l=h(s,f,l));for(var p=l.length;l[0]<=s;)l.shift(),--p;for(;l[p-1]>=f;)l.pop(),--p;var d,v=new Array(p+1);for(i=0;i<=p;++i)d=v[i]=[],d.x0=i>0?l[i-1]:s,d.x1=i<p?l[i]:f;for(i=0;i<u;++i)o=a[i],s<=o&&o<=f&&v[cv(l,o,0,p)].push(t[i]);return v}var n=f,e=c,r=d;return t.value=function(e){return arguments.length?(n="function"==typeof e?e:s(e),t):n},t.domain=function(n){return arguments.length?(e="function"==typeof n?n:s([n[0],n[1]]),t):e},t.thresholds=function(n){return arguments.length?(r="function"==typeof n?n:s(Array.isArray(n)?lv.call(n):n),t):r},t}function g(t,n,e){if(null==e&&(e=o),r=t.length){if((n=+n)<=0||r<2)return+e(t[0],0,t);if(n>=1)return+e(t[r-1],r-1,t);var r,i=(r-1)*n,u=Math.floor(i),a=+e(t[u],u,t),c=+e(t[u+1],u+1,t);return a+(c-a)*(i-u)}}function _(t,e,r){return t=hv.call(t,o).sort(n),Math.ceil((r-e)/(2*(g(t,.75)-g(t,.25))*Math.pow(t.length,-1/3)))}function y(t,n,e){return Math.ceil((e-n)/(3.5*a(t)*Math.pow(t.length,-1/3)))}function m(t,n){var e,r,i=-1,o=t.length;if(null==n){for(;++i<o;)if(null!=(r=t[i])&&r>=r){e=r;break}for(;++i<o;)null!=(r=t[i])&&r>e&&(e=r)}else{for(;++i<o;)if(null!=(r=n(t[i],i,t))&&r>=r){e=r;break}for(;++i<o;)null!=(r=n(t[i],i,t))&&r>e&&(e=r)}return e}function x(t,n){var e,r=0,i=t.length,u=-1,a=i;if(null==n)for(;++u<i;)isNaN(e=o(t[u]))?--a:r+=e;else for(;++u<i;)isNaN(e=o(n(t[u],u,t)))?--a:r+=e;if(a)return r/a}function b(t,e){var r,i=[],u=t.length,a=-1;if(null==e)for(;++a<u;)isNaN(r=o(t[a]))||i.push(r);else for(;++a<u;)isNaN(r=o(e(t[a],a,t)))||i.push(r);return g(i.sort(n),.5)}function w(t){for(var n,e,r,i=t.length,o=-1,u=0;++o<i;)u+=t[o].length;for(e=new Array(u);--i>=0;)for(r=t[i],n=r.length;--n>=0;)e[--u]=r[n];return e}function M(t,n){var e,r,i=-1,o=t.length;if(null==n){for(;++i<o;)if(null!=(r=t[i])&&r>=r){e=r;break}for(;++i<o;)null!=(r=t[i])&&e>r&&(e=r)}else{for(;++i<o;)if(null!=(r=n(t[i],i,t))&&r>=r){e=r;break}for(;++i<o;)null!=(r=n(t[i],i,t))&&e>r&&(e=r)}return e}function T(t){for(var n=0,e=t.length-1,r=t[0],i=new Array(e<0?0:e);n<e;)i[n]=[r,r=t[++n]];return i}function N(t,n){for(var e=n.length,r=new Array(e);e--;)r[e]=t[n[e]];return r}function k(t,e){if(r=t.length){var r,i,o=0,u=0,a=t[u];for(e||(e=n);++o<r;)(e(i=t[o],a)<0||0!==e(a,a))&&(a=i,u=o);return 0===e(a,a)?u:void 0}}function S(t,n,e){for(var r,i,o=(null==e?t.length:e)-(n=null==n?0:+n);o;)i=Math.random()*o--|0,r=t[o+n],t[o+n]=t[i+n],t[i+n]=r;return t}function E(t,n){var e,r=0,i=t.length,o=-1;if(null==n)for(;++o<i;)(e=+t[o])&&(r+=e);else for(;++o<i;)(e=+n(t[o],o,t))&&(r+=e);return r}function A(t){if(!(i=t.length))return[];for(var n=-1,e=M(t,C),r=new Array(e);++n<e;)for(var i,o=-1,u=r[n]=new Array(i);++o<i;)u[o]=t[o][n];return r}function C(t){return t.length}function z(){return A(arguments)}function P(){}function R(t,n){var e=new P;if(t instanceof P)t.each(function(t,n){e.set(n,t)});else if(Array.isArray(t)){var r,i=-1,o=t.length;if(null==n)for(;++i<o;)e.set(i,t[i]);else for(;++i<o;)e.set(n(r=t[i],i,t),r)}else if(t)for(var u in t)e.set(u,t[u]);return e}function L(){function t(n,i,u,a){if(i>=o.length)return null!=r?r(n):null!=e?n.sort(e):n;for(var c,s,f,l=-1,h=n.length,p=o[i++],d=R(),v=u();++l<h;)(f=d.get(c=p(s=n[l])+""))?f.push(s):d.set(c,[s]);return d.each(function(n,e){a(v,e,t(n,i,u,a))}),v}function n(t,e){if(++e>o.length)return t;var i,a=u[e-1];return null!=r&&e>=o.length?i=t.entries():(i=[],t.each(function(t,r){i.push({key:r,values:n(t,e)})})),null!=a?i.sort(function(t,n){return a(t.key,n.key)}):i}var e,r,i,o=[],u=[];return i={object:function(n){return t(n,0,q,U)},map:function(n){return t(n,0,D,O)},entries:function(e){return n(t(e,0,D,O),0)},key:function(t){return o.push(t),i},sortKeys:function(t){return u[o.length-1]=t,i},sortValues:function(t){return e=t,i},rollup:function(t){return r=t,i}}}function q(){return{}}function U(t,n,e){t[n]=e}function D(){return R()}function O(t,n,e){t.set(n,e)}function I(){}function F(t,n){var e=new I;if(t instanceof I)t.each(function(t){e.add(t)});else if(t){var r=-1,i=t.length;if(null==n)for(;++r<i;)e.add(t[r]);else for(;++r<i;)e.add(n(t[r],r,t))}return e}function Y(t){var n=[];for(var e in t)n.push(e);return n}function B(t){var n=[];for(var e in t)n.push(t[e]);return n}function j(t){var n=[];for(var e in t)n.push({key:e,value:t[e]});return n}function H(t,n){return t=null==t?0:+t,n=null==n?1:+n,1===arguments.length?(n=t,t=0):n-=t,function(){return Math.random()*n+t}}function X(t,n){var e,r;return t=null==t?0:+t,n=null==n?1:+n,function(){var i;if(null!=e)i=e,e=null;else do e=2*Math.random()-1,i=2*Math.random()-1,r=e*e+i*i;while(!r||r>1);return t+n*i*Math.sqrt(-2*Math.log(r)/r)}}function V(){var t=X.apply(this,arguments);return function(){return Math.exp(t())}}function W(t){return function(){for(var n=0,e=0;e<t;++e)n+=Math.random();return n}}function $(t){var n=W(t);return function(){return n()/t}}function Z(t){return function(){return-Math.log(1-Math.random())/t}}function G(t){return+t}function K(t){return t*t}function J(t){return t*(2-t)}function Q(t){return((t*=2)<=1?t*t:--t*(2-t)+1)/2}function tt(t){return t*t*t}function nt(t){return--t*t*t+1}function et(t){return((t*=2)<=1?t*t*t:(t-=2)*t*t+2)/2}function rt(t){return 1-Math.cos(t*Mv)}function it(t){return Math.sin(t*Mv)}function ot(t){return(1-Math.cos(wv*t))/2}function ut(t){return Math.pow(2,10*t-10)}function at(t){return 1-Math.pow(2,-10*t)}function ct(t){return((t*=2)<=1?Math.pow(2,10*t-10):2-Math.pow(2,10-10*t))/2}function st(t){return 1-Math.sqrt(1-t*t)}function ft(t){return Math.sqrt(1- --t*t)}function lt(t){return((t*=2)<=1?1-Math.sqrt(1-t*t):Math.sqrt(1-(t-=2)*t)+1)/2}function ht(t){return 1-pt(1-t)}function pt(t){return(t=+t)<Tv?Rv*t*t:t<kv?Rv*(t-=Nv)*t+Sv:t<Av?Rv*(t-=Ev)*t+Cv:Rv*(t-=zv)*t+Pv}function dt(t){return((t*=2)<=1?1-pt(1-t):pt(t-1)+1)/2}function vt(t){for(var n,e=-1,r=t.length,i=t[r-1],o=0;++e<r;)n=i,i=t[e],o+=n[1]*i[0]-n[0]*i[1];return o/2}function gt(t){for(var n,e,r=-1,i=t.length,o=0,u=0,a=t[i-1],c=0;++r<i;)n=a,a=t[r],c+=e=n[0]*a[1]-a[0]*n[1],o+=(n[0]+a[0])*e,u+=(n[1]+a[1])*e;return c*=3,[o/c,u/c]}function _t(t,n,e){return(n[0]-t[0])*(e[1]-t[1])-(n[1]-t[1])*(e[0]-t[0])}function yt(t,n){return t[0]-n[0]||t[1]-n[1]}function mt(t){for(var n=t.length,e=[0,1],r=2,i=2;i<n;++i){for(;r>1&&_t(t[e[r-2]],t[e[r-1]],t[i])<=0;)--r;e[r++]=i}return e.slice(0,r)}function xt(t){if((e=t.length)<3)return null;var n,e,r=new Array(e),i=new Array(e);for(n=0;n<e;++n)r[n]=[+t[n][0],+t[n][1],n];for(r.sort(yt),n=0;n<e;++n)i[n]=[r[n][0],-r[n][1]];var o=mt(r),u=mt(i),a=u[0]===o[0],c=u[u.length-1]===o[o.length-1],s=[];for(n=o.length-1;n>=0;--n)s.push(t[r[o[n]][2]]);for(n=+a;n<u.length-c;++n)s.push(t[r[u[n]][2]]);return s}function bt(t,n){for(var e,r,i=t.length,o=t[i-1],u=n[0],a=n[1],c=o[0],s=o[1],f=!1,l=0;l<i;++l)o=t[l],e=o[0],r=o[1],r>a!=s>a&&u<(c-e)*(a-r)/(s-r)+e&&(f=!f),c=e,s=r;return f}function wt(t){for(var n,e,r=-1,i=t.length,o=t[i-1],u=o[0],a=o[1],c=0;++r<i;)n=u,e=a,o=t[r],u=o[0],a=o[1],n-=u,e-=a,c+=Math.sqrt(n*n+e*e);return c}function Mt(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function Tt(){return new Mt}function Nt(t){var n=+this._x.call(null,t),e=+this._y.call(null,t);return kt(this.cover(n,e),n,e,t)}function kt(t,n,e,r){if(isNaN(n)||isNaN(e))return t;var i,o,u,a,c,s,f,l,h,p=t._root,d={data:r},v=t._x0,g=t._y0,_=t._x1,y=t._y1;if(!p)return t._root=d,t;for(;p.length;)if((s=n>=(o=(v+_)/2))?v=o:_=o,(f=e>=(u=(g+y)/2))?g=u:y=u,i=p,!(p=p[l=f<<1|s]))return i[l]=d,t;if(a=+t._x.call(null,p.data),c=+t._y.call(null,p.data),n===a&&e===c)return d.next=p,i?i[l]=d:t._root=d,t;do i=i?i[l]=new Array(4):t._root=new Array(4),(s=n>=(o=(v+_)/2))?v=o:_=o,(f=e>=(u=(g+y)/2))?g=u:y=u;while((l=f<<1|s)===(h=(c>=u)<<1|a>=o));return i[h]=p,i[l]=d,t}function St(t){var n,e,r,i,o=t.length,u=new Array(o),a=new Array(o),c=1/0,s=1/0,f=-(1/0),l=-(1/0);for(e=0;e<o;++e)isNaN(r=+this._x.call(null,n=t[e]))||isNaN(i=+this._y.call(null,n))||(u[e]=r,a[e]=i,r<c&&(c=r),r>f&&(f=r),i<s&&(s=i),i>l&&(l=i));for(f<c&&(c=this._x0,f=this._x1),l<s&&(s=this._y0,l=this._y1),this.cover(c,s).cover(f,l),e=0;e<o;++e)kt(this,u[e],a[e],t[e]);return this}function Et(t,n){if(isNaN(t=+t)||isNaN(n=+n))return this;var e=this._x0,r=this._y0,i=this._x1,o=this._y1;if(isNaN(e))i=(e=Math.floor(t))+1,o=(r=Math.floor(n))+1;else{if(!(e>t||t>i||r>n||n>o))return this;var u,a,c=i-e,s=this._root;switch(a=(n<(r+o)/2)<<1|t<(e+i)/2){case 0:do u=new Array(4),u[a]=s,s=u;while(c*=2,i=e+c,o=r+c,t>i||n>o);break;case 1:do u=new Array(4),u[a]=s,s=u;while(c*=2,e=i-c,o=r+c,e>t||n>o);break;case 2:do u=new Array(4),u[a]=s,s=u;while(c*=2,i=e+c,r=o-c,t>i||r>n);break;case 3:do u=new Array(4),u[a]=s,s=u;while(c*=2,e=i-c,r=o-c,e>t||r>n)}this._root&&this._root.length&&(this._root=s)}return this._x0=e,this._y0=r,this._x1=i,this._y1=o,this}function At(){var t=[];return this.visit(function(n){if(!n.length)do t.push(n.data);while(n=n.next)}),t}function Ct(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}function zt(t,n,e,r,i){this.node=t,this.x0=n,this.y0=e,this.x1=r,this.y1=i}function Pt(t,n,e){var r,i,o,u,a,c,s,f=this._x0,l=this._y0,h=this._x1,p=this._y1,d=[],v=this._root;for(v&&d.push(new zt(v,f,l,h,p)),null==e?e=1/0:(f=t-e,l=n-e,h=t+e,p=n+e,e*=e);c=d.pop();)if(!(!(v=c.node)||(i=c.x0)>h||(o=c.y0)>p||(u=c.x1)<f||(a=c.y1)<l))if(v.length){var g=(i+u)/2,_=(o+a)/2;d.push(new zt(v[3],g,_,u,a),new zt(v[2],i,_,g,a),new zt(v[1],g,o,u,_),new zt(v[0],i,o,g,_)),(s=(n>=_)<<1|t>=g)&&(c=d[d.length-1],d[d.length-1]=d[d.length-1-s],d[d.length-1-s]=c)}else{var y=t-+this._x.call(null,v.data),m=n-+this._y.call(null,v.data),x=y*y+m*m;if(x<e){var b=Math.sqrt(e=x);f=t-b,l=n-b,h=t+b,p=n+b,r=v.data}}return r}function Rt(t){if(isNaN(o=+this._x.call(null,t))||isNaN(u=+this._y.call(null,t)))return this;var n,e,r,i,o,u,a,c,s,f,l,h,p=this._root,d=this._x0,v=this._y0,g=this._x1,_=this._y1;if(!p)return this;if(p.length)for(;;){if((s=o>=(a=(d+g)/2))?d=a:g=a,(f=u>=(c=(v+_)/2))?v=c:_=c,n=p,!(p=p[l=f<<1|s]))return this;if(!p.length)break;(n[l+1&3]||n[l+2&3]||n[l+3&3])&&(e=n,h=l)}for(;p.data!==t;)if(r=p,!(p=p.next))return this;return(i=p.next)&&delete p.next,r?(i?r.next=i:delete r.next,this):n?(i?n[l]=i:delete n[l],(p=n[0]||n[1]||n[2]||n[3])&&p===(n[3]||n[2]||n[1]||n[0])&&!p.length&&(e?e[h]=p:this._root=p),this):(this._root=i,this)}function Lt(t){for(var n=0,e=t.length;n<e;++n)this.remove(t[n]);return this}function qt(){return this._root}function Ut(){var t=0;return this.visit(function(n){if(!n.length)do++t;while(n=n.next)}),t}function Dt(t){var n,e,r,i,o,u,a=[],c=this._root;for(c&&a.push(new zt(c,this._x0,this._y0,this._x1,this._y1));n=a.pop();)if(!t(c=n.node,r=n.x0,i=n.y0,o=n.x1,u=n.y1)&&c.length){var s=(r+o)/2,f=(i+u)/2;(e=c[3])&&a.push(new zt(e,s,f,o,u)),(e=c[2])&&a.push(new zt(e,r,f,s,u)),(e=c[1])&&a.push(new zt(e,s,i,o,f)),(e=c[0])&&a.push(new zt(e,r,i,s,f))}return this}function Ot(t){var n,e=[],r=[];for(this._root&&e.push(new zt(this._root,this._x0,this._y0,this._x1,this._y1));n=e.pop();){var i=n.node;if(i.length){var o,u=n.x0,a=n.y0,c=n.x1,s=n.y1,f=(u+c)/2,l=(a+s)/2;(o=i[0])&&e.push(new zt(o,u,a,f,l)),(o=i[1])&&e.push(new zt(o,f,a,c,l)),(o=i[2])&&e.push(new zt(o,u,l,f,s)),(o=i[3])&&e.push(new zt(o,f,l,c,s))}r.push(n)}for(;n=r.pop();)t(n.node,n.x0,n.y0,n.x1,n.y1);return this}function It(t){return t[0]}function Ft(t){return arguments.length?(this._x=t,this):this._x}function Yt(t){return t[1]}function Bt(t){return arguments.length?(this._y=t,this):this._y}function jt(t,n,e){var r=new Ht(null==n?It:n,null==e?Yt:e,NaN,NaN,NaN,NaN);return null==t?r:r.addAll(t)}function Ht(t,n,e,r,i,o){this._x=t,this._y=n,this._x0=e,this._y0=r,this._x1=i,this._y1=o,this._root=void 0}function Xt(t){for(var n={data:t.data},e=n;t=t.next;)e=e.next={data:t.data};return n}function Vt(t){if(!(t>=1))throw new Error;this._size=t,this._call=this._error=null,this._tasks=[],this._data=[],this._waiting=this._active=this._ended=this._start=0}function Wt(t){if(!t._start)try{$t(t)}catch(n){if(t._tasks[t._ended+t._active-1])Gt(t,n);else if(!t._data)throw n}}function $t(t){for(;t._start=t._waiting&&t._active<t._size;){var n=t._ended+t._active,e=t._tasks[n],r=e.length-1,i=e[r];e[r]=Zt(t,n),--t._waiting,++t._active,e=i.apply(null,e),t._tasks[n]&&(t._tasks[n]=e||Gv)}}function Zt(t,n){return function(e,r){t._tasks[n]&&(--t._active,++t._ended,t._tasks[n]=null,null==t._error&&(null!=e?Gt(t,e):(t._data[n]=r,t._waiting?Wt(t):Kt(t))))}}function Gt(t,n){var e,r=t._tasks.length;for(t._error=n,t._data=void 0,t._waiting=NaN;--r>=0;)if((e=t._tasks[r])&&(t._tasks[r]=null,e.abort))try{e.abort()}catch(t){}t._active=NaN,Kt(t)}function Kt(t){if(!t._active&&t._call){var n=t._data;t._data=void 0,t._call(t._error,n)}}function Jt(t){return new Vt(arguments.length?+t:1/0)}function Qt(t){return function(){return t}}function tn(t){return t.innerRadius}function nn(t){return t.outerRadius}function en(t){return t.startAngle}function rn(t){return t.endAngle}function on(t){return t&&t.padAngle}function un(t){return t>=1?Qv:t<=-1?-Qv:Math.asin(t)}function an(t,n,e,r,i,o,u,a){var c=e-t,s=r-n,f=u-i,l=a-o,h=(f*(n-o)-l*(t-i))/(l*c-f*s);return[t+h*c,n+h*s]}function cn(t,n,e,r,i,o,u){var a=t-e,c=n-r,s=(u?o:-o)/Math.sqrt(a*a+c*c),f=s*c,l=-s*a,h=t+f,p=n+l,d=e+f,v=r+l,g=(h+d)/2,_=(p+v)/2,y=d-h,m=v-p,x=y*y+m*m,b=i-o,w=h*v-d*p,M=(m<0?-1:1)*Math.sqrt(Math.max(0,b*b*x-w*w)),T=(w*m-y*M)/x,N=(-w*y-m*M)/x,k=(w*m+y*M)/x,S=(-w*y+m*M)/x,E=T-g,A=N-_,C=k-g,z=S-_;return E*E+A*A>C*C+z*z&&(T=k,N=S),{cx:T,cy:N,x01:-f,y01:-l,x11:T*(i/b-1),y11:N*(i/b-1)}}function sn(){function t(){var t,s,f=+n.apply(this,arguments),l=+e.apply(this,arguments),h=o.apply(this,arguments)-Qv,p=u.apply(this,arguments)-Qv,d=Math.abs(p-h),v=p>h;if(c||(c=t=Tt()),l<f&&(s=l,l=f,f=s),l>Kv)if(d>tg-Kv)c.moveTo(l*Math.cos(h),l*Math.sin(h)),c.arc(0,0,l,h,p,!v),f>Kv&&(c.moveTo(f*Math.cos(p),f*Math.sin(p)),c.arc(0,0,f,p,h,v));else{var g,_,y=h,m=p,x=h,b=p,w=d,M=d,T=a.apply(this,arguments)/2,N=T>Kv&&(i?+i.apply(this,arguments):Math.sqrt(f*f+l*l)),k=Math.min(Math.abs(l-f)/2,+r.apply(this,arguments)),S=k,E=k;if(N>Kv){var A=un(N/f*Math.sin(T)),C=un(N/l*Math.sin(T));(w-=2*A)>Kv?(A*=v?1:-1,x+=A,b-=A):(w=0,x=b=(h+p)/2),(M-=2*C)>Kv?(C*=v?1:-1,y+=C,m-=C):(M=0,y=m=(h+p)/2)}var z=l*Math.cos(y),P=l*Math.sin(y),R=f*Math.cos(b),L=f*Math.sin(b);if(k>Kv){var q=l*Math.cos(m),U=l*Math.sin(m),D=f*Math.cos(x),O=f*Math.sin(x);if(d<Jv){var I=w>Kv?an(z,P,D,O,q,U,R,L):[R,L],F=z-I[0],Y=P-I[1],B=q-I[0],j=U-I[1],H=1/Math.sin(Math.acos((F*B+Y*j)/(Math.sqrt(F*F+Y*Y)*Math.sqrt(B*B+j*j)))/2),X=Math.sqrt(I[0]*I[0]+I[1]*I[1]);S=Math.min(k,(f-X)/(H-1)),E=Math.min(k,(l-X)/(H+1))}}M>Kv?E>Kv?(g=cn(D,O,z,P,l,E,v),_=cn(q,U,R,L,l,E,v),c.moveTo(g.cx+g.x01,g.cy+g.y01),E<k?c.arc(g.cx,g.cy,E,Math.atan2(g.y01,g.x01),Math.atan2(_.y01,_.x01),!v):(c.arc(g.cx,g.cy,E,Math.atan2(g.y01,g.x01),Math.atan2(g.y11,g.x11),!v),c.arc(0,0,l,Math.atan2(g.cy+g.y11,g.cx+g.x11),Math.atan2(_.cy+_.y11,_.cx+_.x11),!v),c.arc(_.cx,_.cy,E,Math.atan2(_.y11,_.x11),Math.atan2(_.y01,_.x01),!v))):(c.moveTo(z,P),c.arc(0,0,l,y,m,!v)):c.moveTo(z,P),f>Kv&&w>Kv?S>Kv?(g=cn(R,L,q,U,f,-S,v),_=cn(z,P,D,O,f,-S,v),c.lineTo(g.cx+g.x01,g.cy+g.y01),S<k?c.arc(g.cx,g.cy,S,Math.atan2(g.y01,g.x01),Math.atan2(_.y01,_.x01),!v):(c.arc(g.cx,g.cy,S,Math.atan2(g.y01,g.x01),Math.atan2(g.y11,g.x11),!v),c.arc(0,0,f,Math.atan2(g.cy+g.y11,g.cx+g.x11),Math.atan2(_.cy+_.y11,_.cx+_.x11),v),c.arc(_.cx,_.cy,S,Math.atan2(_.y11,_.x11),Math.atan2(_.y01,_.x01),!v))):c.arc(0,0,f,b,x,v):c.lineTo(R,L)}else c.moveTo(0,0);if(c.closePath(),t)return c=null,t+""||null}var n=tn,e=nn,r=Qt(0),i=null,o=en,u=rn,a=on,c=null;return t.centroid=function(){var t=(+n.apply(this,arguments)+ +e.apply(this,arguments))/2,r=(+o.apply(this,arguments)+ +u.apply(this,arguments))/2-Jv/2;return[Math.cos(r)*t,Math.sin(r)*t]},t.innerRadius=function(e){return arguments.length?(n="function"==typeof e?e:Qt(+e),t):n},t.outerRadius=function(n){return arguments.length?(e="function"==typeof n?n:Qt(+n),t):e},t.cornerRadius=function(n){return arguments.length?(r="function"==typeof n?n:Qt(+n),t):r},t.padRadius=function(n){return arguments.length?(i=null==n?null:"function"==typeof n?n:Qt(+n),t):i},t.startAngle=function(n){return arguments.length?(o="function"==typeof n?n:Qt(+n),t):o},t.endAngle=function(n){return arguments.length?(u="function"==typeof n?n:Qt(+n),t):u},t.padAngle=function(n){return arguments.length?(a="function"==typeof n?n:Qt(+n),t):a},t.context=function(n){return arguments.length?(c=null==n?null:n,t):c},t}function fn(t){this._context=t}function ln(t){return new fn(t)}function hn(t){return t[0]}function pn(t){return t[1]}function dn(){function t(t){var a,c,s,f=t.length,l=!1;for(null==i&&(u=o(s=Tt())),a=0;a<=f;++a)!(a<f&&r(c=t[a],a,t))===l&&((l=!l)?u.lineStart():u.lineEnd()),l&&u.point(+n(c,a,t),+e(c,a,t));if(s)return u=null,s+""||null}var n=hn,e=pn,r=Qt(!0),i=null,o=ln,u=null;return t.x=function(e){return arguments.length?(n="function"==typeof e?e:Qt(+e),t):n},t.y=function(n){return arguments.length?(e="function"==typeof n?n:Qt(+n),t):e},t.defined=function(n){return arguments.length?(r="function"==typeof n?n:Qt(!!n),t):r},t.curve=function(n){return arguments.length?(o=n,null!=i&&(u=o(i)),t):o},t.context=function(n){return arguments.length?(null==n?i=u=null:u=o(i=n),t):i},t}function vn(){function t(t){var n,f,l,h,p,d=t.length,v=!1,g=new Array(d),_=new Array(d);for(null==a&&(s=c(p=Tt())),n=0;n<=d;++n){if(!(n<d&&u(h=t[n],n,t))===v)if(v=!v)f=n,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),l=n-1;l>=f;--l)s.point(g[l],_[l]);s.lineEnd(),s.areaEnd()}v&&(g[n]=+e(h,n,t),_[n]=+i(h,n,t),s.point(r?+r(h,n,t):g[n],o?+o(h,n,t):_[n]))}if(p)return s=null,p+""||null}function n(){return dn().defined(u).curve(c).context(a)}var e=hn,r=null,i=Qt(0),o=pn,u=Qt(!0),a=null,c=ln,s=null;return t.x=function(n){return arguments.length?(e="function"==typeof n?n:Qt(+n),r=null,t):e},t.x0=function(n){return arguments.length?(e="function"==typeof n?n:Qt(+n),t):e},t.x1=function(n){return arguments.length?(r=null==n?null:"function"==typeof n?n:Qt(+n),t):r},t.y=function(n){return arguments.length?(i="function"==typeof n?n:Qt(+n),o=null,t):i},t.y0=function(n){return arguments.length?(i="function"==typeof n?n:Qt(+n),t):i},t.y1=function(n){return arguments.length?(o=null==n?null:"function"==typeof n?n:Qt(+n),t):o},t.lineX0=t.lineY0=function(){return n().x(e).y(i)},t.lineY1=function(){return n().x(e).y(o)},t.lineX1=function(){return n().x(r).y(i)},t.defined=function(n){return arguments.length?(u="function"==typeof n?n:Qt(!!n),t):u},t.curve=function(n){return arguments.length?(c=n,null!=a&&(s=c(a)),t):c},t.context=function(n){return arguments.length?(null==n?a=s=null:s=c(a=n),t):a},t}function gn(t,n){return n<t?-1:n>t?1:n>=t?0:NaN}function _n(t){return t}function yn(){function t(t){var a,c,s,f,l,h=t.length,p=0,d=new Array(h),v=new Array(h),g=+i.apply(this,arguments),_=Math.min(tg,Math.max(-tg,o.apply(this,arguments)-g)),y=Math.min(Math.abs(_)/h,u.apply(this,arguments)),m=y*(_<0?-1:1);for(a=0;a<h;++a)(l=v[d[a]=a]=+n(t[a],a,t))>0&&(p+=l);for(null!=e?d.sort(function(t,n){return e(v[t],v[n])}):null!=r&&d.sort(function(n,e){return r(t[n],t[e])}),a=0,s=p?(_-h*m)/p:0;a<h;++a,g=f)c=d[a],l=v[c],f=g+(l>0?l*s:0)+m,v[c]={data:t[c],index:a,value:l,startAngle:g,endAngle:f,padAngle:y};return v}var n=_n,e=gn,r=null,i=Qt(0),o=Qt(tg),u=Qt(0);return t.value=function(e){return arguments.length?(n="function"==typeof e?e:Qt(+e),t):n},t.sortValues=function(n){return arguments.length?(e=n,r=null,t):e},t.sort=function(n){return arguments.length?(r=n,e=null,t):r},t.startAngle=function(n){return arguments.length?(i="function"==typeof n?n:Qt(+n),t):i},t.endAngle=function(n){return arguments.length?(o="function"==typeof n?n:Qt(+n),t):o},t.padAngle=function(n){return arguments.length?(u="function"==typeof n?n:Qt(+n),t):u},t}function mn(t){this._curve=t}function xn(t){function n(n){return new mn(t(n))}return n._curve=t,n}function bn(t){var n=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?n(xn(t)):n()._curve},t}function wn(){return bn(dn().curve(ng))}function Mn(){var t=vn().curve(ng),n=t.curve,e=t.lineX0,r=t.lineX1,i=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return bn(e())},delete t.lineX0,t.lineEndAngle=function(){return bn(r())},delete t.lineX1,t.lineInnerRadius=function(){return bn(i())},delete t.lineY0,t.lineOuterRadius=function(){return bn(o())},delete t.lineY1,t.curve=function(t){return arguments.length?n(xn(t)):n()._curve},t}function Tn(){function t(){var t;if(r||(r=t=Tt()),n.apply(this,arguments).draw(r,+e.apply(this,arguments)),t)return r=null,t+""||null}var n=Qt(eg),e=Qt(64),r=null;return t.type=function(e){return arguments.length?(n="function"==typeof e?e:Qt(e),t):n},t.size=function(n){return arguments.length?(e="function"==typeof n?n:Qt(+n),t):e},t.context=function(n){return arguments.length?(r=null==n?null:n,t):r},t}function Nn(){}function kn(t,n,e){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+n)/6,(t._y0+4*t._y1+e)/6)}function Sn(t){this._context=t}function En(t){return new Sn(t)}function An(t){this._context=t}function Cn(t){return new An(t)}function zn(t){this._context=t}function Pn(t){return new zn(t)}function Rn(t,n){this._basis=new Sn(t),this._beta=n}function Ln(t,n,e){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-n),t._y2+t._k*(t._y1-e),t._x2,t._y2)}function qn(t,n){this._context=t,this._k=(1-n)/6}function Un(t,n){this._context=t,this._k=(1-n)/6}function Dn(t,n){this._context=t,this._k=(1-n)/6}function On(t,n,e){var r=t._x1,i=t._y1,o=t._x2,u=t._y2;if(t._l01_a>Kv){var a=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,c=3*t._l01_a*(t._l01_a+t._l12_a);r=(r*a-t._x0*t._l12_2a+t._x2*t._l01_2a)/c,i=(i*a-t._y0*t._l12_2a+t._y2*t._l01_2a)/c}if(t._l23_a>Kv){var s=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,f=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*s+t._x1*t._l23_2a-n*t._l12_2a)/f,u=(u*s+t._y1*t._l23_2a-e*t._l12_2a)/f}t._context.bezierCurveTo(r,i,o,u,t._x2,t._y2)}function In(t,n){this._context=t,this._alpha=n}function Fn(t,n){this._context=t,this._alpha=n}function Yn(t,n){this._context=t,this._alpha=n}function Bn(t){this._context=t}function jn(t){return new Bn(t)}function Hn(t){return t<0?-1:1}function Xn(t,n,e){var r=t._x1-t._x0,i=n-t._x1,o=(t._y1-t._y0)/(r||i<0&&-0),u=(e-t._y1)/(i||r<0&&-0),a=(o*i+u*r)/(r+i);return(Hn(o)+Hn(u))*Math.min(Math.abs(o),Math.abs(u),.5*Math.abs(a))||0}function Vn(t,n){var e=t._x1-t._x0;return e?(3*(t._y1-t._y0)/e-n)/2:n}function Wn(t,n,e){var r=t._x0,i=t._y0,o=t._x1,u=t._y1,a=(o-r)/3;t._context.bezierCurveTo(r+a,i+a*n,o-a,u-a*e,o,u)}function $n(t){this._context=t}function Zn(t){this._context=new Gn(t)}function Gn(t){this._context=t}function Kn(t){return new $n(t)}function Jn(t){return new Zn(t)}function Qn(t){this._context=t}function te(t){var n,e,r=t.length-1,i=new Array(r),o=new Array(r),u=new Array(r);for(i[0]=0,o[0]=2,u[0]=t[0]+2*t[1],n=1;n<r-1;++n)i[n]=1,o[n]=4,u[n]=4*t[n]+2*t[n+1];for(i[r-1]=2,o[r-1]=7,u[r-1]=8*t[r-1]+t[r],n=1;n<r;++n)e=i[n]/o[n-1],o[n]-=e,u[n]-=e*u[n-1];for(i[r-1]=u[r-1]/o[r-1],n=r-2;n>=0;--n)i[n]=(u[n]-i[n+1])/o[n];for(o[r-1]=(t[r]+i[r-1])/2,n=0;n<r-1;++n)o[n]=2*t[n+1]-i[n+1];return[i,o]}function ne(t){return new Qn(t)}function ee(t,n){this._context=t,this._t=n}function re(t){return new ee(t,.5)}function ie(t){return new ee(t,0)}function oe(t){return new ee(t,1)}function ue(t,n){if((r=t.length)>1)for(var e,r,i=1,o=t[n[0]],u=o.length;i<r;++i){e=o,o=t[n[i]];for(var a=0;a<u;++a)o[a][1]+=o[a][0]=isNaN(e[a][1])?e[a][0]:e[a][1]}}function ae(t){for(var n=t.length,e=new Array(n);--n>=0;)e[n]=n;return e}function ce(t,n){return t[n]}function se(){function t(t){var o,u,a=n.apply(this,arguments),c=t.length,s=a.length,f=new Array(s);for(o=0;o<s;++o){for(var l,h=a[o],p=f[o]=new Array(c),d=0;d<c;++d)p[d]=l=[0,+i(t[d],h,d,t)],l.data=t[d];p.key=h}for(o=0,u=e(f);o<s;++o)f[u[o]].index=o;return r(f,u),f}var n=Qt([]),e=ae,r=ue,i=ce;return t.keys=function(e){return arguments.length?(n="function"==typeof e?e:Qt(Eg.call(e)),t):n},t.value=function(n){return arguments.length?(i="function"==typeof n?n:Qt(+n),t):i},t.order=function(n){return arguments.length?(e=null==n?ae:"function"==typeof n?n:Qt(Eg.call(n)),t):e},t.offset=function(n){return arguments.length?(r=null==n?ue:n,t):r},t}function fe(t,n){if((r=t.length)>0){for(var e,r,i,o=0,u=t[0].length;o<u;++o){for(i=e=0;e<r;++e)i+=t[e][o][1]||0;if(i)for(e=0;e<r;++e)t[e][o][1]/=i}ue(t,n)}}function le(t,n){if((e=t.length)>0){for(var e,r=0,i=t[n[0]],o=i.length;r<o;++r){for(var u=0,a=0;u<e;++u)a+=t[u][r][1]||0;i[r][1]+=i[r][0]=-a/2}ue(t,n)}}function he(t,n){if((i=t.length)>0&&(r=(e=t[n[0]]).length)>0){for(var e,r,i,o=0,u=1;u<r;++u){for(var a=0,c=0,s=0;a<i;++a){for(var f=t[n[a]],l=f[u][1]||0,h=f[u-1][1]||0,p=(l-h)/2,d=0;d<a;++d){var v=t[n[d]],g=v[u][1]||0,_=v[u-1][1]||0;p+=g-_}c+=l,s+=p*l}e[u-1][1]+=e[u-1][0]=o,c&&(o-=s/c)}e[u-1][1]+=e[u-1][0]=o,ue(t,n)}}function pe(t){var n=t.map(de);return ae(t).sort(function(t,e){return n[t]-n[e]})}function de(t){for(var n,e=0,r=-1,i=t.length;++r<i;)(n=+t[r][1])&&(e+=n);return e}function ve(t){return pe(t).reverse()}function ge(t){var n,e,r=t.length,i=t.map(de),o=ae(t).sort(function(t,n){return i[n]-i[t]}),u=0,a=0,c=[],s=[];for(n=0;n<r;++n)e=o[n],u<a?(u+=i[e],c.push(e)):(a+=i[e],s.push(e));return s.reverse().concat(c)}function _e(t){return ae(t).reverse()}function ye(t,n,e){t.prototype=n.prototype=e,e.constructor=t}function me(t,n){var e=Object.create(t.prototype);for(var r in n)e[r]=n[r];return e}function xe(){}function be(t){var n;return t=(t+"").trim().toLowerCase(),(n=Lg.exec(t))?(n=parseInt(n[1],16),new ke(n>>8&15|n>>4&240,n>>4&15|240&n,(15&n)<<4|15&n,1)):(n=qg.exec(t))?we(parseInt(n[1],16)):(n=Ug.exec(t))?new ke(n[1],n[2],n[3],1):(n=Dg.exec(t))?new ke(255*n[1]/100,255*n[2]/100,255*n[3]/100,1):(n=Og.exec(t))?Me(n[1],n[2],n[3],n[4]):(n=Ig.exec(t))?Me(255*n[1]/100,255*n[2]/100,255*n[3]/100,n[4]):(n=Fg.exec(t))?Se(n[1],n[2]/100,n[3]/100,1):(n=Yg.exec(t))?Se(n[1],n[2]/100,n[3]/100,n[4]):Bg.hasOwnProperty(t)?we(Bg[t]):"transparent"===t?new ke(NaN,NaN,NaN,0):null}function we(t){return new ke(t>>16&255,t>>8&255,255&t,1)}function Me(t,n,e,r){return r<=0&&(t=n=e=NaN),new ke(t,n,e,r)}function Te(t){return t instanceof xe||(t=be(t)),t?(t=t.rgb(),new ke(t.r,t.g,t.b,t.opacity)):new ke}function Ne(t,n,e,r){return 1===arguments.length?Te(t):new ke(t,n,e,null==r?1:r)}function ke(t,n,e,r){this.r=+t,this.g=+n,this.b=+e,this.opacity=+r}function Se(t,n,e,r){return r<=0?t=n=e=NaN:e<=0||e>=1?t=n=NaN:n<=0&&(t=NaN),new Ce(t,n,e,r)}function Ee(t){if(t instanceof Ce)return new Ce(t.h,t.s,t.l,t.opacity);if(t instanceof xe||(t=be(t)),!t)return new Ce;if(t instanceof Ce)return t;t=t.rgb();var n=t.r/255,e=t.g/255,r=t.b/255,i=Math.min(n,e,r),o=Math.max(n,e,r),u=NaN,a=o-i,c=(o+i)/2;return a?(u=n===o?(e-r)/a+6*(e<r):e===o?(r-n)/a+2:(n-e)/a+4,a/=c<.5?o+i:2-o-i,u*=60):a=c>0&&c<1?0:u,new Ce(u,a,c,t.opacity)}function Ae(t,n,e,r){return 1===arguments.length?Ee(t):new Ce(t,n,e,null==r?1:r)}function Ce(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function ze(t,n,e){return 255*(t<60?n+(e-n)*t/60:t<180?e:t<240?n+(e-n)*(240-t)/60:n)}function Pe(t){if(t instanceof Le)return new Le(t.l,t.a,t.b,t.opacity);if(t instanceof Ye){var n=t.h*jg;return new Le(t.l,Math.cos(n)*t.c,Math.sin(n)*t.c,t.opacity)}t instanceof ke||(t=Te(t));var e=Oe(t.r),r=Oe(t.g),i=Oe(t.b),o=qe((.4124564*e+.3575761*r+.1804375*i)/Vg),u=qe((.2126729*e+.7151522*r+.072175*i)/Wg),a=qe((.0193339*e+.119192*r+.9503041*i)/$g);return new Le(116*u-16,500*(o-u),200*(u-a),t.opacity)}function Re(t,n,e,r){return 1===arguments.length?Pe(t):new Le(t,n,e,null==r?1:r)}function Le(t,n,e,r){this.l=+t,this.a=+n,this.b=+e,this.opacity=+r}function qe(t){return t>Jg?Math.pow(t,1/3):t/Kg+Zg}function Ue(t){return t>Gg?t*t*t:Kg*(t-Zg)}function De(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function Oe(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function Ie(t){if(t instanceof Ye)return new Ye(t.h,t.c,t.l,t.opacity);t instanceof Le||(t=Pe(t));var n=Math.atan2(t.b,t.a)*Hg;return new Ye(n<0?n+360:n,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}function Fe(t,n,e,r){return 1===arguments.length?Ie(t):new Ye(t,n,e,null==r?1:r)}function Ye(t,n,e,r){this.h=+t,this.c=+n,this.l=+e,this.opacity=+r}function Be(t){if(t instanceof He)return new He(t.h,t.s,t.l,t.opacity);t instanceof ke||(t=Te(t));var n=t.r/255,e=t.g/255,r=t.b/255,i=(u_*r+i_*n-o_*e)/(u_+i_-o_),o=r-i,u=(r_*(e-i)-n_*o)/e_,a=Math.sqrt(u*u+o*o)/(r_*i*(1-i)),c=a?Math.atan2(u,o)*Hg-120:NaN;return new He(c<0?c+360:c,a,i,t.opacity)}function je(t,n,e,r){return 1===arguments.length?Be(t):new He(t,n,e,null==r?1:r)}function He(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function Xe(t,n,e,r,i){var o=t*t,u=o*t;return((1-3*t+3*o-u)*n+(4-6*o+3*u)*e+(1+3*t+3*o-3*u)*r+u*i)/6}function Ve(t){var n=t.length-1;return function(e){var r=e<=0?e=0:e>=1?(e=1,n-1):Math.floor(e*n),i=t[r],o=t[r+1],u=r>0?t[r-1]:2*i-o,a=r<n-1?t[r+2]:2*o-i;return Xe((e-r/n)*n,u,i,o,a)}}function We(t){var n=t.length;return function(e){var r=Math.floor(((e%=1)<0?++e:e)*n),i=t[(r+n-1)%n],o=t[r%n],u=t[(r+1)%n],a=t[(r+2)%n];return Xe((e-r/n)*n,i,o,u,a)}}function $e(t){return function(){return t}}function Ze(t,n){return function(e){return t+e*n}}function Ge(t,n,e){return t=Math.pow(t,e),n=Math.pow(n,e)-t,e=1/e,function(r){return Math.pow(t+r*n,e)}}function Ke(t,n){var e=n-t;return e?Ze(t,e>180||e<-180?e-360*Math.round(e/360):e):$e(isNaN(t)?n:t)}function Je(t){return 1===(t=+t)?Qe:function(n,e){return e-n?Ge(n,e,t):$e(isNaN(n)?e:n)}}function Qe(t,n){var e=n-t;return e?Ze(t,e):$e(isNaN(t)?n:t)}function tr(t){return function(n){var e,r,i=n.length,o=new Array(i),u=new Array(i),a=new Array(i);for(e=0;e<i;++e)r=Ne(n[e]),o[e]=r.r||0,u[e]=r.g||0,a[e]=r.b||0;return o=t(o),u=t(u),a=t(a),r.opacity=1,function(t){return r.r=o(t),r.g=u(t),r.b=a(t),r+""}}}function nr(t,n){var e,r=n?n.length:0,i=t?Math.min(r,t.length):0,o=new Array(r),u=new Array(r); | |
for(e=0;e<i;++e)o[e]=cr(t[e],n[e]);for(;e<r;++e)u[e]=n[e];return function(t){for(e=0;e<i;++e)u[e]=o[e](t);return u}}function er(t,n){var e=new Date;return t=+t,n-=t,function(r){return e.setTime(t+n*r),e}}function rr(t,n){return t=+t,n-=t,function(e){return t+n*e}}function ir(t,n){var e,r={},i={};null!==t&&"object"==typeof t||(t={}),null!==n&&"object"==typeof n||(n={});for(e in n)e in t?r[e]=cr(t[e],n[e]):i[e]=n[e];return function(t){for(e in r)i[e]=r[e](t);return i}}function or(t){return function(){return t}}function ur(t){return function(n){return t(n)+""}}function ar(t,n){var e,r,i,o=d_.lastIndex=v_.lastIndex=0,u=-1,a=[],c=[];for(t+="",n+="";(e=d_.exec(t))&&(r=v_.exec(n));)(i=r.index)>o&&(i=n.slice(o,i),a[u]?a[u]+=i:a[++u]=i),(e=e[0])===(r=r[0])?a[u]?a[u]+=r:a[++u]=r:(a[++u]=null,c.push({i:u,x:rr(e,r)})),o=v_.lastIndex;return o<n.length&&(i=n.slice(o),a[u]?a[u]+=i:a[++u]=i),a.length<2?c[0]?ur(c[0].x):or(n):(n=c.length,function(t){for(var e,r=0;r<n;++r)a[(e=c[r]).i]=e.x(t);return a.join("")})}function cr(t,n){var e,r=typeof n;return null==n||"boolean"===r?$e(n):("number"===r?rr:"string"===r?(e=be(n))?(n=e,l_):ar:n instanceof be?l_:n instanceof Date?er:Array.isArray(n)?nr:isNaN(n)?ir:rr)(t,n)}function sr(t,n){return t=+t,n-=t,function(e){return Math.round(t+n*e)}}function fr(t,n,e,r,i,o){var u,a,c;return(u=Math.sqrt(t*t+n*n))&&(t/=u,n/=u),(c=t*e+n*r)&&(e-=t*c,r-=n*c),(a=Math.sqrt(e*e+r*r))&&(e/=a,r/=a,c/=a),t*r<n*e&&(t=-t,n=-n,c=-c,u=-u),{translateX:i,translateY:o,rotate:Math.atan2(n,t)*g_,skewX:Math.atan(c)*g_,scaleX:u,scaleY:a}}function lr(t){return"none"===t?__:(a_||(a_=document.createElement("DIV"),c_=document.documentElement,s_=document.defaultView),a_.style.transform=t,t=s_.getComputedStyle(c_.appendChild(a_),null).getPropertyValue("transform"),c_.removeChild(a_),t=t.slice(7,-1).split(","),fr(+t[0],+t[1],+t[2],+t[3],+t[4],+t[5]))}function hr(t){return null==t?__:(f_||(f_=document.createElementNS("http://www.w3.org/2000/svg","g")),f_.setAttribute("transform",t),(t=f_.transform.baseVal.consolidate())?(t=t.matrix,fr(t.a,t.b,t.c,t.d,t.e,t.f)):__)}function pr(t,n,e,r){function i(t){return t.length?t.pop()+" ":""}function o(t,r,i,o,u,a){if(t!==i||r!==o){var c=u.push("translate(",null,n,null,e);a.push({i:c-4,x:rr(t,i)},{i:c-2,x:rr(r,o)})}else(i||o)&&u.push("translate("+i+n+o+e)}function u(t,n,e,o){t!==n?(t-n>180?n+=360:n-t>180&&(t+=360),o.push({i:e.push(i(e)+"rotate(",null,r)-2,x:rr(t,n)})):n&&e.push(i(e)+"rotate("+n+r)}function a(t,n,e,o){t!==n?o.push({i:e.push(i(e)+"skewX(",null,r)-2,x:rr(t,n)}):n&&e.push(i(e)+"skewX("+n+r)}function c(t,n,e,r,o,u){if(t!==e||n!==r){var a=o.push(i(o)+"scale(",null,",",null,")");u.push({i:a-4,x:rr(t,e)},{i:a-2,x:rr(n,r)})}else 1===e&&1===r||o.push(i(o)+"scale("+e+","+r+")")}return function(n,e){var r=[],i=[];return n=t(n),e=t(e),o(n.translateX,n.translateY,e.translateX,e.translateY,r,i),u(n.rotate,e.rotate,r,i),a(n.skewX,e.skewX,r,i),c(n.scaleX,n.scaleY,e.scaleX,e.scaleY,r,i),n=e=null,function(t){for(var n,e=-1,o=i.length;++e<o;)r[(n=i[e]).i]=n.x(t);return r.join("")}}}function dr(t){return((t=Math.exp(t))+1/t)/2}function vr(t){return((t=Math.exp(t))-1/t)/2}function gr(t){return((t=Math.exp(2*t))-1)/(t+1)}function _r(t,n){var e,r,i=t[0],o=t[1],u=t[2],a=n[0],c=n[1],s=n[2],f=a-i,l=c-o,h=f*f+l*l;if(h<M_)r=Math.log(s/u)/x_,e=function(t){return[i+t*f,o+t*l,u*Math.exp(x_*t*r)]};else{var p=Math.sqrt(h),d=(s*s-u*u+w_*h)/(2*u*b_*p),v=(s*s-u*u-w_*h)/(2*s*b_*p),g=Math.log(Math.sqrt(d*d+1)-d),_=Math.log(Math.sqrt(v*v+1)-v);r=(_-g)/x_,e=function(t){var n=t*r,e=dr(g),a=u/(b_*p)*(e*gr(x_*n+g)-vr(g));return[i+a*f,o+a*l,u*e/dr(x_*n+g)]}}return e.duration=1e3*r,e}function yr(t){return function(n,e){var r=t((n=Ae(n)).h,(e=Ae(e)).h),i=Qe(n.s,e.s),o=Qe(n.l,e.l),u=Qe(n.opacity,e.opacity);return function(t){return n.h=r(t),n.s=i(t),n.l=o(t),n.opacity=u(t),n+""}}}function mr(t,n){var e=Qe((t=Re(t)).l,(n=Re(n)).l),r=Qe(t.a,n.a),i=Qe(t.b,n.b),o=Qe(t.opacity,n.opacity);return function(n){return t.l=e(n),t.a=r(n),t.b=i(n),t.opacity=o(n),t+""}}function xr(t){return function(n,e){var r=t((n=Fe(n)).h,(e=Fe(e)).h),i=Qe(n.c,e.c),o=Qe(n.l,e.l),u=Qe(n.opacity,e.opacity);return function(t){return n.h=r(t),n.c=i(t),n.l=o(t),n.opacity=u(t),n+""}}}function br(t){return function n(e){function r(n,r){var i=t((n=je(n)).h,(r=je(r)).h),o=Qe(n.s,r.s),u=Qe(n.l,r.l),a=Qe(n.opacity,r.opacity);return function(t){return n.h=i(t),n.s=o(t),n.l=u(Math.pow(t,e)),n.opacity=a(t),n+""}}return e=+e,r.gamma=n,r}(1)}function wr(t,n){for(var e=new Array(n),r=0;r<n;++r)e[r]=t(r/(n-1));return e}function Mr(){for(var t,n=0,e=arguments.length,r={};n<e;++n){if(!(t=arguments[n]+"")||t in r)throw new Error("illegal type: "+t);r[t]=[]}return new Tr(r)}function Tr(t){this._=t}function Nr(t,n){return t.trim().split(/^|\s+/).map(function(t){var e="",r=t.indexOf(".");if(r>=0&&(e=t.slice(r+1),t=t.slice(0,r)),t&&!n.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:e}})}function kr(t,n){for(var e,r=0,i=t.length;r<i;++r)if((e=t[r]).name===n)return e.value}function Sr(t,n,e){for(var r=0,i=t.length;r<i;++r)if(t[r].name===n){t[r]=C_,t=t.slice(0,r).concat(t.slice(r+1));break}return null!=e&&t.push({name:n,value:e}),t}function Er(t){return new Function("d","return {"+t.map(function(t,n){return JSON.stringify(t)+": d["+n+"]"}).join(",")+"}")}function Ar(t,n){var e=Er(t);return function(r,i){return n(e(r),i,t)}}function Cr(t){var n=Object.create(null),e=[];return t.forEach(function(t){for(var r in t)r in n||e.push(n[r]=r)}),e}function zr(t){function n(t,n){var r,i,o=e(t,function(t,e){return r?r(t,e-1):(i=t,void(r=n?Ar(t,n):Er(t)))});return o.columns=i,o}function e(t,n){function e(){if(f>=s)return u;if(i)return i=!1,o;var n,e=f;if(34===t.charCodeAt(e)){for(var r=e;r++<s;)if(34===t.charCodeAt(r)){if(34!==t.charCodeAt(r+1))break;++r}return f=r+2,n=t.charCodeAt(r+1),13===n?(i=!0,10===t.charCodeAt(r+2)&&++f):10===n&&(i=!0),t.slice(e+1,r).replace(/""/g,'"')}for(;f<s;){var a=1;if(n=t.charCodeAt(f++),10===n)i=!0;else if(13===n)i=!0,10===t.charCodeAt(f)&&(++f,++a);else if(n!==c)continue;return t.slice(e,f-a)}return t.slice(e)}for(var r,i,o={},u={},a=[],s=t.length,f=0,l=0;(r=e())!==u;){for(var h=[];r!==o&&r!==u;)h.push(r),r=e();n&&null==(h=n(h,l++))||a.push(h)}return a}function r(n,e){return null==e&&(e=Cr(n)),[e.map(u).join(t)].concat(n.map(function(n){return e.map(function(t){return u(n[t])}).join(t)})).join("\n")}function i(t){return t.map(o).join("\n")}function o(n){return n.map(u).join(t)}function u(t){return null==t?"":a.test(t+="")?'"'+t.replace(/\"/g,'""')+'"':t}var a=new RegExp('["'+t+"\n]"),c=t.charCodeAt(0);return{parse:n,parseRows:e,format:r,formatRows:i}}function Pr(t,n){function e(t){var n,e=s.status;if(!e&&Lr(s)||e>=200&&e<300||304===e){if(o)try{n=o.call(r,s)}catch(t){return void a.call("error",r,t)}else n=s;a.call("load",r,n)}else a.call("error",r,t)}var r,i,o,u,a=Mr("beforesend","progress","load","error"),c=R(),s=new XMLHttpRequest,f=null,l=null,h=0;if("undefined"==typeof XDomainRequest||"withCredentials"in s||!/^(http(s)?:)?\/\//.test(t)||(s=new XDomainRequest),"onload"in s?s.onload=s.onerror=s.ontimeout=e:s.onreadystatechange=function(t){s.readyState>3&&e(t)},s.onprogress=function(t){a.call("progress",r,t)},r={header:function(t,n){return t=(t+"").toLowerCase(),arguments.length<2?c.get(t):(null==n?c.remove(t):c.set(t,n+""),r)},mimeType:function(t){return arguments.length?(i=null==t?null:t+"",r):i},responseType:function(t){return arguments.length?(u=t,r):u},timeout:function(t){return arguments.length?(h=+t,r):h},user:function(t){return arguments.length<1?f:(f=null==t?null:t+"",r)},password:function(t){return arguments.length<1?l:(l=null==t?null:t+"",r)},response:function(t){return o=t,r},get:function(t,n){return r.send("GET",t,n)},post:function(t,n){return r.send("POST",t,n)},send:function(n,e,o){return s.open(n,t,!0,f,l),null==i||c.has("accept")||c.set("accept",i+",*/*"),s.setRequestHeader&&c.each(function(t,n){s.setRequestHeader(n,t)}),null!=i&&s.overrideMimeType&&s.overrideMimeType(i),null!=u&&(s.responseType=u),h>0&&(s.timeout=h),null==o&&"function"==typeof e&&(o=e,e=null),null!=o&&1===o.length&&(o=Rr(o)),null!=o&&r.on("error",o).on("load",function(t){o(null,t)}),a.call("beforesend",r,s),s.send(null==e?null:e),r},abort:function(){return s.abort(),r},on:function(){var t=a.on.apply(a,arguments);return t===a?r:t}},null!=n){if("function"!=typeof n)throw new Error("invalid callback: "+n);return r.get(n)}return r}function Rr(t){return function(n,e){t(null==n?e:null)}}function Lr(t){var n=t.responseType;return n&&"text"!==n?t.response:t.responseText}function qr(t,n){return function(e,r){var i=Pr(e).mimeType(t).response(n);if(null!=r){if("function"!=typeof r)throw new Error("invalid callback: "+r);return i.get(r)}return i}}function Ur(t,n){return function(e,r,i){arguments.length<3&&(i=r,r=null);var o=Pr(e).mimeType(t);return o.row=function(t){return arguments.length?o.response(Dr(n,r=t)):r},o.row(r),i?o.get(i):o}}function Dr(t,n){return function(e){return t(e.responseText,n)}}function Or(){return ty||(ry(Ir),ty=ey.now()+ny)}function Ir(){ty=0}function Fr(){this._call=this._time=this._next=null}function Yr(t,n,e){var r=new Fr;return r.restart(t,n,e),r}function Br(){Or(),++Z_;for(var t,n=z_;n;)(t=ty-n._time)>=0&&n._call.call(null,t),n=n._next;--Z_}function jr(){ty=(Q_=ey.now())+ny,Z_=G_=0;try{Br()}finally{Z_=0,Xr(),ty=0}}function Hr(){var t=ey.now(),n=t-Q_;n>J_&&(ny-=n,Q_=t)}function Xr(){for(var t,n,e=z_,r=1/0;e;)e._call?(r>e._time&&(r=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:z_=n);P_=t,Vr(r)}function Vr(t){if(!Z_){G_&&(G_=clearTimeout(G_));var n=t-ty;n>24?(t<1/0&&(G_=setTimeout(jr,n)),K_&&(K_=clearInterval(K_))):(K_||(K_=setInterval(Hr,J_)),Z_=1,ry(jr))}}function Wr(t,n,e){var r=new Fr;return n=null==n?0:+n,r.restart(function(e){r.stop(),t(e+n)},n,e),r}function $r(t,n,e){var r=new Fr,i=n;return null==n?(r.restart(t,n,e),r):(n=+n,e=null==e?Or():+e,r.restart(function o(u){u+=i,r.restart(o,i+=n,e),t(u)},n,e),r)}function Zr(t,n,e,r){function i(n){return t(n=new Date(+n)),n}return i.floor=i,i.ceil=function(e){return t(e=new Date(e-1)),n(e,1),t(e),e},i.round=function(t){var n=i(t),e=i.ceil(t);return t-n<e-t?n:e},i.offset=function(t,e){return n(t=new Date(+t),null==e?1:Math.floor(e)),t},i.range=function(e,r,o){var u=[];if(e=i.ceil(e),o=null==o?1:Math.floor(o),!(e<r&&o>0))return u;do u.push(new Date(+e));while(n(e,o),t(e),e<r);return u},i.filter=function(e){return Zr(function(n){if(n>=n)for(;t(n),!e(n);)n.setTime(n-1)},function(t,r){if(t>=t)for(;--r>=0;)for(;n(t,1),!e(t););})},e&&(i.count=function(n,r){return iy.setTime(+n),oy.setTime(+r),t(iy),t(oy),Math.floor(e(iy,oy))},i.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?i.filter(r?function(n){return r(n)%t===0}:function(n){return i.count(0,n)%t===0}):i:null}),i}function Gr(t){return Zr(function(n){n.setDate(n.getDate()-(n.getDay()+7-t)%7),n.setHours(0,0,0,0)},function(t,n){t.setDate(t.getDate()+7*n)},function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*sy)/hy})}function Kr(t){return Zr(function(n){n.setUTCDate(n.getUTCDate()-(n.getUTCDay()+7-t)%7),n.setUTCHours(0,0,0,0)},function(t,n){t.setUTCDate(t.getUTCDate()+7*n)},function(t,n){return(n-t)/hy})}function Jr(t,n){if((e=(t=n?t.toExponential(n-1):t.toExponential()).indexOf("e"))<0)return null;var e,r=t.slice(0,e);return[r.length>1?r[0]+r.slice(2):r,+t.slice(e+1)]}function Qr(t){return t=Jr(Math.abs(t)),t?t[1]:NaN}function ti(t,n){return function(e,r){for(var i=e.length,o=[],u=0,a=t[0],c=0;i>0&&a>0&&(c+a+1>r&&(a=Math.max(1,r-c)),o.push(e.substring(i-=a,i+a)),!((c+=a+1)>r));)a=t[u=(u+1)%t.length];return o.reverse().join(n)}}function ni(t,n){t=t.toPrecision(n);t:for(var e,r=t.length,i=1,o=-1;i<r;++i)switch(t[i]){case".":o=e=i;break;case"0":0===o&&(o=i),e=i;break;case"e":break t;default:o>0&&(o=0)}return o>0?t.slice(0,o)+t.slice(e+1):t}function ei(t,n){var e=Jr(t,n);if(!e)return t+"";var r=e[0],i=e[1],o=i-(cm=3*Math.max(-8,Math.min(8,Math.floor(i/3))))+1,u=r.length;return o===u?r:o>u?r+new Array(o-u+1).join("0"):o>0?r.slice(0,o)+"."+r.slice(o):"0."+new Array(1-o).join("0")+Jr(t,Math.max(0,n+o-1))[0]}function ri(t,n){var e=Jr(t,n);if(!e)return t+"";var r=e[0],i=e[1];return i<0?"0."+new Array(-i).join("0")+r:r.length>i+1?r.slice(0,i+1)+"."+r.slice(i+1):r+new Array(i-r.length+2).join("0")}function ii(t){return new oi(t)}function oi(t){if(!(n=lm.exec(t)))throw new Error("invalid format: "+t);var n,e=n[1]||" ",r=n[2]||">",i=n[3]||"-",o=n[4]||"",u=!!n[5],a=n[6]&&+n[6],c=!!n[7],s=n[8]&&+n[8].slice(1),f=n[9]||"";"n"===f?(c=!0,f="g"):fm[f]||(f=""),(u||"0"===e&&"="===r)&&(u=!0,e="0",r="="),this.fill=e,this.align=r,this.sign=i,this.symbol=o,this.zero=u,this.width=a,this.comma=c,this.precision=s,this.type=f}function ui(t){return t}function ai(t){function n(t){function n(t){var n,i,c,y=d,m=v;if("c"===p)m=g(t)+m,t="";else{t=+t;var x=(t<0||1/t<0)&&(t*=-1,!0);if(t=g(t,h),x)for(n=-1,i=t.length,x=!1;++n<i;)if(c=t.charCodeAt(n),48<c&&c<58||"x"===p&&96<c&&c<103||"X"===p&&64<c&&c<71){x=!0;break}if(y=(x?"("===a?a:"-":"-"===a||"("===a?"":a)+y,m=m+("s"===p?pm[8+cm/3]:"")+(x&&"("===a?")":""),_)for(n=-1,i=t.length;++n<i;)if(c=t.charCodeAt(n),48>c||c>57){m=(46===c?o+t.slice(n+1):t.slice(n))+m,t=t.slice(0,n);break}}l&&!s&&(t=r(t,1/0));var b=y.length+t.length+m.length,w=b<f?new Array(f-b+1).join(e):"";switch(l&&s&&(t=r(w+t,w.length?f-m.length:1/0),w=""),u){case"<":return y+t+m+w;case"=":return y+w+t+m;case"^":return w.slice(0,b=w.length>>1)+y+t+m+w.slice(b)}return w+y+t+m}t=ii(t);var e=t.fill,u=t.align,a=t.sign,c=t.symbol,s=t.zero,f=t.width,l=t.comma,h=t.precision,p=t.type,d="$"===c?i[0]:"#"===c&&/[boxX]/.test(p)?"0"+p.toLowerCase():"",v="$"===c?i[1]:/[%p]/.test(p)?"%":"",g=fm[p],_=!p||/[defgprs%]/.test(p);return h=null==h?p?6:12:/[gprs]/.test(p)?Math.max(1,Math.min(21,h)):Math.max(0,Math.min(20,h)),n.toString=function(){return t+""},n}function e(t,e){var r=n((t=ii(t),t.type="f",t)),i=3*Math.max(-8,Math.min(8,Math.floor(Qr(e)/3))),o=Math.pow(10,-i),u=pm[8+i/3];return function(t){return r(o*t)+u}}var r=t.grouping&&t.thousands?ti(t.grouping,t.thousands):ui,i=t.currency,o=t.decimal;return{format:n,formatPrefix:e}}function ci(n){return hm=ai(n),t.format=hm.format,t.formatPrefix=hm.formatPrefix,hm}function si(t){return Math.max(0,-Qr(Math.abs(t)))}function fi(t,n){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(Qr(n)/3)))-Qr(Math.abs(t)))}function li(t,n){return t=Math.abs(t),n=Math.abs(n)-t,Math.max(0,Qr(n)-Qr(t))+1}function hi(t){if(0<=t.y&&t.y<100){var n=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return n.setFullYear(t.y),n}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function pi(t){if(0<=t.y&&t.y<100){var n=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return n.setUTCFullYear(t.y),n}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function di(t){return{y:t,m:0,d:1,H:0,M:0,S:0,L:0}}function vi(t){function n(t,n){return function(e){var r,i,o,u=[],a=-1,c=0,s=t.length;for(e instanceof Date||(e=new Date(+e));++a<s;)37===t.charCodeAt(a)&&(u.push(t.slice(c,a)),null!=(i=vm[r=t.charAt(++a)])?r=t.charAt(++a):i="e"===r?" ":"0",(o=n[r])&&(r=o(e,i)),u.push(r),c=a+1);return u.push(t.slice(c,a)),u.join("")}}function e(t,n){return function(e){var i=di(1900),o=r(i,t,e+="",0);if(o!=e.length)return null;if("p"in i&&(i.H=i.H%12+12*i.p),"W"in i||"U"in i){"w"in i||(i.w="W"in i?1:0);var u="Z"in i?pi(di(i.y)).getUTCDay():n(di(i.y)).getDay();i.m=0,i.d="W"in i?(i.w+6)%7+7*i.W-(u+5)%7:i.w+7*i.U-(u+6)%7}return"Z"in i?(i.H+=i.Z/100|0,i.M+=i.Z%100,pi(i)):n(i)}}function r(t,n,e,r){for(var i,o,u=0,a=n.length,c=e.length;u<a;){if(r>=c)return-1;if(i=n.charCodeAt(u++),37===i){if(i=n.charAt(u++),o=B[i in vm?n.charAt(u++):i],!o||(r=o(t,e,r))<0)return-1}else if(i!=e.charCodeAt(r++))return-1}return r}function i(t,n,e){var r=C.exec(n.slice(e));return r?(t.p=z[r[0].toLowerCase()],e+r[0].length):-1}function o(t,n,e){var r=L.exec(n.slice(e));return r?(t.w=q[r[0].toLowerCase()],e+r[0].length):-1}function u(t,n,e){var r=P.exec(n.slice(e));return r?(t.w=R[r[0].toLowerCase()],e+r[0].length):-1}function a(t,n,e){var r=O.exec(n.slice(e));return r?(t.m=I[r[0].toLowerCase()],e+r[0].length):-1}function c(t,n,e){var r=U.exec(n.slice(e));return r?(t.m=D[r[0].toLowerCase()],e+r[0].length):-1}function s(t,n,e){return r(t,w,n,e)}function f(t,n,e){return r(t,M,n,e)}function l(t,n,e){return r(t,T,n,e)}function h(t){return S[t.getDay()]}function p(t){return k[t.getDay()]}function d(t){return A[t.getMonth()]}function v(t){return E[t.getMonth()]}function g(t){return N[+(t.getHours()>=12)]}function _(t){return S[t.getUTCDay()]}function y(t){return k[t.getUTCDay()]}function m(t){return A[t.getUTCMonth()]}function x(t){return E[t.getUTCMonth()]}function b(t){return N[+(t.getUTCHours()>=12)]}var w=t.dateTime,M=t.date,T=t.time,N=t.periods,k=t.days,S=t.shortDays,E=t.months,A=t.shortMonths,C=yi(N),z=mi(N),P=yi(k),R=mi(k),L=yi(S),q=mi(S),U=yi(E),D=mi(E),O=yi(A),I=mi(A),F={a:h,A:p,b:d,B:v,c:null,d:Li,e:Li,H:qi,I:Ui,j:Di,L:Oi,m:Ii,M:Fi,p:g,S:Yi,U:Bi,w:ji,W:Hi,x:null,X:null,y:Xi,Y:Vi,Z:Wi,"%":co},Y={a:_,A:y,b:m,B:x,c:null,d:$i,e:$i,H:Zi,I:Gi,j:Ki,L:Ji,m:Qi,M:to,p:b,S:no,U:eo,w:ro,W:io,x:null,X:null,y:oo,Y:uo,Z:ao,"%":co},B={a:o,A:u,b:a,B:c,c:s,d:Si,e:Si,H:Ai,I:Ai,j:Ei,L:Pi,m:ki,M:Ci,p:i,S:zi,U:bi,w:xi,W:wi,x:f,X:l,y:Ti,Y:Mi,Z:Ni,"%":Ri};return F.x=n(M,F),F.X=n(T,F),F.c=n(w,F),Y.x=n(M,Y),Y.X=n(T,Y),Y.c=n(w,Y),{format:function(t){var e=n(t+="",F);return e.toString=function(){return t},e},parse:function(t){var n=e(t+="",hi);return n.toString=function(){return t},n},utcFormat:function(t){var e=n(t+="",Y);return e.toString=function(){return t},e},utcParse:function(t){var n=e(t,pi);return n.toString=function(){return t},n}}}function gi(t,n,e){var r=t<0?"-":"",i=(r?-t:t)+"",o=i.length;return r+(o<e?new Array(e-o+1).join(n)+i:i)}function _i(t){return t.replace(ym,"\\$&")}function yi(t){return new RegExp("^(?:"+t.map(_i).join("|")+")","i")}function mi(t){for(var n={},e=-1,r=t.length;++e<r;)n[t[e].toLowerCase()]=e;return n}function xi(t,n,e){var r=gm.exec(n.slice(e,e+1));return r?(t.w=+r[0],e+r[0].length):-1}function bi(t,n,e){var r=gm.exec(n.slice(e));return r?(t.U=+r[0],e+r[0].length):-1}function wi(t,n,e){var r=gm.exec(n.slice(e));return r?(t.W=+r[0],e+r[0].length):-1}function Mi(t,n,e){var r=gm.exec(n.slice(e,e+4));return r?(t.y=+r[0],e+r[0].length):-1}function Ti(t,n,e){var r=gm.exec(n.slice(e,e+2));return r?(t.y=+r[0]+(+r[0]>68?1900:2e3),e+r[0].length):-1}function Ni(t,n,e){var r=/^(Z)|([+-]\d\d)(?:\:?(\d\d))?/.exec(n.slice(e,e+6));return r?(t.Z=r[1]?0:-(r[2]+(r[3]||"00")),e+r[0].length):-1}function ki(t,n,e){var r=gm.exec(n.slice(e,e+2));return r?(t.m=r[0]-1,e+r[0].length):-1}function Si(t,n,e){var r=gm.exec(n.slice(e,e+2));return r?(t.d=+r[0],e+r[0].length):-1}function Ei(t,n,e){var r=gm.exec(n.slice(e,e+3));return r?(t.m=0,t.d=+r[0],e+r[0].length):-1}function Ai(t,n,e){var r=gm.exec(n.slice(e,e+2));return r?(t.H=+r[0],e+r[0].length):-1}function Ci(t,n,e){var r=gm.exec(n.slice(e,e+2));return r?(t.M=+r[0],e+r[0].length):-1}function zi(t,n,e){var r=gm.exec(n.slice(e,e+2));return r?(t.S=+r[0],e+r[0].length):-1}function Pi(t,n,e){var r=gm.exec(n.slice(e,e+3));return r?(t.L=+r[0],e+r[0].length):-1}function Ri(t,n,e){var r=_m.exec(n.slice(e,e+1));return r?e+r[0].length:-1}function Li(t,n){return gi(t.getDate(),n,2)}function qi(t,n){return gi(t.getHours(),n,2)}function Ui(t,n){return gi(t.getHours()%12||12,n,2)}function Di(t,n){return gi(1+my.count(Dy(t),t),n,3)}function Oi(t,n){return gi(t.getMilliseconds(),n,3)}function Ii(t,n){return gi(t.getMonth()+1,n,2)}function Fi(t,n){return gi(t.getMinutes(),n,2)}function Yi(t,n){return gi(t.getSeconds(),n,2)}function Bi(t,n){return gi(by.count(Dy(t),t),n,2)}function ji(t){return t.getDay()}function Hi(t,n){return gi(wy.count(Dy(t),t),n,2)}function Xi(t,n){return gi(t.getFullYear()%100,n,2)}function Vi(t,n){return gi(t.getFullYear()%1e4,n,4)}function Wi(t){var n=t.getTimezoneOffset();return(n>0?"-":(n*=-1,"+"))+gi(n/60|0,"0",2)+gi(n%60,"0",2)}function $i(t,n){return gi(t.getUTCDate(),n,2)}function Zi(t,n){return gi(t.getUTCHours(),n,2)}function Gi(t,n){return gi(t.getUTCHours()%12||12,n,2)}function Ki(t,n){return gi(1+jy.count(am(t),t),n,3)}function Ji(t,n){return gi(t.getUTCMilliseconds(),n,3)}function Qi(t,n){return gi(t.getUTCMonth()+1,n,2)}function to(t,n){return gi(t.getUTCMinutes(),n,2)}function no(t,n){return gi(t.getUTCSeconds(),n,2)}function eo(t,n){return gi(Xy.count(am(t),t),n,2)}function ro(t){return t.getUTCDay()}function io(t,n){return gi(Vy.count(am(t),t),n,2)}function oo(t,n){return gi(t.getUTCFullYear()%100,n,2)}function uo(t,n){return gi(t.getUTCFullYear()%1e4,n,4)}function ao(){return"+0000"}function co(){return"%"}function so(n){return dm=vi(n),t.timeFormat=dm.format,t.timeParse=dm.parse,t.utcFormat=dm.utcFormat,t.utcParse=dm.utcParse,dm}function fo(t){return t.toISOString()}function lo(t){var n=new Date(t);return isNaN(n)?null:n}function ho(t){function n(n){var o=n+"",u=e.get(o);if(!u){if(i!==Nm)return i;e.set(o,u=r.push(n))}return t[(u-1)%t.length]}var e=R(),r=[],i=Nm;return t=null==t?[]:Tm.call(t),n.domain=function(t){if(!arguments.length)return r.slice();r=[],e=R();for(var i,o,u=-1,a=t.length;++u<a;)e.has(o=(i=t[u])+"")||e.set(o,r.push(i));return n},n.range=function(e){return arguments.length?(t=Tm.call(e),n):t.slice()},n.unknown=function(t){return arguments.length?(i=t,n):i},n.copy=function(){return ho().domain(r).range(t).unknown(i)},n}function po(){function t(){var t=i().length,r=u[1]<u[0],h=u[r-0],p=u[1-r];n=(p-h)/Math.max(1,t-c+2*s),a&&(n=Math.floor(n)),h+=(p-h-n*(t-c))*f,e=n*(1-c),a&&(h=Math.round(h),e=Math.round(e));var d=l(t).map(function(t){return h+n*t});return o(r?d.reverse():d)}var n,e,r=ho().unknown(void 0),i=r.domain,o=r.range,u=[0,1],a=!1,c=0,s=0,f=.5;return delete r.unknown,r.domain=function(n){return arguments.length?(i(n),t()):i()},r.range=function(n){return arguments.length?(u=[+n[0],+n[1]],t()):u.slice()},r.rangeRound=function(n){return u=[+n[0],+n[1]],a=!0,t()},r.bandwidth=function(){return e},r.step=function(){return n},r.round=function(n){return arguments.length?(a=!!n,t()):a},r.padding=function(n){return arguments.length?(c=s=Math.max(0,Math.min(1,n)),t()):c},r.paddingInner=function(n){return arguments.length?(c=Math.max(0,Math.min(1,n)),t()):c},r.paddingOuter=function(n){return arguments.length?(s=Math.max(0,Math.min(1,n)),t()):s},r.align=function(n){return arguments.length?(f=Math.max(0,Math.min(1,n)),t()):f},r.copy=function(){return po().domain(i()).range(u).round(a).paddingInner(c).paddingOuter(s).align(f)},t()}function vo(t){var n=t.copy;return t.padding=t.paddingOuter,delete t.paddingInner,delete t.paddingOuter,t.copy=function(){return vo(n())},t}function go(){return vo(po().paddingInner(1))}function _o(t){return function(){return t}}function yo(t){return+t}function mo(t,n){return(n-=t=+t)?function(e){return(e-t)/n}:_o(n)}function xo(t){return function(n,e){var r=t(n=+n,e=+e);return function(t){return t<=n?0:t>=e?1:r(t)}}}function bo(t){return function(n,e){var r=t(n=+n,e=+e);return function(t){return t<=0?n:t>=1?e:r(t)}}}function wo(t,n,e,r){var i=t[0],o=t[1],u=n[0],a=n[1];return o<i?(i=e(o,i),u=r(a,u)):(i=e(i,o),u=r(u,a)),function(t){return u(i(t))}}function Mo(t,n,e,r){var i=Math.min(t.length,n.length)-1,o=new Array(i),u=new Array(i),a=-1;for(t[i]<t[0]&&(t=t.slice().reverse(),n=n.slice().reverse());++a<i;)o[a]=e(t[a],t[a+1]),u[a]=r(n[a],n[a+1]);return function(n){var e=cv(t,n,1,i)-1;return u[e](o[e](n))}}function To(t,n){return n.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp())}function No(t,n){function e(){return i=Math.min(a.length,c.length)>2?Mo:wo,o=u=null,r}function r(n){return(o||(o=i(a,c,f?xo(t):t,s)))(+n)}var i,o,u,a=km,c=km,s=cr,f=!1;return r.invert=function(t){return(u||(u=i(c,a,mo,f?bo(n):n)))(+t)},r.domain=function(t){return arguments.length?(a=Mm.call(t,yo),e()):a.slice()},r.range=function(t){return arguments.length?(c=Tm.call(t),e()):c.slice()},r.rangeRound=function(t){return c=Tm.call(t),s=sr,e()},r.clamp=function(t){return arguments.length?(f=!!t,e()):f},r.interpolate=function(t){return arguments.length?(s=t,e()):s},e()}function ko(n,e,r){var i,o=n[0],u=n[n.length-1],a=p(o,u,null==e?10:e);switch(r=ii(null==r?",f":r),r.type){case"s":var c=Math.max(Math.abs(o),Math.abs(u));return null!=r.precision||isNaN(i=fi(a,c))||(r.precision=i),t.formatPrefix(r,c);case"":case"e":case"g":case"p":case"r":null!=r.precision||isNaN(i=li(a,Math.max(Math.abs(o),Math.abs(u))))||(r.precision=i-("e"===r.type));break;case"f":case"%":null!=r.precision||isNaN(i=si(a))||(r.precision=i-2*("%"===r.type))}return t.format(r)}function So(t){var n=t.domain;return t.ticks=function(t){var e=n();return h(e[0],e[e.length-1],null==t?10:t)},t.tickFormat=function(t,e){return ko(n(),t,e)},t.nice=function(e){var r=n(),i=r.length-1,o=null==e?10:e,u=r[0],a=r[i],c=p(u,a,o);return c&&(c=p(Math.floor(u/c)*c,Math.ceil(a/c)*c,o),r[0]=Math.floor(u/c)*c,r[i]=Math.ceil(a/c)*c,n(r)),t},t}function Eo(){var t=No(mo,rr);return t.copy=function(){return To(t,Eo())},So(t)}function Ao(){function t(t){return+t}var n=[0,1];return t.invert=t,t.domain=t.range=function(e){return arguments.length?(n=Mm.call(e,yo),t):n.slice()},t.copy=function(){return Ao().domain(n)},So(t)}function Co(t,n){t=t.slice();var e,r=0,i=t.length-1,o=t[r],u=t[i];return u<o&&(e=r,r=i,i=e,e=o,o=u,u=e),t[r]=n.floor(o),t[i]=n.ceil(u),t}function zo(t,n){return(n=Math.log(n/t))?function(e){return Math.log(e/t)/n}:_o(n)}function Po(t,n){return t<0?function(e){return-Math.pow(-n,e)*Math.pow(-t,1-e)}:function(e){return Math.pow(n,e)*Math.pow(t,1-e)}}function Ro(t){return isFinite(t)?+("1e"+t):t<0?0:t}function Lo(t){return 10===t?Ro:t===Math.E?Math.exp:function(n){return Math.pow(t,n)}}function qo(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),function(n){return Math.log(n)/t})}function Uo(t){return function(n){return-t(-n)}}function Do(){function n(){return o=qo(i),u=Lo(i),r()[0]<0&&(o=Uo(o),u=Uo(u)),e}var e=No(zo,Po).domain([1,10]),r=e.domain,i=10,o=qo(10),u=Lo(10);return e.base=function(t){return arguments.length?(i=+t,n()):i},e.domain=function(t){return arguments.length?(r(t),n()):r()},e.ticks=function(t){var n,e=r(),a=e[0],c=e[e.length-1];(n=c<a)&&(p=a,a=c,c=p);var s,f,l,p=o(a),d=o(c),v=null==t?10:+t,g=[];if(!(i%1)&&d-p<v){if(p=Math.round(p)-1,d=Math.round(d)+1,a>0){for(;p<d;++p)for(f=1,s=u(p);f<i;++f)if(l=s*f,!(l<a)){if(l>c)break;g.push(l)}}else for(;p<d;++p)for(f=i-1,s=u(p);f>=1;--f)if(l=s*f,!(l<a)){if(l>c)break;g.push(l)}}else g=h(p,d,Math.min(d-p,v)).map(u);return n?g.reverse():g},e.tickFormat=function(n,r){if(null==r&&(r=10===i?".0e":","),"function"!=typeof r&&(r=t.format(r)),n===1/0)return r;null==n&&(n=10);var a=Math.max(1,i*n/e.ticks().length);return function(t){var n=t/u(Math.round(o(t)));return n*i<i-.5&&(n*=i),n<=a?r(t):""}},e.nice=function(){return r(Co(r(),{floor:function(t){return u(Math.floor(o(t)))},ceil:function(t){return u(Math.ceil(o(t)))}}))},e.copy=function(){return To(e,Do().base(i))},e}function Oo(t,n){return t<0?-Math.pow(-t,n):Math.pow(t,n)}function Io(){function t(t,n){return(n=Oo(n,e)-(t=Oo(t,e)))?function(r){return(Oo(r,e)-t)/n}:_o(n)}function n(t,n){return n=Oo(n,e)-(t=Oo(t,e)),function(r){return Oo(t+n*r,1/e)}}var e=1,r=No(t,n),i=r.domain;return r.exponent=function(t){return arguments.length?(e=+t,i(i())):e},r.copy=function(){return To(r,Io().exponent(e))},So(r)}function Fo(){return Io().exponent(.5)}function Yo(){function t(){var t=0,n=Math.max(1,i.length);for(o=new Array(n-1);++t<n;)o[t-1]=g(r,t/n);return e}function e(t){if(!isNaN(t=+t))return i[cv(o,t)]}var r=[],i=[],o=[];return e.invertExtent=function(t){var n=i.indexOf(t);return n<0?[NaN,NaN]:[n>0?o[n-1]:r[0],n<o.length?o[n]:r[r.length-1]]},e.domain=function(e){if(!arguments.length)return r.slice();r=[];for(var i,o=0,u=e.length;o<u;++o)i=e[o],null==i||isNaN(i=+i)||r.push(i);return r.sort(n),t()},e.range=function(n){return arguments.length?(i=Tm.call(n),t()):i.slice()},e.quantiles=function(){return o.slice()},e.copy=function(){return Yo().domain(r).range(i)},e}function Bo(){function t(t){if(t<=t)return u[cv(o,t,0,i)]}function n(){var n=-1;for(o=new Array(i);++n<i;)o[n]=((n+1)*r-(n-i)*e)/(i+1);return t}var e=0,r=1,i=1,o=[.5],u=[0,1];return t.domain=function(t){return arguments.length?(e=+t[0],r=+t[1],n()):[e,r]},t.range=function(t){return arguments.length?(i=(u=Tm.call(t)).length-1,n()):u.slice()},t.invertExtent=function(t){var n=u.indexOf(t);return n<0?[NaN,NaN]:n<1?[e,o[0]]:n>=i?[o[i-1],r]:[o[n-1],o[n]]},t.copy=function(){return Bo().domain([e,r]).range(u)},So(t)}function jo(){function t(t){if(t<=t)return e[cv(n,t,0,r)]}var n=[.5],e=[0,1],r=1;return t.domain=function(i){return arguments.length?(n=Tm.call(i),r=Math.min(n.length,e.length-1),t):n.slice()},t.range=function(i){return arguments.length?(e=Tm.call(i),r=Math.min(n.length,e.length-1),t):e.slice()},t.invertExtent=function(t){var r=e.indexOf(t);return[n[r-1],n[r]]},t.copy=function(){return jo().domain(n).range(e)},t}function Ho(t){return new Date(t)}function Xo(t){return t instanceof Date?+t:+new Date(+t)}function Vo(t,n,r,i,o,u,a,c,s){function f(e){return(a(e)<e?g:u(e)<e?_:o(e)<e?y:i(e)<e?m:n(e)<e?r(e)<e?x:b:t(e)<e?w:M)(e)}function l(n,r,i,o){if(null==n&&(n=10),"number"==typeof n){var u=Math.abs(i-r)/n,a=e(function(t){return t[2]}).right(T,u);a===T.length?(o=p(r/Rm,i/Rm,n),n=t):a?(a=T[u/T[a-1][2]<T[a][2]/u?a-1:a],o=a[1],n=a[0]):(o=p(r,i,n),n=c)}return null==o?n:n.every(o)}var h=No(mo,rr),d=h.invert,v=h.domain,g=s(".%L"),_=s(":%S"),y=s("%I:%M"),m=s("%I %p"),x=s("%a %d"),b=s("%b %d"),w=s("%B"),M=s("%Y"),T=[[a,1,Sm],[a,5,5*Sm],[a,15,15*Sm],[a,30,30*Sm],[u,1,Em],[u,5,5*Em],[u,15,15*Em],[u,30,30*Em],[o,1,Am],[o,3,3*Am],[o,6,6*Am],[o,12,12*Am],[i,1,Cm],[i,2,2*Cm],[r,1,zm],[n,1,Pm],[n,3,3*Pm],[t,1,Rm]];return h.invert=function(t){return new Date(d(t))},h.domain=function(t){return arguments.length?v(Mm.call(t,Xo)):v().map(Ho)},h.ticks=function(t,n){var e,r=v(),i=r[0],o=r[r.length-1],u=o<i;return u&&(e=i,i=o,o=e),e=l(t,i,o,n),e=e?e.range(i,o+1):[],u?e.reverse():e},h.tickFormat=function(t,n){return null==n?f:s(n)},h.nice=function(t,n){var e=v();return(t=l(t,e[0],e[e.length-1],n))?v(Co(e,t)):h},h.copy=function(){return To(h,Vo(t,n,r,i,o,u,a,c,s))},h}function Wo(){return Vo(Dy,qy,by,my,_y,vy,py,uy,t.timeFormat).domain([new Date(2e3,0,1),new Date(2e3,0,2)])}function $o(){return Vo(am,om,Xy,jy,Yy,Iy,py,uy,t.utcFormat).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])}function Zo(t){return t.match(/.{6}/g).map(function(t){return"#"+t})}function Go(t){(t<0||t>1)&&(t-=Math.floor(t));var n=Math.abs(t-.5);return Ym.h=360*t-100,Ym.s=1.5-1.5*n,Ym.l=.8-.9*n,Ym+""}function Ko(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}}function Jo(t){function n(n){var o=(n-e)/(r-e);return t(i?Math.max(0,Math.min(1,o)):o)}var e=0,r=1,i=!1;return n.domain=function(t){return arguments.length?(e=+t[0],r=+t[1],n):[e,r]},n.clamp=function(t){return arguments.length?(i=!!t,n):i},n.interpolator=function(e){return arguments.length?(t=e,n):t},n.copy=function(){return Jo(t).domain([e,r]).clamp(i)},So(n)}function Qo(t){var n=t+="",e=n.indexOf(":");return e>=0&&"xmlns"!==(n=t.slice(0,e))&&(t=t.slice(e+1)),Wm.hasOwnProperty(n)?{space:Wm[n],local:t}:t}function tu(t){return function(){var n=this.ownerDocument,e=this.namespaceURI;return e===Vm&&n.documentElement.namespaceURI===Vm?n.createElement(t):n.createElementNS(e,t)}}function nu(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function eu(t){var n=Qo(t);return(n.local?nu:tu)(n)}function ru(){return new iu}function iu(){this._="@"+(++$m).toString(36)}function ou(t,n,e){return t=uu(t,n,e),function(n){var e=n.relatedTarget;e&&(e===this||8&e.compareDocumentPosition(this))||t.call(this,n)}}function uu(n,e,r){return function(i){var o=t.event;t.event=i;try{n.call(this,this.__data__,e,r)}finally{t.event=o}}}function au(t){return t.trim().split(/^|\s+/).map(function(t){var n="",e=t.indexOf("."); | |
return e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),{type:t,name:n}})}function cu(t){return function(){var n=this.__on;if(n){for(var e,r=0,i=-1,o=n.length;r<o;++r)e=n[r],t.type&&e.type!==t.type||e.name!==t.name?n[++i]=e:this.removeEventListener(e.type,e.listener,e.capture);++i?n.length=i:delete this.__on}}}function su(t,n,e){var r=Qm.hasOwnProperty(t.type)?ou:uu;return function(i,o,u){var a,c=this.__on,s=r(n,o,u);if(c)for(var f=0,l=c.length;f<l;++f)if((a=c[f]).type===t.type&&a.name===t.name)return this.removeEventListener(a.type,a.listener,a.capture),this.addEventListener(a.type,a.listener=s,a.capture=e),void(a.value=n);this.addEventListener(t.type,s,e),a={type:t.type,name:t.name,value:n,listener:s,capture:e},c?c.push(a):this.__on=[a]}}function fu(t,n,e){var r,i,o=au(t+""),u=o.length;{if(!(arguments.length<2)){for(a=n?su:cu,null==e&&(e=!1),r=0;r<u;++r)this.each(a(o[r],n,e));return this}var a=this.node().__on;if(a)for(var c,s=0,f=a.length;s<f;++s)for(r=0,c=a[s];r<u;++r)if((i=o[r]).type===c.type&&i.name===c.name)return c.value}}function lu(n,e,r,i){var o=t.event;n.sourceEvent=t.event,t.event=n;try{return e.apply(r,i)}finally{t.event=o}}function hu(){for(var n,e=t.event;n=e.sourceEvent;)e=n;return e}function pu(t,n){var e=t.ownerSVGElement||t;if(e.createSVGPoint){var r=e.createSVGPoint();return r.x=n.clientX,r.y=n.clientY,r=r.matrixTransform(t.getScreenCTM().inverse()),[r.x,r.y]}var i=t.getBoundingClientRect();return[n.clientX-i.left-t.clientLeft,n.clientY-i.top-t.clientTop]}function du(t){var n=hu();return n.changedTouches&&(n=n.changedTouches[0]),pu(t,n)}function vu(){}function gu(t){return null==t?vu:function(){return this.querySelector(t)}}function _u(t){"function"!=typeof t&&(t=gu(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,u,a=n[i],c=a.length,s=r[i]=new Array(c),f=0;f<c;++f)(o=a[f])&&(u=t.call(o,o.__data__,f,a))&&("__data__"in o&&(u.__data__=o.__data__),s[f]=u);return new Ra(r,this._parents)}function yu(){return[]}function mu(t){return null==t?yu:function(){return this.querySelectorAll(t)}}function xu(t){"function"!=typeof t&&(t=mu(t));for(var n=this._groups,e=n.length,r=[],i=[],o=0;o<e;++o)for(var u,a=n[o],c=a.length,s=0;s<c;++s)(u=a[s])&&(r.push(t.call(u,u.__data__,s,a)),i.push(u));return new Ra(r,i)}function bu(t){"function"!=typeof t&&(t=Jm(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,u=n[i],a=u.length,c=r[i]=[],s=0;s<a;++s)(o=u[s])&&t.call(o,o.__data__,s,u)&&c.push(o);return new Ra(r,this._parents)}function wu(t){return new Array(t.length)}function Mu(){return new Ra(this._enter||this._groups.map(wu),this._parents)}function Tu(t,n){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=n}function Nu(t){return function(){return t}}function ku(t,n,e,r,i,o){for(var u,a=0,c=n.length,s=o.length;a<s;++a)(u=n[a])?(u.__data__=o[a],r[a]=u):e[a]=new Tu(t,o[a]);for(;a<c;++a)(u=n[a])&&(i[a]=u)}function Su(t,n,e,r,i,o,u){var a,c,s,f={},l=n.length,h=o.length,p=new Array(l);for(a=0;a<l;++a)(c=n[a])&&(p[a]=s=nx+u.call(c,c.__data__,a,n),s in f?i[a]=c:f[s]=c);for(a=0;a<h;++a)s=nx+u.call(t,o[a],a,o),(c=f[s])?(r[a]=c,c.__data__=o[a],f[s]=null):e[a]=new Tu(t,o[a]);for(a=0;a<l;++a)(c=n[a])&&f[p[a]]===c&&(i[a]=c)}function Eu(t,n){if(!t)return p=new Array(this.size()),s=-1,this.each(function(t){p[++s]=t}),p;var e=n?Su:ku,r=this._parents,i=this._groups;"function"!=typeof t&&(t=Nu(t));for(var o=i.length,u=new Array(o),a=new Array(o),c=new Array(o),s=0;s<o;++s){var f=r[s],l=i[s],h=l.length,p=t.call(f,f&&f.__data__,s,r),d=p.length,v=a[s]=new Array(d),g=u[s]=new Array(d),_=c[s]=new Array(h);e(f,l,v,g,_,p,n);for(var y,m,x=0,b=0;x<d;++x)if(y=v[x]){for(x>=b&&(b=x+1);!(m=g[b])&&++b<d;);y._next=m||null}}return u=new Ra(u,r),u._enter=a,u._exit=c,u}function Au(){return new Ra(this._exit||this._groups.map(wu),this._parents)}function Cu(t){for(var n=this._groups,e=t._groups,r=n.length,i=e.length,o=Math.min(r,i),u=new Array(r),a=0;a<o;++a)for(var c,s=n[a],f=e[a],l=s.length,h=u[a]=new Array(l),p=0;p<l;++p)(c=s[p]||f[p])&&(h[p]=c);for(;a<r;++a)u[a]=n[a];return new Ra(u,this._parents)}function zu(){for(var t=this._groups,n=-1,e=t.length;++n<e;)for(var r,i=t[n],o=i.length-1,u=i[o];--o>=0;)(r=i[o])&&(u&&u!==r.nextSibling&&u.parentNode.insertBefore(r,u),u=r);return this}function Pu(t){function n(n,e){return n&&e?t(n.__data__,e.__data__):!n-!e}t||(t=Ru);for(var e=this._groups,r=e.length,i=new Array(r),o=0;o<r;++o){for(var u,a=e[o],c=a.length,s=i[o]=new Array(c),f=0;f<c;++f)(u=a[f])&&(s[f]=u);s.sort(n)}return new Ra(i,this._parents).order()}function Ru(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function Lu(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this}function qu(){var t=new Array(this.size()),n=-1;return this.each(function(){t[++n]=this}),t}function Uu(){for(var t=this._groups,n=0,e=t.length;n<e;++n)for(var r=t[n],i=0,o=r.length;i<o;++i){var u=r[i];if(u)return u}return null}function Du(){var t=0;return this.each(function(){++t}),t}function Ou(){return!this.node()}function Iu(t){for(var n=this._groups,e=0,r=n.length;e<r;++e)for(var i,o=n[e],u=0,a=o.length;u<a;++u)(i=o[u])&&t.call(i,i.__data__,u,o);return this}function Fu(t){return function(){this.removeAttribute(t)}}function Yu(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Bu(t,n){return function(){this.setAttribute(t,n)}}function ju(t,n){return function(){this.setAttributeNS(t.space,t.local,n)}}function Hu(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttribute(t):this.setAttribute(t,e)}}function Xu(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,e)}}function Vu(t,n){var e=Qo(t);if(arguments.length<2){var r=this.node();return e.local?r.getAttributeNS(e.space,e.local):r.getAttribute(e)}return this.each((null==n?e.local?Yu:Fu:"function"==typeof n?e.local?Xu:Hu:e.local?ju:Bu)(e,n))}function Wu(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function $u(t){return function(){this.style.removeProperty(t)}}function Zu(t,n,e){return function(){this.style.setProperty(t,n,e)}}function Gu(t,n,e){return function(){var r=n.apply(this,arguments);null==r?this.style.removeProperty(t):this.style.setProperty(t,r,e)}}function Ku(t,n,e){var r;return arguments.length>1?this.each((null==n?$u:"function"==typeof n?Gu:Zu)(t,n,null==e?"":e)):Wu(r=this.node()).getComputedStyle(r,null).getPropertyValue(t)}function Ju(t){return function(){delete this[t]}}function Qu(t,n){return function(){this[t]=n}}function ta(t,n){return function(){var e=n.apply(this,arguments);null==e?delete this[t]:this[t]=e}}function na(t,n){return arguments.length>1?this.each((null==n?Ju:"function"==typeof n?ta:Qu)(t,n)):this.node()[t]}function ea(t){return t.trim().split(/^|\s+/)}function ra(t){return t.classList||new ia(t)}function ia(t){this._node=t,this._names=ea(t.getAttribute("class")||"")}function oa(t,n){for(var e=ra(t),r=-1,i=n.length;++r<i;)e.add(n[r])}function ua(t,n){for(var e=ra(t),r=-1,i=n.length;++r<i;)e.remove(n[r])}function aa(t){return function(){oa(this,t)}}function ca(t){return function(){ua(this,t)}}function sa(t,n){return function(){(n.apply(this,arguments)?oa:ua)(this,t)}}function fa(t,n){var e=ea(t+"");if(arguments.length<2){for(var r=ra(this.node()),i=-1,o=e.length;++i<o;)if(!r.contains(e[i]))return!1;return!0}return this.each(("function"==typeof n?sa:n?aa:ca)(e,n))}function la(){this.textContent=""}function ha(t){return function(){this.textContent=t}}function pa(t){return function(){var n=t.apply(this,arguments);this.textContent=null==n?"":n}}function da(t){return arguments.length?this.each(null==t?la:("function"==typeof t?pa:ha)(t)):this.node().textContent}function va(){this.innerHTML=""}function ga(t){return function(){this.innerHTML=t}}function _a(t){return function(){var n=t.apply(this,arguments);this.innerHTML=null==n?"":n}}function ya(t){return arguments.length?this.each(null==t?va:("function"==typeof t?_a:ga)(t)):this.node().innerHTML}function ma(){this.nextSibling&&this.parentNode.appendChild(this)}function xa(){return this.each(ma)}function ba(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function wa(){return this.each(ba)}function Ma(t){var n="function"==typeof t?t:eu(t);return this.select(function(){return this.appendChild(n.apply(this,arguments))})}function Ta(){return null}function Na(t,n){var e="function"==typeof t?t:eu(t),r=null==n?Ta:"function"==typeof n?n:gu(n);return this.select(function(){return this.insertBefore(e.apply(this,arguments),r.apply(this,arguments)||null)})}function ka(){var t=this.parentNode;t&&t.removeChild(this)}function Sa(){return this.each(ka)}function Ea(t){return arguments.length?this.property("__data__",t):this.node().__data__}function Aa(t,n,e){var r=Wu(t),i=r.CustomEvent;i?i=new i(n,e):(i=r.document.createEvent("Event"),e?(i.initEvent(n,e.bubbles,e.cancelable),i.detail=e.detail):i.initEvent(n,!1,!1)),t.dispatchEvent(i)}function Ca(t,n){return function(){return Aa(this,t,n)}}function za(t,n){return function(){return Aa(this,t,n.apply(this,arguments))}}function Pa(t,n){return this.each(("function"==typeof n?za:Ca)(t,n))}function Ra(t,n){this._groups=t,this._parents=n}function La(){return new Ra([[document.documentElement]],ex)}function qa(t){return"string"==typeof t?new Ra([[document.querySelector(t)]],[document.documentElement]):new Ra([[t]],ex)}function Ua(t){return"string"==typeof t?new Ra([document.querySelectorAll(t)],[document.documentElement]):new Ra([null==t?[]:t],ex)}function Da(t,n,e){arguments.length<3&&(e=n,n=hu().changedTouches);for(var r,i=0,o=n?n.length:0;i<o;++i)if((r=n[i]).identifier===e)return pu(t,r);return null}function Oa(t,n){null==n&&(n=hu().touches);for(var e=0,r=n?n.length:0,i=new Array(r);e<r;++e)i[e]=pu(t,n[e]);return i}function Ia(t,n,e,r,i,o){var u=t.__transition;if(u){if(e in u)return}else t.__transition={};ja(t,e,{name:n,index:r,group:i,on:rx,tween:ix,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:ox})}function Fa(t,n){var e=t.__transition;if(!e||!(e=e[n])||e.state>ox)throw new Error("too late");return e}function Ya(t,n){var e=t.__transition;if(!e||!(e=e[n])||e.state>ax)throw new Error("too late");return e}function Ba(t,n){var e=t.__transition;if(!e||!(e=e[n]))throw new Error("too late");return e}function ja(t,n,e){function r(t){e.state=ux,e.timer.restart(i,e.delay,e.time),e.delay<=t&&i(t-e.delay)}function i(r){var s,f,l,h;if(e.state!==ux)return u();for(s in c)if(h=c[s],h.name===e.name){if(h.state===cx)return Wr(i);h.state===sx?(h.state=lx,h.timer.stop(),h.on.call("interrupt",t,t.__data__,h.index,h.group),delete c[s]):+s<n&&(h.state=lx,h.timer.stop(),delete c[s])}if(Wr(function(){e.state===cx&&(e.state=sx,e.timer.restart(o,e.delay,e.time),o(r))}),e.state=ax,e.on.call("start",t,t.__data__,e.index,e.group),e.state===ax){for(e.state=cx,a=new Array(l=e.tween.length),s=0,f=-1;s<l;++s)(h=e.tween[s].value.call(t,t.__data__,e.index,e.group))&&(a[++f]=h);a.length=f+1}}function o(n){for(var r=n<e.duration?e.ease.call(null,n/e.duration):(e.timer.restart(u),e.state=fx,1),i=-1,o=a.length;++i<o;)a[i].call(null,r);e.state===fx&&(e.on.call("end",t,t.__data__,e.index,e.group),u())}function u(){e.state=lx,e.timer.stop(),delete c[n];for(var r in c)return;delete t.__transition}var a,c=t.__transition;c[n]=e,e.timer=Yr(r,0,e.time)}function Ha(t,n){var e,r,i,o=t.__transition,u=!0;if(o){n=null==n?null:n+"";for(i in o)(e=o[i]).name===n?(r=e.state>ax&&e.state<fx,e.state=lx,e.timer.stop(),r&&e.on.call("interrupt",t,t.__data__,e.index,e.group),delete o[i]):u=!1;u&&delete t.__transition}}function Xa(t){return this.each(function(){Ha(this,t)})}function Va(t,n){var e,r;return function(){var i=Ya(this,t),o=i.tween;if(o!==e){r=e=o;for(var u=0,a=r.length;u<a;++u)if(r[u].name===n){r=r.slice(),r.splice(u,1);break}}i.tween=r}}function Wa(t,n,e){var r,i;if("function"!=typeof e)throw new Error;return function(){var o=Ya(this,t),u=o.tween;if(u!==r){i=(r=u).slice();for(var a={name:n,value:e},c=0,s=i.length;c<s;++c)if(i[c].name===n){i[c]=a;break}c===s&&i.push(a)}o.tween=i}}function $a(t,n){var e=this._id;if(t+="",arguments.length<2){for(var r,i=Ba(this.node(),e).tween,o=0,u=i.length;o<u;++o)if((r=i[o]).name===t)return r.value;return null}return this.each((null==n?Va:Wa)(e,t,n))}function Za(t,n,e){var r=t._id;return t.each(function(){var t=Ya(this,r);(t.value||(t.value={}))[n]=e.apply(this,arguments)}),function(t){return Ba(t,r).value[n]}}function Ga(t,n){var e;return("number"==typeof n?rr:n instanceof be?l_:(e=be(n))?(n=e,l_):ar)(t,n)}function Ka(t){return function(){this.removeAttribute(t)}}function Ja(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Qa(t,n,e){var r,i;return function(){var o=this.getAttribute(t);return o===e?null:o===r?i:i=n(r=o,e)}}function tc(t,n,e){var r,i;return function(){var o=this.getAttributeNS(t.space,t.local);return o===e?null:o===r?i:i=n(r=o,e)}}function nc(t,n,e){var r,i,o;return function(){var u,a=e(this);return null==a?void this.removeAttribute(t):(u=this.getAttribute(t),u===a?null:u===r&&a===i?o:o=n(r=u,i=a))}}function ec(t,n,e){var r,i,o;return function(){var u,a=e(this);return null==a?void this.removeAttributeNS(t.space,t.local):(u=this.getAttributeNS(t.space,t.local),u===a?null:u===r&&a===i?o:o=n(r=u,i=a))}}function rc(t,n){var e=Qo(t),r="transform"===e?m_:Ga;return this.attrTween(t,"function"==typeof n?(e.local?ec:nc)(e,r,Za(this,"attr."+t,n)):null==n?(e.local?Ja:Ka)(e):(e.local?tc:Qa)(e,r,n))}function ic(t,n){function e(){var e=this,r=n.apply(e,arguments);return r&&function(n){e.setAttributeNS(t.space,t.local,r(n))}}return e._value=n,e}function oc(t,n){function e(){var e=this,r=n.apply(e,arguments);return r&&function(n){e.setAttribute(t,r(n))}}return e._value=n,e}function uc(t,n){var e="attr."+t;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==n)return this.tween(e,null);if("function"!=typeof n)throw new Error;var r=Qo(t);return this.tween(e,(r.local?ic:oc)(r,n))}function ac(t,n){return function(){Fa(this,t).delay=+n.apply(this,arguments)}}function cc(t,n){return n=+n,function(){Fa(this,t).delay=n}}function sc(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?ac:cc)(n,t)):Ba(this.node(),n).delay}function fc(t,n){return function(){Ya(this,t).duration=+n.apply(this,arguments)}}function lc(t,n){return n=+n,function(){Ya(this,t).duration=n}}function hc(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?fc:lc)(n,t)):Ba(this.node(),n).duration}function pc(t,n){if("function"!=typeof n)throw new Error;return function(){Ya(this,t).ease=n}}function dc(t){var n=this._id;return arguments.length?this.each(pc(n,t)):Ba(this.node(),n).ease}function vc(t){"function"!=typeof t&&(t=Jm(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,u=n[i],a=u.length,c=r[i]=[],s=0;s<a;++s)(o=u[s])&&t.call(o,o.__data__,s,u)&&c.push(o);return new Uc(r,this._parents,this._name,this._id)}function gc(t){if(t._id!==this._id)throw new Error;for(var n=this._groups,e=t._groups,r=n.length,i=e.length,o=Math.min(r,i),u=new Array(r),a=0;a<o;++a)for(var c,s=n[a],f=e[a],l=s.length,h=u[a]=new Array(l),p=0;p<l;++p)(c=s[p]||f[p])&&(h[p]=c);for(;a<r;++a)u[a]=n[a];return new Uc(u,this._parents,this._name,this._id)}function _c(t){return(t+"").trim().split(/^|\s+/).every(function(t){var n=t.indexOf(".");return n>=0&&(t=t.slice(0,n)),!t||"start"===t})}function yc(t,n,e){var r,i,o=_c(n)?Fa:Ya;return function(){var u=o(this,t),a=u.on;a!==r&&(i=(r=a).copy()).on(n,e),u.on=i}}function mc(t,n){var e=this._id;return arguments.length<2?Ba(this.node(),e).on.on(t):this.each(yc(e,t,n))}function xc(t){return function(){var n=this.parentNode;for(var e in this.__transition)if(+e!==t)return;n&&n.removeChild(this)}}function bc(){return this.on("end.remove",xc(this._id))}function wc(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=gu(t));for(var r=this._groups,i=r.length,o=new Array(i),u=0;u<i;++u)for(var a,c,s=r[u],f=s.length,l=o[u]=new Array(f),h=0;h<f;++h)(a=s[h])&&(c=t.call(a,a.__data__,h,s))&&("__data__"in a&&(c.__data__=a.__data__),l[h]=c,Ia(l[h],n,e,h,l,Ba(a,e)));return new Uc(o,this._parents,n,e)}function Mc(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=mu(t));for(var r=this._groups,i=r.length,o=[],u=[],a=0;a<i;++a)for(var c,s=r[a],f=s.length,l=0;l<f;++l)if(c=s[l]){for(var h,p=t.call(c,c.__data__,l,s),d=Ba(c,e),v=0,g=p.length;v<g;++v)(h=p[v])&&Ia(h,n,e,v,p,d);o.push(p),u.push(c)}return new Uc(o,u,n,e)}function Tc(){return new hx(this._groups,this._parents)}function Nc(t,n){var e,r,i;return function(){var o=Wu(this).getComputedStyle(this,null),u=o.getPropertyValue(t),a=(this.style.removeProperty(t),o.getPropertyValue(t));return u===a?null:u===e&&a===r?i:i=n(e=u,r=a)}}function kc(t){return function(){this.style.removeProperty(t)}}function Sc(t,n,e){var r,i;return function(){var o=Wu(this).getComputedStyle(this,null).getPropertyValue(t);return o===e?null:o===r?i:i=n(r=o,e)}}function Ec(t,n,e){var r,i,o;return function(){var u=Wu(this).getComputedStyle(this,null),a=u.getPropertyValue(t),c=e(this);return null==c&&(this.style.removeProperty(t),c=u.getPropertyValue(t)),a===c?null:a===r&&c===i?o:o=n(r=a,i=c)}}function Ac(t,n,e){var r="transform"==(t+="")?y_:Ga;return null==n?this.styleTween(t,Nc(t,r)).on("end.style."+t,kc(t)):this.styleTween(t,"function"==typeof n?Ec(t,r,Za(this,"style."+t,n)):Sc(t,r,n),e)}function Cc(t,n,e){function r(){var r=this,i=n.apply(r,arguments);return i&&function(n){r.style.setProperty(t,i(n),e)}}return r._value=n,r}function zc(t,n,e){var r="style."+(t+="");if(arguments.length<2)return(r=this.tween(r))&&r._value;if(null==n)return this.tween(r,null);if("function"!=typeof n)throw new Error;return this.tween(r,Cc(t,n,null==e?"":e))}function Pc(t){return function(){this.textContent=t}}function Rc(t){return function(){var n=t(this);this.textContent=null==n?"":n}}function Lc(t){return this.tween("text","function"==typeof t?Rc(Za(this,"text",t)):Pc(null==t?"":t+""))}function qc(){for(var t=this._name,n=this._id,e=Oc(),r=this._groups,i=r.length,o=0;o<i;++o)for(var u,a=r[o],c=a.length,s=0;s<c;++s)if(u=a[s]){var f=Ba(u,n);Ia(u,t,e,s,a,{time:f.time+f.delay+f.duration,delay:0,duration:f.duration,ease:f.ease})}return new Uc(r,this._parents,t,e)}function Uc(t,n,e,r){this._groups=t,this._parents=n,this._name=e,this._id=r}function Dc(t){return La().transition(t)}function Oc(){return++px}function Ic(t,n){for(var e;!(e=t.__transition)||!(e=e[n]);)if(!(t=t.parentNode))return vx.time=Or(),vx;return e}function Fc(t){var n,e;t instanceof Uc?(n=t._id,t=t._name):(n=Oc(),(e=vx).time=Or(),t=null==t?null:t+"");for(var r=this._groups,i=r.length,o=0;o<i;++o)for(var u,a=r[o],c=a.length,s=0;s<c;++s)(u=a[s])&&Ia(u,t,n,s,a,e||Ic(u,n));return new Uc(r,this._parents,t,n)}function Yc(t,n){var e,r,i=t.__transition;if(i){n=null==n?null:n+"";for(r in i)if((e=i[r]).state>ux&&e.name===n)return new Uc([[t]],gx,n,+r)}return null}function Bc(t){return t}function jc(t,n,e){var r=t(e);return"translate("+(isFinite(r)?r:n(e))+",0)"}function Hc(t,n,e){var r=t(e);return"translate(0,"+(isFinite(r)?r:n(e))+")"}function Xc(t){var n=t.bandwidth()/2;return t.round()&&(n=Math.round(n)),function(e){return t(e)+n}}function Vc(){return!this.__axis}function Wc(t,n){function e(e){var s,f=null==i?n.ticks?n.ticks.apply(n,r):n.domain():i,l=null==o?n.tickFormat?n.tickFormat.apply(n,r):Bc:o,h=Math.max(u,0)+c,p=t===yx||t===xx?jc:Hc,d=n.range(),v=d[0]+.5,g=d[d.length-1]+.5,_=(n.bandwidth?Xc:Bc)(n.copy()),y=e.selection?e.selection():e,m=y.selectAll(".domain").data([null]),x=y.selectAll(".tick").data(f,n).order(),b=x.exit(),w=x.enter().append("g").attr("class","tick"),M=x.select("line"),T=x.select("text"),N=t===yx||t===bx?-1:1,k=t===bx||t===mx?(s="x","y"):(s="y","x");m=m.merge(m.enter().insert("path",".tick").attr("class","domain").attr("stroke","#000")),x=x.merge(w),M=M.merge(w.append("line").attr("stroke","#000").attr(s+"2",N*u).attr(k+"1",.5).attr(k+"2",.5)),T=T.merge(w.append("text").attr("fill","#000").attr(s,N*h).attr(k,.5).attr("dy",t===yx?"0em":t===xx?"0.71em":"0.32em")),e!==y&&(m=m.transition(e),x=x.transition(e),M=M.transition(e),T=T.transition(e),b=b.transition(e).attr("opacity",wx).attr("transform",function(t){return p(_,this.parentNode.__axis||_,t)}),w.attr("opacity",wx).attr("transform",function(t){return p(this.parentNode.__axis||_,_,t)})),b.remove(),m.attr("d",t===bx||t==mx?"M"+N*a+","+v+"H0.5V"+g+"H"+N*a:"M"+v+","+N*a+"V0.5H"+g+"V"+N*a),x.attr("opacity",1).attr("transform",function(t){return p(_,_,t)}),M.attr(s+"2",N*u),T.attr(s,N*h).text(l),y.filter(Vc).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",t===mx?"start":t===bx?"end":"middle"),y.each(function(){this.__axis=_})}var r=[],i=null,o=null,u=6,a=6,c=3;return e.scale=function(t){return arguments.length?(n=t,e):n},e.ticks=function(){return r=_x.call(arguments),e},e.tickArguments=function(t){return arguments.length?(r=null==t?[]:_x.call(t),e):r.slice()},e.tickValues=function(t){return arguments.length?(i=null==t?null:_x.call(t),e):i&&i.slice()},e.tickFormat=function(t){return arguments.length?(o=t,e):o},e.tickSize=function(t){return arguments.length?(u=a=+t,e):u},e.tickSizeInner=function(t){return arguments.length?(u=+t,e):u},e.tickSizeOuter=function(t){return arguments.length?(a=+t,e):a},e.tickPadding=function(t){return arguments.length?(c=+t,e):c},e}function $c(t){return Wc(yx,t)}function Zc(t){return Wc(mx,t)}function Gc(t){return Wc(xx,t)}function Kc(t){return Wc(bx,t)}function Jc(t,n){return t.parent===n.parent?1:2}function Qc(t){return t.reduce(ts,0)/t.length}function ts(t,n){return t+n.x}function ns(t){return 1+t.reduce(es,0)}function es(t,n){return Math.max(t,n.y)}function rs(t){for(var n;n=t.children;)t=n[0];return t}function is(t){for(var n;n=t.children;)t=n[n.length-1];return t}function os(){function t(t){var o,u=0;t.eachAfter(function(t){var e=t.children;e?(t.x=Qc(e),t.y=ns(e)):(t.x=o?u+=n(t,o):0,t.y=0,o=t)});var a=rs(t),c=is(t),s=a.x-n(a,c)/2,f=c.x+n(c,a)/2;return t.eachAfter(i?function(n){n.x=(n.x-t.x)*e,n.y=(t.y-n.y)*r}:function(n){n.x=(n.x-s)/(f-s)*e,n.y=(1-(t.y?n.y/t.y:1))*r})}var n=Jc,e=1,r=1,i=!1;return t.separation=function(e){return arguments.length?(n=e,t):n},t.size=function(n){return arguments.length?(i=!1,e=+n[0],r=+n[1],t):i?null:[e,r]},t.nodeSize=function(n){return arguments.length?(i=!0,e=+n[0],r=+n[1],t):i?[e,r]:null},t}function us(t){var n,e,r,i,o=this,u=[o];do for(n=u.reverse(),u=[];o=n.pop();)if(t(o),e=o.children)for(r=0,i=e.length;r<i;++r)u.push(e[r]);while(u.length);return this}function as(t){for(var n,e,r=this,i=[r];r=i.pop();)if(t(r),n=r.children)for(e=n.length-1;e>=0;--e)i.push(n[e]);return this}function cs(t){for(var n,e,r,i=this,o=[i],u=[];i=o.pop();)if(u.push(i),n=i.children)for(e=0,r=n.length;e<r;++e)o.push(n[e]);for(;i=u.pop();)t(i);return this}function ss(t){return this.eachAfter(function(n){for(var e=+t(n.data)||0,r=n.children,i=r&&r.length;--i>=0;)e+=r[i].value;n.value=e})}function fs(t){return this.eachBefore(function(n){n.children&&n.children.sort(t)})}function ls(t){for(var n=this,e=hs(n,t),r=[n];n!==e;)n=n.parent,r.push(n);for(var i=r.length;t!==e;)r.splice(i,0,t),t=t.parent;return r}function hs(t,n){if(t===n)return t;var e=t.ancestors(),r=n.ancestors(),i=null;for(t=e.pop(),n=r.pop();t===n;)i=t,t=e.pop(),n=r.pop();return i}function ps(){for(var t=this,n=[t];t=t.parent;)n.push(t);return n}function ds(){var t=[];return this.each(function(n){t.push(n)}),t}function vs(){var t=[];return this.eachBefore(function(n){n.children||t.push(n)}),t}function gs(){var t=this,n=[];return t.each(function(e){e!==t&&n.push({source:e.parent,target:e})}),n}function _s(t,n){var e,r,i,o,u,a=new ws(t),c=+t.value&&(a.value=t.value),s=[a];for(null==n&&(n=ms);e=s.pop();)if(c&&(e.value=+e.data.value),(i=n(e.data))&&(u=i.length))for(e.children=new Array(u),o=u-1;o>=0;--o)s.push(r=e.children[o]=new ws(i[o])),r.parent=e,r.depth=e.depth+1;return a.eachBefore(bs)}function ys(){return _s(this).eachBefore(xs)}function ms(t){return t.children}function xs(t){t.data=t.data.data}function bs(t){var n=0;do t.height=n;while((t=t.parent)&&t.height<++n)}function ws(t){this.data=t,this.depth=this.height=0,this.parent=null}function Ms(t){this._=t,this.next=null}function Ts(t){for(var n,e=(t=t.slice()).length,r=null,i=r;e;){var o=new Ms(t[e-1]);i=i?i.next=o:r=o,t[n]=t[--e]}return{head:r,tail:i}}function Ns(t){return Ss(Ts(t),[])}function ks(t,n){var e=n.x-t.x,r=n.y-t.y,i=t.r-n.r;return i*i+1e-6>e*e+r*r}function Ss(t,n){var e,r,i,o=null,u=t.head;switch(n.length){case 1:e=Es(n[0]);break;case 2:e=As(n[0],n[1]);break;case 3:e=Cs(n[0],n[1],n[2])}for(;u;)i=u._,r=u.next,e&&ks(e,i)?o=u:(o?(t.tail=o,o.next=null):t.head=t.tail=null,n.push(i),e=Ss(t,n),n.pop(),t.head?(u.next=t.head,t.head=u):(u.next=null,t.head=t.tail=u),o=t.tail,o.next=r),u=r;return t.tail=o,e}function Es(t){return{x:t.x,y:t.y,r:t.r}}function As(t,n){var e=t.x,r=t.y,i=t.r,o=n.x,u=n.y,a=n.r,c=o-e,s=u-r,f=a-i,l=Math.sqrt(c*c+s*s);return{x:(e+o+c/l*f)/2,y:(r+u+s/l*f)/2,r:(l+i+a)/2}}function Cs(t,n,e){var r=t.x,i=t.y,o=t.r,u=n.x,a=n.y,c=n.r,s=e.x,f=e.y,l=e.r,h=2*(r-u),p=2*(i-a),d=2*(c-o),v=r*r+i*i-o*o-u*u-a*a+c*c,g=2*(r-s),_=2*(i-f),y=2*(l-o),m=r*r+i*i-o*o-s*s-f*f+l*l,x=g*p-h*_,b=(p*m-_*v)/x-r,w=(_*d-p*y)/x,M=(g*v-h*m)/x-i,T=(h*y-g*d)/x,N=w*w+T*T-1,k=2*(b*w+M*T+o),S=b*b+M*M-o*o,E=(-k-Math.sqrt(k*k-4*N*S))/(2*N);return{x:b+w*E+r,y:M+T*E+i,r:E}}function zs(t,n,e){var r=t.x,i=t.y,o=n.r+e.r,u=t.r+e.r,a=n.x-r,c=n.y-i,s=a*a+c*c;if(s){var f=.5+((u*=u)-(o*=o))/(2*s),l=Math.sqrt(Math.max(0,2*o*(u+s)-(u-=s)*u-o*o))/(2*s);e.x=r+f*a+l*c,e.y=i+f*c-l*a}else e.x=r+u,e.y=i}function Ps(t,n){var e=n.x-t.x,r=n.y-t.y,i=t.r+n.r;return i*i>e*e+r*r}function Rs(t,n,e){var r=t.x-n,i=t.y-e;return r*r+i*i}function Ls(t){this._=t,this.next=null,this.previous=null}function qs(t){if(!(i=t.length))return 0;var n,e,r,i;if(n=t[0],n.x=0,n.y=0,!(i>1))return n.r;if(e=t[1],n.x=-e.r,e.x=n.r,e.y=0,!(i>2))return n.r+e.r;zs(e,n,r=t[2]);var o,u,a,c,s,f,l,h=n.r*n.r,p=e.r*e.r,d=r.r*r.r,v=h+p+d,g=h*n.x+p*e.x+d*r.x,_=h*n.y+p*e.y+d*r.y;n=new Ls(n),e=new Ls(e),r=new Ls(r),n.next=r.previous=e,e.next=n.previous=r,r.next=e.previous=n;t:for(a=3;a<i;++a){if(zs(n._,e._,r=t[a]),r=new Ls(r),(s=n.previous)===(c=e.next)){if(Ps(c._,r._)){n=e,e=c,--a;continue t}}else{f=c._.r,l=s._.r;do if(f<=l){if(Ps(c._,r._)){e=c,n.next=e,e.previous=n,--a;continue t}c=c.next,f+=c._.r}else{if(Ps(s._,r._)){n=s,n.next=e,e.previous=n,--a;continue t}s=s.previous,l+=s._.r}while(c!==s.next)}for(r.previous=n,r.next=e,n.next=e.previous=e=r,v+=d=r._.r*r._.r,g+=d*r._.x,_+=d*r._.y,h=Rs(n._,o=g/v,u=_/v);(r=r.next)!==e;)(d=Rs(r._,o,u))<h&&(n=r,h=d);e=n.next}for(n=[e._],r=e;(r=r.next)!==e;)n.push(r._);for(r=Ns(n),a=0;a<i;++a)n=t[a],n.x-=r.x,n.y-=r.y;return r.r}function Us(t){return qs(t),t}function Ds(t){return null==t?null:Os(t)}function Os(t){if("function"!=typeof t)throw new Error;return t}function Is(){return 0}function Fs(t){return function(){return t}}function Ys(t){return Math.sqrt(t.value)}function Bs(){function t(t){return t.x=e/2,t.y=r/2,n?t.eachBefore(js(n)).eachAfter(Hs(i,.5)).eachBefore(Xs(1)):t.eachBefore(js(Ys)).eachAfter(Hs(Is,1)).eachAfter(Hs(i,t.r/Math.min(e,r))).eachBefore(Xs(Math.min(e,r)/(2*t.r))),t}var n=null,e=1,r=1,i=Is;return t.radius=function(e){return arguments.length?(n=Ds(e),t):n},t.size=function(n){return arguments.length?(e=+n[0],r=+n[1],t):[e,r]},t.padding=function(n){return arguments.length?(i="function"==typeof n?n:Fs(+n),t):i},t}function js(t){return function(n){n.children||(n.r=Math.max(0,+t(n)||0))}}function Hs(t,n){return function(e){if(r=e.children){var r,i,o,u=r.length,a=t(e)*n||0;if(a)for(i=0;i<u;++i)r[i].r+=a;if(o=qs(r),a)for(i=0;i<u;++i)r[i].r-=a;e.r=o+a}}}function Xs(t){return function(n){var e=n.parent;n.r*=t,e&&(n.x=e.x+t*n.x,n.y=e.y+t*n.y)}}function Vs(t){t.x0=Math.round(t.x0),t.y0=Math.round(t.y0),t.x1=Math.round(t.x1),t.y1=Math.round(t.y1)}function Ws(t,n,e,r,i){for(var o,u=t.children,a=-1,c=u.length,s=t.value&&(r-n)/t.value;++a<c;)o=u[a],o.y0=e,o.y1=i,o.x0=n,o.x1=n+=o.value*s}function $s(){function t(t){var u=t.height+1;return t.x0=t.y0=i,t.x1=e,t.y1=r/u,t.eachBefore(n(r,u)),o&&t.eachBefore(Vs),t}function n(t,n){return function(e){e.children&&Ws(e,e.x0,t*(e.depth+1)/n,e.x1,t*(e.depth+2)/n);var r=e.x0,o=e.y0,u=e.x1-i,a=e.y1-i;u<r&&(r=u=(r+u)/2),a<o&&(o=a=(o+a)/2),e.x0=r,e.y0=o,e.x1=u,e.y1=a}}var e=1,r=1,i=0,o=!1;return t.round=function(n){return arguments.length?(o=!!n,t):o},t.size=function(n){return arguments.length?(e=+n[0],r=+n[1],t):[e,r]},t.padding=function(n){return arguments.length?(i=+n,t):i},t}function Zs(t){return t.id}function Gs(t){return t.parentId}function Ks(){function t(t){var r,i,o,u,a,c,s,f=t.length,l=new Array(f),h={};for(i=0;i<f;++i)r=t[i],a=l[i]=new ws(r),null!=(c=n(r,i,t))&&(c+="")&&(s=Mx+(a.id=c),h[s]=s in h?Nx:a);for(i=0;i<f;++i)if(a=l[i],c=e(t[i],i,t),null!=c&&(c+="")){if(u=h[Mx+c],!u)throw new Error("missing: "+c);if(u===Nx)throw new Error("ambiguous: "+c);u.children?u.children.push(a):u.children=[a],a.parent=u}else{if(o)throw new Error("multiple roots");o=a}if(!o)throw new Error("no root");if(o.parent=Tx,o.eachBefore(function(t){t.depth=t.parent.depth+1,--f}).eachBefore(bs),o.parent=null,f>0)throw new Error("cycle");return o}var n=Zs,e=Gs;return t.id=function(e){return arguments.length?(n=Os(e),t):n},t.parentId=function(n){return arguments.length?(e=Os(n),t):e},t}function Js(t,n){return t.parent===n.parent?1:2}function Qs(t){var n=t.children;return n?n[0]:t.t}function tf(t){var n=t.children;return n?n[n.length-1]:t.t}function nf(t,n,e){var r=e/(n.i-t.i);n.c-=r,n.s+=e,t.c+=r,n.z+=e,n.m+=e}function ef(t){for(var n,e=0,r=0,i=t.children,o=i.length;--o>=0;)n=i[o],n.z+=e,n.m+=e,e+=n.s+(r+=n.c)}function rf(t,n,e){return t.a.parent===n.parent?t.a:e}function of(t,n){this._=t,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=n}function uf(t){for(var n,e,r,i,o,u=new of(t,0),a=[u];n=a.pop();)if(r=n._.children)for(n.children=new Array(o=r.length),i=o-1;i>=0;--i)a.push(e=n.children[i]=new of(r[i],i)),e.parent=n;return(u.parent=new of(null,0)).children=[u],u}function af(){function t(t){var r=uf(t);if(r.eachAfter(n),r.parent.m=-r.z,r.eachBefore(e),c)t.eachBefore(i);else{var s=t,f=t,l=t;t.eachBefore(function(t){t.x<s.x&&(s=t),t.x>f.x&&(f=t),t.depth>l.depth&&(l=t)});var h=s===f?1:o(s,f)/2,p=h-s.x,d=u/(f.x+h+p),v=a/(l.depth||1);t.eachBefore(function(t){t.x=(t.x+p)*d,t.y=t.depth*v})}return t}function n(t){var n=t.children,e=t.parent.children,i=t.i?e[t.i-1]:null;if(n){ef(t);var u=(n[0].z+n[n.length-1].z)/2;i?(t.z=i.z+o(t._,i._),t.m=t.z-u):t.z=u}else i&&(t.z=i.z+o(t._,i._));t.parent.A=r(t,i,t.parent.A||e[0])}function e(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function r(t,n,e){if(n){for(var r,i=t,u=t,a=n,c=i.parent.children[0],s=i.m,f=u.m,l=a.m,h=c.m;a=tf(a),i=Qs(i),a&&i;)c=Qs(c),u=tf(u),u.a=t,r=a.z+l-i.z-s+o(a._,i._),r>0&&(nf(rf(a,t,e),t,r),s+=r,f+=r),l+=a.m,s+=i.m,h+=c.m,f+=u.m;a&&!tf(u)&&(u.t=a,u.m+=l-f),i&&!Qs(c)&&(c.t=i,c.m+=s-h,e=t)}return e}function i(t){t.x*=u,t.y=t.depth*a}var o=Js,u=1,a=1,c=null;return t.separation=function(n){return arguments.length?(o=n,t):o},t.size=function(n){return arguments.length?(c=!1,u=+n[0],a=+n[1],t):c?null:[u,a]},t.nodeSize=function(n){return arguments.length?(c=!0,u=+n[0],a=+n[1],t):c?[u,a]:null},t}function cf(t,n,e,r,i){for(var o,u=t.children,a=-1,c=u.length,s=t.value&&(i-e)/t.value;++a<c;)o=u[a],o.x0=n,o.x1=r,o.y0=e,o.y1=e+=o.value*s}function sf(t,n,e,r,i,o){for(var u,a,c,s,f,l,h,p,d,v,g,_=[],y=n.children,m=0,x=0,b=y.length,w=n.value;m<b;){c=i-e,s=o-r;do f=y[x++].value;while(!f&&x<b);for(l=h=f,v=Math.max(s/c,c/s)/(w*t),g=f*f*v,d=Math.max(h/g,g/l);x<b;++x){if(f+=a=y[x].value,a<l&&(l=a),a>h&&(h=a),g=f*f*v,p=Math.max(h/g,g/l),p>d){f-=a;break}d=p}_.push(u={value:f,dice:c<s,children:y.slice(m,x)}),u.dice?Ws(u,e,r,i,w?r+=s*f/w:o):cf(u,e,r,w?e+=c*f/w:i,o), | |
w-=f,m=x}return _}function ff(){function t(t){return t.x0=t.y0=0,t.x1=i,t.y1=o,t.eachBefore(n),u=[0],r&&t.eachBefore(Vs),t}function n(t){var n=u[t.depth],r=t.x0+n,i=t.y0+n,o=t.x1-n,h=t.y1-n;o<r&&(r=o=(r+o)/2),h<i&&(i=h=(i+h)/2),t.x0=r,t.y0=i,t.x1=o,t.y1=h,t.children&&(n=u[t.depth+1]=a(t)/2,r+=l(t)-n,i+=c(t)-n,o-=s(t)-n,h-=f(t)-n,o<r&&(r=o=(r+o)/2),h<i&&(i=h=(i+h)/2),e(t,r,i,o,h))}var e=Sx,r=!1,i=1,o=1,u=[0],a=Is,c=Is,s=Is,f=Is,l=Is;return t.round=function(n){return arguments.length?(r=!!n,t):r},t.size=function(n){return arguments.length?(i=+n[0],o=+n[1],t):[i,o]},t.tile=function(n){return arguments.length?(e=Os(n),t):e},t.padding=function(n){return arguments.length?t.paddingInner(n).paddingOuter(n):t.paddingInner()},t.paddingInner=function(n){return arguments.length?(a="function"==typeof n?n:Fs(+n),t):a},t.paddingOuter=function(n){return arguments.length?t.paddingTop(n).paddingRight(n).paddingBottom(n).paddingLeft(n):t.paddingTop()},t.paddingTop=function(n){return arguments.length?(c="function"==typeof n?n:Fs(+n),t):c},t.paddingRight=function(n){return arguments.length?(s="function"==typeof n?n:Fs(+n),t):s},t.paddingBottom=function(n){return arguments.length?(f="function"==typeof n?n:Fs(+n),t):f},t.paddingLeft=function(n){return arguments.length?(l="function"==typeof n?n:Fs(+n),t):l},t}function lf(t,n,e,r,i){function o(t,n,e,r,i,u,a){if(t>=n-1){var s=c[t];return s.x0=r,s.y0=i,s.x1=u,s.y1=a,void 0}for(var l=f[t],h=e/2+l,p=t+1,d=n-1;p<d;){var v=p+d>>>1;f[v]<h?p=v+1:d=v}var g=f[p]-l,_=e-g;if(a-i>u-r){var y=(i*_+a*g)/e;o(t,p,g,r,i,u,y),o(p,n,_,r,y,u,a)}else{var m=(r*_+u*g)/e;o(t,p,g,r,i,m,a),o(p,n,_,m,i,u,a)}}var u,a,c=t.children,s=c.length,f=new Array(s+1);for(f[0]=a=u=0;u<s;++u)f[u+1]=a+=c[u].value;o(0,s,t.value,n,e,r,i)}function hf(t,n,e,r,i){(1&t.depth?cf:Ws)(t,n,e,r,i)}function pf(t,n){function e(){var e,i,o=r.length,u=0,a=0;for(e=0;e<o;++e)i=r[e],u+=i.x,a+=i.y;for(u=u/o-t,a=a/o-n,e=0;e<o;++e)i=r[e],i.x-=u,i.y-=a}var r;return null==t&&(t=0),null==n&&(n=0),e.initialize=function(t){r=t},e.x=function(n){return arguments.length?(t=+n,e):t},e.y=function(t){return arguments.length?(n=+t,e):n},e}function df(t){return function(){return t}}function vf(){return 1e-6*(Math.random()-.5)}function gf(t){return t.x+t.vx}function _f(t){return t.y+t.vy}function yf(t){function n(){function t(t,n,e,r,i){var o=t.data,a=t.r,p=l+a;{if(!o)return n>s+p||r<s-p||e>f+p||i<f-p;if(o.index>c.index){var d=s-o.x-o.vx,v=f-o.y-o.vy,g=d*d+v*v;g<p*p&&(0===d&&(d=vf(),g+=d*d),0===v&&(v=vf(),g+=v*v),g=(p-(g=Math.sqrt(g)))/g*u,c.vx+=(d*=g)*(p=(a*=a)/(h+a)),c.vy+=(v*=g)*p,o.vx-=d*(p=1-p),o.vy-=v*p)}}}for(var n,r,c,s,f,l,h,p=i.length,d=0;d<a;++d)for(r=jt(i,gf,_f).visitAfter(e),n=0;n<p;++n)c=i[n],l=o[c.index],h=l*l,s=c.x+c.vx,f=c.y+c.vy,r.visit(t)}function e(t){if(t.data)return t.r=o[t.data.index];for(var n=t.r=0;n<4;++n)t[n]&&t[n].r>t.r&&(t.r=t[n].r)}function r(){if(i){var n,e,r=i.length;for(o=new Array(r),n=0;n<r;++n)e=i[n],o[e.index]=+t(e,n,i)}}var i,o,u=1,a=1;return"function"!=typeof t&&(t=df(null==t?1:+t)),n.initialize=function(t){i=t,r()},n.iterations=function(t){return arguments.length?(a=+t,n):a},n.strength=function(t){return arguments.length?(u=+t,n):u},n.radius=function(e){return arguments.length?(t="function"==typeof e?e:df(+e),r(),n):t},n}function mf(t){return t.index}function xf(t,n){var e=t.get(n);if(!e)throw new Error("missing: "+n);return e}function bf(t){function n(t){return 1/Math.min(s[t.source.index],s[t.target.index])}function e(n){for(var e=0,r=t.length;e<d;++e)for(var i,o,c,s,l,h,p,v=0;v<r;++v)i=t[v],o=i.source,c=i.target,s=c.x+c.vx-o.x-o.vx||vf(),l=c.y+c.vy-o.y-o.vy||vf(),h=Math.sqrt(s*s+l*l),h=(h-a[v])/h*n*u[v],s*=h,l*=h,c.vx-=s*(p=f[v]),c.vy-=l*p,o.vx+=s*(p=1-p),o.vy+=l*p}function r(){if(c){var n,e,r=c.length,h=t.length,p=R(c,l);for(n=0,s=new Array(r);n<h;++n)e=t[n],e.index=n,"object"!=typeof e.source&&(e.source=xf(p,e.source)),"object"!=typeof e.target&&(e.target=xf(p,e.target)),s[e.source.index]=(s[e.source.index]||0)+1,s[e.target.index]=(s[e.target.index]||0)+1;for(n=0,f=new Array(h);n<h;++n)e=t[n],f[n]=s[e.source.index]/(s[e.source.index]+s[e.target.index]);u=new Array(h),i(),a=new Array(h),o()}}function i(){if(c)for(var n=0,e=t.length;n<e;++n)u[n]=+h(t[n],n,t)}function o(){if(c)for(var n=0,e=t.length;n<e;++n)a[n]=+p(t[n],n,t)}var u,a,c,s,f,l=mf,h=n,p=df(30),d=1;return null==t&&(t=[]),e.initialize=function(t){c=t,r()},e.links=function(n){return arguments.length?(t=n,r(),e):t},e.id=function(t){return arguments.length?(l=t,e):l},e.iterations=function(t){return arguments.length?(d=+t,e):d},e.strength=function(t){return arguments.length?(h="function"==typeof t?t:df(+t),i(),e):h},e.distance=function(t){return arguments.length?(p="function"==typeof t?t:df(+t),o(),e):p},e}function wf(t){return t.x}function Mf(t){return t.y}function Tf(t){function n(){e(),p.call("tick",o),u<a&&(h.stop(),p.call("end",o))}function e(){var n,e,r=t.length;for(u+=(s-u)*c,l.each(function(t){t(u)}),n=0;n<r;++n)e=t[n],null==e.fx?e.x+=e.vx*=f:(e.x=e.fx,e.vx=0),null==e.fy?e.y+=e.vy*=f:(e.y=e.fy,e.vy=0)}function r(){for(var n,e=0,r=t.length;e<r;++e){if(n=t[e],n.index=e,isNaN(n.x)||isNaN(n.y)){var i=Ax*Math.sqrt(e),o=e*Cx;n.x=i*Math.cos(o),n.y=i*Math.sin(o)}(isNaN(n.vx)||isNaN(n.vy))&&(n.vx=n.vy=0)}}function i(n){return n.initialize&&n.initialize(t),n}var o,u=1,a=.001,c=1-Math.pow(a,1/300),s=0,f=.6,l=R(),h=Yr(n),p=Mr("tick","end");return null==t&&(t=[]),r(),o={tick:e,restart:function(){return h.restart(n),o},stop:function(){return h.stop(),o},nodes:function(n){return arguments.length?(t=n,r(),l.each(i),o):t},alpha:function(t){return arguments.length?(u=+t,o):u},alphaMin:function(t){return arguments.length?(a=+t,o):a},alphaDecay:function(t){return arguments.length?(c=+t,o):+c},alphaTarget:function(t){return arguments.length?(s=+t,o):s},velocityDecay:function(t){return arguments.length?(f=1-t,o):1-f},force:function(t,n){return arguments.length>1?(null==n?l.remove(t):l.set(t,i(n)),o):l.get(t)},find:function(n,e,r){var i,o,u,a,c,s=0,f=t.length;for(null==r?r=1/0:r*=r,s=0;s<f;++s)a=t[s],i=n-a.x,o=e-a.y,u=i*i+o*o,u<r&&(c=a,r=u);return c},on:function(t,n){return arguments.length>1?(p.on(t,n),o):p.on(t)}}}function Nf(){function t(t){var n,a=i.length,c=jt(i,wf,Mf).visitAfter(e);for(u=t,n=0;n<a;++n)o=i[n],c.visit(r)}function n(){if(i){var t,n,e=i.length;for(a=new Array(e),t=0;t<e;++t)n=i[t],a[n.index]=+c(n,t,i)}}function e(t){var n,e,r,i,o,u=0;if(t.length){for(r=i=o=0;o<4;++o)(n=t[o])&&(e=n.value)&&(u+=e,r+=e*n.x,i+=e*n.y);t.x=r/u,t.y=i/u}else{n=t,n.x=n.data.x,n.y=n.data.y;do u+=a[n.data.index];while(n=n.next)}t.value=u}function r(t,n,e,r){if(!t.value)return!0;var i=t.x-o.x,c=t.y-o.y,h=r-n,p=i*i+c*c;if(h*h/l<p)return p<f&&(0===i&&(i=vf(),p+=i*i),0===c&&(c=vf(),p+=c*c),p<s&&(p=Math.sqrt(s*p)),o.vx+=i*t.value*u/p,o.vy+=c*t.value*u/p),!0;if(!(t.length||p>=f)){(t.data!==o||t.next)&&(0===i&&(i=vf(),p+=i*i),0===c&&(c=vf(),p+=c*c),p<s&&(p=Math.sqrt(s*p)));do t.data!==o&&(h=a[t.data.index]*u/p,o.vx+=i*h,o.vy+=c*h);while(t=t.next)}}var i,o,u,a,c=df(-30),s=1,f=1/0,l=.81;return t.initialize=function(t){i=t,n()},t.strength=function(e){return arguments.length?(c="function"==typeof e?e:df(+e),n(),t):c},t.distanceMin=function(n){return arguments.length?(s=n*n,t):Math.sqrt(s)},t.distanceMax=function(n){return arguments.length?(f=n*n,t):Math.sqrt(f)},t.theta=function(n){return arguments.length?(l=n*n,t):Math.sqrt(l)},t}function kf(t){function n(t){for(var n,e=0,u=r.length;e<u;++e)n=r[e],n.vx+=(o[e]-n.x)*i[e]*t}function e(){if(r){var n,e=r.length;for(i=new Array(e),o=new Array(e),n=0;n<e;++n)i[n]=isNaN(o[n]=+t(r[n],n,r))?0:+u(r[n],n,r)}}var r,i,o,u=df(.1);return"function"!=typeof t&&(t=df(null==t?0:+t)),n.initialize=function(t){r=t,e()},n.strength=function(t){return arguments.length?(u="function"==typeof t?t:df(+t),e(),n):u},n.x=function(r){return arguments.length?(t="function"==typeof r?r:df(+r),e(),n):t},n}function Sf(t){function n(t){for(var n,e=0,u=r.length;e<u;++e)n=r[e],n.vy+=(o[e]-n.y)*i[e]*t}function e(){if(r){var n,e=r.length;for(i=new Array(e),o=new Array(e),n=0;n<e;++n)i[n]=isNaN(o[n]=+t(r[n],n,r))?0:+u(r[n],n,r)}}var r,i,o,u=df(.1);return"function"!=typeof t&&(t=df(null==t?0:+t)),n.initialize=function(t){r=t,e()},n.strength=function(t){return arguments.length?(u="function"==typeof t?t:df(+t),e(),n):u},n.y=function(r){return arguments.length?(t="function"==typeof r?r:df(+r),e(),n):t},n}function Ef(){t.event.stopImmediatePropagation()}function Af(){t.event.preventDefault(),t.event.stopImmediatePropagation()}function Cf(t){var n=t.document.documentElement,e=qa(t).on("dragstart.drag",Af,!0);"onselectstart"in n?e.on("selectstart.drag",Af,!0):(n.__noselect=n.style.MozUserSelect,n.style.MozUserSelect="none")}function zf(t,n){var e=t.document.documentElement,r=qa(t).on("dragstart.drag",null);n&&(r.on("click.drag",Af,!0),setTimeout(function(){r.on("click.drag",null)},0)),"onselectstart"in e?r.on("selectstart.drag",null):(e.style.MozUserSelect=e.__noselect,delete e.__noselect)}function Pf(t){return function(){return t}}function Rf(t,n,e,r,i,o,u,a,c,s){this.target=t,this.type=n,this.subject=e,this.identifier=r,this.active=i,this.x=o,this.y=u,this.dx=a,this.dy=c,this._=s}function Lf(){return!t.event.button}function qf(){return this.parentNode}function Uf(n){return null==n?{x:t.event.x,y:t.event.y}:n}function Df(){function n(t){t.on("mousedown.drag",e).on("touchstart.drag",o).on("touchmove.drag",u).on("touchend.drag touchcancel.drag",a).style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function e(){if(!f&&l.apply(this,arguments)){var n=c("mouse",h.apply(this,arguments),du,this,arguments);n&&(qa(t.event.view).on("mousemove.drag",r,!0).on("mouseup.drag",i,!0),Cf(t.event.view),Ef(),s=!1,n("start"))}}function r(){Af(),s=!0,d.mouse("drag")}function i(){qa(t.event.view).on("mousemove.drag mouseup.drag",null),zf(t.event.view,s),Af(),d.mouse("end")}function o(){if(l.apply(this,arguments)){var n,e,r=t.event.changedTouches,i=h.apply(this,arguments),o=r.length;for(n=0;n<o;++n)(e=c(r[n].identifier,i,Da,this,arguments))&&(Ef(),e("start"))}}function u(){var n,e,r=t.event.changedTouches,i=r.length;for(n=0;n<i;++n)(e=d[r[n].identifier])&&(Af(),e("drag"))}function a(){var n,e,r=t.event.changedTouches,i=r.length;for(f&&clearTimeout(f),f=setTimeout(function(){f=null},500),n=0;n<i;++n)(e=d[r[n].identifier])&&(Ef(),e("end"))}function c(e,r,i,o,u){var a,c,s,f=i(r,e),l=v.copy();if(lu(new Rf(n,"beforestart",a,e,g,f[0],f[1],0,0,l),function(){return null!=(t.event.subject=a=p.apply(o,u))&&(c=a.x-f[0]||0,s=a.y-f[1]||0,!0)}))return function t(h){var p,v=f;switch(h){case"start":d[e]=t,p=g++;break;case"end":delete d[e],--g;case"drag":f=i(r,e),p=g}lu(new Rf(n,h,a,e,p,f[0]+c,f[1]+s,f[0]-v[0],f[1]-v[1],l),l.apply,l,[h,o,u])}}var s,f,l=Lf,h=qf,p=Uf,d={},v=Mr("start","drag","end"),g=0;return n.filter=function(t){return arguments.length?(l="function"==typeof t?t:Pf(!!t),n):l},n.container=function(t){return arguments.length?(h="function"==typeof t?t:Pf(t),n):h},n.subject=function(t){return arguments.length?(p="function"==typeof t?t:Pf(t),n):p},n.on=function(){var t=v.on.apply(v,arguments);return t===v?n:t},n}function Of(t){return function(){return t}}function If(t){return t[0]}function Ff(t){return t[1]}function Yf(){this._=null}function Bf(t){t.U=t.C=t.L=t.R=t.P=t.N=null}function jf(t,n){var e=n,r=n.R,i=e.U;i?i.L===e?i.L=r:i.R=r:t._=r,r.U=i,e.U=r,e.R=r.L,e.R&&(e.R.U=e),r.L=e}function Hf(t,n){var e=n,r=n.L,i=e.U;i?i.L===e?i.L=r:i.R=r:t._=r,r.U=i,e.U=r,e.L=r.R,e.L&&(e.L.U=e),r.R=e}function Xf(t){for(;t.L;)t=t.L;return t}function Vf(t,n,e,r){var i=[null,null],o=qx.push(i)-1;return i.left=t,i.right=n,e&&$f(i,t,n,e),r&&$f(i,n,t,r),Rx[t.index].halfedges.push(o),Rx[n.index].halfedges.push(o),i}function Wf(t,n,e){var r=[n,e];return r.left=t,r}function $f(t,n,e,r){t[0]||t[1]?t.left===e?t[1]=r:t[0]=r:(t[0]=r,t.left=n,t.right=e)}function Zf(t,n,e,r,i){var o,u=t[0],a=t[1],c=u[0],s=u[1],f=a[0],l=a[1],h=0,p=1,d=f-c,v=l-s;if(o=n-c,d||!(o>0)){if(o/=d,d<0){if(o<h)return;o<p&&(p=o)}else if(d>0){if(o>p)return;o>h&&(h=o)}if(o=r-c,d||!(o<0)){if(o/=d,d<0){if(o>p)return;o>h&&(h=o)}else if(d>0){if(o<h)return;o<p&&(p=o)}if(o=e-s,v||!(o>0)){if(o/=v,v<0){if(o<h)return;o<p&&(p=o)}else if(v>0){if(o>p)return;o>h&&(h=o)}if(o=i-s,v||!(o<0)){if(o/=v,v<0){if(o>p)return;o>h&&(h=o)}else if(v>0){if(o<h)return;o<p&&(p=o)}return!(h>0||p<1)||(h>0&&(t[0]=[c+h*d,s+h*v]),p<1&&(t[1]=[c+p*d,s+p*v]),!0)}}}}}function Gf(t,n,e,r,i){var o=t[1];if(o)return!0;var u,a,c=t[0],s=t.left,f=t.right,l=s[0],h=s[1],p=f[0],d=f[1],v=(l+p)/2,g=(h+d)/2;if(d===h){if(v<n||v>=r)return;if(l>p){if(c){if(c[1]>=i)return}else c=[v,e];o=[v,i]}else{if(c){if(c[1]<e)return}else c=[v,i];o=[v,e]}}else if(u=(l-p)/(d-h),a=g-u*v,u<-1||u>1)if(l>p){if(c){if(c[1]>=i)return}else c=[(e-a)/u,e];o=[(i-a)/u,i]}else{if(c){if(c[1]<e)return}else c=[(i-a)/u,i];o=[(e-a)/u,e]}else if(h<d){if(c){if(c[0]>=r)return}else c=[n,u*n+a];o=[r,u*r+a]}else{if(c){if(c[0]<n)return}else c=[r,u*r+a];o=[n,u*n+a]}return t[0]=c,t[1]=o,!0}function Kf(t,n,e,r){for(var i,o=qx.length;o--;)Gf(i=qx[o],t,n,e,r)&&Zf(i,t,n,e,r)&&(Math.abs(i[0][0]-i[1][0])>Ox||Math.abs(i[0][1]-i[1][1])>Ox)||delete qx[o]}function Jf(t){return Rx[t.index]={site:t,halfedges:[]}}function Qf(t,n){var e=t.site,r=n.left,i=n.right;return e===i&&(i=r,r=e),i?Math.atan2(i[1]-r[1],i[0]-r[0]):(e===r?(r=n[1],i=n[0]):(r=n[0],i=n[1]),Math.atan2(r[0]-i[0],i[1]-r[1]))}function tl(t,n){return n[+(n.left!==t.site)]}function nl(t,n){return n[+(n.left===t.site)]}function el(){for(var t,n,e,r,i=0,o=Rx.length;i<o;++i)if((t=Rx[i])&&(r=(n=t.halfedges).length)){var u=new Array(r),a=new Array(r);for(e=0;e<r;++e)u[e]=e,a[e]=Qf(t,qx[n[e]]);for(u.sort(function(t,n){return a[n]-a[t]}),e=0;e<r;++e)a[e]=n[u[e]];for(e=0;e<r;++e)n[e]=a[e]}}function rl(t,n,e,r){var i,o,u,a,c,s,f,l,h,p,d,v,g=Rx.length,_=!0;for(i=0;i<g;++i)if(o=Rx[i]){for(u=o.site,c=o.halfedges,a=c.length;a--;)qx[c[a]]||c.splice(a,1);for(a=0,s=c.length;a<s;)p=nl(o,qx[c[a]]),d=p[0],v=p[1],f=tl(o,qx[c[++a%s]]),l=f[0],h=f[1],(Math.abs(d-l)>Ox||Math.abs(v-h)>Ox)&&(c.splice(a,0,qx.push(Wf(u,p,Math.abs(d-t)<Ox&&r-v>Ox?[t,Math.abs(l-t)<Ox?h:r]:Math.abs(v-r)<Ox&&e-d>Ox?[Math.abs(h-r)<Ox?l:e,r]:Math.abs(d-e)<Ox&&v-n>Ox?[e,Math.abs(l-e)<Ox?h:n]:Math.abs(v-n)<Ox&&d-t>Ox?[Math.abs(h-n)<Ox?l:t,n]:null))-1),++s);s&&(_=!1)}if(_){var y,m,x,b=1/0;for(i=0,_=null;i<g;++i)(o=Rx[i])&&(u=o.site,y=u[0]-t,m=u[1]-n,x=y*y+m*m,x<b&&(b=x,_=o));if(_){var w=[t,n],M=[t,r],T=[e,r],N=[e,n];_.halfedges.push(qx.push(Wf(u=_.site,w,M))-1,qx.push(Wf(u,M,T))-1,qx.push(Wf(u,T,N))-1,qx.push(Wf(u,N,w))-1)}}for(i=0;i<g;++i)(o=Rx[i])&&(o.halfedges.length||delete Rx[i])}function il(){Bf(this),this.x=this.y=this.arc=this.site=this.cy=null}function ol(t){var n=t.P,e=t.N;if(n&&e){var r=n.site,i=t.site,o=e.site;if(r!==o){var u=i[0],a=i[1],c=r[0]-u,s=r[1]-a,f=o[0]-u,l=o[1]-a,h=2*(c*l-s*f);if(!(h>=-Ix)){var p=c*c+s*s,d=f*f+l*l,v=(l*p-s*d)/h,g=(c*d-f*p)/h,_=Ux.pop()||new il;_.arc=t,_.site=i,_.x=v+u,_.y=(_.cy=g+a)+Math.sqrt(v*v+g*g),t.circle=_;for(var y=null,m=Lx._;m;)if(_.y<m.y||_.y===m.y&&_.x<=m.x){if(!m.L){y=m.P;break}m=m.L}else{if(!m.R){y=m;break}m=m.R}Lx.insert(y,_),y||(zx=_)}}}}function ul(t){var n=t.circle;n&&(n.P||(zx=n.N),Lx.remove(n),Ux.push(n),Bf(n),t.circle=null)}function al(){Bf(this),this.edge=this.site=this.circle=null}function cl(t){var n=Dx.pop()||new al;return n.site=t,n}function sl(t){ul(t),Px.remove(t),Dx.push(t),Bf(t)}function fl(t){var n=t.circle,e=n.x,r=n.cy,i=[e,r],o=t.P,u=t.N,a=[t];sl(t);for(var c=o;c.circle&&Math.abs(e-c.circle.x)<Ox&&Math.abs(r-c.circle.cy)<Ox;)o=c.P,a.unshift(c),sl(c),c=o;a.unshift(c),ul(c);for(var s=u;s.circle&&Math.abs(e-s.circle.x)<Ox&&Math.abs(r-s.circle.cy)<Ox;)u=s.N,a.push(s),sl(s),s=u;a.push(s),ul(s);var f,l=a.length;for(f=1;f<l;++f)s=a[f],c=a[f-1],$f(s.edge,c.site,s.site,i);c=a[0],s=a[l-1],s.edge=Vf(c.site,s.site,null,i),ol(c),ol(s)}function ll(t){for(var n,e,r,i,o=t[0],u=t[1],a=Px._;a;)if(r=hl(a,u)-o,r>Ox)a=a.L;else{if(i=o-pl(a,u),!(i>Ox)){r>-Ox?(n=a.P,e=a):i>-Ox?(n=a,e=a.N):n=e=a;break}if(!a.R){n=a;break}a=a.R}Jf(t);var c=cl(t);if(Px.insert(n,c),n||e){if(n===e)return ul(n),e=cl(n.site),Px.insert(c,e),c.edge=e.edge=Vf(n.site,c.site),ol(n),void ol(e);if(!e)return void(c.edge=Vf(n.site,c.site));ul(n),ul(e);var s=n.site,f=s[0],l=s[1],h=t[0]-f,p=t[1]-l,d=e.site,v=d[0]-f,g=d[1]-l,_=2*(h*g-p*v),y=h*h+p*p,m=v*v+g*g,x=[(g*y-p*m)/_+f,(h*m-v*y)/_+l];$f(e.edge,s,d,x),c.edge=Vf(s,t,null,x),e.edge=Vf(t,d,null,x),ol(n),ol(e)}}function hl(t,n){var e=t.site,r=e[0],i=e[1],o=i-n;if(!o)return r;var u=t.P;if(!u)return-(1/0);e=u.site;var a=e[0],c=e[1],s=c-n;if(!s)return a;var f=a-r,l=1/o-1/s,h=f/s;return l?(-h+Math.sqrt(h*h-2*l*(f*f/(-2*s)-c+s/2+i-o/2)))/l+r:(r+a)/2}function pl(t,n){var e=t.N;if(e)return hl(e,n);var r=t.site;return r[1]===n?r[0]:1/0}function dl(t,n,e){return(t[0]-e[0])*(n[1]-t[1])-(t[0]-n[0])*(e[1]-t[1])}function vl(t,n){return n[1]-t[1]||n[0]-t[0]}function gl(t,n){var e,r,i,o=t.sort(vl).pop();for(qx=[],Rx=new Array(t.length),Px=new Yf,Lx=new Yf;;)if(i=zx,o&&(!i||o[1]<i.y||o[1]===i.y&&o[0]<i.x))o[0]===e&&o[1]===r||(ll(o),e=o[0],r=o[1]),o=t.pop();else{if(!i)break;fl(i.arc)}if(el(),n){var u=+n[0][0],a=+n[0][1],c=+n[1][0],s=+n[1][1];Kf(u,a,c,s),rl(u,a,c,s)}this.edges=qx,this.cells=Rx,Px=Lx=qx=Rx=null}function _l(){function t(t){return new gl(t.map(function(r,i){var o=[Math.round(n(r,i,t)/Ox)*Ox,Math.round(e(r,i,t)/Ox)*Ox];return o.index=i,o.data=r,o}),r)}var n=If,e=Ff,r=null;return t.polygons=function(n){return t(n).polygons()},t.links=function(n){return t(n).links()},t.triangles=function(n){return t(n).triangles()},t.x=function(e){return arguments.length?(n="function"==typeof e?e:Of(+e),t):n},t.y=function(n){return arguments.length?(e="function"==typeof n?n:Of(+n),t):e},t.extent=function(n){return arguments.length?(r=null==n?null:[[+n[0][0],+n[0][1]],[+n[1][0],+n[1][1]]],t):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},t.size=function(n){return arguments.length?(r=null==n?null:[[0,0],[+n[0],+n[1]]],t):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},t}function yl(t){return function(){return t}}function ml(t,n,e){this.target=t,this.type=n,this.transform=e}function xl(t,n,e){this.k=t,this.x=n,this.y=e}function bl(t){return t.__zoom||Fx}function wl(){t.event.stopImmediatePropagation()}function Ml(){t.event.preventDefault(),t.event.stopImmediatePropagation()}function Tl(){return!t.event.button}function Nl(){var t,n,e=this;return e instanceof SVGElement?(e=e.ownerSVGElement||e,t=e.width.baseVal.value,n=e.height.baseVal.value):(t=e.clientWidth,n=e.clientHeight),[[0,0],[t,n]]}function kl(){return this.__zoom||Fx}function Sl(){function n(t){t.on("wheel.zoom",s).on("mousedown.zoom",f).on("dblclick.zoom",l).on("touchstart.zoom",h).on("touchmove.zoom",p).on("touchend.zoom touchcancel.zoom",d).style("-webkit-tap-highlight-color","rgba(0,0,0,0)").property("__zoom",kl)}function e(t,n){return n=Math.max(m,Math.min(x,n)),n===t.k?t:new xl(n,t.x,t.y)}function r(t,n,e){var r=n[0]-e[0]*t.k,i=n[1]-e[1]*t.k;return r===t.x&&i===t.y?t:new xl(t.k,r,i)}function i(t,n){var e=t.invertX(n[0][0])-b,r=t.invertX(n[1][0])-w,i=t.invertY(n[0][1])-M,o=t.invertY(n[1][1])-T;return t.translate(r>e?(e+r)/2:Math.min(0,e)||Math.max(0,r),o>i?(i+o)/2:Math.min(0,i)||Math.max(0,o))}function o(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function u(t,n,e){t.on("start.zoom",function(){a(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){a(this,arguments).end()}).tween("zoom",function(){var t=this,r=arguments,i=a(t,r),u=y.apply(t,r),c=e||o(u),s=Math.max(u[1][0]-u[0][0],u[1][1]-u[0][1]),f=t.__zoom,l="function"==typeof n?n.apply(t,r):n,h=k(f.invert(c).concat(s/f.k),l.invert(c).concat(s/l.k));return function(t){if(1===t)t=l;else{var n=h(t),e=s/n[2];t=new xl(e,c[0]-n[0]*e,c[1]-n[1]*e)}i.zoom(null,t)}})}function a(t,n){for(var e,r=0,i=S.length;r<i;++r)if((e=S[r]).that===t)return e;return new c(t,n)}function c(t,n){this.that=t,this.args=n,this.index=-1,this.active=0,this.extent=y.apply(t,n)}function s(){function n(){o.wheel=null,o.end()}if(_.apply(this,arguments)){var o=a(this,arguments),u=this.__zoom,c=Math.max(m,Math.min(x,u.k*Math.pow(2,-t.event.deltaY*(t.event.deltaMode?120:1)/500))),s=du(this);if(o.wheel)o.mouse[0][0]===s[0]&&o.mouse[0][1]===s[1]||(o.mouse[1]=u.invert(o.mouse[0]=s)),clearTimeout(o.wheel);else{if(u.k===c)return;o.mouse=[s,u.invert(s)],Ha(this),o.start()}Ml(),o.wheel=setTimeout(n,C),o.zoom("mouse",i(r(e(u,c),o.mouse[0],o.mouse[1]),o.extent))}}function f(){function n(){Ml(),o.moved=!0,o.zoom("mouse",i(r(o.that.__zoom,o.mouse[0]=du(o.that),o.mouse[1]),o.extent))}function e(){u.on("mousemove.zoom mouseup.zoom",null),zf(t.event.view,o.moved),Ml(),o.end()}if(!g&&_.apply(this,arguments)){var o=a(this,arguments),u=qa(t.event.view).on("mousemove.zoom",n,!0).on("mouseup.zoom",e,!0),c=du(this);Cf(t.event.view),wl(),o.mouse=[c,this.__zoom.invert(c)],Ha(this),o.start()}}function l(){if(_.apply(this,arguments)){var o=this.__zoom,a=du(this),c=o.invert(a),s=o.k*(t.event.shiftKey?.5:2),f=i(r(e(o,s),a,c),y.apply(this,arguments));Ml(),N>0?qa(this).transition().duration(N).call(u,f,a):qa(this).call(n.transform,f)}}function h(){if(_.apply(this,arguments)){var n,e,r,i=a(this,arguments),o=t.event.changedTouches,u=o.length;for(wl(),n=0;n<u;++n)e=o[n],r=Da(this,o,e.identifier),r=[r,this.__zoom.invert(r),e.identifier],i.touch0?i.touch1||(i.touch1=r):i.touch0=r;return v&&(v=clearTimeout(v),!i.touch1)?(i.end(),r=qa(this).on("dblclick.zoom"),void(r&&r.apply(this,arguments))):void(t.event.touches.length===u&&(v=setTimeout(function(){v=null},A),Ha(this),i.start()))}}function p(){var n,o,u,c,s=a(this,arguments),f=t.event.changedTouches,l=f.length;for(Ml(),v&&(v=clearTimeout(v)),n=0;n<l;++n)o=f[n],u=Da(this,f,o.identifier),s.touch0&&s.touch0[2]===o.identifier?s.touch0[0]=u:s.touch1&&s.touch1[2]===o.identifier&&(s.touch1[0]=u);if(o=s.that.__zoom,s.touch1){var h=s.touch0[0],p=s.touch0[1],d=s.touch1[0],g=s.touch1[1],_=(_=d[0]-h[0])*_+(_=d[1]-h[1])*_,y=(y=g[0]-p[0])*y+(y=g[1]-p[1])*y;o=e(o,Math.sqrt(_/y)),u=[(h[0]+d[0])/2,(h[1]+d[1])/2],c=[(p[0]+g[0])/2,(p[1]+g[1])/2]}else{if(!s.touch0)return;u=s.touch0[0],c=s.touch0[1]}s.zoom("touch",i(r(o,u,c),s.extent))}function d(){var n,e,r=a(this,arguments),i=t.event.changedTouches,o=i.length;for(wl(),g&&clearTimeout(g),g=setTimeout(function(){g=null},A),n=0;n<o;++n)e=i[n],r.touch0&&r.touch0[2]===e.identifier?delete r.touch0:r.touch1&&r.touch1[2]===e.identifier&&delete r.touch1;r.touch1&&!r.touch0&&(r.touch0=r.touch1,delete r.touch1),r.touch0||r.end()}var v,g,_=Tl,y=Nl,m=0,x=1/0,b=-x,w=x,M=b,T=w,N=250,k=_r,S=[],E=Mr("start","zoom","end"),A=500,C=150;return n.transform=function(t,n){var e=t.selection?t.selection():t;e.property("__zoom",kl),t!==e?u(t,n):e.interrupt().each(function(){a(this,arguments).start().zoom(null,"function"==typeof n?n.apply(this,arguments):n).end()})},n.scaleBy=function(t,e){n.scaleTo(t,function(){var t=this.__zoom.k,n="function"==typeof e?e.apply(this,arguments):e;return t*n})},n.scaleTo=function(t,u){n.transform(t,function(){var t=y.apply(this,arguments),n=this.__zoom,a=o(t),c=n.invert(a),s="function"==typeof u?u.apply(this,arguments):u;return i(r(e(n,s),a,c),t)})},n.translateBy=function(t,e,r){n.transform(t,function(){return i(this.__zoom.translate("function"==typeof e?e.apply(this,arguments):e,"function"==typeof r?r.apply(this,arguments):r),y.apply(this,arguments))})},c.prototype={start:function(){return 1===++this.active&&(this.index=S.push(this)-1,this.emit("start")),this},zoom:function(t,n){return this.mouse&&"mouse"!==t&&(this.mouse[1]=n.invert(this.mouse[0])),this.touch0&&"touch"!==t&&(this.touch0[1]=n.invert(this.touch0[0])),this.touch1&&"touch"!==t&&(this.touch1[1]=n.invert(this.touch1[0])),this.that.__zoom=n,this.emit("zoom"),this},end:function(){return 0===--this.active&&(S.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(t){lu(new ml(n,t,this.that.__zoom),E.apply,E,[t,this.that,this.args])}},n.filter=function(t){return arguments.length?(_="function"==typeof t?t:yl(!!t),n):_},n.extent=function(t){return arguments.length?(y="function"==typeof t?t:yl([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),n):y},n.scaleExtent=function(t){return arguments.length?(m=+t[0],x=+t[1],n):[m,x]},n.translateExtent=function(t){return arguments.length?(b=+t[0][0],w=+t[1][0],M=+t[0][1],T=+t[1][1],n):[[b,M],[w,T]]},n.duration=function(t){return arguments.length?(N=+t,n):N},n.interpolate=function(t){return arguments.length?(k=t,n):k},n.on=function(){var t=E.on.apply(E,arguments);return t===E?n:t},n}function El(t){return function(){return t}}function Al(t,n,e){this.target=t,this.type=n,this.selection=e}function Cl(){t.event.stopImmediatePropagation()}function zl(){t.event.preventDefault(),t.event.stopImmediatePropagation()}function Pl(t){return{type:t}}function Rl(){return!t.event.button}function Ll(){var t=this.ownerSVGElement||this;return[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function ql(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function Ul(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}function Dl(t){var n=t.__brush;return n?n.dim.output(n.selection):null}function Ol(){return Yl(Xx)}function Il(){return Yl(Vx)}function Fl(){return Yl(Wx)}function Yl(n){function e(t){var e=t.property("__brush",a).selectAll(".overlay").data([Pl("overlay")]);e.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",$x.overlay).merge(e).each(function(){var t=ql(this).extent;qa(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])}),t.selectAll(".selection").data([Pl("selection")]).enter().append("rect").attr("class","selection").attr("cursor",$x.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var i=t.selectAll(".handle").data(n.handles,function(t){return t.type});i.exit().remove(),i.enter().append("rect").attr("class",function(t){return"handle handle--"+t.type}).attr("cursor",function(t){return $x[t.type]}),t.each(r).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",u)}function r(){var t=qa(this),n=ql(this).selection;n?(t.selectAll(".selection").style("display",null).attr("x",n[0][0]).attr("y",n[0][1]).attr("width",n[1][0]-n[0][0]).attr("height",n[1][1]-n[0][1]),t.selectAll(".handle").style("display",null).attr("x",function(t){return"e"===t.type[t.type.length-1]?n[1][0]-h/2:n[0][0]-h/2}).attr("y",function(t){return"s"===t.type[0]?n[1][1]-h/2:n[0][1]-h/2}).attr("width",function(t){return"n"===t.type||"s"===t.type?n[1][0]-n[0][0]+h:h}).attr("height",function(t){return"e"===t.type||"w"===t.type?n[1][1]-n[0][1]+h:h})):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function i(t,n){return t.__brush.emitter||new o(t,n)}function o(t,n){this.that=t,this.args=n,this.state=t.__brush,this.active=0}function u(){function e(){var t=du(T);!U||w||M||(Math.abs(t[0]-O[0])>Math.abs(t[1]-O[1])?M=!0:w=!0),O=t,b=!0,zl(),o()}function o(){var t;switch(m=O[0]-D[0],x=O[1]-D[1],k){case Bx:case Yx:S&&(m=Math.max(P-l,Math.min(L-v,m)),h=l+m,g=v+m),E&&(x=Math.max(R-p,Math.min(q-_,x)),d=p+x,y=_+x);break;case jx:S<0?(m=Math.max(P-l,Math.min(L-l,m)),h=l+m,g=v):S>0&&(m=Math.max(P-v,Math.min(L-v,m)),h=l,g=v+m),E<0?(x=Math.max(R-p,Math.min(q-p,x)),d=p+x,y=_):E>0&&(x=Math.max(R-_,Math.min(q-_,x)),d=p,y=_+x);break;case Hx:S&&(h=Math.max(P,Math.min(L,l-m*S)),g=Math.max(P,Math.min(L,v+m*S))),E&&(d=Math.max(R,Math.min(q,p-x*E)),y=Math.max(R,Math.min(q,_+x*E)))}g<h&&(S*=-1,t=l,l=v,v=t,t=h,h=g,g=t,N in Zx&&Y.attr("cursor",$x[N=Zx[N]])),y<d&&(E*=-1,t=p,p=_,_=t,t=d,d=y,y=t,N in Gx&&Y.attr("cursor",$x[N=Gx[N]])),A.selection&&(z=A.selection),w&&(h=z[0][0],g=z[1][0]),M&&(d=z[0][1],y=z[1][1]),z[0][0]===h&&z[0][1]===d&&z[1][0]===g&&z[1][1]===y||(A.selection=[[h,d],[g,y]],r.call(T),I.brush())}function u(){if(Cl(),t.event.touches){if(t.event.touches.length)return;c&&clearTimeout(c),c=setTimeout(function(){c=null},500),F.on("touchmove.brush touchend.brush touchcancel.brush",null)}else zf(t.event.view,b),B.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);F.attr("pointer-events","all"),Y.attr("cursor",$x.overlay),A.selection&&(z=A.selection),Ul(z)&&(A.selection=null,r.call(T)),I.end()}function a(){switch(t.event.keyCode){case 16:U=S&&E;break;case 18:k===jx&&(S&&(v=g-m*S,l=h+m*S),E&&(_=y-x*E,p=d+x*E),k=Hx,o());break;case 32:k!==jx&&k!==Hx||(S<0?v=g-m:S>0&&(l=h-m),E<0?_=y-x:E>0&&(p=d-x),k=Bx,Y.attr("cursor",$x.selection),o());break;default:return}zl()}function s(){switch(t.event.keyCode){case 16:U&&(w=M=U=!1,o());break;case 18:k===Hx&&(S<0?v=g:S>0&&(l=h),E<0?_=y:E>0&&(p=d),k=jx,o());break;case 32:k===Bx&&(t.event.altKey?(S&&(v=g-m*S,l=h+m*S),E&&(_=y-x*E,p=d+x*E),k=Hx):(S<0?v=g:S>0&&(l=h),E<0?_=y:E>0&&(p=d),k=jx),Y.attr("cursor",$x[N]),o());break;default:return}zl()}if(t.event.touches){if(t.event.changedTouches.length<t.event.touches.length)return zl()}else if(c)return;if(f.apply(this,arguments)){var l,h,p,d,v,g,_,y,m,x,b,w,M,T=this,N=t.event.target.__data__.type,k="selection"===(t.event.metaKey?N="overlay":N)?Yx:t.event.altKey?Hx:jx,S=n===Vx?null:Kx[N],E=n===Xx?null:Jx[N],A=ql(T),C=A.extent,z=A.selection,P=C[0][0],R=C[0][1],L=C[1][0],q=C[1][1],U=S&&E&&t.event.shiftKey,D=du(T),O=D,I=i(T,arguments).beforestart();"overlay"===N?A.selection=z=[[l=n===Vx?P:D[0],p=n===Xx?R:D[1]],[v=n===Vx?L:l,_=n===Xx?q:p]]:(l=z[0][0],p=z[0][1],v=z[1][0],_=z[1][1]),h=l,d=p,g=v,y=_;var F=qa(T).attr("pointer-events","none"),Y=F.selectAll(".overlay").attr("cursor",$x[N]);if(t.event.touches)F.on("touchmove.brush",e,!0).on("touchend.brush touchcancel.brush",u,!0);else{var B=qa(t.event.view).on("keydown.brush",a,!0).on("keyup.brush",s,!0).on("mousemove.brush",e,!0).on("mouseup.brush",u,!0);Cf(t.event.view)}Cl(),Ha(T),r.call(T),I.start()}}function a(){var t=this.__brush||{selection:null};return t.extent=s.apply(this,arguments),t.dim=n,t}var c,s=Ll,f=Rl,l=Mr(e,"start","brush","end"),h=6;return e.move=function(t,e){t.selection?t.on("start.brush",function(){i(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){i(this,arguments).end()}).tween("brush",function(){function t(t){u.selection=1===t&&Ul(s)?null:f(t),r.call(o),a.brush()}var o=this,u=o.__brush,a=i(o,arguments),c=u.selection,s=n.input("function"==typeof e?e.apply(this,arguments):e,u.extent),f=cr(c,s);return c&&s?t:t(1)}):t.each(function(){var t=this,o=arguments,u=t.__brush,a=n.input("function"==typeof e?e.apply(t,o):e,u.extent),c=i(t,o).beforestart();Ha(t),u.selection=null==a||Ul(a)?null:a,r.call(t),c.start().brush().end()})},o.prototype={beforestart:function(){return 1===++this.active&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting&&(this.starting=!1,this.emit("start")),this},brush:function(){return this.emit("brush"),this},end:function(){return 0===--this.active&&(delete this.state.emitter,this.emit("end")),this},emit:function(t){lu(new Al(e,t,n.output(this.state.selection)),l.apply,l,[t,this.that,this.args])}},e.extent=function(t){return arguments.length?(s="function"==typeof t?t:El([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),e):s},e.filter=function(t){return arguments.length?(f="function"==typeof t?t:El(!!t),e):f},e.handleSize=function(t){return arguments.length?(h=+t,e):h},e.on=function(){var t=l.on.apply(l,arguments);return t===l?e:t},e}function Bl(t){return function(n,e){return t(n.source.value+n.target.value,e.source.value+e.target.value)}}function jl(){function t(t){var o,u,a,c,s,f,h=t.length,p=[],d=l(h),v=[],g=[],_=g.groups=new Array(h),y=new Array(h*h);for(o=0,s=-1;++s<h;){for(u=0,f=-1;++f<h;)u+=t[s][f];p.push(u),v.push(l(h)),o+=u}for(e&&d.sort(function(t,n){return e(p[t],p[n])}),r&&v.forEach(function(n,e){n.sort(function(n,i){return r(t[e][n],t[e][i])})}),o=ib(0,rb-n*h)/o,c=o?n:rb/h,u=0,s=-1;++s<h;){for(a=u,f=-1;++f<h;){var m=d[s],x=v[m][f],b=t[m][x],w=u,M=u+=b*o;y[x*h+m]={index:m,subindex:x,startAngle:w, | |
endAngle:M,value:b}}_[m]={index:m,startAngle:a,endAngle:u,value:p[m]},u+=c}for(s=-1;++s<h;)for(f=s-1;++f<h;){var T=y[f*h+s],N=y[s*h+f];(T.value||N.value)&&g.push(T.value<N.value?{source:N,target:T}:{source:T,target:N})}return i?g.sort(i):g}var n=0,e=null,r=null,i=null;return t.padAngle=function(e){return arguments.length?(n=ib(0,e),t):n},t.sortGroups=function(n){return arguments.length?(e=n,t):e},t.sortSubgroups=function(n){return arguments.length?(r=n,t):r},t.sortChords=function(n){return arguments.length?(null==n?i=null:(i=Bl(n))._=n,t):i&&i._},t}function Hl(t){return function(){return t}}function Xl(t){return t.source}function Vl(t){return t.target}function Wl(t){return t.radius}function $l(t){return t.startAngle}function Zl(t){return t.endAngle}function Gl(){function t(){var t,a=ob.call(arguments),c=n.apply(this,a),s=e.apply(this,a),f=+r.apply(this,(a[0]=c,a)),l=i.apply(this,a)-eb,h=o.apply(this,a)-eb,p=f*Qx(l),d=f*tb(l),v=+r.apply(this,(a[0]=s,a)),g=i.apply(this,a)-eb,_=o.apply(this,a)-eb;if(u||(u=t=Tt()),u.moveTo(p,d),u.arc(0,0,f,l,h),l===g&&h===_||(u.quadraticCurveTo(0,0,v*Qx(g),v*tb(g)),u.arc(0,0,v,g,_)),u.quadraticCurveTo(0,0,p,d),u.closePath(),t)return u=null,t+""||null}var n=Xl,e=Vl,r=Wl,i=$l,o=Zl,u=null;return t.radius=function(n){return arguments.length?(r="function"==typeof n?n:Hl(+n),t):r},t.startAngle=function(n){return arguments.length?(i="function"==typeof n?n:Hl(+n),t):i},t.endAngle=function(n){return arguments.length?(o="function"==typeof n?n:Hl(+n),t):o},t.source=function(e){return arguments.length?(n=e,t):n},t.target=function(n){return arguments.length?(e=n,t):e},t.context=function(n){return arguments.length?(u=null==n?null:n,t):u},t}function Kl(){return new Jl}function Jl(){this.reset()}function Ql(t,n,e){var r=t.s=n+e,i=r-n,o=r-i;t.t=n-o+(e-i)}function th(t){return t>1?0:t<-1?Fb:Math.acos(t)}function nh(t){return t>1?Yb:t<-1?-Yb:Math.asin(t)}function eh(t){return(t=tw(t/2))*t}function rh(){}function ih(t,n){t&&ow.hasOwnProperty(t.type)&&ow[t.type](t,n)}function oh(t,n,e){var r,i=-1,o=t.length-e;for(n.lineStart();++i<o;)r=t[i],n.point(r[0],r[1],r[2]);n.lineEnd()}function uh(t,n){var e=-1,r=t.length;for(n.polygonStart();++e<r;)oh(t[e],n,1);n.polygonEnd()}function ah(t,n){t&&iw.hasOwnProperty(t.type)?iw[t.type](t,n):ih(t,n)}function ch(){cw.point=fh}function sh(){lh(ub,ab)}function fh(t,n){cw.point=lh,ub=t,ab=n,t*=Xb,n*=Xb,cb=t,sb=Zb(n=n/2+Bb),fb=tw(n)}function lh(t,n){t*=Xb,n*=Xb,n=n/2+Bb;var e=t-cb,r=e>=0?1:-1,i=r*e,o=Zb(n),u=tw(n),a=fb*u,c=sb*o+a*Zb(i),s=a*r*tw(i);uw.add($b(s,c)),cb=t,sb=o,fb=u}function hh(t){return aw.reset(),ah(t,cw),2*aw}function ph(t){return[$b(t[1],t[0]),nh(t[2])]}function dh(t){var n=t[0],e=t[1],r=Zb(e);return[r*Zb(n),r*tw(n),tw(e)]}function vh(t,n){return t[0]*n[0]+t[1]*n[1]+t[2]*n[2]}function gh(t,n){return[t[1]*n[2]-t[2]*n[1],t[2]*n[0]-t[0]*n[2],t[0]*n[1]-t[1]*n[0]]}function _h(t,n){t[0]+=n[0],t[1]+=n[1],t[2]+=n[2]}function yh(t,n){return[t[0]*n,t[1]*n,t[2]*n]}function mh(t){var n=ew(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=n,t[1]/=n,t[2]/=n}function xh(t,n){mb.push(xb=[lb=t,pb=t]),n<hb&&(hb=n),n>db&&(db=n)}function bh(t,n){var e=dh([t*Xb,n*Xb]);if(yb){var r=gh(yb,e),i=[r[1],-r[0],0],o=gh(i,r);mh(o),o=ph(o);var u,a=t-vb,c=a>0?1:-1,s=o[0]*Hb*c,f=Vb(a)>180;f^(c*vb<s&&s<c*t)?(u=o[1]*Hb,u>db&&(db=u)):(s=(s+360)%360-180,f^(c*vb<s&&s<c*t)?(u=-o[1]*Hb,u<hb&&(hb=u)):(n<hb&&(hb=n),n>db&&(db=n))),f?t<vb?Sh(lb,t)>Sh(lb,pb)&&(pb=t):Sh(t,pb)>Sh(lb,pb)&&(lb=t):pb>=lb?(t<lb&&(lb=t),t>pb&&(pb=t)):t>vb?Sh(lb,t)>Sh(lb,pb)&&(pb=t):Sh(t,pb)>Sh(lb,pb)&&(lb=t)}else xh(t,n);yb=e,vb=t}function wh(){fw.point=bh}function Mh(){xb[0]=lb,xb[1]=pb,fw.point=xh,yb=null}function Th(t,n){if(yb){var e=t-vb;sw.add(Vb(e)>180?e+(e>0?360:-360):e)}else gb=t,_b=n;cw.point(t,n),bh(t,n)}function Nh(){cw.lineStart()}function kh(){Th(gb,_b),cw.lineEnd(),Vb(sw)>Ob&&(lb=-(pb=180)),xb[0]=lb,xb[1]=pb,yb=null}function Sh(t,n){return(n-=t)<0?n+360:n}function Eh(t,n){return t[0]-n[0]}function Ah(t,n){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:n<t[0]||t[1]<n}function Ch(t){var n,e,r,i,o,u,a;if(db=pb=-(lb=hb=1/0),mb=[],ah(t,fw),e=mb.length){for(mb.sort(Eh),n=1,r=mb[0],o=[r];n<e;++n)i=mb[n],Ah(r,i[0])||Ah(r,i[1])?(Sh(r[0],i[1])>Sh(r[0],r[1])&&(r[1]=i[1]),Sh(i[0],r[1])>Sh(r[0],r[1])&&(r[0]=i[0])):o.push(r=i);for(u=-(1/0),e=o.length-1,n=0,r=o[e];n<=e;r=i,++n)i=o[n],(a=Sh(r[1],i[0]))>u&&(u=a,lb=i[0],pb=r[1])}return mb=xb=null,lb===1/0||hb===1/0?[[NaN,NaN],[NaN,NaN]]:[[lb,hb],[pb,db]]}function zh(t,n){t*=Xb,n*=Xb;var e=Zb(n);Ph(e*Zb(t),e*tw(t),tw(n))}function Ph(t,n,e){++bb,Mb+=(t-Mb)/bb,Tb+=(n-Tb)/bb,Nb+=(e-Nb)/bb}function Rh(){lw.point=Lh}function Lh(t,n){t*=Xb,n*=Xb;var e=Zb(n);Lb=e*Zb(t),qb=e*tw(t),Ub=tw(n),lw.point=qh,Ph(Lb,qb,Ub)}function qh(t,n){t*=Xb,n*=Xb;var e=Zb(n),r=e*Zb(t),i=e*tw(t),o=tw(n),u=$b(ew((u=qb*o-Ub*i)*u+(u=Ub*r-Lb*o)*u+(u=Lb*i-qb*r)*u),Lb*r+qb*i+Ub*o);wb+=u,kb+=u*(Lb+(Lb=r)),Sb+=u*(qb+(qb=i)),Eb+=u*(Ub+(Ub=o)),Ph(Lb,qb,Ub)}function Uh(){lw.point=zh}function Dh(){lw.point=Ih}function Oh(){Fh(Pb,Rb),lw.point=zh}function Ih(t,n){Pb=t,Rb=n,t*=Xb,n*=Xb,lw.point=Fh;var e=Zb(n);Lb=e*Zb(t),qb=e*tw(t),Ub=tw(n),Ph(Lb,qb,Ub)}function Fh(t,n){t*=Xb,n*=Xb;var e=Zb(n),r=e*Zb(t),i=e*tw(t),o=tw(n),u=qb*o-Ub*i,a=Ub*r-Lb*o,c=Lb*i-qb*r,s=ew(u*u+a*a+c*c),f=Lb*r+qb*i+Ub*o,l=s&&-th(f)/s,h=$b(s,f);Ab+=l*u,Cb+=l*a,zb+=l*c,wb+=h,kb+=h*(Lb+(Lb=r)),Sb+=h*(qb+(qb=i)),Eb+=h*(Ub+(Ub=o)),Ph(Lb,qb,Ub)}function Yh(t){bb=wb=Mb=Tb=Nb=kb=Sb=Eb=Ab=Cb=zb=0,ah(t,lw);var n=Ab,e=Cb,r=zb,i=n*n+e*e+r*r;return i<Ib&&(n=kb,e=Sb,r=Eb,wb<Ob&&(n=Mb,e=Tb,r=Nb),i=n*n+e*e+r*r,i<Ib)?[NaN,NaN]:[$b(e,n)*Hb,nh(r/ew(i))*Hb]}function Bh(t){return function(){return t}}function jh(t,n){function e(e,r){return e=t(e,r),n(e[0],e[1])}return t.invert&&n.invert&&(e.invert=function(e,r){return e=n.invert(e,r),e&&t.invert(e[0],e[1])}),e}function Hh(t,n){return[t>Fb?t-jb:t<-Fb?t+jb:t,n]}function Xh(t,n,e){return(t%=jb)?n||e?jh(Wh(t),$h(n,e)):Wh(t):n||e?$h(n,e):Hh}function Vh(t){return function(n,e){return n+=t,[n>Fb?n-jb:n<-Fb?n+jb:n,e]}}function Wh(t){var n=Vh(t);return n.invert=Vh(-t),n}function $h(t,n){function e(t,n){var e=Zb(n),a=Zb(t)*e,c=tw(t)*e,s=tw(n),f=s*r+a*i;return[$b(c*o-f*u,a*r-s*i),nh(f*o+c*u)]}var r=Zb(t),i=tw(t),o=Zb(n),u=tw(n);return e.invert=function(t,n){var e=Zb(n),a=Zb(t)*e,c=tw(t)*e,s=tw(n),f=s*o-c*u;return[$b(c*o+s*u,a*r+f*i),nh(f*r-a*i)]},e}function Zh(t){function n(n){return n=t(n[0]*Xb,n[1]*Xb),n[0]*=Hb,n[1]*=Hb,n}return t=Xh(t[0]*Xb,t[1]*Xb,t.length>2?t[2]*Xb:0),n.invert=function(n){return n=t.invert(n[0]*Xb,n[1]*Xb),n[0]*=Hb,n[1]*=Hb,n},n}function Gh(t,n,e,r,i,o){if(e){var u=Zb(n),a=tw(n),c=r*e;null==i?(i=n+r*jb,o=n-c/2):(i=Kh(u,i),o=Kh(u,o),(r>0?i<o:i>o)&&(i+=r*jb));for(var s,f=i;r>0?f>o:f<o;f-=c)s=ph([u,-a*Zb(f),-a*tw(f)]),t.point(s[0],s[1])}}function Kh(t,n){n=dh(n),n[0]-=t,mh(n);var e=th(-n[1]);return((-n[2]<0?-e:e)+jb-Ob)%jb}function Jh(){function t(t,n){e.push(t=r(t,n)),t[0]*=Hb,t[1]*=Hb}function n(){var t=i.apply(this,arguments),n=o.apply(this,arguments)*Xb,c=u.apply(this,arguments)*Xb;return e=[],r=Xh(-t[0]*Xb,-t[1]*Xb,0).invert,Gh(a,n,c,1),t={type:"Polygon",coordinates:[e]},e=r=null,t}var e,r,i=Bh([0,0]),o=Bh(90),u=Bh(6),a={point:t};return n.center=function(t){return arguments.length?(i="function"==typeof t?t:Bh([+t[0],+t[1]]),n):i},n.radius=function(t){return arguments.length?(o="function"==typeof t?t:Bh(+t),n):o},n.precision=function(t){return arguments.length?(u="function"==typeof t?t:Bh(+t),n):u},n}function Qh(){var t,n=[];return{point:function(n,e){t.push([n,e])},lineStart:function(){n.push(t=[])},lineEnd:rh,rejoin:function(){n.length>1&&n.push(n.pop().concat(n.shift()))},result:function(){var e=n;return n=[],t=null,e}}}function tp(t,n,e,r,i,o){var u,a=t[0],c=t[1],s=n[0],f=n[1],l=0,h=1,p=s-a,d=f-c;if(u=e-a,p||!(u>0)){if(u/=p,p<0){if(u<l)return;u<h&&(h=u)}else if(p>0){if(u>h)return;u>l&&(l=u)}if(u=i-a,p||!(u<0)){if(u/=p,p<0){if(u>h)return;u>l&&(l=u)}else if(p>0){if(u<l)return;u<h&&(h=u)}if(u=r-c,d||!(u>0)){if(u/=d,d<0){if(u<l)return;u<h&&(h=u)}else if(d>0){if(u>h)return;u>l&&(l=u)}if(u=o-c,d||!(u<0)){if(u/=d,d<0){if(u>h)return;u>l&&(l=u)}else if(d>0){if(u<l)return;u<h&&(h=u)}return l>0&&(t[0]=a+l*p,t[1]=c+l*d),h<1&&(n[0]=a+h*p,n[1]=c+h*d),!0}}}}}function np(t,n){return Vb(t[0]-n[0])<Ob&&Vb(t[1]-n[1])<Ob}function ep(t,n,e,r){this.x=t,this.z=n,this.o=e,this.e=r,this.v=!1,this.n=this.p=null}function rp(t,n,e,r,i){var o,u,a=[],c=[];if(t.forEach(function(t){if(!((n=t.length-1)<=0)){var n,e,r=t[0],u=t[n];if(np(r,u)){for(i.lineStart(),o=0;o<n;++o)i.point((r=t[o])[0],r[1]);return void i.lineEnd()}a.push(e=new ep(r,t,null,!0)),c.push(e.o=new ep(r,null,e,!1)),a.push(e=new ep(u,t,null,!1)),c.push(e.o=new ep(u,null,e,!0))}}),a.length){for(c.sort(n),ip(a),ip(c),o=0,u=c.length;o<u;++o)c[o].e=e=!e;for(var s,f,l=a[0];;){for(var h=l,p=!0;h.v;)if((h=h.n)===l)return;s=h.z,i.lineStart();do{if(h.v=h.o.v=!0,h.e){if(p)for(o=0,u=s.length;o<u;++o)i.point((f=s[o])[0],f[1]);else r(h.x,h.n.x,1,i);h=h.n}else{if(p)for(s=h.p.z,o=s.length-1;o>=0;--o)i.point((f=s[o])[0],f[1]);else r(h.x,h.p.x,-1,i);h=h.p}h=h.o,s=h.z,p=!p}while(!h.v);i.lineEnd()}}}function ip(t){if(n=t.length){for(var n,e,r=0,i=t[0];++r<n;)i.n=e=t[r],e.p=i,i=e;i.n=e=t[0],e.p=i}}function op(t,n,e,r){function i(i,o){return t<=i&&i<=e&&n<=o&&o<=r}function o(i,o,a,s){var f=0,l=0;if(null==i||(f=u(i,a))!==(l=u(o,a))||c(i,o)<0^a>0){do s.point(0===f||3===f?t:e,f>1?r:n);while((f=(f+a+4)%4)!==l)}else s.point(o[0],o[1])}function u(r,i){return Vb(r[0]-t)<Ob?i>0?0:3:Vb(r[0]-e)<Ob?i>0?2:1:Vb(r[1]-n)<Ob?i>0?1:0:i>0?3:2}function a(t,n){return c(t.x,n.x)}function c(t,n){var e=u(t,1),r=u(n,1);return e!==r?e-r:0===e?n[1]-t[1]:1===e?t[0]-n[0]:2===e?t[1]-n[1]:n[0]-t[0]}return function(u){function c(t,n){i(t,n)&&S.point(t,n)}function s(){for(var n=0,e=0,i=g.length;e<i;++e)for(var o,u,a=g[e],c=1,s=a.length,f=a[0],l=f[0],h=f[1];c<s;++c)o=l,u=h,f=a[c],l=f[0],h=f[1],u<=r?h>r&&(l-o)*(r-u)>(h-u)*(t-o)&&++n:h<=r&&(l-o)*(r-u)<(h-u)*(t-o)&&--n;return n}function f(){S=E,v=[],g=[],k=!0}function l(){var t=s(),n=k&&t,e=(v=w(v)).length;(n||e)&&(u.polygonStart(),n&&(u.lineStart(),o(null,null,1,u),u.lineEnd()),e&&rp(v,a,t,o,u),u.polygonEnd()),S=u,v=g=_=null}function h(){A.point=d,g&&g.push(_=[]),N=!0,T=!1,b=M=NaN}function p(){v&&(d(y,m),x&&T&&E.rejoin(),v.push(E.result())),A.point=c,T&&S.lineEnd()}function d(o,u){var a=i(o,u);if(g&&_.push([o,u]),N)y=o,m=u,x=a,N=!1,a&&(S.lineStart(),S.point(o,u));else if(a&&T)S.point(o,u);else{var c=[b=Math.max(Tw,Math.min(Mw,b)),M=Math.max(Tw,Math.min(Mw,M))],s=[o=Math.max(Tw,Math.min(Mw,o)),u=Math.max(Tw,Math.min(Mw,u))];tp(c,s,t,n,e,r)?(T||(S.lineStart(),S.point(c[0],c[1])),S.point(s[0],s[1]),a||S.lineEnd(),k=!1):a&&(S.lineStart(),S.point(o,u),k=!1)}b=o,M=u,T=a}var v,g,_,y,m,x,b,M,T,N,k,S=u,E=Qh(),A={point:c,lineStart:h,lineEnd:p,polygonStart:f,polygonEnd:l};return A}}function up(){var t,n,e,r=0,i=0,o=960,u=500;return e={stream:function(e){return t&&n===e?t:t=op(r,i,o,u)(n=e)},extent:function(a){return arguments.length?(r=+a[0][0],i=+a[0][1],o=+a[1][0],u=+a[1][1],t=n=null,e):[[r,i],[o,u]]}}}function ap(){kw.point=sp,kw.lineEnd=cp}function cp(){kw.point=kw.lineEnd=rh}function sp(t,n){t*=Xb,n*=Xb,hw=t,pw=tw(n),dw=Zb(n),kw.point=fp}function fp(t,n){t*=Xb,n*=Xb;var e=tw(n),r=Zb(n),i=Vb(t-hw),o=Zb(i),u=tw(i),a=r*u,c=dw*e-pw*r*o,s=pw*e+dw*r*o;Nw.add($b(ew(a*a+c*c),s)),hw=t,pw=e,dw=r}function lp(t){return Nw.reset(),ah(t,kw),+Nw}function hp(t,n){return Sw[0]=t,Sw[1]=n,lp(Ew)}function pp(t,n,e){var r=l(t,n-Ob,e).concat(n);return function(t){return r.map(function(n){return[t,n]})}}function dp(t,n,e){var r=l(t,n-Ob,e).concat(n);return function(t){return r.map(function(n){return[n,t]})}}function vp(){function t(){return{type:"MultiLineString",coordinates:n()}}function n(){return l(Gb(o/_)*_,i,_).map(p).concat(l(Gb(s/y)*y,c,y).map(d)).concat(l(Gb(r/v)*v,e,v).filter(function(t){return Vb(t%_)>Ob}).map(f)).concat(l(Gb(a/g)*g,u,g).filter(function(t){return Vb(t%y)>Ob}).map(h))}var e,r,i,o,u,a,c,s,f,h,p,d,v=10,g=v,_=90,y=360,m=2.5;return t.lines=function(){return n().map(function(t){return{type:"LineString",coordinates:t}})},t.outline=function(){return{type:"Polygon",coordinates:[p(o).concat(d(c).slice(1),p(i).reverse().slice(1),d(s).reverse().slice(1))]}},t.extent=function(n){return arguments.length?t.extentMajor(n).extentMinor(n):t.extentMinor()},t.extentMajor=function(n){return arguments.length?(o=+n[0][0],i=+n[1][0],s=+n[0][1],c=+n[1][1],o>i&&(n=o,o=i,i=n),s>c&&(n=s,s=c,c=n),t.precision(m)):[[o,s],[i,c]]},t.extentMinor=function(n){return arguments.length?(r=+n[0][0],e=+n[1][0],a=+n[0][1],u=+n[1][1],r>e&&(n=r,r=e,e=n),a>u&&(n=a,a=u,u=n),t.precision(m)):[[r,a],[e,u]]},t.step=function(n){return arguments.length?t.stepMajor(n).stepMinor(n):t.stepMinor()},t.stepMajor=function(n){return arguments.length?(_=+n[0],y=+n[1],t):[_,y]},t.stepMinor=function(n){return arguments.length?(v=+n[0],g=+n[1],t):[v,g]},t.precision=function(n){return arguments.length?(m=+n,f=pp(a,u,90),h=dp(r,e,m),p=pp(s,c,90),d=dp(o,i,m),t):m},t.extentMajor([[-180,-90+Ob],[180,90-Ob]]).extentMinor([[-180,-80-Ob],[180,80+Ob]])}function gp(){return vp()()}function _p(t,n){var e=t[0]*Xb,r=t[1]*Xb,i=n[0]*Xb,o=n[1]*Xb,u=Zb(r),a=tw(r),c=Zb(o),s=tw(o),f=u*Zb(e),l=u*tw(e),h=c*Zb(i),p=c*tw(i),d=2*nh(ew(eh(o-r)+u*c*eh(i-e))),v=tw(d),g=d?function(t){var n=tw(t*=d)/v,e=tw(d-t)/v,r=e*f+n*h,i=e*l+n*p,o=e*a+n*s;return[$b(i,r)*Hb,$b(o,ew(r*r+i*i))*Hb]}:function(){return[e*Hb,r*Hb]};return g.distance=d,g}function yp(t){return t}function mp(){zw.point=xp}function xp(t,n){zw.point=bp,vw=_w=t,gw=yw=n}function bp(t,n){Cw.add(yw*t-_w*n),_w=t,yw=n}function wp(){bp(vw,gw)}function Mp(t,n){t<Pw&&(Pw=t),t>Lw&&(Lw=t),n<Rw&&(Rw=n),n>qw&&(qw=n)}function Tp(t,n){Dw+=t,Ow+=n,++Iw}function Np(){Vw.point=kp}function kp(t,n){Vw.point=Sp,Tp(bw=t,ww=n)}function Sp(t,n){var e=t-bw,r=n-ww,i=ew(e*e+r*r);Fw+=i*(bw+t)/2,Yw+=i*(ww+n)/2,Bw+=i,Tp(bw=t,ww=n)}function Ep(){Vw.point=Tp}function Ap(){Vw.point=zp}function Cp(){Pp(mw,xw)}function zp(t,n){Vw.point=Pp,Tp(mw=bw=t,xw=ww=n)}function Pp(t,n){var e=t-bw,r=n-ww,i=ew(e*e+r*r);Fw+=i*(bw+t)/2,Yw+=i*(ww+n)/2,Bw+=i,i=ww*t-bw*n,jw+=i*(bw+t),Hw+=i*(ww+n),Xw+=3*i,Tp(bw=t,ww=n)}function Rp(t){this._context=t}function Lp(){this._string=[]}function qp(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function Up(t,n){function e(t){return t&&("function"==typeof o&&i.pointRadius(+o.apply(this,arguments)),ah(t,r(i))),i.result()}var r,i,o=4.5;return e.area=function(t){return ah(t,r(zw)),zw.result()},e.bounds=function(t){return ah(t,r(Uw)),Uw.result()},e.centroid=function(t){return ah(t,r(Vw)),Vw.result()},e.projection=function(n){return arguments.length?(r=null==n?(t=null,yp):(t=n).stream,e):t},e.context=function(t){return arguments.length?(i=null==t?(n=null,new Lp):new Rp(n=t),"function"!=typeof o&&i.pointRadius(o),e):n},e.pointRadius=function(t){return arguments.length?(o="function"==typeof t?t:(i.pointRadius(+t),+t),e):o},e.projection(t).context(n)}function Dp(t,n){var e=n[0],r=n[1],i=[tw(e),-Zb(e),0],o=0,u=0;Ww.reset();for(var a=0,c=t.length;a<c;++a)if(f=(s=t[a]).length)for(var s,f,l=s[f-1],h=l[0],p=l[1]/2+Bb,d=tw(p),v=Zb(p),g=0;g<f;++g,h=y,d=x,v=b,l=_){var _=s[g],y=_[0],m=_[1]/2+Bb,x=tw(m),b=Zb(m),w=y-h,M=w>=0?1:-1,T=M*w,N=T>Fb,k=d*x;if(Ww.add($b(k*M*tw(T),v*b+k*Zb(T))),o+=N?w+M*jb:w,N^h>=e^y>=e){var S=gh(dh(l),dh(_));mh(S);var E=gh(i,S);mh(E);var A=(N^w>=0?-1:1)*nh(E[2]);(r>A||r===A&&(S[0]||S[1]))&&(u+=N^w>=0?1:-1)}}return(o<-Ob||o<Ob&&Ww<-Ob)^1&u}function Op(t,n,e,r){return function(i,o){function u(n,e){var r=i(n,e);t(n=r[0],e=r[1])&&o.point(n,e)}function a(t,n){var e=i(t,n);g.point(e[0],e[1])}function c(){b.point=a,g.lineStart()}function s(){b.point=u,g.lineEnd()}function f(t,n){v.push([t,n]);var e=i(t,n);m.point(e[0],e[1])}function l(){m.lineStart(),v=[]}function h(){f(v[0][0],v[0][1]),m.lineEnd();var t,n,e,r,i=m.clean(),u=y.result(),a=u.length;if(v.pop(),p.push(v),v=null,a)if(1&i){if(e=u[0],(n=e.length-1)>0){for(x||(o.polygonStart(),x=!0),o.lineStart(),t=0;t<n;++t)o.point((r=e[t])[0],r[1]);o.lineEnd()}}else a>1&&2&i&&u.push(u.pop().concat(u.shift())),d.push(u.filter(Ip))}var p,d,v,g=n(o),_=i.invert(r[0],r[1]),y=Qh(),m=n(y),x=!1,b={point:u,lineStart:c,lineEnd:s,polygonStart:function(){b.point=f,b.lineStart=l,b.lineEnd=h,d=[],p=[]},polygonEnd:function(){b.point=u,b.lineStart=c,b.lineEnd=s,d=w(d);var t=Dp(p,_);d.length?(x||(o.polygonStart(),x=!0),rp(d,Fp,t,e,o)):t&&(x||(o.polygonStart(),x=!0),o.lineStart(),e(null,null,1,o),o.lineEnd()),x&&(o.polygonEnd(),x=!1),d=p=null},sphere:function(){o.polygonStart(),o.lineStart(),e(null,null,1,o),o.lineEnd(),o.polygonEnd()}};return b}}function Ip(t){return t.length>1}function Fp(t,n){return((t=t.x)[0]<0?t[1]-Yb-Ob:Yb-t[1])-((n=n.x)[0]<0?n[1]-Yb-Ob:Yb-n[1])}function Yp(t){var n,e=NaN,r=NaN,i=NaN;return{lineStart:function(){t.lineStart(),n=1},point:function(o,u){var a=o>0?Fb:-Fb,c=Vb(o-e);Vb(c-Fb)<Ob?(t.point(e,r=(r+u)/2>0?Yb:-Yb),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(a,r),t.point(o,r),n=0):i!==a&&c>=Fb&&(Vb(e-i)<Ob&&(e-=i*Ob),Vb(o-a)<Ob&&(o-=a*Ob),r=Bp(e,r,o,u),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(a,r),n=0),t.point(e=o,r=u),i=a},lineEnd:function(){t.lineEnd(),e=r=NaN},clean:function(){return 2-n}}}function Bp(t,n,e,r){var i,o,u=tw(t-e);return Vb(u)>Ob?Wb((tw(n)*(o=Zb(r))*tw(e)-tw(r)*(i=Zb(n))*tw(t))/(i*o*u)):(n+r)/2}function jp(t,n,e,r){var i;if(null==t)i=e*Yb,r.point(-Fb,i),r.point(0,i),r.point(Fb,i),r.point(Fb,0),r.point(Fb,-i),r.point(0,-i),r.point(-Fb,-i),r.point(-Fb,0),r.point(-Fb,i);else if(Vb(t[0]-n[0])>Ob){var o=t[0]<n[0]?Fb:-Fb;i=e*o/2,r.point(-o,i),r.point(0,i),r.point(o,i)}else r.point(n[0],n[1])}function Hp(t,n){function e(e,r,i,o){Gh(o,t,n,i,e,r)}function r(t,n){return Zb(t)*Zb(n)>a}function i(t){var n,e,i,a,f;return{lineStart:function(){a=i=!1,f=1},point:function(l,h){var p,d=[l,h],v=r(l,h),g=c?v?0:u(l,h):v?u(l+(l<0?Fb:-Fb),h):0;if(!n&&(a=i=v)&&t.lineStart(),v!==i&&(p=o(n,d),(np(n,p)||np(d,p))&&(d[0]+=Ob,d[1]+=Ob,v=r(d[0],d[1]))),v!==i)f=0,v?(t.lineStart(),p=o(d,n),t.point(p[0],p[1])):(p=o(n,d),t.point(p[0],p[1]),t.lineEnd()),n=p;else if(s&&n&&c^v){var _;g&e||!(_=o(d,n,!0))||(f=0,c?(t.lineStart(),t.point(_[0][0],_[0][1]),t.point(_[1][0],_[1][1]),t.lineEnd()):(t.point(_[1][0],_[1][1]),t.lineEnd(),t.lineStart(),t.point(_[0][0],_[0][1])))}!v||n&&np(n,d)||t.point(d[0],d[1]),n=d,i=v,e=g},lineEnd:function(){i&&t.lineEnd(),n=null},clean:function(){return f|(a&&i)<<1}}}function o(t,n,e){var r=dh(t),i=dh(n),o=[1,0,0],u=gh(r,i),c=vh(u,u),s=u[0],f=c-s*s;if(!f)return!e&&t;var l=a*c/f,h=-a*s/f,p=gh(o,u),d=yh(o,l),v=yh(u,h);_h(d,v);var g=p,_=vh(d,g),y=vh(g,g),m=_*_-y*(vh(d,d)-1);if(!(m<0)){var x=ew(m),b=yh(g,(-_-x)/y);if(_h(b,d),b=ph(b),!e)return b;var w,M=t[0],T=n[0],N=t[1],k=n[1];T<M&&(w=M,M=T,T=w);var S=T-M,E=Vb(S-Fb)<Ob,A=E||S<Ob;if(!E&&k<N&&(w=N,N=k,k=w),A?E?N+k>0^b[1]<(Vb(b[0]-M)<Ob?N:k):N<=b[1]&&b[1]<=k:S>Fb^(M<=b[0]&&b[0]<=T)){var C=yh(g,(-_+x)/y);return _h(C,d),[b,ph(C)]}}}function u(n,e){var r=c?t:Fb-t,i=0;return n<-r?i|=1:n>r&&(i|=2),e<-r?i|=4:e>r&&(i|=8),i}var a=Zb(t),c=a>0,s=Vb(a)>Ob;return Op(r,i,e,c?[0,-t]:[-Fb,t-Fb])}function Xp(t){return{stream:Vp(t)}}function Vp(t){return function(n){var e=new Wp;for(var r in t)e[r]=t[r];return e.stream=n,e}}function Wp(){}function $p(t,n,e){var r=n[1][0]-n[0][0],i=n[1][1]-n[0][1],o=t.clipExtent&&t.clipExtent();t.scale(150).translate([0,0]),null!=o&&t.clipExtent(null),ah(e,t.stream(Uw));var u=Uw.result(),a=Math.min(r/(u[1][0]-u[0][0]),i/(u[1][1]-u[0][1])),c=+n[0][0]+(r-a*(u[1][0]+u[0][0]))/2,s=+n[0][1]+(i-a*(u[1][1]+u[0][1]))/2;return null!=o&&t.clipExtent(o),t.scale(150*a).translate([c,s])}function Zp(t,n,e){return $p(t,[[0,0],n],e)}function Gp(t,n){return+n?Jp(t,n):Kp(t)}function Kp(t){return Vp({point:function(n,e){n=t(n,e),this.stream.point(n[0],n[1])}})}function Jp(t,n){function e(r,i,o,u,a,c,s,f,l,h,p,d,v,g){var _=s-r,y=f-i,m=_*_+y*y;if(m>4*n&&v--){var x=u+h,b=a+p,w=c+d,M=ew(x*x+b*b+w*w),T=nh(w/=M),N=Vb(Vb(w)-1)<Ob||Vb(o-l)<Ob?(o+l)/2:$b(b,x),k=t(N,T),S=k[0],E=k[1],A=S-r,C=E-i,z=y*A-_*C;(z*z/m>n||Vb((_*A+y*C)/m-.5)>.3||u*h+a*p+c*d<Gw)&&(e(r,i,o,u,a,c,S,E,N,x/=M,b/=M,w,v,g),g.point(S,E),e(S,E,N,x,b,w,s,f,l,h,p,d,v,g))}}return function(n){function r(e,r){e=t(e,r),n.point(e[0],e[1])}function i(){_=NaN,w.point=o,n.lineStart()}function o(r,i){var o=dh([r,i]),u=t(r,i);e(_,y,g,m,x,b,_=u[0],y=u[1],g=r,m=o[0],x=o[1],b=o[2],Zw,n),n.point(_,y)}function u(){w.point=r,n.lineEnd()}function a(){i(),w.point=c,w.lineEnd=s}function c(t,n){o(f=t,n),l=_,h=y,p=m,d=x,v=b,w.point=o}function s(){e(_,y,g,m,x,b,l,h,f,p,d,v,Zw,n),w.lineEnd=u,u()}var f,l,h,p,d,v,g,_,y,m,x,b,w={point:r,lineStart:i,lineEnd:u,polygonStart:function(){n.polygonStart(),w.lineStart=a},polygonEnd:function(){n.polygonEnd(),w.lineStart=i}};return w}}function Qp(t){return td(function(){return t})()}function td(t){function n(t){return t=f(t[0]*Xb,t[1]*Xb),[t[0]*g+a,c-t[1]*g]}function e(t){return t=f.invert((t[0]-a)/g,(c-t[1])/g),t&&[t[0]*Hb,t[1]*Hb]}function r(t,n){return t=u(t,n),[t[0]*g+a,c-t[1]*g]}function i(){f=jh(s=Xh(b,w,M),u);var t=u(m,x);return a=_-t[0]*g,c=y+t[1]*g,o()}function o(){return d=v=null,n}var u,a,c,s,f,l,h,p,d,v,g=150,_=480,y=250,m=0,x=0,b=0,w=0,M=0,T=null,N=$w,k=null,S=yp,E=.5,A=Gp(r,E);return n.stream=function(t){return d&&v===t?d:d=Kw(N(s,A(S(v=t))))},n.clipAngle=function(t){return arguments.length?(N=+t?Hp(T=t*Xb,6*Xb):(T=null,$w),o()):T*Hb},n.clipExtent=function(t){return arguments.length?(S=null==t?(k=l=h=p=null,yp):op(k=+t[0][0],l=+t[0][1],h=+t[1][0],p=+t[1][1]),o()):null==k?null:[[k,l],[h,p]]},n.scale=function(t){return arguments.length?(g=+t,i()):g},n.translate=function(t){return arguments.length?(_=+t[0],y=+t[1],i()):[_,y]},n.center=function(t){return arguments.length?(m=t[0]%360*Xb,x=t[1]%360*Xb,i()):[m*Hb,x*Hb]},n.rotate=function(t){return arguments.length?(b=t[0]%360*Xb,w=t[1]%360*Xb,M=t.length>2?t[2]%360*Xb:0,i()):[b*Hb,w*Hb,M*Hb]},n.precision=function(t){return arguments.length?(A=Gp(r,E=t*t),o()):ew(E)},n.fitExtent=function(t,e){return $p(n,t,e)},n.fitSize=function(t,e){return Zp(n,t,e)},function(){return u=t.apply(this,arguments),n.invert=u.invert&&e,i()}}function nd(t){var n=0,e=Fb/3,r=td(t),i=r(n,e);return i.parallels=function(t){return arguments.length?r(n=t[0]*Xb,e=t[1]*Xb):[n*Hb,e*Hb]},i}function ed(t){function n(t,n){return[t*e,tw(n)/e]}var e=Zb(t);return n.invert=function(t,n){return[t/e,nh(n*e)]},n}function rd(t,n){function e(t,n){var e=ew(o-2*i*tw(n))/i;return[e*tw(t*=i),u-e*Zb(t)]}var r=tw(t),i=(r+tw(n))/2;if(Vb(i)<Ob)return ed(t);var o=1+r*(2*i-r),u=ew(o)/i;return e.invert=function(t,n){var e=u-n;return[$b(t,Vb(e))/i*nw(e),nh((o-(t*t+e*e)*i*i)/(2*i))]},e}function id(){return nd(rd).scale(155.424).center([0,33.6442])}function od(){return id().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function ud(t){var n=t.length;return{point:function(e,r){for(var i=-1;++i<n;)t[i].point(e,r)},sphere:function(){for(var e=-1;++e<n;)t[e].sphere()},lineStart:function(){for(var e=-1;++e<n;)t[e].lineStart()},lineEnd:function(){for(var e=-1;++e<n;)t[e].lineEnd()},polygonStart:function(){for(var e=-1;++e<n;)t[e].polygonStart()},polygonEnd:function(){for(var e=-1;++e<n;)t[e].polygonEnd()}}}function ad(){function t(t){var n=t[0],e=t[1];return a=null,i.point(n,e),a||(o.point(n,e),a)||(u.point(n,e),a)}function n(){return e=r=null,t}var e,r,i,o,u,a,c=od(),s=id().rotate([154,0]).center([-2,58.5]).parallels([55,65]),f=id().rotate([157,0]).center([-3,19.9]).parallels([8,18]),l={point:function(t,n){a=[t,n]}};return t.invert=function(t){var n=c.scale(),e=c.translate(),r=(t[0]-e[0])/n,i=(t[1]-e[1])/n;return(i>=.12&&i<.234&&r>=-.425&&r<-.214?s:i>=.166&&i<.234&&r>=-.214&&r<-.115?f:c).invert(t)},t.stream=function(t){return e&&r===t?e:e=ud([c.stream(r=t),s.stream(t),f.stream(t)])},t.precision=function(t){return arguments.length?(c.precision(t),s.precision(t),f.precision(t),n()):c.precision()},t.scale=function(n){return arguments.length?(c.scale(n),s.scale(.35*n),f.scale(n),t.translate(c.translate())):c.scale()},t.translate=function(t){if(!arguments.length)return c.translate();var e=c.scale(),r=+t[0],a=+t[1];return i=c.translate(t).clipExtent([[r-.455*e,a-.238*e],[r+.455*e,a+.238*e]]).stream(l),o=s.translate([r-.307*e,a+.201*e]).clipExtent([[r-.425*e+Ob,a+.12*e+Ob],[r-.214*e-Ob,a+.234*e-Ob]]).stream(l),u=f.translate([r-.205*e,a+.212*e]).clipExtent([[r-.214*e+Ob,a+.166*e+Ob],[r-.115*e-Ob,a+.234*e-Ob]]).stream(l),n()},t.fitExtent=function(n,e){return $p(t,n,e)},t.fitSize=function(n,e){return Zp(t,n,e)},t.scale(1070)}function cd(t){return function(n,e){var r=Zb(n),i=Zb(e),o=t(r*i);return[o*i*tw(n),o*tw(e)]}}function sd(t){return function(n,e){var r=ew(n*n+e*e),i=t(r),o=tw(i),u=Zb(i);return[$b(n*o,r*u),nh(r&&e*o/r)]}}function fd(){return Qp(Jw).scale(124.75).clipAngle(179.999)}function ld(){return Qp(Qw).scale(79.4188).clipAngle(179.999)}function hd(t,n){return[t,Jb(rw((Yb+n)/2))]}function pd(){return dd(hd).scale(961/jb)}function dd(t){var n,e=Qp(t),r=e.scale,i=e.translate,o=e.clipExtent;return e.scale=function(t){return arguments.length?(r(t),n&&e.clipExtent(null),e):r()},e.translate=function(t){return arguments.length?(i(t),n&&e.clipExtent(null),e):i()},e.clipExtent=function(t){if(!arguments.length)return n?null:o();if(n=null==t){var u=Fb*r(),a=i();t=[[a[0]-u,a[1]-u],[a[0]+u,a[1]+u]]}return o(t),e},e.clipExtent(null)}function vd(t){return rw((Yb+t)/2)}function gd(t,n){function e(t,n){o>0?n<-Yb+Ob&&(n=-Yb+Ob):n>Yb-Ob&&(n=Yb-Ob);var e=o/Qb(vd(n),i);return[e*tw(i*t),o-e*Zb(i*t)]}var r=Zb(t),i=t===n?tw(t):Jb(r/Zb(n))/Jb(vd(n)/vd(t)),o=r*Qb(vd(t),i)/i;return i?(e.invert=function(t,n){var e=o-n,r=nw(i)*ew(t*t+e*e);return[$b(t,Vb(e))/i*nw(e),2*Wb(Qb(o/r,1/i))-Yb]},e):hd}function _d(){return nd(gd).scale(109.5).parallels([30,30])}function yd(t,n){return[t,n]}function md(){return Qp(yd).scale(152.63)}function xd(t,n){function e(t,n){var e=o-n,r=i*t;return[e*tw(r),o-e*Zb(r)]}var r=Zb(t),i=t===n?tw(t):(r-Zb(n))/(n-t),o=r/i+t;return Vb(i)<Ob?yd:(e.invert=function(t,n){var e=o-n;return[$b(t,Vb(e))/i*nw(e),o-nw(i)*ew(t*t+e*e)]},e)}function bd(){return nd(xd).scale(131.154).center([0,13.9389])}function wd(t,n){var e=Zb(n),r=Zb(t)*e;return[e*tw(t)/r,tw(n)/r]}function Md(){return Qp(wd).scale(144.049).clipAngle(60)}function Td(t,n,e,r){return 1===t&&1===n&&0===e&&0===r?yp:Vp({point:function(i,o){this.stream.point(i*t+e,o*n+r)}})}function Nd(){function t(){return i=o=null,u}var n,e,r,i,o,u,a=1,c=0,s=0,f=1,l=1,h=yp,p=null,d=yp;return u={stream:function(t){return i&&o===t?i:i=h(d(o=t))},clipExtent:function(i){return arguments.length?(d=null==i?(p=n=e=r=null,yp):op(p=+i[0][0],n=+i[0][1],e=+i[1][0],r=+i[1][1]),t()):null==p?null:[[p,n],[e,r]]},scale:function(n){return arguments.length?(h=Td((a=+n)*f,a*l,c,s),t()):a},translate:function(n){return arguments.length?(h=Td(a*f,a*l,c=+n[0],s=+n[1]),t()):[c,s]},reflectX:function(n){return arguments.length?(h=Td(a*(f=n?-1:1),a*l,c,s),t()):f<0},reflectY:function(n){return arguments.length?(h=Td(a*f,a*(l=n?-1:1),c,s),t()):l<0},fitExtent:function(t,n){return $p(u,t,n)},fitSize:function(t,n){return Zp(u,t,n)}}}function kd(t,n){return[Zb(n)*tw(t),tw(n)]}function Sd(){return Qp(kd).scale(249.5).clipAngle(90+Ob)}function Ed(t,n){var e=Zb(n),r=1+Zb(t)*e;return[e*tw(t)/r,tw(n)/r]}function Ad(){return Qp(Ed).scale(250).clipAngle(142)}function Cd(t,n){return[Jb(rw((Yb+n)/2)),-t]}function zd(){var t=dd(Cd),n=t.center,e=t.rotate;return t.center=function(t){return arguments.length?n([-t[1],t[0]]):(t=n(),[t[1],-t[0]])},t.rotate=function(t){return arguments.length?e([t[0],t[1],t.length>2?t[2]+90:90]):(t=e(),[t[0],t[1],t[2]-90])},e([0,0,90]).scale(159.155)}function Pd(t){return this.attr("transform",function(n,e){return"translate("+["function"==typeof t?t.call(this,n,e):t]+")"})}function Rd(t){if("string"==typeof t){var n,e={},r=t.split(/([\.#])/g);for(t=r.shift();n=r.shift();)"."==n?e.class=e.class?e.class+" "+r.shift():r.shift():"#"==n&&(e.id=r.shift());return{tag:t,attr:e}}return t}function Ld(t){var n,e=Rd(t);t=eu(e.tag),n=this.select(function(){return this.appendChild(t.apply(this,arguments))});for(var r in e.attr)n.attr(r,e.attr[r]);return n}function qd(t){var n,e=gu(t),r=Rd(t);t=eu(r.tag),n=this.select(function(){return e.apply(this,arguments)||this.appendChild(t.apply(this,arguments))});for(var i in r.attr)n.attr(i,r.attr[i]);return n}function Ud(t,n){return this.selectAll("tspan").data(t).enter().append("tspan").text(function(t){return t}).attr("x",0).attr("dy",function(t,e){return e?n||15:0})}function Dd(t,n){return this.selectAll(null).data(t).enter().append(n)}function Od(t,n){if("object"==typeof t){for(var e in t)this.attr(e.replace(/([a-z\d])([A-Z])/g,"$1-$2").toLowerCase(),t[e]);return this}return 1==arguments.length?this.attr(t):this.attr(t,n)}function Id(){for(var t=arguments,n=0,e=t.length;n<e;)"string"!=typeof t[n]&&"number"!=typeof t[n]||(t[n]=function(t){return function(n){return n[t]}}(t[n])),n++;return function(n){for(var e=0,r=t.length;e++<r;)n=t[e-1].call(this,n);return n}}function Fd(t,n){function e(t,n,e){var n=n.replace(/([a-z\d])([A-Z])/g,"$1-$2").toLowerCase(),i="top left bottom right padding-top padding-left padding-bottom padding-right border-top b-width border-left-width border-botto-width m border-right-width margin-top margin-left margin-bottom margin-right font-size width height stroke-width line-height margin padding border max-width min-width";return~i.indexOf(n)?t.style(n,"function"==typeof e?Id(e,r):r(e)):t.style(n,e),t}function r(t){return t.match?t:t+"px"}if("object"==typeof t){for(var i in t)e(this,i,t[i]);return this}return 1==arguments.length?this.style(t):e(this,t,n)}function Yd(t,n){var e=t.split(" "),r=[],i=[],o=n||40,u=0;return e.forEach(function(t){u+t.length>o&&(r.push(i.join(" ")),i.length=0,u=0),u+=t.length,i.push(t)}),i.length&&r.push(i.join(" ")),r.filter(function(t){return""!=t})}function Bd(t){return"function"==typeof t?function(n,e){return t(n)<t(e)?-1:t(n)>t(e)?1:t(n)>=t(e)?0:NaN}:function(n,e){return n[t]<e[t]?-1:n[t]>e[t]?1:n[t]>=e[t]?0:NaN}}function jd(t){return"function"==typeof t?function(n,e){return t(e)<t(n)?-1:t(e)>t(n)?1:t(e)>=t(n)?0:NaN}:function(n,e){return e[t]<n[t]?-1:e[t]>n[t]?1:e[t]>=n[t]?0:NaN}}function Hd(t){return t=t||{},t.margin=t.margin||{top:20,right:20,bottom:20,left:20},["top","right","bottom","left"].forEach(function(n){t.margin[n]||0==t.margin[n]||(t.margin[n]=20)}),t.width=t.width||t.totalWidth-t.margin.left-t.margin.right||900,t.height=t.height||t.totalHeight-t.margin.top-t.margin.bottom||460,t.totalWidth=t.width+t.margin.left+t.margin.right,t.totalHeight=t.height+t.margin.top+t.margin.bottom,t.parentSel=t.parentSel||qa("body"),t.rootsvg=t.parentSel.append("svg"),t.svg=t.rootsvg.attr("width",t.totalWidth).attr("height",t.totalHeight).append("g").attr("transform","translate("+t.margin.left+","+t.margin.top+")"),t.x=t.x||Eo().range([0,t.width]),t.y=t.y||Eo().range([t.height,0]),t.xAxis=t.xAxis||Gc().scale(t.x),t.yAxis=t.yAxis||Kc().scale(t.y),t.drawAxis=function(){t.svg.append("g").attr("class","x axis").attr("transform","translate(0,"+t.height+")").call(t.xAxis),t.svg.append("g").attr("class","y axis").call(t.yAxis)},t}function Xd(n,e,r){function i(t){e.classed("tooltip-hidden",!1).html("").appendMany(r,"div").html(function(n){return n(t)}),qa(this).classed("tooltipped",!0)}function o(n){var r=e;if(r.size()){var i=t.event,o=i.clientX,u=i.clientY,a=r.node(),c=a.getBoundingClientRect(),s=window.scrollY?window.scrollY:document.documentElement&&document.documentElement.scrollTop?document.documentElement.scrollTop:document.body.scrollTop,f=u+s-c.height-18;r.style("top",(f<0?18+u:f)+"px"),r.style("left",Math.min(Math.max(20,o-c.width/2),window.innerWidth-c.width-20)+"px")}}function u(t){e.classed("tooltip-hidden",!0),Ua(".tooltipped").classed("tooltipped",!1)}if(n.size()){e=e||qa(".tooltip"),n.on("mouseover.attachTooltip",i).on("mousemove.attachTooltip",o).on("mouseout.attachTooltip",u).on("click.attachTooltip",function(t){console.log(t)});var a=n.datum();r=r||Y(a).filter(function(t){return"object"!=typeof a[t]&&"array"!=a[t]; | |
}).map(function(t){return function(n){return t+": <b>"+n[t]+"</b>"}})}}function Vd(t,n){var e=Jt();t.forEach(function(t){var r=t.split(".").reverse()[0],i={csv:W_,tsv:$_,json:H_}[r];return i?void e.defer(i,t):n(new Error("Invalid type",t))}),e.awaitAll(n)}function Wd(t,n){return L().key(n).entries(t).map(function(t){return t.values.key=t.key,t.values})}function $d(t,n){return n?Math.round(t*(n=Math.pow(10,n)))/n:Math.round(t)}function Zd(){function n(){var t=0;s.forEach(function(n,e){n<pageYOffset-d+g&&(t=e)}),t=Math.min(i-1,t),c!=t&&(a.classed("graph-scroll-active",function(n,e){return e===t}),u.call("active",null,t),c=t);var n=pageYOffset>o;h!=n&&(h=n,f.classed("graph-scroll-below",h));var e=!h&&pageYOffset>d;l!=e&&(l=e,f.classed("graph-scroll-fixed",l))}function e(){s=[];var t;a.each(function(n,e){e||(t=this.getBoundingClientRect().top),s.push(this.getBoundingClientRect().top-t)});var n=p.node().getBoundingClientRect(),e=f.node().getBoundingClientRect();d=n.top+pageYOffset,o=n.bottom-e.height+pageYOffset}function r(){if(l){var n;switch(t.event.keyCode){case 39:if(t.event.metaKey)return;case 40:case 34:n=t.event.metaKey?1/0:1;break;case 37:if(t.event.metaKey)return;case 38:case 33:n=t.event.metaKey?-(1/0):-1;break;case 32:n=t.event.shiftKey?-1:1;break;default:return}var e=Math.max(0,Math.min(c+n,i-1));qa(document.documentElement).interrupt().transition().duration(500).tween("scroll",function(){var t=rr(pageYOffset,s[e]+d);return function(n){scrollTo(0,t(n))}}),t.event.preventDefault()}}var i,o,u=Mr("scroll","active"),a=qa("null"),c=NaN,s=[],f=qa("null"),l=null,h=null,p=qa("body"),d=0,v=Math.random(),g=200,_={};return _.container=function(t){return t?(p=t,_):p},_.graph=function(t){return t?(f=t,_):f},_.eventId=function(t){return t?(v=t,_):v},_.sections=function(t){return t?(a=t,i=a.size(),qa(window).on("scroll.gscroll"+v,n).on("resize.gscroll"+v,e).on("keydown.gscroll"+v,r),e(),Yr(function(){return n(),!0}),_):a},_.on=function(){var t=u.on.apply(u,arguments);return t===u?_:t},_.offset=function(t){return t?(g=t,_):_},_}function Gd(t){return t>1?aM:t<-1?-aM:Math.asin(t)}function Kd(t){return t>1?0:t<-1?uM:Math.acos(t)}function Jd(t){return t>0?Math.sqrt(t):0}function Qd(t){function n(t,n){return[t*e,iM(n)/e]}var e=eM(t);return n.invert=function(t,n){return[t/e,Gd(n*e)]},n}function tv(t,n,e,r,i,o,u,a){function c(c,s){if(!s)return[t*c/uM,0];var f=s*s,l=t+f*(n+f*(e+f*r)),h=s*(i-1+f*(o-a+f*u)),p=(l*l+h*h)/(2*h),d=c*Gd(l/p)/uM;return[p*iM(d),s*(1+f*a)+p*(1-eM(d))]}return arguments.length<8&&(a=0),c.invert=function(c,s){var f,l,h=uM*c/t,p=s,d=50;do{var v=p*p,g=t+v*(n+v*(e+v*r)),_=p*(i-1+v*(o-a+v*u)),y=g*g+_*_,m=2*_,x=y/m,b=x*x,w=Gd(g/x)/uM,M=h*w,T=g*g,N=(2*n+v*(4*e+6*v*r))*p,k=i+v*(3*o+5*v*u),S=2*(g*N+_*(k-1)),E=2*(k-1),A=(S*m-y*E)/(m*m),C=eM(M),z=iM(M),P=x*C,R=x*z,L=h/uM*(1/Jd(1-T/b))*(N*x-g*A)/b,q=R-c,U=p*(1+v*a)+x-P-s,D=A*z+P*L,O=P*w,I=1+A-(A*C-R*L),F=R*w,Y=D*F-I*O;if(!Y)break;h-=f=(U*D-q*I)/Y,p-=l=(q*F-U*O)/Y}while((tM(f)>oM||tM(l)>oM)&&--d>0);return[h,p]},c}function nv(t,n){var e=n*n,r=e*e;return[t*(.8707-.131979*e+r*(-.013791+r*(.003971*e-.001529*r))),n*(1.007226+e*(.015085+r*(-.044475+.028874*e-.005916*r)))]}function ev(){return Qp(nv).scale(175.295)}function rv(t){function n(n,e){var r=eM(e),i=(t-1)/(t-r*eM(n));return[i*r*iM(n),i*iM(e)]}return n.invert=function(n,e){var r=n*n+e*e,i=Jd(r),o=(t-Jd(1-r*(t+1)/(t-1)))/((t-1)/i+i/(t-1));return[nM(n*o,i*Jd(1-o*o)),i?Gd(e*o/i):0]},n}function iv(t,n){function e(n,e){var u=r(n,e),a=u[1],c=a*o/(t-1)+i;return[u[0]*i/c,a/c]}var r=rv(t);if(!n)return r;var i=eM(n),o=iM(n);return e.invert=function(n,e){var u=(t-1)/(t-1-e*o);return r.invert(u*n,u*e*i)},e}function ov(){var t=2,n=0,e=td(iv),r=e(t,n);return r.distance=function(r){return arguments.length?e(t=+r,n):t},r.tilt=function(r){return arguments.length?e(t,n=r*fM):n*sM},r.scale(432.147).clipAngle(Kd(1/t)*sM-1e-6)}var uv="4.4.0",av=e(n),cv=av.right,sv=av.left,fv=Array.prototype,lv=fv.slice,hv=fv.map,pv=Math.sqrt(50),dv=Math.sqrt(10),vv=Math.sqrt(2),gv="$";P.prototype=R.prototype={constructor:P,has:function(t){return gv+t in this},get:function(t){return this[gv+t]},set:function(t,n){return this[gv+t]=n,this},remove:function(t){var n=gv+t;return n in this&&delete this[n]},clear:function(){for(var t in this)t[0]===gv&&delete this[t]},keys:function(){var t=[];for(var n in this)n[0]===gv&&t.push(n.slice(1));return t},values:function(){var t=[];for(var n in this)n[0]===gv&&t.push(this[n]);return t},entries:function(){var t=[];for(var n in this)n[0]===gv&&t.push({key:n.slice(1),value:this[n]});return t},size:function(){var t=0;for(var n in this)n[0]===gv&&++t;return t},empty:function(){for(var t in this)if(t[0]===gv)return!1;return!0},each:function(t){for(var n in this)n[0]===gv&&t(this[n],n.slice(1),this)}};var _v=R.prototype;I.prototype=F.prototype={constructor:I,has:_v.has,add:function(t){return t+="",this[gv+t]=t,this},remove:_v.remove,clear:_v.clear,values:_v.keys,size:_v.size,empty:_v.empty,each:_v.each};var yv=3,mv=function t(n){function e(t){return Math.pow(t,n)}return n=+n,e.exponent=t,e}(yv),xv=function t(n){function e(t){return 1-Math.pow(1-t,n)}return n=+n,e.exponent=t,e}(yv),bv=function t(n){function e(t){return((t*=2)<=1?Math.pow(t,n):2-Math.pow(2-t,n))/2}return n=+n,e.exponent=t,e}(yv),wv=Math.PI,Mv=wv/2,Tv=4/11,Nv=6/11,kv=8/11,Sv=.75,Ev=9/11,Av=10/11,Cv=.9375,zv=21/22,Pv=63/64,Rv=1/Tv/Tv,Lv=1.70158,qv=function t(n){function e(t){return t*t*((n+1)*t-n)}return n=+n,e.overshoot=t,e}(Lv),Uv=function t(n){function e(t){return--t*t*((n+1)*t+n)+1}return n=+n,e.overshoot=t,e}(Lv),Dv=function t(n){function e(t){return((t*=2)<1?t*t*((n+1)*t-n):(t-=2)*t*((n+1)*t+n)+2)/2}return n=+n,e.overshoot=t,e}(Lv),Ov=2*Math.PI,Iv=1,Fv=.3,Yv=function t(n,e){function r(t){return n*Math.pow(2,10*--t)*Math.sin((i-t)/e)}var i=Math.asin(1/(n=Math.max(1,n)))*(e/=Ov);return r.amplitude=function(n){return t(n,e*Ov)},r.period=function(e){return t(n,e)},r}(Iv,Fv),Bv=function t(n,e){function r(t){return 1-n*Math.pow(2,-10*(t=+t))*Math.sin((t+i)/e)}var i=Math.asin(1/(n=Math.max(1,n)))*(e/=Ov);return r.amplitude=function(n){return t(n,e*Ov)},r.period=function(e){return t(n,e)},r}(Iv,Fv),jv=function t(n,e){function r(t){return((t=2*t-1)<0?n*Math.pow(2,10*t)*Math.sin((i-t)/e):2-n*Math.pow(2,-10*t)*Math.sin((i+t)/e))/2}var i=Math.asin(1/(n=Math.max(1,n)))*(e/=Ov);return r.amplitude=function(n){return t(n,e*Ov)},r.period=function(e){return t(n,e)},r}(Iv,Fv),Hv=Math.PI,Xv=2*Hv,Vv=1e-6,Wv=Xv-Vv;Mt.prototype=Tt.prototype={constructor:Mt,moveTo:function(t,n){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,n){this._+="L"+(this._x1=+t)+","+(this._y1=+n)},quadraticCurveTo:function(t,n,e,r){this._+="Q"+ +t+","+ +n+","+(this._x1=+e)+","+(this._y1=+r)},bezierCurveTo:function(t,n,e,r,i,o){this._+="C"+ +t+","+ +n+","+ +e+","+ +r+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(t,n,e,r,i){t=+t,n=+n,e=+e,r=+r,i=+i;var o=this._x1,u=this._y1,a=e-t,c=r-n,s=o-t,f=u-n,l=s*s+f*f;if(i<0)throw new Error("negative radius: "+i);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=n);else if(l>Vv)if(Math.abs(f*a-c*s)>Vv&&i){var h=e-o,p=r-u,d=a*a+c*c,v=h*h+p*p,g=Math.sqrt(d),_=Math.sqrt(l),y=i*Math.tan((Hv-Math.acos((d+l-v)/(2*g*_)))/2),m=y/_,x=y/g;Math.abs(m-1)>Vv&&(this._+="L"+(t+m*s)+","+(n+m*f)),this._+="A"+i+","+i+",0,0,"+ +(f*h>s*p)+","+(this._x1=t+x*a)+","+(this._y1=n+x*c)}else this._+="L"+(this._x1=t)+","+(this._y1=n);else;},arc:function(t,n,e,r,i,o){t=+t,n=+n,e=+e;var u=e*Math.cos(r),a=e*Math.sin(r),c=t+u,s=n+a,f=1^o,l=o?r-i:i-r;if(e<0)throw new Error("negative radius: "+e);null===this._x1?this._+="M"+c+","+s:(Math.abs(this._x1-c)>Vv||Math.abs(this._y1-s)>Vv)&&(this._+="L"+c+","+s),e&&(l>Wv?this._+="A"+e+","+e+",0,1,"+f+","+(t-u)+","+(n-a)+"A"+e+","+e+",0,1,"+f+","+(this._x1=c)+","+(this._y1=s):(l<0&&(l=l%Xv+Xv),this._+="A"+e+","+e+",0,"+ +(l>=Hv)+","+f+","+(this._x1=t+e*Math.cos(i))+","+(this._y1=n+e*Math.sin(i))))},rect:function(t,n,e,r){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)+"h"+ +e+"v"+ +r+"h"+-e+"Z"},toString:function(){return this._}};var $v=jt.prototype=Ht.prototype;$v.copy=function(){var t,n,e=new Ht(this._x,this._y,this._x0,this._y0,this._x1,this._y1),r=this._root;if(!r)return e;if(!r.length)return e._root=Xt(r),e;for(t=[{source:r,target:e._root=new Array(4)}];r=t.pop();)for(var i=0;i<4;++i)(n=r.source[i])&&(n.length?t.push({source:n,target:r.target[i]=new Array(4)}):r.target[i]=Xt(n));return e},$v.add=Nt,$v.addAll=St,$v.cover=Et,$v.data=At,$v.extent=Ct,$v.find=Pt,$v.remove=Rt,$v.removeAll=Lt,$v.root=qt,$v.size=Ut,$v.visit=Dt,$v.visitAfter=Ot,$v.x=Ft,$v.y=Bt;var Zv=[].slice,Gv={};Vt.prototype=Jt.prototype={constructor:Vt,defer:function(t){if("function"!=typeof t||this._call)throw new Error;if(null!=this._error)return this;var n=Zv.call(arguments,1);return n.push(t),++this._waiting,this._tasks.push(n),Wt(this),this},abort:function(){return null==this._error&&Gt(this,new Error("abort")),this},await:function(t){if("function"!=typeof t||this._call)throw new Error;return this._call=function(n,e){t.apply(null,[n].concat(e))},Kt(this),this},awaitAll:function(t){if("function"!=typeof t||this._call)throw new Error;return this._call=t,Kt(this),this}};var Kv=1e-12,Jv=Math.PI,Qv=Jv/2,tg=2*Jv;fn.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._context.lineTo(t,n)}}};var ng=xn(ln);mn.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,n){this._curve.point(n*Math.sin(t),n*-Math.cos(t))}};var eg={draw:function(t,n){var e=Math.sqrt(n/Jv);t.moveTo(e,0),t.arc(0,0,e,0,tg)}},rg={draw:function(t,n){var e=Math.sqrt(n/5)/2;t.moveTo(-3*e,-e),t.lineTo(-e,-e),t.lineTo(-e,-3*e),t.lineTo(e,-3*e),t.lineTo(e,-e),t.lineTo(3*e,-e),t.lineTo(3*e,e),t.lineTo(e,e),t.lineTo(e,3*e),t.lineTo(-e,3*e),t.lineTo(-e,e),t.lineTo(-3*e,e),t.closePath()}},ig=Math.sqrt(1/3),og=2*ig,ug={draw:function(t,n){var e=Math.sqrt(n/og),r=e*ig;t.moveTo(0,-e),t.lineTo(r,0),t.lineTo(0,e),t.lineTo(-r,0),t.closePath()}},ag=.8908130915292852,cg=Math.sin(Jv/10)/Math.sin(7*Jv/10),sg=Math.sin(tg/10)*cg,fg=-Math.cos(tg/10)*cg,lg={draw:function(t,n){var e=Math.sqrt(n*ag),r=sg*e,i=fg*e;t.moveTo(0,-e),t.lineTo(r,i);for(var o=1;o<5;++o){var u=tg*o/5,a=Math.cos(u),c=Math.sin(u);t.lineTo(c*e,-a*e),t.lineTo(a*r-c*i,c*r+a*i)}t.closePath()}},hg={draw:function(t,n){var e=Math.sqrt(n),r=-e/2;t.rect(r,r,e,e)}},pg=Math.sqrt(3),dg={draw:function(t,n){var e=-Math.sqrt(n/(3*pg));t.moveTo(0,2*e),t.lineTo(-pg*e,-e),t.lineTo(pg*e,-e),t.closePath()}},vg=-.5,gg=Math.sqrt(3)/2,_g=1/Math.sqrt(12),yg=3*(_g/2+1),mg={draw:function(t,n){var e=Math.sqrt(n/yg),r=e/2,i=e*_g,o=r,u=e*_g+e,a=-o,c=u;t.moveTo(r,i),t.lineTo(o,u),t.lineTo(a,c),t.lineTo(vg*r-gg*i,gg*r+vg*i),t.lineTo(vg*o-gg*u,gg*o+vg*u),t.lineTo(vg*a-gg*c,gg*a+vg*c),t.lineTo(vg*r+gg*i,vg*i-gg*r),t.lineTo(vg*o+gg*u,vg*u-gg*o),t.lineTo(vg*a+gg*c,vg*c-gg*a),t.closePath()}},xg=[eg,rg,ug,hg,lg,dg,mg];Sn.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:kn(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:kn(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},An.prototype={areaStart:Nn,areaEnd:Nn,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x2,this._y2),this._context.closePath();break;case 2:this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break;case 3:this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x2=t,this._y2=n;break;case 1:this._point=2,this._x3=t,this._y3=n;break;case 2:this._point=3,this._x4=t,this._y4=n,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+n)/6);break;default:kn(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},zn.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var e=(this._x0+4*this._x1+t)/6,r=(this._y0+4*this._y1+n)/6;this._line?this._context.lineTo(e,r):this._context.moveTo(e,r);break;case 3:this._point=4;default:kn(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Rn.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,n=this._y,e=t.length-1;if(e>0)for(var r,i=t[0],o=n[0],u=t[e]-i,a=n[e]-o,c=-1;++c<=e;)r=c/e,this._basis.point(this._beta*t[c]+(1-this._beta)*(i+r*u),this._beta*n[c]+(1-this._beta)*(o+r*a));this._x=this._y=null,this._basis.lineEnd()},point:function(t,n){this._x.push(+t),this._y.push(+n)}};var bg=function t(n){function e(t){return 1===n?new Sn(t):new Rn(t,n)}return e.beta=function(n){return t(+n)},e}(.85);qn.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Ln(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2,this._x1=t,this._y1=n;break;case 2:this._point=3;default:Ln(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var wg=function t(n){function e(t){return new qn(t,n)}return e.tension=function(n){return t(+n)},e}(0);Un.prototype={areaStart:Nn,areaEnd:Nn,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Ln(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Mg=function t(n){function e(t){return new Un(t,n)}return e.tension=function(n){return t(+n)},e}(0);Dn.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Ln(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Tg=function t(n){function e(t){return new Dn(t,n)}return e.tension=function(n){return t(+n)},e}(0);In.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3;default:On(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Ng=function t(n){function e(t){return n?new In(t,n):new qn(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);Fn.prototype={areaStart:Nn,areaEnd:Nn,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:On(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var kg=function t(n){function e(t){return n?new Fn(t,n):new Un(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);Yn.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:On(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Sg=function t(n){function e(t){return n?new Yn(t,n):new Dn(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);Bn.prototype={areaStart:Nn,areaEnd:Nn,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(t,n){t=+t,n=+n,this._point?this._context.lineTo(t,n):(this._point=1,this._context.moveTo(t,n))}},$n.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:Wn(this,this._t0,Vn(this,this._t0))}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){var e=NaN;if(t=+t,n=+n,t!==this._x1||n!==this._y1){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,Wn(this,Vn(this,e=Xn(this,t,n)),e);break;default:Wn(this,this._t0,e=Xn(this,t,n))}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n,this._t0=e}}},(Zn.prototype=Object.create($n.prototype)).point=function(t,n){$n.prototype.point.call(this,n,t)},Gn.prototype={moveTo:function(t,n){this._context.moveTo(n,t)},closePath:function(){this._context.closePath()},lineTo:function(t,n){this._context.lineTo(n,t)},bezierCurveTo:function(t,n,e,r,i,o){this._context.bezierCurveTo(n,t,r,e,o,i)}},Qn.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var t=this._x,n=this._y,e=t.length;if(e)if(this._line?this._context.lineTo(t[0],n[0]):this._context.moveTo(t[0],n[0]),2===e)this._context.lineTo(t[1],n[1]);else for(var r=te(t),i=te(n),o=0,u=1;u<e;++o,++u)this._context.bezierCurveTo(r[0][o],i[0][o],r[1][o],i[1][o],t[u],n[u]);(this._line||0!==this._line&&1===e)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(t,n){this._x.push(+t),this._y.push(+n)}},ee.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&2===this._point&&this._context.lineTo(this._x,this._y),(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,n),this._context.lineTo(t,n);else{var e=this._x*(1-this._t)+t*this._t;this._context.lineTo(e,this._y),this._context.lineTo(e,n)}}this._x=t,this._y=n}};var Eg=Array.prototype.slice,Ag=.7,Cg=1/Ag,zg="\\s*([+-]?\\d+)\\s*",Pg="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Rg="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Lg=/^#([0-9a-f]{3})$/,qg=/^#([0-9a-f]{6})$/,Ug=new RegExp("^rgb\\("+[zg,zg,zg]+"\\)$"),Dg=new RegExp("^rgb\\("+[Rg,Rg,Rg]+"\\)$"),Og=new RegExp("^rgba\\("+[zg,zg,zg,Pg]+"\\)$"),Ig=new RegExp("^rgba\\("+[Rg,Rg,Rg,Pg]+"\\)$"),Fg=new RegExp("^hsl\\("+[Pg,Rg,Rg]+"\\)$"),Yg=new RegExp("^hsla\\("+[Pg,Rg,Rg,Pg]+"\\)$"),Bg={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};ye(xe,be,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}}),ye(ke,Ne,me(xe,{brighter:function(t){return t=null==t?Cg:Math.pow(Cg,t),new ke(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?Ag:Math.pow(Ag,t),new ke(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var t=this.opacity;return t=isNaN(t)?1:Math.max(0,Math.min(1,t)),(1===t?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}})),ye(Ce,Ae,me(xe,{brighter:function(t){return t=null==t?Cg:Math.pow(Cg,t),new Ce(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?Ag:Math.pow(Ag,t),new Ce(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),n=isNaN(t)||isNaN(this.s)?0:this.s,e=this.l,r=e+(e<.5?e:1-e)*n,i=2*e-r;return new ke(ze(t>=240?t-240:t+120,i,r),ze(t,i,r),ze(t<120?t+240:t-120,i,r),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}));var jg=Math.PI/180,Hg=180/Math.PI,Xg=18,Vg=.95047,Wg=1,$g=1.08883,Zg=4/29,Gg=6/29,Kg=3*Gg*Gg,Jg=Gg*Gg*Gg;ye(Le,Re,me(xe,{brighter:function(t){return new Le(this.l+Xg*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new Le(this.l-Xg*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,n=isNaN(this.a)?t:t+this.a/500,e=isNaN(this.b)?t:t-this.b/200;return t=Wg*Ue(t),n=Vg*Ue(n),e=$g*Ue(e),new ke(De(3.2404542*n-1.5371385*t-.4985314*e),De(-.969266*n+1.8760108*t+.041556*e),De(.0556434*n-.2040259*t+1.0572252*e),this.opacity)}})),ye(Ye,Fe,me(xe,{brighter:function(t){return new Ye(this.h,this.c,this.l+Xg*(null==t?1:t),this.opacity)},darker:function(t){return new Ye(this.h,this.c,this.l-Xg*(null==t?1:t),this.opacity)},rgb:function(){return Pe(this).rgb()}}));var Qg=-.14861,t_=1.78277,n_=-.29227,e_=-.90649,r_=1.97294,i_=r_*e_,o_=r_*t_,u_=t_*n_-e_*Qg;ye(He,je,me(xe,{brighter:function(t){return t=null==t?Cg:Math.pow(Cg,t),new He(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?Ag:Math.pow(Ag,t),new He(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*jg,n=+this.l,e=isNaN(this.s)?0:this.s*n*(1-n),r=Math.cos(t),i=Math.sin(t);return new ke(255*(n+e*(Qg*r+t_*i)),255*(n+e*(n_*r+e_*i)),255*(n+e*(r_*r)),this.opacity)}}));var a_,c_,s_,f_,l_=function t(n){function e(t,n){var e=r((t=Ne(t)).r,(n=Ne(n)).r),i=r(t.g,n.g),o=r(t.b,n.b),u=r(t.opacity,n.opacity);return function(n){return t.r=e(n),t.g=i(n),t.b=o(n),t.opacity=u(n),t+""}}var r=Je(n);return e.gamma=t,e}(1),h_=tr(Ve),p_=tr(We),d_=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,v_=new RegExp(d_.source,"g"),g_=180/Math.PI,__={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1},y_=pr(lr,"px, ","px)","deg)"),m_=pr(hr,", ",")",")"),x_=Math.SQRT2,b_=2,w_=4,M_=1e-12,T_=yr(Ke),N_=yr(Qe),k_=xr(Ke),S_=xr(Qe),E_=br(Ke),A_=br(Qe),C_={value:function(){}};Tr.prototype=Mr.prototype={constructor:Tr,on:function(t,n){var e,r=this._,i=Nr(t+"",r),o=-1,u=i.length;{if(!(arguments.length<2)){if(null!=n&&"function"!=typeof n)throw new Error("invalid callback: "+n);for(;++o<u;)if(e=(t=i[o]).type)r[e]=Sr(r[e],t.name,n);else if(null==n)for(e in r)r[e]=Sr(r[e],t.name,null);return this}for(;++o<u;)if((e=(t=i[o]).type)&&(e=kr(r[e],t.name)))return e}},copy:function(){var t={},n=this._;for(var e in n)t[e]=n[e].slice();return new Tr(t)},call:function(t,n){if((e=arguments.length-2)>0)for(var e,r,i=new Array(e),o=0;o<e;++o)i[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(r=this._[t],o=0,e=r.length;o<e;++o)r[o].value.apply(n,i)},apply:function(t,n,e){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var r=this._[t],i=0,o=r.length;i<o;++i)r[i].value.apply(n,e)}};var z_,P_,R_=zr(","),L_=R_.parse,q_=R_.parseRows,U_=R_.format,D_=R_.formatRows,O_=zr("\t"),I_=O_.parse,F_=O_.parseRows,Y_=O_.format,B_=O_.formatRows,j_=qr("text/html",function(t){return document.createRange().createContextualFragment(t.responseText)}),H_=qr("application/json",function(t){return JSON.parse(t.responseText)}),X_=qr("text/plain",function(t){return t.responseText}),V_=qr("application/xml",function(t){var n=t.responseXML;if(!n)throw new Error("parse error");return n}),W_=Ur("text/csv",L_),$_=Ur("text/tab-separated-values",I_),Z_=0,G_=0,K_=0,J_=1e3,Q_=0,ty=0,ny=0,ey="object"==typeof performance&&performance.now?performance:Date,ry="function"==typeof requestAnimationFrame?requestAnimationFrame:function(t){setTimeout(t,17)};Fr.prototype=Yr.prototype={constructor:Fr,restart:function(t,n,e){if("function"!=typeof t)throw new TypeError("callback is not a function");e=(null==e?Or():+e)+(null==n?0:+n),this._next||P_===this||(P_?P_._next=this:z_=this,P_=this),this._call=t,this._time=e,Vr()},stop:function(){this._call&&(this._call=null,this._time=1/0,Vr())}};var iy=new Date,oy=new Date,uy=Zr(function(){},function(t,n){t.setTime(+t+n)},function(t,n){return n-t});uy.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?Zr(function(n){n.setTime(Math.floor(n/t)*t)},function(n,e){n.setTime(+n+e*t)},function(n,e){return(e-n)/t}):uy:null};var ay=uy.range,cy=1e3,sy=6e4,fy=36e5,ly=864e5,hy=6048e5,py=Zr(function(t){t.setTime(Math.floor(t/cy)*cy)},function(t,n){t.setTime(+t+n*cy)},function(t,n){return(n-t)/cy},function(t){return t.getUTCSeconds()}),dy=py.range,vy=Zr(function(t){t.setTime(Math.floor(t/sy)*sy)},function(t,n){t.setTime(+t+n*sy)},function(t,n){return(n-t)/sy},function(t){return t.getMinutes()}),gy=vy.range,_y=Zr(function(t){var n=t.getTimezoneOffset()*sy%fy;n<0&&(n+=fy),t.setTime(Math.floor((+t-n)/fy)*fy+n); | |
},function(t,n){t.setTime(+t+n*fy)},function(t,n){return(n-t)/fy},function(t){return t.getHours()}),yy=_y.range,my=Zr(function(t){t.setHours(0,0,0,0)},function(t,n){t.setDate(t.getDate()+n)},function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*sy)/ly},function(t){return t.getDate()-1}),xy=my.range,by=Gr(0),wy=Gr(1),My=Gr(2),Ty=Gr(3),Ny=Gr(4),ky=Gr(5),Sy=Gr(6),Ey=by.range,Ay=wy.range,Cy=My.range,zy=Ty.range,Py=Ny.range,Ry=ky.range,Ly=Sy.range,qy=Zr(function(t){t.setDate(1),t.setHours(0,0,0,0)},function(t,n){t.setMonth(t.getMonth()+n)},function(t,n){return n.getMonth()-t.getMonth()+12*(n.getFullYear()-t.getFullYear())},function(t){return t.getMonth()}),Uy=qy.range,Dy=Zr(function(t){t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,n){t.setFullYear(t.getFullYear()+n)},function(t,n){return n.getFullYear()-t.getFullYear()},function(t){return t.getFullYear()});Dy.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Zr(function(n){n.setFullYear(Math.floor(n.getFullYear()/t)*t),n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,e){n.setFullYear(n.getFullYear()+e*t)}):null};var Oy=Dy.range,Iy=Zr(function(t){t.setUTCSeconds(0,0)},function(t,n){t.setTime(+t+n*sy)},function(t,n){return(n-t)/sy},function(t){return t.getUTCMinutes()}),Fy=Iy.range,Yy=Zr(function(t){t.setUTCMinutes(0,0,0)},function(t,n){t.setTime(+t+n*fy)},function(t,n){return(n-t)/fy},function(t){return t.getUTCHours()}),By=Yy.range,jy=Zr(function(t){t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCDate(t.getUTCDate()+n)},function(t,n){return(n-t)/ly},function(t){return t.getUTCDate()-1}),Hy=jy.range,Xy=Kr(0),Vy=Kr(1),Wy=Kr(2),$y=Kr(3),Zy=Kr(4),Gy=Kr(5),Ky=Kr(6),Jy=Xy.range,Qy=Vy.range,tm=Wy.range,nm=$y.range,em=Zy.range,rm=Gy.range,im=Ky.range,om=Zr(function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCMonth(t.getUTCMonth()+n)},function(t,n){return n.getUTCMonth()-t.getUTCMonth()+12*(n.getUTCFullYear()-t.getUTCFullYear())},function(t){return t.getUTCMonth()}),um=om.range,am=Zr(function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCFullYear(t.getUTCFullYear()+n)},function(t,n){return n.getUTCFullYear()-t.getUTCFullYear()},function(t){return t.getUTCFullYear()});am.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Zr(function(n){n.setUTCFullYear(Math.floor(n.getUTCFullYear()/t)*t),n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,e){n.setUTCFullYear(n.getUTCFullYear()+e*t)}):null};var cm,sm=am.range,fm={"":ni,"%":function(t,n){return(100*t).toFixed(n)},b:function(t){return Math.round(t).toString(2)},c:function(t){return t+""},d:function(t){return Math.round(t).toString(10)},e:function(t,n){return t.toExponential(n)},f:function(t,n){return t.toFixed(n)},g:function(t,n){return t.toPrecision(n)},o:function(t){return Math.round(t).toString(8)},p:function(t,n){return ri(100*t,n)},r:ri,s:ei,X:function(t){return Math.round(t).toString(16).toUpperCase()},x:function(t){return Math.round(t).toString(16)}},lm=/^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;oi.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(null==this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(null==this.precision?"":"."+Math.max(0,0|this.precision))+this.type};var hm,pm=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];ci({decimal:".",thousands:",",grouping:[3],currency:["$",""]});var dm,vm={"-":"",_:" ",0:"0"},gm=/^\s*\d+/,_m=/^%/,ym=/[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;so({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var mm="%Y-%m-%dT%H:%M:%S.%LZ",xm=Date.prototype.toISOString?fo:t.utcFormat(mm),bm=+new Date("2000-01-01T00:00:00.000Z")?lo:t.utcParse(mm),wm=Array.prototype,Mm=wm.map,Tm=wm.slice,Nm={name:"implicit"},km=[0,1],Sm=1e3,Em=60*Sm,Am=60*Em,Cm=24*Am,zm=7*Cm,Pm=30*Cm,Rm=365*Cm,Lm=Zo("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"),qm=Zo("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6"),Um=Zo("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9"),Dm=Zo("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5"),Om=A_(je(300,.5,0),je(-240,.5,1)),Im=A_(je(-100,.75,.35),je(80,1.5,.8)),Fm=A_(je(260,.75,.35),je(80,1.5,.8)),Ym=je(),Bm=Ko(Zo("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),jm=Ko(Zo("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),Hm=Ko(Zo("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),Xm=Ko(Zo("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921")),Vm="http://www.w3.org/1999/xhtml",Wm={svg:"http://www.w3.org/2000/svg",xhtml:Vm,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"},$m=0;iu.prototype=ru.prototype={constructor:iu,get:function(t){for(var n=this._;!(n in t);)if(!(t=t.parentNode))return;return t[n]},set:function(t,n){return t[this._]=n},remove:function(t){return this._ in t&&delete t[this._]},toString:function(){return this._}};var Zm=function(t){return function(){return this.matches(t)}};if("undefined"!=typeof document){var Gm=document.documentElement;if(!Gm.matches){var Km=Gm.webkitMatchesSelector||Gm.msMatchesSelector||Gm.mozMatchesSelector||Gm.oMatchesSelector;Zm=function(t){return function(){return Km.call(this,t)}}}}var Jm=Zm,Qm={};if(t.event=null,"undefined"!=typeof document){var tx=document.documentElement;"onmouseenter"in tx||(Qm={mouseenter:"mouseover",mouseleave:"mouseout"})}Tu.prototype={constructor:Tu,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,n){return this._parent.insertBefore(t,n)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}};var nx="$";ia.prototype={add:function(t){var n=this._names.indexOf(t);n<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var n=this._names.indexOf(t);n>=0&&(this._names.splice(n,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var ex=[null];Ra.prototype=La.prototype={constructor:Ra,select:_u,selectAll:xu,filter:bu,data:Eu,enter:Mu,exit:Au,merge:Cu,order:zu,sort:Pu,call:Lu,nodes:qu,node:Uu,size:Du,empty:Ou,each:Iu,attr:Vu,style:Ku,property:na,classed:fa,text:da,html:ya,raise:xa,lower:wa,append:Ma,insert:Na,remove:Sa,datum:Ea,on:fu,dispatch:Pa};var rx=Mr("start","end","interrupt"),ix=[],ox=0,ux=1,ax=2,cx=3,sx=4,fx=5,lx=6,hx=La.prototype.constructor,px=0,dx=La.prototype;Uc.prototype=Dc.prototype={constructor:Uc,select:wc,selectAll:Mc,filter:vc,merge:gc,selection:Tc,transition:qc,call:dx.call,nodes:dx.nodes,node:dx.node,size:dx.size,empty:dx.empty,each:dx.each,on:mc,attr:rc,attrTween:uc,style:Ac,styleTween:zc,text:Lc,remove:bc,tween:$a,delay:sc,duration:hc,ease:dc};var vx={time:null,delay:0,duration:250,ease:et};La.prototype.interrupt=Xa,La.prototype.transition=Fc;var gx=[null],_x=Array.prototype.slice,yx=1,mx=2,xx=3,bx=4,wx=1e-6;ws.prototype=_s.prototype={constructor:ws,each:us,eachAfter:cs,eachBefore:as,sum:ss,sort:fs,path:ls,ancestors:ps,descendants:ds,leaves:vs,links:gs,copy:ys};var Mx="$",Tx={depth:-1},Nx={};of.prototype=Object.create(ws.prototype);var kx=(1+Math.sqrt(5))/2,Sx=function t(n){function e(t,e,r,i,o){sf(n,t,e,r,i,o)}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}(kx),Ex=function t(n){function e(t,e,r,i,o){if((u=t._squarify)&&u.ratio===n)for(var u,a,c,s,f,l=-1,h=u.length,p=t.value;++l<h;){for(a=u[l],c=a.children,s=a.value=0,f=c.length;s<f;++s)a.value+=c[s].value;a.dice?Ws(a,e,r,i,r+=(o-r)*a.value/p):cf(a,e,r,e+=(i-e)*a.value/p,o),p-=a.value}else t._squarify=u=sf(n,t,e,r,i,o),u.ratio=n}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}(kx),Ax=10,Cx=Math.PI*(3-Math.sqrt(5));Rf.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t},Yf.prototype={constructor:Yf,insert:function(t,n){var e,r,i;if(t){if(n.P=t,n.N=t.N,t.N&&(t.N.P=n),t.N=n,t.R){for(t=t.R;t.L;)t=t.L;t.L=n}else t.R=n;e=t}else this._?(t=Xf(this._),n.P=null,n.N=t,t.P=t.L=n,e=t):(n.P=n.N=null,this._=n,e=null);for(n.L=n.R=null,n.U=e,n.C=!0,t=n;e&&e.C;)r=e.U,e===r.L?(i=r.R,i&&i.C?(e.C=i.C=!1,r.C=!0,t=r):(t===e.R&&(jf(this,e),t=e,e=t.U),e.C=!1,r.C=!0,Hf(this,r))):(i=r.L,i&&i.C?(e.C=i.C=!1,r.C=!0,t=r):(t===e.L&&(Hf(this,e),t=e,e=t.U),e.C=!1,r.C=!0,jf(this,r))),e=t.U;this._.C=!1},remove:function(t){t.N&&(t.N.P=t.P),t.P&&(t.P.N=t.N),t.N=t.P=null;var n,e,r,i=t.U,o=t.L,u=t.R;if(e=o?u?Xf(u):o:u,i?i.L===t?i.L=e:i.R=e:this._=e,o&&u?(r=e.C,e.C=t.C,e.L=o,o.U=e,e!==u?(i=e.U,e.U=t.U,t=e.R,i.L=t,e.R=u,u.U=e):(e.U=i,i=e,t=e.R)):(r=t.C,t=e),t&&(t.U=i),!r){if(t&&t.C)return void(t.C=!1);do{if(t===this._)break;if(t===i.L){if(n=i.R,n.C&&(n.C=!1,i.C=!0,jf(this,i),n=i.R),n.L&&n.L.C||n.R&&n.R.C){n.R&&n.R.C||(n.L.C=!1,n.C=!0,Hf(this,n),n=i.R),n.C=i.C,i.C=n.R.C=!1,jf(this,i),t=this._;break}}else if(n=i.L,n.C&&(n.C=!1,i.C=!0,Hf(this,i),n=i.L),n.L&&n.L.C||n.R&&n.R.C){n.L&&n.L.C||(n.R.C=!1,n.C=!0,jf(this,n),n=i.L),n.C=i.C,i.C=n.L.C=!1,Hf(this,i),t=this._;break}n.C=!0,t=i,i=i.U}while(!t.C);t&&(t.C=!1)}}};var zx,Px,Rx,Lx,qx,Ux=[],Dx=[],Ox=1e-6,Ix=1e-12;gl.prototype={constructor:gl,polygons:function(){var t=this.edges;return this.cells.map(function(n){var e=n.halfedges.map(function(e){return tl(n,t[e])});return e.data=n.site.data,e})},triangles:function(){var t=[],n=this.edges;return this.cells.forEach(function(e,r){for(var i,o=e.site,u=e.halfedges,a=-1,c=u.length,s=n[u[c-1]],f=s.left===o?s.right:s.left;++a<c;)i=f,s=n[u[a]],f=s.left===o?s.right:s.left,i&&f&&r<i.index&&r<f.index&&dl(o,i,f)<0&&t.push([o.data,i.data,f.data])}),t},links:function(){return this.edges.filter(function(t){return t.right}).map(function(t){return{source:t.left.data,target:t.right.data}})},find:function(t,n,e){var r,i=this,o=i._found||0,u=i.cells[o]||i.cells[o=0],a=t-u.site[0],c=n-u.site[1],s=a*a+c*c;do u=i.cells[r=o],o=null,u.halfedges.forEach(function(e){var r=i.edges[e],a=r.left;if(a!==u.site&&a||(a=r.right)){var c=t-a[0],f=n-a[1],l=c*c+f*f;l<s&&(s=l,o=a.index)}});while(null!==o);return i._found=r,null==e||s<=e*e?u.site:null}},xl.prototype={constructor:xl,scale:function(t){return 1===t?this:new xl(this.k*t,this.x,this.y)},translate:function(t,n){return 0===t&0===n?this:new xl(this.k,this.x+this.k*t,this.y+this.k*n)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Fx=new xl(1,0,0);bl.prototype=xl.prototype;var Yx={name:"drag"},Bx={name:"space"},jx={name:"handle"},Hx={name:"center"},Xx={name:"x",handles:["e","w"].map(Pl),input:function(t,n){return t&&[[t[0],n[0][1]],[t[1],n[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},Vx={name:"y",handles:["n","s"].map(Pl),input:function(t,n){return t&&[[n[0][0],t[0]],[n[1][0],t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},Wx={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(Pl),input:function(t){return t},output:function(t){return t}},$x={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Zx={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Gx={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},Kx={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},Jx={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1},Qx=Math.cos,tb=Math.sin,nb=Math.PI,eb=nb/2,rb=2*nb,ib=Math.max,ob=Array.prototype.slice;Jl.prototype={constructor:Jl,reset:function(){this.s=this.t=0},add:function(t){Ql(Db,t,this.t),Ql(this,Db.s,this.s),this.s?this.t+=Db.t:this.s=Db.t},valueOf:function(){return this.s}};var ub,ab,cb,sb,fb,lb,hb,pb,db,vb,gb,_b,yb,mb,xb,bb,wb,Mb,Tb,Nb,kb,Sb,Eb,Ab,Cb,zb,Pb,Rb,Lb,qb,Ub,Db=new Jl,Ob=1e-6,Ib=1e-12,Fb=Math.PI,Yb=Fb/2,Bb=Fb/4,jb=2*Fb,Hb=180/Fb,Xb=Fb/180,Vb=Math.abs,Wb=Math.atan,$b=Math.atan2,Zb=Math.cos,Gb=Math.ceil,Kb=Math.exp,Jb=Math.log,Qb=Math.pow,tw=Math.sin,nw=Math.sign||function(t){return t>0?1:t<0?-1:0},ew=Math.sqrt,rw=Math.tan,iw={Feature:function(t,n){ih(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r<i;)ih(e[r].geometry,n)}},ow={Sphere:function(t,n){n.sphere()},Point:function(t,n){t=t.coordinates,n.point(t[0],t[1],t[2])},MultiPoint:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)t=e[r],n.point(t[0],t[1],t[2])},LineString:function(t,n){oh(t.coordinates,n,0)},MultiLineString:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)oh(e[r],n,0)},Polygon:function(t,n){uh(t.coordinates,n)},MultiPolygon:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)uh(e[r],n)},GeometryCollection:function(t,n){for(var e=t.geometries,r=-1,i=e.length;++r<i;)ih(e[r],n)}},uw=Kl(),aw=Kl(),cw={point:rh,lineStart:rh,lineEnd:rh,polygonStart:function(){uw.reset(),cw.lineStart=ch,cw.lineEnd=sh},polygonEnd:function(){var t=+uw;aw.add(t<0?jb+t:t),this.lineStart=this.lineEnd=this.point=rh},sphere:function(){aw.add(jb)}},sw=Kl(),fw={point:xh,lineStart:wh,lineEnd:Mh,polygonStart:function(){fw.point=Th,fw.lineStart=Nh,fw.lineEnd=kh,sw.reset(),cw.polygonStart()},polygonEnd:function(){cw.polygonEnd(),fw.point=xh,fw.lineStart=wh,fw.lineEnd=Mh,uw<0?(lb=-(pb=180),hb=-(db=90)):sw>Ob?db=90:sw<-Ob&&(hb=-90),xb[0]=lb,xb[1]=pb}},lw={sphere:rh,point:zh,lineStart:Rh,lineEnd:Uh,polygonStart:function(){lw.lineStart=Dh,lw.lineEnd=Oh},polygonEnd:function(){lw.lineStart=Rh,lw.lineEnd=Uh}};Hh.invert=Hh;var hw,pw,dw,vw,gw,_w,yw,mw,xw,bw,ww,Mw=1e9,Tw=-Mw,Nw=Kl(),kw={sphere:rh,point:rh,lineStart:ap,lineEnd:rh,polygonStart:rh,polygonEnd:rh},Sw=[null,null],Ew={type:"LineString",coordinates:Sw},Aw=Kl(),Cw=Kl(),zw={point:rh,lineStart:rh,lineEnd:rh,polygonStart:function(){zw.lineStart=mp,zw.lineEnd=wp},polygonEnd:function(){zw.lineStart=zw.lineEnd=zw.point=rh,Aw.add(Vb(Cw)),Cw.reset()},result:function(){var t=Aw/2;return Aw.reset(),t}},Pw=1/0,Rw=Pw,Lw=-Pw,qw=Lw,Uw={point:Mp,lineStart:rh,lineEnd:rh,polygonStart:rh,polygonEnd:rh,result:function(){var t=[[Pw,Rw],[Lw,qw]];return Lw=qw=-(Rw=Pw=1/0),t}},Dw=0,Ow=0,Iw=0,Fw=0,Yw=0,Bw=0,jw=0,Hw=0,Xw=0,Vw={point:Tp,lineStart:Np,lineEnd:Ep,polygonStart:function(){Vw.lineStart=Ap,Vw.lineEnd=Cp},polygonEnd:function(){Vw.point=Tp,Vw.lineStart=Np,Vw.lineEnd=Ep},result:function(){var t=Xw?[jw/Xw,Hw/Xw]:Bw?[Fw/Bw,Yw/Bw]:Iw?[Dw/Iw,Ow/Iw]:[NaN,NaN];return Dw=Ow=Iw=Fw=Yw=Bw=jw=Hw=Xw=0,t}};Rp.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._context.moveTo(t,n),this._point=1;break;case 1:this._context.lineTo(t,n);break;default:this._context.moveTo(t+this._radius,n),this._context.arc(t,n,this._radius,0,jb)}},result:rh},Lp.prototype={_circle:qp(4.5),pointRadius:function(t){return this._circle=qp(t),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._string.push("Z"),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._string.push("M",t,",",n),this._point=1;break;case 1:this._string.push("L",t,",",n);break;default:this._string.push("M",t,",",n,this._circle)}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}}};var Ww=Kl(),$w=Op(function(){return!0},Yp,jp,[-Fb,-Yb]);Wp.prototype={constructor:Wp,point:function(t,n){this.stream.point(t,n)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};var Zw=16,Gw=Zb(30*Xb),Kw=Vp({point:function(t,n){this.stream.point(t*Xb,n*Xb)}}),Jw=cd(function(t){return ew(2/(1+t))});Jw.invert=sd(function(t){return 2*nh(t/2)});var Qw=cd(function(t){return(t=th(t))&&t/tw(t)});Qw.invert=sd(function(t){return t}),hd.invert=function(t,n){return[t,2*Wb(Kb(n))-Yb]},yd.invert=yd,wd.invert=sd(Wb),kd.invert=sd(nh),Ed.invert=sd(function(t){return 2*Wb(t)}),Cd.invert=function(t,n){return[-n,2*Wb(Kb(t))-Yb]},Id.not=function(t){return!t},Id.run=function(t){return t()},Id.objToFn=function(t,n){return 1==arguments.length&&(n=void 0),function(e){return void 0!==typeof t[e]?t[e]:n}},La.prototype.translate=Pd,Dc.prototype.translate=Pd,La.prototype.append=Ld,La.prototype.selectAppend=qd,La.prototype.tspans=Ud,La.prototype.appendMany=Dd,La.prototype.at=Od,La.prototype.st=Fd,Dc.prototype.at=Od,Dc.prototype.st=Fd,La.prototype.prop=La.prototype.property;var tM=Math.abs,nM=Math.atan2,eM=Math.cos,rM=Math.log,iM=Math.sin,oM=1e-6,uM=Math.PI,aM=uM/2,cM=Jd(2),sM=180/uM,fM=uM/180;Jd(8),rM(1+cM),Jd(3),eM(35*fM),tv(2.8284,-1.6988,.75432,-.18071,1.76003,-.38914,.042555),tv(2.583819,-.835827,.170354,-.038094,1.543313,-.411435,.082742),tv(5/6*uM,-.62636,-.0344,0,1.3493,-.05524,0,.045),tv(2.6516,-.76534,.19123,-.047094,1.36289,-.13965,.031762),Qd(0),Jd(6),Jd(7);nv.invert=function(t,n){var e,r=n,i=25;do{var o=r*r,u=o*o;r-=e=(r*(1.007226+o*(.015085+u*(-.044475+.028874*o-.005916*u)))-n)/(1.007226+o*(.045255+u*(-.311325+.259866*o-.005916*11*u)))}while(tM(e)>oM&&--i>0);return[t/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]};var lM=[[0,90],[-90,0],[0,0],[90,0],[180,0],[0,-90]];[[0,2,1],[0,3,2],[5,1,2],[5,2,3],[0,1,4],[0,4,3],[5,4,1],[5,3,4]].map(function(t){return t.map(function(t){return lM[t]})});var hM=(2/Jd(3),[[.9986,-.062],[1,0],[.9986,.062],[.9954,.124],[.99,.186],[.9822,.248],[.973,.31],[.96,.372],[.9427,.434],[.9216,.4958],[.8962,.5571],[.8679,.6176],[.835,.6769],[.7986,.7346],[.7597,.7903],[.7186,.8435],[.6732,.8936],[.6213,.9394],[.5722,.9761],[.5322,1]]);hM.forEach(function(t){t[1]*=1.0144});var pM=4*uM+3*Jd(3);2*Jd(2*uM*Jd(3)/pM);t.geoNaturalEarth=ev,t.geoSatellite=ov,t.version=uv,t.bisect=cv,t.bisectRight=cv,t.bisectLeft=sv,t.ascending=n,t.bisector=e,t.descending=i,t.deviation=a,t.extent=c,t.histogram=v,t.thresholdFreedmanDiaconis=_,t.thresholdScott=y,t.thresholdSturges=d,t.max=m,t.mean=x,t.median=b,t.merge=w,t.min=M,t.pairs=T,t.permute=N,t.quantile=g,t.range=l,t.scan=k,t.shuffle=S,t.sum=E,t.ticks=h,t.tickStep=p,t.transpose=A,t.variance=u,t.zip=z,t.entries=j,t.keys=Y,t.values=B,t.map=R,t.set=F,t.nest=L,t.randomUniform=H,t.randomNormal=X,t.randomLogNormal=V,t.randomBates=$,t.randomIrwinHall=W,t.randomExponential=Z,t.easeLinear=G,t.easeQuad=Q,t.easeQuadIn=K,t.easeQuadOut=J,t.easeQuadInOut=Q,t.easeCubic=et,t.easeCubicIn=tt,t.easeCubicOut=nt,t.easeCubicInOut=et,t.easePoly=bv,t.easePolyIn=mv,t.easePolyOut=xv,t.easePolyInOut=bv,t.easeSin=ot,t.easeSinIn=rt,t.easeSinOut=it,t.easeSinInOut=ot,t.easeExp=ct,t.easeExpIn=ut,t.easeExpOut=at,t.easeExpInOut=ct,t.easeCircle=lt,t.easeCircleIn=st,t.easeCircleOut=ft,t.easeCircleInOut=lt,t.easeBounce=pt,t.easeBounceIn=ht,t.easeBounceOut=pt,t.easeBounceInOut=dt,t.easeBack=Dv,t.easeBackIn=qv,t.easeBackOut=Uv,t.easeBackInOut=Dv,t.easeElastic=Bv,t.easeElasticIn=Yv,t.easeElasticOut=Bv,t.easeElasticInOut=jv,t.polygonArea=vt,t.polygonCentroid=gt,t.polygonHull=xt,t.polygonContains=bt,t.polygonLength=wt,t.path=Tt,t.quadtree=jt,t.queue=Jt,t.arc=sn,t.area=vn,t.line=dn,t.pie=yn,t.radialArea=Mn,t.radialLine=wn,t.symbol=Tn,t.symbols=xg,t.symbolCircle=eg,t.symbolCross=rg,t.symbolDiamond=ug,t.symbolSquare=hg,t.symbolStar=lg,t.symbolTriangle=dg,t.symbolWye=mg,t.curveBasisClosed=Cn,t.curveBasisOpen=Pn,t.curveBasis=En,t.curveBundle=bg,t.curveCardinalClosed=Mg,t.curveCardinalOpen=Tg,t.curveCardinal=wg,t.curveCatmullRomClosed=kg,t.curveCatmullRomOpen=Sg,t.curveCatmullRom=Ng,t.curveLinearClosed=jn,t.curveLinear=ln,t.curveMonotoneX=Kn,t.curveMonotoneY=Jn,t.curveNatural=ne,t.curveStep=re,t.curveStepAfter=oe,t.curveStepBefore=ie,t.stack=se,t.stackOffsetExpand=fe,t.stackOffsetNone=ue,t.stackOffsetSilhouette=le,t.stackOffsetWiggle=he,t.stackOrderAscending=pe,t.stackOrderDescending=ve,t.stackOrderInsideOut=ge,t.stackOrderNone=ae,t.stackOrderReverse=_e,t.color=be,t.rgb=Ne,t.hsl=Ae,t.lab=Re,t.hcl=Fe,t.cubehelix=je,t.interpolate=cr,t.interpolateArray=nr,t.interpolateDate=er,t.interpolateNumber=rr,t.interpolateObject=ir,t.interpolateRound=sr,t.interpolateString=ar,t.interpolateTransformCss=y_,t.interpolateTransformSvg=m_,t.interpolateZoom=_r,t.interpolateRgb=l_,t.interpolateRgbBasis=h_,t.interpolateRgbBasisClosed=p_,t.interpolateHsl=T_,t.interpolateHslLong=N_,t.interpolateLab=mr,t.interpolateHcl=k_,t.interpolateHclLong=S_,t.interpolateCubehelix=E_,t.interpolateCubehelixLong=A_,t.interpolateBasis=Ve,t.interpolateBasisClosed=We,t.quantize=wr,t.dispatch=Mr,t.dsvFormat=zr,t.csvParse=L_,t.csvParseRows=q_,t.csvFormat=U_,t.csvFormatRows=D_,t.tsvParse=I_,t.tsvParseRows=F_,t.tsvFormat=Y_,t.tsvFormatRows=B_,t.request=Pr,t.html=j_,t.json=H_,t.text=X_,t.xml=V_,t.csv=W_,t.tsv=$_,t.now=Or,t.timer=Yr,t.timerFlush=Br,t.timeout=Wr,t.interval=$r,t.timeInterval=Zr,t.timeMillisecond=uy,t.timeMilliseconds=ay,t.timeSecond=py,t.timeSeconds=dy,t.timeMinute=vy,t.timeMinutes=gy,t.timeHour=_y,t.timeHours=yy,t.timeDay=my,t.timeDays=xy,t.timeWeek=by,t.timeWeeks=Ey,t.timeSunday=by,t.timeSundays=Ey,t.timeMonday=wy,t.timeMondays=Ay;t.timeTuesday=My;t.timeTuesdays=Cy,t.timeWednesday=Ty,t.timeWednesdays=zy,t.timeThursday=Ny,t.timeThursdays=Py,t.timeFriday=ky,t.timeFridays=Ry,t.timeSaturday=Sy,t.timeSaturdays=Ly,t.timeMonth=qy,t.timeMonths=Uy,t.timeYear=Dy,t.timeYears=Oy,t.utcMillisecond=uy,t.utcMilliseconds=ay,t.utcSecond=py,t.utcSeconds=dy,t.utcMinute=Iy,t.utcMinutes=Fy,t.utcHour=Yy,t.utcHours=By,t.utcDay=jy,t.utcDays=Hy,t.utcWeek=Xy,t.utcWeeks=Jy,t.utcSunday=Xy,t.utcSundays=Jy,t.utcMonday=Vy,t.utcMondays=Qy,t.utcTuesday=Wy,t.utcTuesdays=tm,t.utcWednesday=$y,t.utcWednesdays=nm,t.utcThursday=Zy,t.utcThursdays=em,t.utcFriday=Gy,t.utcFridays=rm,t.utcSaturday=Ky,t.utcSaturdays=im,t.utcMonth=om,t.utcMonths=um,t.utcYear=am,t.utcYears=sm,t.formatLocale=ai,t.formatDefaultLocale=ci,t.formatSpecifier=ii,t.precisionFixed=si,t.precisionPrefix=fi,t.precisionRound=li,t.isoFormat=xm,t.isoParse=bm,t.timeFormatLocale=vi,t.timeFormatDefaultLocale=so,t.scaleBand=po,t.scalePoint=go,t.scaleIdentity=Ao,t.scaleLinear=Eo,t.scaleLog=Do,t.scaleOrdinal=ho,t.scaleImplicit=Nm,t.scalePow=Io,t.scaleSqrt=Fo,t.scaleQuantile=Yo,t.scaleQuantize=Bo,t.scaleThreshold=jo,t.scaleTime=Wo,t.scaleUtc=$o,t.schemeCategory10=Lm,t.schemeCategory20b=qm,t.schemeCategory20c=Um,t.schemeCategory20=Dm,t.scaleSequential=Jo,t.interpolateCubehelixDefault=Om,t.interpolateRainbow=Go,t.interpolateWarm=Im,t.interpolateCool=Fm,t.interpolateViridis=Bm,t.interpolateMagma=jm,t.interpolateInferno=Hm,t.interpolatePlasma=Xm,t.creator=eu,t.customEvent=lu,t.local=ru,t.matcher=Jm,t.mouse=du,t.namespace=Qo,t.namespaces=Wm,t.select=qa,t.selectAll=Ua,t.selection=La,t.selector=gu,t.selectorAll=mu,t.touch=Da,t.touches=Oa,t.window=Wu,t.active=Yc,t.interrupt=Ha,t.transition=Dc,t.axisTop=$c,t.axisRight=Zc,t.axisBottom=Gc,t.axisLeft=Kc,t.cluster=os,t.hierarchy=_s,t.pack=Bs,t.packSiblings=Us,t.packEnclose=Ns,t.partition=$s,t.stratify=Ks,t.tree=af,t.treemap=ff,t.treemapBinary=lf,t.treemapDice=Ws,t.treemapSlice=cf,t.treemapSliceDice=hf,t.treemapSquarify=Sx,t.treemapResquarify=Ex,t.forceCenter=pf,t.forceCollide=yf,t.forceLink=bf,t.forceManyBody=Nf,t.forceSimulation=Tf,t.forceX=kf,t.forceY=Sf,t.drag=Df,t.dragDisable=Cf,t.dragEnable=zf,t.voronoi=_l,t.zoom=Sl,t.zoomIdentity=Fx,t.zoomTransform=bl,t.brush=Fl,t.brushX=Ol,t.brushY=Il,t.brushSelection=Dl,t.chord=jl,t.ribbon=Gl,t.geoAlbers=od,t.geoAlbersUsa=ad,t.geoArea=hh,t.geoAzimuthalEqualArea=fd,t.geoAzimuthalEqualAreaRaw=Jw,t.geoAzimuthalEquidistant=ld,t.geoAzimuthalEquidistantRaw=Qw,t.geoBounds=Ch,t.geoCentroid=Yh,t.geoCircle=Jh,t.geoClipExtent=up,t.geoConicConformal=_d,t.geoConicConformalRaw=gd,t.geoConicEqualArea=id,t.geoConicEqualAreaRaw=rd,t.geoConicEquidistant=bd,t.geoConicEquidistantRaw=xd,t.geoDistance=hp,t.geoEquirectangular=md,t.geoEquirectangularRaw=yd,t.geoGnomonic=Md,t.geoGnomonicRaw=wd,t.geoGraticule=vp,t.geoGraticule10=gp,t.geoIdentity=Nd,t.geoInterpolate=_p,t.geoLength=lp,t.geoMercator=pd,t.geoMercatorRaw=hd,t.geoOrthographic=Sd,t.geoOrthographicRaw=kd,t.geoPath=Up,t.geoProjection=Qp,t.geoProjectionMutator=td,t.geoRotation=Zh,t.geoStereographic=Ad,t.geoStereographicRaw=Ed,t.geoStream=ah,t.geoTransform=Xp,t.geoTransverseMercator=zd,t.geoTransverseMercatorRaw=Cd,t.wordwrap=Yd,t.parseAttributes=Rd,t.f=Id,t.ascendingKey=Bd,t.descendingKey=jd,t.conventions=Hd,t.attachTooltip=Xd,t.loadData=Vd,t.nestBy=Wd,t.round=$d,t.graphScroll=Zd,Object.defineProperty(t,"__esModule",{value:!0})}); |
export * from "d3" | |
export * from "d3-jetpack-module" | |
export * from "graph-scroll" | |
export { | |
geoNaturalEarth, | |
geoSatellite | |
} from "d3-geo-projection" |
{ | |
"name": "d3-custom-example", | |
"version": "0.0.1", | |
"scripts": { | |
"build": "rollup -c && uglifyjs d3.js -c -m -o d3.min.js" | |
}, | |
"devDependencies": { | |
"d3": "4", | |
"rollup": "0.34", | |
"rollup-plugin-node-resolve": "1", | |
"uglify-js": "2" | |
}, | |
"dependencies": { | |
"d3-geo-projection": "^1.2.1", | |
"d3-jetpack-module": "*", | |
"graph-scroll": "*" | |
} | |
} |
import npm from "rollup-plugin-node-resolve"; | |
export default { | |
entry: "index.js", | |
format: "umd", | |
moduleName: "d3", | |
plugins: [npm({jsnext: true})], | |
dest: "d3.js" | |
}; |