3cd0a0e31dd0664eca9ded766e179262b496f479
[rails.git] / vendor / assets / iD / iD.js
1 (function () {
2 var version = "4.13.0";
3
4 function d3_ascending(a, b) {
5   return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
6 }
7
8 function d3_bisector(compare) {
9   if (compare.length === 1) compare = ascendingComparator(compare);
10   return {
11     left: function(a, x, lo, hi) {
12       if (lo == null) lo = 0;
13       if (hi == null) hi = a.length;
14       while (lo < hi) {
15         var mid = lo + hi >>> 1;
16         if (compare(a[mid], x) < 0) lo = mid + 1;
17         else hi = mid;
18       }
19       return lo;
20     },
21     right: function(a, x, lo, hi) {
22       if (lo == null) lo = 0;
23       if (hi == null) hi = a.length;
24       while (lo < hi) {
25         var mid = lo + hi >>> 1;
26         if (compare(a[mid], x) > 0) hi = mid;
27         else lo = mid + 1;
28       }
29       return lo;
30     }
31   };
32 }
33
34 function ascendingComparator(f) {
35   return function(d, x) {
36     return d3_ascending(f(d), x);
37   };
38 }
39
40 var ascendingBisect = d3_bisector(d3_ascending);
41 var bisectRight = ascendingBisect.right;
42 var bisectLeft = ascendingBisect.left;
43
44 function pairs(array, f) {
45   if (f == null) f = pair;
46   var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);
47   while (i < n) pairs[i] = f(p, p = array[++i]);
48   return pairs;
49 }
50
51 function pair(a, b) {
52   return [a, b];
53 }
54
55 function cross(values0, values1, reduce) {
56   var n0 = values0.length,
57       n1 = values1.length,
58       values = new Array(n0 * n1),
59       i0,
60       i1,
61       i,
62       value0;
63
64   if (reduce == null) reduce = pair;
65
66   for (i0 = i = 0; i0 < n0; ++i0) {
67     for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {
68       values[i] = reduce(value0, values1[i1]);
69     }
70   }
71
72   return values;
73 }
74
75 function d3_descending(a, b) {
76   return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
77 }
78
79 function number(x) {
80   return x === null ? NaN : +x;
81 }
82
83 function variance(values, valueof) {
84   var n = values.length,
85       m = 0,
86       i = -1,
87       mean = 0,
88       value,
89       delta,
90       sum = 0;
91
92   if (valueof == null) {
93     while (++i < n) {
94       if (!isNaN(value = number(values[i]))) {
95         delta = value - mean;
96         mean += delta / ++m;
97         sum += delta * (value - mean);
98       }
99     }
100   }
101
102   else {
103     while (++i < n) {
104       if (!isNaN(value = number(valueof(values[i], i, values)))) {
105         delta = value - mean;
106         mean += delta / ++m;
107         sum += delta * (value - mean);
108       }
109     }
110   }
111
112   if (m > 1) return sum / (m - 1);
113 }
114
115 function deviation(array, f) {
116   var v = variance(array, f);
117   return v ? Math.sqrt(v) : v;
118 }
119
120 function extent(values, valueof) {
121   var n = values.length,
122       i = -1,
123       value,
124       min,
125       max;
126
127   if (valueof == null) {
128     while (++i < n) { // Find the first comparable value.
129       if ((value = values[i]) != null && value >= value) {
130         min = max = value;
131         while (++i < n) { // Compare the remaining values.
132           if ((value = values[i]) != null) {
133             if (min > value) min = value;
134             if (max < value) max = value;
135           }
136         }
137       }
138     }
139   }
140
141   else {
142     while (++i < n) { // Find the first comparable value.
143       if ((value = valueof(values[i], i, values)) != null && value >= value) {
144         min = max = value;
145         while (++i < n) { // Compare the remaining values.
146           if ((value = valueof(values[i], i, values)) != null) {
147             if (min > value) min = value;
148             if (max < value) max = value;
149           }
150         }
151       }
152     }
153   }
154
155   return [min, max];
156 }
157
158 var array = Array.prototype;
159
160 var slice = array.slice;
161 var map = array.map;
162
163 function constant(x) {
164   return function() {
165     return x;
166   };
167 }
168
169 function identity(x) {
170   return x;
171 }
172
173 function d3_range(start, stop, step) {
174   start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
175
176   var i = -1,
177       n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
178       range = new Array(n);
179
180   while (++i < n) {
181     range[i] = start + i * step;
182   }
183
184   return range;
185 }
186
187 var e10 = Math.sqrt(50),
188     e5 = Math.sqrt(10),
189     e2 = Math.sqrt(2);
190
191 function ticks(start, stop, count) {
192   var reverse,
193       i = -1,
194       n,
195       ticks,
196       step;
197
198   stop = +stop, start = +start, count = +count;
199   if (start === stop && count > 0) return [start];
200   if (reverse = stop < start) n = start, start = stop, stop = n;
201   if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
202
203   if (step > 0) {
204     start = Math.ceil(start / step);
205     stop = Math.floor(stop / step);
206     ticks = new Array(n = Math.ceil(stop - start + 1));
207     while (++i < n) ticks[i] = (start + i) * step;
208   } else {
209     start = Math.floor(start * step);
210     stop = Math.ceil(stop * step);
211     ticks = new Array(n = Math.ceil(start - stop + 1));
212     while (++i < n) ticks[i] = (start - i) / step;
213   }
214
215   if (reverse) ticks.reverse();
216
217   return ticks;
218 }
219
220 function tickIncrement(start, stop, count) {
221   var step = (stop - start) / Math.max(0, count),
222       power = Math.floor(Math.log(step) / Math.LN10),
223       error = step / Math.pow(10, power);
224   return power >= 0
225       ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
226       : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
227 }
228
229 function tickStep(start, stop, count) {
230   var step0 = Math.abs(stop - start) / Math.max(0, count),
231       step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
232       error = step0 / step1;
233   if (error >= e10) step1 *= 10;
234   else if (error >= e5) step1 *= 5;
235   else if (error >= e2) step1 *= 2;
236   return stop < start ? -step1 : step1;
237 }
238
239 function sturges(values) {
240   return Math.ceil(Math.log(values.length) / Math.LN2) + 1;
241 }
242
243 function histogram() {
244   var value = identity,
245       domain = extent,
246       threshold = sturges;
247
248   function histogram(data) {
249     var i,
250         n = data.length,
251         x,
252         values = new Array(n);
253
254     for (i = 0; i < n; ++i) {
255       values[i] = value(data[i], i, data);
256     }
257
258     var xz = domain(values),
259         x0 = xz[0],
260         x1 = xz[1],
261         tz = threshold(values, x0, x1);
262
263     // Convert number of thresholds into uniform thresholds.
264     if (!Array.isArray(tz)) {
265       tz = tickStep(x0, x1, tz);
266       tz = d3_range(Math.ceil(x0 / tz) * tz, Math.floor(x1 / tz) * tz, tz); // exclusive
267     }
268
269     // Remove any thresholds outside the domain.
270     var m = tz.length;
271     while (tz[0] <= x0) tz.shift(), --m;
272     while (tz[m - 1] > x1) tz.pop(), --m;
273
274     var bins = new Array(m + 1),
275         bin;
276
277     // Initialize bins.
278     for (i = 0; i <= m; ++i) {
279       bin = bins[i] = [];
280       bin.x0 = i > 0 ? tz[i - 1] : x0;
281       bin.x1 = i < m ? tz[i] : x1;
282     }
283
284     // Assign data to bins by value, ignoring any outside the domain.
285     for (i = 0; i < n; ++i) {
286       x = values[i];
287       if (x0 <= x && x <= x1) {
288         bins[bisectRight(tz, x, 0, m)].push(data[i]);
289       }
290     }
291
292     return bins;
293   }
294
295   histogram.value = function(_) {
296     return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
297   };
298
299   histogram.domain = function(_) {
300     return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
301   };
302
303   histogram.thresholds = function(_) {
304     return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
305   };
306
307   return histogram;
308 }
309
310 function threshold(values, p, valueof) {
311   if (valueof == null) valueof = number;
312   if (!(n = values.length)) return;
313   if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
314   if (p >= 1) return +valueof(values[n - 1], n - 1, values);
315   var n,
316       i = (n - 1) * p,
317       i0 = Math.floor(i),
318       value0 = +valueof(values[i0], i0, values),
319       value1 = +valueof(values[i0 + 1], i0 + 1, values);
320   return value0 + (value1 - value0) * (i - i0);
321 }
322
323 function freedmanDiaconis(values, min, max) {
324   values = map.call(values, number).sort(d3_ascending);
325   return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3)));
326 }
327
328 function scott(values, min, max) {
329   return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
330 }
331
332 function max(values, valueof) {
333   var n = values.length,
334       i = -1,
335       value,
336       max;
337
338   if (valueof == null) {
339     while (++i < n) { // Find the first comparable value.
340       if ((value = values[i]) != null && value >= value) {
341         max = value;
342         while (++i < n) { // Compare the remaining values.
343           if ((value = values[i]) != null && value > max) {
344             max = value;
345           }
346         }
347       }
348     }
349   }
350
351   else {
352     while (++i < n) { // Find the first comparable value.
353       if ((value = valueof(values[i], i, values)) != null && value >= value) {
354         max = value;
355         while (++i < n) { // Compare the remaining values.
356           if ((value = valueof(values[i], i, values)) != null && value > max) {
357             max = value;
358           }
359         }
360       }
361     }
362   }
363
364   return max;
365 }
366
367 function mean(values, valueof) {
368   var n = values.length,
369       m = n,
370       i = -1,
371       value,
372       sum = 0;
373
374   if (valueof == null) {
375     while (++i < n) {
376       if (!isNaN(value = number(values[i]))) sum += value;
377       else --m;
378     }
379   }
380
381   else {
382     while (++i < n) {
383       if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
384       else --m;
385     }
386   }
387
388   if (m) return sum / m;
389 }
390
391 function d3_median(values, valueof) {
392   var n = values.length,
393       i = -1,
394       value,
395       numbers = [];
396
397   if (valueof == null) {
398     while (++i < n) {
399       if (!isNaN(value = number(values[i]))) {
400         numbers.push(value);
401       }
402     }
403   }
404
405   else {
406     while (++i < n) {
407       if (!isNaN(value = number(valueof(values[i], i, values)))) {
408         numbers.push(value);
409       }
410     }
411   }
412
413   return threshold(numbers.sort(d3_ascending), 0.5);
414 }
415
416 function merge(arrays) {
417   var n = arrays.length,
418       m,
419       i = -1,
420       j = 0,
421       merged,
422       array;
423
424   while (++i < n) j += arrays[i].length;
425   merged = new Array(j);
426
427   while (--n >= 0) {
428     array = arrays[n];
429     m = array.length;
430     while (--m >= 0) {
431       merged[--j] = array[m];
432     }
433   }
434
435   return merged;
436 }
437
438 function min(values, valueof) {
439   var n = values.length,
440       i = -1,
441       value,
442       min;
443
444   if (valueof == null) {
445     while (++i < n) { // Find the first comparable value.
446       if ((value = values[i]) != null && value >= value) {
447         min = value;
448         while (++i < n) { // Compare the remaining values.
449           if ((value = values[i]) != null && min > value) {
450             min = value;
451           }
452         }
453       }
454     }
455   }
456
457   else {
458     while (++i < n) { // Find the first comparable value.
459       if ((value = valueof(values[i], i, values)) != null && value >= value) {
460         min = value;
461         while (++i < n) { // Compare the remaining values.
462           if ((value = valueof(values[i], i, values)) != null && min > value) {
463             min = value;
464           }
465         }
466       }
467     }
468   }
469
470   return min;
471 }
472
473 function permute(array, indexes) {
474   var i = indexes.length, permutes = new Array(i);
475   while (i--) permutes[i] = array[indexes[i]];
476   return permutes;
477 }
478
479 function scan(values, compare) {
480   if (!(n = values.length)) return;
481   var n,
482       i = 0,
483       j = 0,
484       xi,
485       xj = values[j];
486
487   if (compare == null) compare = d3_ascending;
488
489   while (++i < n) {
490     if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
491       xj = xi, j = i;
492     }
493   }
494
495   if (compare(xj, xj) === 0) return j;
496 }
497
498 function shuffle(array, i0, i1) {
499   var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),
500       t,
501       i;
502
503   while (m) {
504     i = Math.random() * m-- | 0;
505     t = array[m + i0];
506     array[m + i0] = array[i + i0];
507     array[i + i0] = t;
508   }
509
510   return array;
511 }
512
513 function sum(values, valueof) {
514   var n = values.length,
515       i = -1,
516       value,
517       sum = 0;
518
519   if (valueof == null) {
520     while (++i < n) {
521       if (value = +values[i]) sum += value; // Note: zero and null are equivalent.
522     }
523   }
524
525   else {
526     while (++i < n) {
527       if (value = +valueof(values[i], i, values)) sum += value;
528     }
529   }
530
531   return sum;
532 }
533
534 function transpose(matrix) {
535   if (!(n = matrix.length)) return [];
536   for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {
537     for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {
538       row[j] = matrix[j][i];
539     }
540   }
541   return transpose;
542 }
543
544 function length(d) {
545   return d.length;
546 }
547
548 function zip() {
549   return transpose(arguments);
550 }
551
552 var slice$1 = Array.prototype.slice;
553
554 function identity$1(x) {
555   return x;
556 }
557
558 var top = 1,
559     right = 2,
560     bottom = 3,
561     left = 4,
562     epsilon = 1e-6;
563
564 function translateX(x) {
565   return "translate(" + (x + 0.5) + ",0)";
566 }
567
568 function translateY(y) {
569   return "translate(0," + (y + 0.5) + ")";
570 }
571
572 function number$1(scale) {
573   return function(d) {
574     return +scale(d);
575   };
576 }
577
578 function center(scale) {
579   var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset.
580   if (scale.round()) offset = Math.round(offset);
581   return function(d) {
582     return +scale(d) + offset;
583   };
584 }
585
586 function entering() {
587   return !this.__axis;
588 }
589
590 function axis(orient, scale) {
591   var tickArguments = [],
592       tickValues = null,
593       tickFormat = null,
594       tickSizeInner = 6,
595       tickSizeOuter = 6,
596       tickPadding = 3,
597       k = orient === top || orient === left ? -1 : 1,
598       x = orient === left || orient === right ? "x" : "y",
599       transform = orient === top || orient === bottom ? translateX : translateY;
600
601   function axis(context) {
602     var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues,
603         format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1) : tickFormat,
604         spacing = Math.max(tickSizeInner, 0) + tickPadding,
605         range = scale.range(),
606         range0 = +range[0] + 0.5,
607         range1 = +range[range.length - 1] + 0.5,
608         position = (scale.bandwidth ? center : number$1)(scale.copy()),
609         selection = context.selection ? context.selection() : context,
610         path = selection.selectAll(".domain").data([null]),
611         tick = selection.selectAll(".tick").data(values, scale).order(),
612         tickExit = tick.exit(),
613         tickEnter = tick.enter().append("g").attr("class", "tick"),
614         line = tick.select("line"),
615         text = tick.select("text");
616
617     path = path.merge(path.enter().insert("path", ".tick")
618         .attr("class", "domain")
619         .attr("stroke", "#000"));
620
621     tick = tick.merge(tickEnter);
622
623     line = line.merge(tickEnter.append("line")
624         .attr("stroke", "#000")
625         .attr(x + "2", k * tickSizeInner));
626
627     text = text.merge(tickEnter.append("text")
628         .attr("fill", "#000")
629         .attr(x, k * spacing)
630         .attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em"));
631
632     if (context !== selection) {
633       path = path.transition(context);
634       tick = tick.transition(context);
635       line = line.transition(context);
636       text = text.transition(context);
637
638       tickExit = tickExit.transition(context)
639           .attr("opacity", epsilon)
640           .attr("transform", function(d) { return isFinite(d = position(d)) ? transform(d) : this.getAttribute("transform"); });
641
642       tickEnter
643           .attr("opacity", epsilon)
644           .attr("transform", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : position(d)); });
645     }
646
647     tickExit.remove();
648
649     path
650         .attr("d", orient === left || orient == right
651             ? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter
652             : "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter);
653
654     tick
655         .attr("opacity", 1)
656         .attr("transform", function(d) { return transform(position(d)); });
657
658     line
659         .attr(x + "2", k * tickSizeInner);
660
661     text
662         .attr(x, k * spacing)
663         .text(format);
664
665     selection.filter(entering)
666         .attr("fill", "none")
667         .attr("font-size", 10)
668         .attr("font-family", "sans-serif")
669         .attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle");
670
671     selection
672         .each(function() { this.__axis = position; });
673   }
674
675   axis.scale = function(_) {
676     return arguments.length ? (scale = _, axis) : scale;
677   };
678
679   axis.ticks = function() {
680     return tickArguments = slice$1.call(arguments), axis;
681   };
682
683   axis.tickArguments = function(_) {
684     return arguments.length ? (tickArguments = _ == null ? [] : slice$1.call(_), axis) : tickArguments.slice();
685   };
686
687   axis.tickValues = function(_) {
688     return arguments.length ? (tickValues = _ == null ? null : slice$1.call(_), axis) : tickValues && tickValues.slice();
689   };
690
691   axis.tickFormat = function(_) {
692     return arguments.length ? (tickFormat = _, axis) : tickFormat;
693   };
694
695   axis.tickSize = function(_) {
696     return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;
697   };
698
699   axis.tickSizeInner = function(_) {
700     return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;
701   };
702
703   axis.tickSizeOuter = function(_) {
704     return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;
705   };
706
707   axis.tickPadding = function(_) {
708     return arguments.length ? (tickPadding = +_, axis) : tickPadding;
709   };
710
711   return axis;
712 }
713
714 function axisTop(scale) {
715   return axis(top, scale);
716 }
717
718 function axisRight(scale) {
719   return axis(right, scale);
720 }
721
722 function axisBottom(scale) {
723   return axis(bottom, scale);
724 }
725
726 function axisLeft(scale) {
727   return axis(left, scale);
728 }
729
730 var noop = {value: function() {}};
731
732 function dispatch() {
733   for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {
734     if (!(t = arguments[i] + "") || (t in _)) throw new Error("illegal type: " + t);
735     _[t] = [];
736   }
737   return new Dispatch(_);
738 }
739
740 function Dispatch(_) {
741   this._ = _;
742 }
743
744 function parseTypenames(typenames, types) {
745   return typenames.trim().split(/^|\s+/).map(function(t) {
746     var name = "", i = t.indexOf(".");
747     if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
748     if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t);
749     return {type: t, name: name};
750   });
751 }
752
753 Dispatch.prototype = dispatch.prototype = {
754   constructor: Dispatch,
755   on: function(typename, callback) {
756     var _ = this._,
757         T = parseTypenames(typename + "", _),
758         t,
759         i = -1,
760         n = T.length;
761
762     // If no callback was specified, return the callback of the given type and name.
763     if (arguments.length < 2) {
764       while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
765       return;
766     }
767
768     // If a type was specified, set the callback for the given type and name.
769     // Otherwise, if a null callback was specified, remove callbacks of the given name.
770     if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
771     while (++i < n) {
772       if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
773       else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);
774     }
775
776     return this;
777   },
778   copy: function() {
779     var copy = {}, _ = this._;
780     for (var t in _) copy[t] = _[t].slice();
781     return new Dispatch(copy);
782   },
783   call: function(type, that) {
784     if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];
785     if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
786     for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
787   },
788   apply: function(type, that, args) {
789     if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
790     for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
791   }
792 };
793
794 function get(type, name) {
795   for (var i = 0, n = type.length, c; i < n; ++i) {
796     if ((c = type[i]).name === name) {
797       return c.value;
798     }
799   }
800 }
801
802 function set(type, name, callback) {
803   for (var i = 0, n = type.length; i < n; ++i) {
804     if (type[i].name === name) {
805       type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
806       break;
807     }
808   }
809   if (callback != null) type.push({name: name, value: callback});
810   return type;
811 }
812
813 var xhtml = "http://www.w3.org/1999/xhtml";
814
815 var namespaces = {
816   svg: "http://www.w3.org/2000/svg",
817   xhtml: xhtml,
818   xlink: "http://www.w3.org/1999/xlink",
819   xml: "http://www.w3.org/XML/1998/namespace",
820   xmlns: "http://www.w3.org/2000/xmlns/"
821 };
822
823 function namespace(name) {
824   var prefix = name += "", i = prefix.indexOf(":");
825   if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
826   return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;
827 }
828
829 function creatorInherit(name) {
830   return function() {
831     var document = this.ownerDocument,
832         uri = this.namespaceURI;
833     return uri === xhtml && document.documentElement.namespaceURI === xhtml
834         ? document.createElement(name)
835         : document.createElementNS(uri, name);
836   };
837 }
838
839 function creatorFixed(fullname) {
840   return function() {
841     return this.ownerDocument.createElementNS(fullname.space, fullname.local);
842   };
843 }
844
845 function creator(name) {
846   var fullname = namespace(name);
847   return (fullname.local
848       ? creatorFixed
849       : creatorInherit)(fullname);
850 }
851
852 function none() {}
853
854 function selector(selector) {
855   return selector == null ? none : function() {
856     return this.querySelector(selector);
857   };
858 }
859
860 function selection_select(select) {
861   if (typeof select !== "function") select = selector(select);
862
863   for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
864     for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
865       if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
866         if ("__data__" in node) subnode.__data__ = node.__data__;
867         subgroup[i] = subnode;
868       }
869     }
870   }
871
872   return new Selection(subgroups, this._parents);
873 }
874
875 function empty() {
876   return [];
877 }
878
879 function selectorAll(selector) {
880   return selector == null ? empty : function() {
881     return this.querySelectorAll(selector);
882   };
883 }
884
885 function selection_selectAll(select) {
886   if (typeof select !== "function") select = selectorAll(select);
887
888   for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
889     for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
890       if (node = group[i]) {
891         subgroups.push(select.call(node, node.__data__, i, group));
892         parents.push(node);
893       }
894     }
895   }
896
897   return new Selection(subgroups, parents);
898 }
899
900 var matcher = function(selector) {
901   return function() {
902     return this.matches(selector);
903   };
904 };
905
906 if (typeof document !== "undefined") {
907   var element = document.documentElement;
908   if (!element.matches) {
909     var vendorMatches = element.webkitMatchesSelector
910         || element.msMatchesSelector
911         || element.mozMatchesSelector
912         || element.oMatchesSelector;
913     matcher = function(selector) {
914       return function() {
915         return vendorMatches.call(this, selector);
916       };
917     };
918   }
919 }
920
921 var matcher$1 = matcher;
922
923 function selection_filter(match) {
924   if (typeof match !== "function") match = matcher$1(match);
925
926   for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
927     for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
928       if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
929         subgroup.push(node);
930       }
931     }
932   }
933
934   return new Selection(subgroups, this._parents);
935 }
936
937 function sparse(update) {
938   return new Array(update.length);
939 }
940
941 function selection_enter() {
942   return new Selection(this._enter || this._groups.map(sparse), this._parents);
943 }
944
945 function EnterNode(parent, datum) {
946   this.ownerDocument = parent.ownerDocument;
947   this.namespaceURI = parent.namespaceURI;
948   this._next = null;
949   this._parent = parent;
950   this.__data__ = datum;
951 }
952
953 EnterNode.prototype = {
954   constructor: EnterNode,
955   appendChild: function(child) { return this._parent.insertBefore(child, this._next); },
956   insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },
957   querySelector: function(selector) { return this._parent.querySelector(selector); },
958   querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }
959 };
960
961 function constant$1(x) {
962   return function() {
963     return x;
964   };
965 }
966
967 var keyPrefix = "$"; // Protect against keys like “__proto__”.
968
969 function bindIndex(parent, group, enter, update, exit, data) {
970   var i = 0,
971       node,
972       groupLength = group.length,
973       dataLength = data.length;
974
975   // Put any non-null nodes that fit into update.
976   // Put any null nodes into enter.
977   // Put any remaining data into enter.
978   for (; i < dataLength; ++i) {
979     if (node = group[i]) {
980       node.__data__ = data[i];
981       update[i] = node;
982     } else {
983       enter[i] = new EnterNode(parent, data[i]);
984     }
985   }
986
987   // Put any non-null nodes that don’t fit into exit.
988   for (; i < groupLength; ++i) {
989     if (node = group[i]) {
990       exit[i] = node;
991     }
992   }
993 }
994
995 function bindKey(parent, group, enter, update, exit, data, key) {
996   var i,
997       node,
998       nodeByKeyValue = {},
999       groupLength = group.length,
1000       dataLength = data.length,
1001       keyValues = new Array(groupLength),
1002       keyValue;
1003
1004   // Compute the key for each node.
1005   // If multiple nodes have the same key, the duplicates are added to exit.
1006   for (i = 0; i < groupLength; ++i) {
1007     if (node = group[i]) {
1008       keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);
1009       if (keyValue in nodeByKeyValue) {
1010         exit[i] = node;
1011       } else {
1012         nodeByKeyValue[keyValue] = node;
1013       }
1014     }
1015   }
1016
1017   // Compute the key for each datum.
1018   // If there a node associated with this key, join and add it to update.
1019   // If there is not (or the key is a duplicate), add it to enter.
1020   for (i = 0; i < dataLength; ++i) {
1021     keyValue = keyPrefix + key.call(parent, data[i], i, data);
1022     if (node = nodeByKeyValue[keyValue]) {
1023       update[i] = node;
1024       node.__data__ = data[i];
1025       nodeByKeyValue[keyValue] = null;
1026     } else {
1027       enter[i] = new EnterNode(parent, data[i]);
1028     }
1029   }
1030
1031   // Add any remaining nodes that were not bound to data to exit.
1032   for (i = 0; i < groupLength; ++i) {
1033     if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {
1034       exit[i] = node;
1035     }
1036   }
1037 }
1038
1039 function selection_data(value, key) {
1040   if (!value) {
1041     data = new Array(this.size()), j = -1;
1042     this.each(function(d) { data[++j] = d; });
1043     return data;
1044   }
1045
1046   var bind = key ? bindKey : bindIndex,
1047       parents = this._parents,
1048       groups = this._groups;
1049
1050   if (typeof value !== "function") value = constant$1(value);
1051
1052   for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
1053     var parent = parents[j],
1054         group = groups[j],
1055         groupLength = group.length,
1056         data = value.call(parent, parent && parent.__data__, j, parents),
1057         dataLength = data.length,
1058         enterGroup = enter[j] = new Array(dataLength),
1059         updateGroup = update[j] = new Array(dataLength),
1060         exitGroup = exit[j] = new Array(groupLength);
1061
1062     bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
1063
1064     // Now connect the enter nodes to their following update node, such that
1065     // appendChild can insert the materialized enter node before this node,
1066     // rather than at the end of the parent node.
1067     for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
1068       if (previous = enterGroup[i0]) {
1069         if (i0 >= i1) i1 = i0 + 1;
1070         while (!(next = updateGroup[i1]) && ++i1 < dataLength);
1071         previous._next = next || null;
1072       }
1073     }
1074   }
1075
1076   update = new Selection(update, parents);
1077   update._enter = enter;
1078   update._exit = exit;
1079   return update;
1080 }
1081
1082 function selection_exit() {
1083   return new Selection(this._exit || this._groups.map(sparse), this._parents);
1084 }
1085
1086 function selection_merge(selection$$1) {
1087
1088   for (var groups0 = this._groups, groups1 = selection$$1._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
1089     for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
1090       if (node = group0[i] || group1[i]) {
1091         merge[i] = node;
1092       }
1093     }
1094   }
1095
1096   for (; j < m0; ++j) {
1097     merges[j] = groups0[j];
1098   }
1099
1100   return new Selection(merges, this._parents);
1101 }
1102
1103 function selection_order() {
1104
1105   for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {
1106     for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
1107       if (node = group[i]) {
1108         if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
1109         next = node;
1110       }
1111     }
1112   }
1113
1114   return this;
1115 }
1116
1117 function selection_sort(compare) {
1118   if (!compare) compare = ascending;
1119
1120   function compareNode(a, b) {
1121     return a && b ? compare(a.__data__, b.__data__) : !a - !b;
1122   }
1123
1124   for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
1125     for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
1126       if (node = group[i]) {
1127         sortgroup[i] = node;
1128       }
1129     }
1130     sortgroup.sort(compareNode);
1131   }
1132
1133   return new Selection(sortgroups, this._parents).order();
1134 }
1135
1136 function ascending(a, b) {
1137   return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
1138 }
1139
1140 function selection_call() {
1141   var callback = arguments[0];
1142   arguments[0] = this;
1143   callback.apply(null, arguments);
1144   return this;
1145 }
1146
1147 function selection_nodes() {
1148   var nodes = new Array(this.size()), i = -1;
1149   this.each(function() { nodes[++i] = this; });
1150   return nodes;
1151 }
1152
1153 function selection_node() {
1154
1155   for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
1156     for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
1157       var node = group[i];
1158       if (node) return node;
1159     }
1160   }
1161
1162   return null;
1163 }
1164
1165 function selection_size() {
1166   var size = 0;
1167   this.each(function() { ++size; });
1168   return size;
1169 }
1170
1171 function selection_empty() {
1172   return !this.node();
1173 }
1174
1175 function selection_each(callback) {
1176
1177   for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
1178     for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
1179       if (node = group[i]) callback.call(node, node.__data__, i, group);
1180     }
1181   }
1182
1183   return this;
1184 }
1185
1186 function attrRemove(name) {
1187   return function() {
1188     this.removeAttribute(name);
1189   };
1190 }
1191
1192 function attrRemoveNS(fullname) {
1193   return function() {
1194     this.removeAttributeNS(fullname.space, fullname.local);
1195   };
1196 }
1197
1198 function attrConstant(name, value) {
1199   return function() {
1200     this.setAttribute(name, value);
1201   };
1202 }
1203
1204 function attrConstantNS(fullname, value) {
1205   return function() {
1206     this.setAttributeNS(fullname.space, fullname.local, value);
1207   };
1208 }
1209
1210 function attrFunction(name, value) {
1211   return function() {
1212     var v = value.apply(this, arguments);
1213     if (v == null) this.removeAttribute(name);
1214     else this.setAttribute(name, v);
1215   };
1216 }
1217
1218 function attrFunctionNS(fullname, value) {
1219   return function() {
1220     var v = value.apply(this, arguments);
1221     if (v == null) this.removeAttributeNS(fullname.space, fullname.local);
1222     else this.setAttributeNS(fullname.space, fullname.local, v);
1223   };
1224 }
1225
1226 function selection_attr(name, value) {
1227   var fullname = namespace(name);
1228
1229   if (arguments.length < 2) {
1230     var node = this.node();
1231     return fullname.local
1232         ? node.getAttributeNS(fullname.space, fullname.local)
1233         : node.getAttribute(fullname);
1234   }
1235
1236   return this.each((value == null
1237       ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function"
1238       ? (fullname.local ? attrFunctionNS : attrFunction)
1239       : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));
1240 }
1241
1242 function defaultView(node) {
1243   return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node
1244       || (node.document && node) // node is a Window
1245       || node.defaultView; // node is a Document
1246 }
1247
1248 function styleRemove(name) {
1249   return function() {
1250     this.style.removeProperty(name);
1251   };
1252 }
1253
1254 function styleConstant(name, value, priority) {
1255   return function() {
1256     this.style.setProperty(name, value, priority);
1257   };
1258 }
1259
1260 function styleFunction(name, value, priority) {
1261   return function() {
1262     var v = value.apply(this, arguments);
1263     if (v == null) this.style.removeProperty(name);
1264     else this.style.setProperty(name, v, priority);
1265   };
1266 }
1267
1268 function selection_style(name, value, priority) {
1269   return arguments.length > 1
1270       ? this.each((value == null
1271             ? styleRemove : typeof value === "function"
1272             ? styleFunction
1273             : styleConstant)(name, value, priority == null ? "" : priority))
1274       : styleValue(this.node(), name);
1275 }
1276
1277 function styleValue(node, name) {
1278   return node.style.getPropertyValue(name)
1279       || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);
1280 }
1281
1282 function propertyRemove(name) {
1283   return function() {
1284     delete this[name];
1285   };
1286 }
1287
1288 function propertyConstant(name, value) {
1289   return function() {
1290     this[name] = value;
1291   };
1292 }
1293
1294 function propertyFunction(name, value) {
1295   return function() {
1296     var v = value.apply(this, arguments);
1297     if (v == null) delete this[name];
1298     else this[name] = v;
1299   };
1300 }
1301
1302 function selection_property(name, value) {
1303   return arguments.length > 1
1304       ? this.each((value == null
1305           ? propertyRemove : typeof value === "function"
1306           ? propertyFunction
1307           : propertyConstant)(name, value))
1308       : this.node()[name];
1309 }
1310
1311 function classArray(string) {
1312   return string.trim().split(/^|\s+/);
1313 }
1314
1315 function classList(node) {
1316   return node.classList || new ClassList(node);
1317 }
1318
1319 function ClassList(node) {
1320   this._node = node;
1321   this._names = classArray(node.getAttribute("class") || "");
1322 }
1323
1324 ClassList.prototype = {
1325   add: function(name) {
1326     var i = this._names.indexOf(name);
1327     if (i < 0) {
1328       this._names.push(name);
1329       this._node.setAttribute("class", this._names.join(" "));
1330     }
1331   },
1332   remove: function(name) {
1333     var i = this._names.indexOf(name);
1334     if (i >= 0) {
1335       this._names.splice(i, 1);
1336       this._node.setAttribute("class", this._names.join(" "));
1337     }
1338   },
1339   contains: function(name) {
1340     return this._names.indexOf(name) >= 0;
1341   }
1342 };
1343
1344 function classedAdd(node, names) {
1345   var list = classList(node), i = -1, n = names.length;
1346   while (++i < n) list.add(names[i]);
1347 }
1348
1349 function classedRemove(node, names) {
1350   var list = classList(node), i = -1, n = names.length;
1351   while (++i < n) list.remove(names[i]);
1352 }
1353
1354 function classedTrue(names) {
1355   return function() {
1356     classedAdd(this, names);
1357   };
1358 }
1359
1360 function classedFalse(names) {
1361   return function() {
1362     classedRemove(this, names);
1363   };
1364 }
1365
1366 function classedFunction(names, value) {
1367   return function() {
1368     (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
1369   };
1370 }
1371
1372 function selection_classed(name, value) {
1373   var names = classArray(name + "");
1374
1375   if (arguments.length < 2) {
1376     var list = classList(this.node()), i = -1, n = names.length;
1377     while (++i < n) if (!list.contains(names[i])) return false;
1378     return true;
1379   }
1380
1381   return this.each((typeof value === "function"
1382       ? classedFunction : value
1383       ? classedTrue
1384       : classedFalse)(names, value));
1385 }
1386
1387 function textRemove() {
1388   this.textContent = "";
1389 }
1390
1391 function textConstant(value) {
1392   return function() {
1393     this.textContent = value;
1394   };
1395 }
1396
1397 function textFunction(value) {
1398   return function() {
1399     var v = value.apply(this, arguments);
1400     this.textContent = v == null ? "" : v;
1401   };
1402 }
1403
1404 function selection_text(value) {
1405   return arguments.length
1406       ? this.each(value == null
1407           ? textRemove : (typeof value === "function"
1408           ? textFunction
1409           : textConstant)(value))
1410       : this.node().textContent;
1411 }
1412
1413 function htmlRemove() {
1414   this.innerHTML = "";
1415 }
1416
1417 function htmlConstant(value) {
1418   return function() {
1419     this.innerHTML = value;
1420   };
1421 }
1422
1423 function htmlFunction(value) {
1424   return function() {
1425     var v = value.apply(this, arguments);
1426     this.innerHTML = v == null ? "" : v;
1427   };
1428 }
1429
1430 function selection_html(value) {
1431   return arguments.length
1432       ? this.each(value == null
1433           ? htmlRemove : (typeof value === "function"
1434           ? htmlFunction
1435           : htmlConstant)(value))
1436       : this.node().innerHTML;
1437 }
1438
1439 function raise() {
1440   if (this.nextSibling) this.parentNode.appendChild(this);
1441 }
1442
1443 function selection_raise() {
1444   return this.each(raise);
1445 }
1446
1447 function lower() {
1448   if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
1449 }
1450
1451 function selection_lower() {
1452   return this.each(lower);
1453 }
1454
1455 function selection_append(name) {
1456   var create = typeof name === "function" ? name : creator(name);
1457   return this.select(function() {
1458     return this.appendChild(create.apply(this, arguments));
1459   });
1460 }
1461
1462 function constantNull() {
1463   return null;
1464 }
1465
1466 function selection_insert(name, before) {
1467   var create = typeof name === "function" ? name : creator(name),
1468       select = before == null ? constantNull : typeof before === "function" ? before : selector(before);
1469   return this.select(function() {
1470     return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
1471   });
1472 }
1473
1474 function remove() {
1475   var parent = this.parentNode;
1476   if (parent) parent.removeChild(this);
1477 }
1478
1479 function selection_remove() {
1480   return this.each(remove);
1481 }
1482
1483 function selection_cloneShallow() {
1484   return this.parentNode.insertBefore(this.cloneNode(false), this.nextSibling);
1485 }
1486
1487 function selection_cloneDeep() {
1488   return this.parentNode.insertBefore(this.cloneNode(true), this.nextSibling);
1489 }
1490
1491 function selection_clone(deep) {
1492   return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
1493 }
1494
1495 function selection_datum(value) {
1496   return arguments.length
1497       ? this.property("__data__", value)
1498       : this.node().__data__;
1499 }
1500
1501 var filterEvents = {};
1502
1503 var event = null;
1504
1505 if (typeof document !== "undefined") {
1506   var element$1 = document.documentElement;
1507   if (!("onmouseenter" in element$1)) {
1508     filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"};
1509   }
1510 }
1511
1512 function filterContextListener(listener, index, group) {
1513   listener = contextListener(listener, index, group);
1514   return function(event) {
1515     var related = event.relatedTarget;
1516     if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {
1517       listener.call(this, event);
1518     }
1519   };
1520 }
1521
1522 function contextListener(listener, index, group) {
1523   return function(event1) {
1524     var event0 = event; // Events can be reentrant (e.g., focus).
1525     event = event1;
1526     try {
1527       listener.call(this, this.__data__, index, group);
1528     } finally {
1529       event = event0;
1530     }
1531   };
1532 }
1533
1534 function parseTypenames$1(typenames) {
1535   return typenames.trim().split(/^|\s+/).map(function(t) {
1536     var name = "", i = t.indexOf(".");
1537     if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
1538     return {type: t, name: name};
1539   });
1540 }
1541
1542 function onRemove(typename) {
1543   return function() {
1544     var on = this.__on;
1545     if (!on) return;
1546     for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
1547       if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
1548         this.removeEventListener(o.type, o.listener, o.capture);
1549       } else {
1550         on[++i] = o;
1551       }
1552     }
1553     if (++i) on.length = i;
1554     else delete this.__on;
1555   };
1556 }
1557
1558 function onAdd(typename, value, capture) {
1559   var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;
1560   return function(d, i, group) {
1561     var on = this.__on, o, listener = wrap(value, i, group);
1562     if (on) for (var j = 0, m = on.length; j < m; ++j) {
1563       if ((o = on[j]).type === typename.type && o.name === typename.name) {
1564         this.removeEventListener(o.type, o.listener, o.capture);
1565         this.addEventListener(o.type, o.listener = listener, o.capture = capture);
1566         o.value = value;
1567         return;
1568       }
1569     }
1570     this.addEventListener(typename.type, listener, capture);
1571     o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};
1572     if (!on) this.__on = [o];
1573     else on.push(o);
1574   };
1575 }
1576
1577 function selection_on(typename, value, capture) {
1578   var typenames = parseTypenames$1(typename + ""), i, n = typenames.length, t;
1579
1580   if (arguments.length < 2) {
1581     var on = this.node().__on;
1582     if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
1583       for (i = 0, o = on[j]; i < n; ++i) {
1584         if ((t = typenames[i]).type === o.type && t.name === o.name) {
1585           return o.value;
1586         }
1587       }
1588     }
1589     return;
1590   }
1591
1592   on = value ? onAdd : onRemove;
1593   if (capture == null) capture = false;
1594   for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));
1595   return this;
1596 }
1597
1598 function customEvent(event1, listener, that, args) {
1599   var event0 = event;
1600   event1.sourceEvent = event;
1601   event = event1;
1602   try {
1603     return listener.apply(that, args);
1604   } finally {
1605     event = event0;
1606   }
1607 }
1608
1609 function dispatchEvent(node, type, params) {
1610   var window = defaultView(node),
1611       event = window.CustomEvent;
1612
1613   if (typeof event === "function") {
1614     event = new event(type, params);
1615   } else {
1616     event = window.document.createEvent("Event");
1617     if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;
1618     else event.initEvent(type, false, false);
1619   }
1620
1621   node.dispatchEvent(event);
1622 }
1623
1624 function dispatchConstant(type, params) {
1625   return function() {
1626     return dispatchEvent(this, type, params);
1627   };
1628 }
1629
1630 function dispatchFunction(type, params) {
1631   return function() {
1632     return dispatchEvent(this, type, params.apply(this, arguments));
1633   };
1634 }
1635
1636 function selection_dispatch(type, params) {
1637   return this.each((typeof params === "function"
1638       ? dispatchFunction
1639       : dispatchConstant)(type, params));
1640 }
1641
1642 var root = [null];
1643
1644 function Selection(groups, parents) {
1645   this._groups = groups;
1646   this._parents = parents;
1647 }
1648
1649 function selection() {
1650   return new Selection([[document.documentElement]], root);
1651 }
1652
1653 Selection.prototype = selection.prototype = {
1654   constructor: Selection,
1655   select: selection_select,
1656   selectAll: selection_selectAll,
1657   filter: selection_filter,
1658   data: selection_data,
1659   enter: selection_enter,
1660   exit: selection_exit,
1661   merge: selection_merge,
1662   order: selection_order,
1663   sort: selection_sort,
1664   call: selection_call,
1665   nodes: selection_nodes,
1666   node: selection_node,
1667   size: selection_size,
1668   empty: selection_empty,
1669   each: selection_each,
1670   attr: selection_attr,
1671   style: selection_style,
1672   property: selection_property,
1673   classed: selection_classed,
1674   text: selection_text,
1675   html: selection_html,
1676   raise: selection_raise,
1677   lower: selection_lower,
1678   append: selection_append,
1679   insert: selection_insert,
1680   remove: selection_remove,
1681   clone: selection_clone,
1682   datum: selection_datum,
1683   on: selection_on,
1684   dispatch: selection_dispatch
1685 };
1686
1687 function d3_select(selector) {
1688   return typeof selector === "string"
1689       ? new Selection([[document.querySelector(selector)]], [document.documentElement])
1690       : new Selection([[selector]], root);
1691 }
1692
1693 function create(name) {
1694   return d3_select(creator(name).call(document.documentElement));
1695 }
1696
1697 var nextId = 0;
1698
1699 function local() {
1700   return new Local;
1701 }
1702
1703 function Local() {
1704   this._ = "@" + (++nextId).toString(36);
1705 }
1706
1707 Local.prototype = local.prototype = {
1708   constructor: Local,
1709   get: function(node) {
1710     var id = this._;
1711     while (!(id in node)) if (!(node = node.parentNode)) return;
1712     return node[id];
1713   },
1714   set: function(node, value) {
1715     return node[this._] = value;
1716   },
1717   remove: function(node) {
1718     return this._ in node && delete node[this._];
1719   },
1720   toString: function() {
1721     return this._;
1722   }
1723 };
1724
1725 function sourceEvent() {
1726   var current = event, source;
1727   while (source = current.sourceEvent) current = source;
1728   return current;
1729 }
1730
1731 function point(node, event) {
1732   var svg = node.ownerSVGElement || node;
1733
1734   if (svg.createSVGPoint) {
1735     var point = svg.createSVGPoint();
1736     point.x = event.clientX, point.y = event.clientY;
1737     point = point.matrixTransform(node.getScreenCTM().inverse());
1738     return [point.x, point.y];
1739   }
1740
1741   var rect = node.getBoundingClientRect();
1742   return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];
1743 }
1744
1745 function d3_mouse(node) {
1746   var event = sourceEvent();
1747   if (event.changedTouches) event = event.changedTouches[0];
1748   return point(node, event);
1749 }
1750
1751 function d3_selectAll(selector) {
1752   return typeof selector === "string"
1753       ? new Selection([document.querySelectorAll(selector)], [document.documentElement])
1754       : new Selection([selector == null ? [] : selector], root);
1755 }
1756
1757 function touch(node, touches, identifier) {
1758   if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches;
1759
1760   for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) {
1761     if ((touch = touches[i]).identifier === identifier) {
1762       return point(node, touch);
1763     }
1764   }
1765
1766   return null;
1767 }
1768
1769 function d3_touches(node, touches) {
1770   if (touches == null) touches = sourceEvent().touches;
1771
1772   for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) {
1773     points[i] = point(node, touches[i]);
1774   }
1775
1776   return points;
1777 }
1778
1779 function nopropagation() {
1780   event.stopImmediatePropagation();
1781 }
1782
1783 function noevent() {
1784   event.preventDefault();
1785   event.stopImmediatePropagation();
1786 }
1787
1788 function dragDisable(view) {
1789   var root = view.document.documentElement,
1790       selection$$1 = d3_select(view).on("dragstart.drag", noevent, true);
1791   if ("onselectstart" in root) {
1792     selection$$1.on("selectstart.drag", noevent, true);
1793   } else {
1794     root.__noselect = root.style.MozUserSelect;
1795     root.style.MozUserSelect = "none";
1796   }
1797 }
1798
1799 function yesdrag(view, noclick) {
1800   var root = view.document.documentElement,
1801       selection$$1 = d3_select(view).on("dragstart.drag", null);
1802   if (noclick) {
1803     selection$$1.on("click.drag", noevent, true);
1804     setTimeout(function() { selection$$1.on("click.drag", null); }, 0);
1805   }
1806   if ("onselectstart" in root) {
1807     selection$$1.on("selectstart.drag", null);
1808   } else {
1809     root.style.MozUserSelect = root.__noselect;
1810     delete root.__noselect;
1811   }
1812 }
1813
1814 function constant$2(x) {
1815   return function() {
1816     return x;
1817   };
1818 }
1819
1820 function DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) {
1821   this.target = target;
1822   this.type = type;
1823   this.subject = subject;
1824   this.identifier = id;
1825   this.active = active;
1826   this.x = x;
1827   this.y = y;
1828   this.dx = dx;
1829   this.dy = dy;
1830   this._ = dispatch;
1831 }
1832
1833 DragEvent.prototype.on = function() {
1834   var value = this._.on.apply(this._, arguments);
1835   return value === this._ ? this : value;
1836 };
1837
1838 // Ignore right-click, since that should open the context menu.
1839 function defaultFilter() {
1840   return !event.button;
1841 }
1842
1843 function defaultContainer() {
1844   return this.parentNode;
1845 }
1846
1847 function defaultSubject(d) {
1848   return d == null ? {x: event.x, y: event.y} : d;
1849 }
1850
1851 function defaultTouchable() {
1852   return "ontouchstart" in this;
1853 }
1854
1855 function drag() {
1856   var filter = defaultFilter,
1857       container = defaultContainer,
1858       subject = defaultSubject,
1859       touchable = defaultTouchable,
1860       gestures = {},
1861       listeners = dispatch("start", "drag", "end"),
1862       active = 0,
1863       mousedownx,
1864       mousedowny,
1865       mousemoving,
1866       touchending,
1867       clickDistance2 = 0;
1868
1869   function drag(selection$$1) {
1870     selection$$1
1871         .on("mousedown.drag", mousedowned)
1872       .filter(touchable)
1873         .on("touchstart.drag", touchstarted)
1874         .on("touchmove.drag", touchmoved)
1875         .on("touchend.drag touchcancel.drag", touchended)
1876         .style("touch-action", "none")
1877         .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)");
1878   }
1879
1880   function mousedowned() {
1881     if (touchending || !filter.apply(this, arguments)) return;
1882     var gesture = beforestart("mouse", container.apply(this, arguments), d3_mouse, this, arguments);
1883     if (!gesture) return;
1884     d3_select(event.view).on("mousemove.drag", mousemoved, true).on("mouseup.drag", mouseupped, true);
1885     dragDisable(event.view);
1886     nopropagation();
1887     mousemoving = false;
1888     mousedownx = event.clientX;
1889     mousedowny = event.clientY;
1890     gesture("start");
1891   }
1892
1893   function mousemoved() {
1894     noevent();
1895     if (!mousemoving) {
1896       var dx = event.clientX - mousedownx, dy = event.clientY - mousedowny;
1897       mousemoving = dx * dx + dy * dy > clickDistance2;
1898     }
1899     gestures.mouse("drag");
1900   }
1901
1902   function mouseupped() {
1903     d3_select(event.view).on("mousemove.drag mouseup.drag", null);
1904     yesdrag(event.view, mousemoving);
1905     noevent();
1906     gestures.mouse("end");
1907   }
1908
1909   function touchstarted() {
1910     if (!filter.apply(this, arguments)) return;
1911     var touches = event.changedTouches,
1912         c = container.apply(this, arguments),
1913         n = touches.length, i, gesture;
1914
1915     for (i = 0; i < n; ++i) {
1916       if (gesture = beforestart(touches[i].identifier, c, touch, this, arguments)) {
1917         nopropagation();
1918         gesture("start");
1919       }
1920     }
1921   }
1922
1923   function touchmoved() {
1924     var touches = event.changedTouches,
1925         n = touches.length, i, gesture;
1926
1927     for (i = 0; i < n; ++i) {
1928       if (gesture = gestures[touches[i].identifier]) {
1929         noevent();
1930         gesture("drag");
1931       }
1932     }
1933   }
1934
1935   function touchended() {
1936     var touches = event.changedTouches,
1937         n = touches.length, i, gesture;
1938
1939     if (touchending) clearTimeout(touchending);
1940     touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!
1941     for (i = 0; i < n; ++i) {
1942       if (gesture = gestures[touches[i].identifier]) {
1943         nopropagation();
1944         gesture("end");
1945       }
1946     }
1947   }
1948
1949   function beforestart(id, container, point$$1, that, args) {
1950     var p = point$$1(container, id), s, dx, dy,
1951         sublisteners = listeners.copy();
1952
1953     if (!customEvent(new DragEvent(drag, "beforestart", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {
1954       if ((event.subject = s = subject.apply(that, args)) == null) return false;
1955       dx = s.x - p[0] || 0;
1956       dy = s.y - p[1] || 0;
1957       return true;
1958     })) return;
1959
1960     return function gesture(type) {
1961       var p0 = p, n;
1962       switch (type) {
1963         case "start": gestures[id] = gesture, n = active++; break;
1964         case "end": delete gestures[id], --active; // nobreak
1965         case "drag": p = point$$1(container, id), n = active; break;
1966       }
1967       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]);
1968     };
1969   }
1970
1971   drag.filter = function(_) {
1972     return arguments.length ? (filter = typeof _ === "function" ? _ : constant$2(!!_), drag) : filter;
1973   };
1974
1975   drag.container = function(_) {
1976     return arguments.length ? (container = typeof _ === "function" ? _ : constant$2(_), drag) : container;
1977   };
1978
1979   drag.subject = function(_) {
1980     return arguments.length ? (subject = typeof _ === "function" ? _ : constant$2(_), drag) : subject;
1981   };
1982
1983   drag.touchable = function(_) {
1984     return arguments.length ? (touchable = typeof _ === "function" ? _ : constant$2(!!_), drag) : touchable;
1985   };
1986
1987   drag.on = function() {
1988     var value = listeners.on.apply(listeners, arguments);
1989     return value === listeners ? drag : value;
1990   };
1991
1992   drag.clickDistance = function(_) {
1993     return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2);
1994   };
1995
1996   return drag;
1997 }
1998
1999 function define(constructor, factory, prototype) {
2000   constructor.prototype = factory.prototype = prototype;
2001   prototype.constructor = constructor;
2002 }
2003
2004 function extend(parent, definition) {
2005   var prototype = Object.create(parent.prototype);
2006   for (var key in definition) prototype[key] = definition[key];
2007   return prototype;
2008 }
2009
2010 function Color() {}
2011
2012 var darker = 0.7;
2013 var brighter = 1 / darker;
2014
2015 var reI = "\\s*([+-]?\\d+)\\s*",
2016     reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",
2017     reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
2018     reHex3 = /^#([0-9a-f]{3})$/,
2019     reHex6 = /^#([0-9a-f]{6})$/,
2020     reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"),
2021     reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"),
2022     reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"),
2023     reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"),
2024     reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"),
2025     reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$");
2026
2027 var named = {
2028   aliceblue: 0xf0f8ff,
2029   antiquewhite: 0xfaebd7,
2030   aqua: 0x00ffff,
2031   aquamarine: 0x7fffd4,
2032   azure: 0xf0ffff,
2033   beige: 0xf5f5dc,
2034   bisque: 0xffe4c4,
2035   black: 0x000000,
2036   blanchedalmond: 0xffebcd,
2037   blue: 0x0000ff,
2038   blueviolet: 0x8a2be2,
2039   brown: 0xa52a2a,
2040   burlywood: 0xdeb887,
2041   cadetblue: 0x5f9ea0,
2042   chartreuse: 0x7fff00,
2043   chocolate: 0xd2691e,
2044   coral: 0xff7f50,
2045   cornflowerblue: 0x6495ed,
2046   cornsilk: 0xfff8dc,
2047   crimson: 0xdc143c,
2048   cyan: 0x00ffff,
2049   darkblue: 0x00008b,
2050   darkcyan: 0x008b8b,
2051   darkgoldenrod: 0xb8860b,
2052   darkgray: 0xa9a9a9,
2053   darkgreen: 0x006400,
2054   darkgrey: 0xa9a9a9,
2055   darkkhaki: 0xbdb76b,
2056   darkmagenta: 0x8b008b,
2057   darkolivegreen: 0x556b2f,
2058   darkorange: 0xff8c00,
2059   darkorchid: 0x9932cc,
2060   darkred: 0x8b0000,
2061   darksalmon: 0xe9967a,
2062   darkseagreen: 0x8fbc8f,
2063   darkslateblue: 0x483d8b,
2064   darkslategray: 0x2f4f4f,
2065   darkslategrey: 0x2f4f4f,
2066   darkturquoise: 0x00ced1,
2067   darkviolet: 0x9400d3,
2068   deeppink: 0xff1493,
2069   deepskyblue: 0x00bfff,
2070   dimgray: 0x696969,
2071   dimgrey: 0x696969,
2072   dodgerblue: 0x1e90ff,
2073   firebrick: 0xb22222,
2074   floralwhite: 0xfffaf0,
2075   forestgreen: 0x228b22,
2076   fuchsia: 0xff00ff,
2077   gainsboro: 0xdcdcdc,
2078   ghostwhite: 0xf8f8ff,
2079   gold: 0xffd700,
2080   goldenrod: 0xdaa520,
2081   gray: 0x808080,
2082   green: 0x008000,
2083   greenyellow: 0xadff2f,
2084   grey: 0x808080,
2085   honeydew: 0xf0fff0,
2086   hotpink: 0xff69b4,
2087   indianred: 0xcd5c5c,
2088   indigo: 0x4b0082,
2089   ivory: 0xfffff0,
2090   khaki: 0xf0e68c,
2091   lavender: 0xe6e6fa,
2092   lavenderblush: 0xfff0f5,
2093   lawngreen: 0x7cfc00,
2094   lemonchiffon: 0xfffacd,
2095   lightblue: 0xadd8e6,
2096   lightcoral: 0xf08080,
2097   lightcyan: 0xe0ffff,
2098   lightgoldenrodyellow: 0xfafad2,
2099   lightgray: 0xd3d3d3,
2100   lightgreen: 0x90ee90,
2101   lightgrey: 0xd3d3d3,
2102   lightpink: 0xffb6c1,
2103   lightsalmon: 0xffa07a,
2104   lightseagreen: 0x20b2aa,
2105   lightskyblue: 0x87cefa,
2106   lightslategray: 0x778899,
2107   lightslategrey: 0x778899,
2108   lightsteelblue: 0xb0c4de,
2109   lightyellow: 0xffffe0,
2110   lime: 0x00ff00,
2111   limegreen: 0x32cd32,
2112   linen: 0xfaf0e6,
2113   magenta: 0xff00ff,
2114   maroon: 0x800000,
2115   mediumaquamarine: 0x66cdaa,
2116   mediumblue: 0x0000cd,
2117   mediumorchid: 0xba55d3,
2118   mediumpurple: 0x9370db,
2119   mediumseagreen: 0x3cb371,
2120   mediumslateblue: 0x7b68ee,
2121   mediumspringgreen: 0x00fa9a,
2122   mediumturquoise: 0x48d1cc,
2123   mediumvioletred: 0xc71585,
2124   midnightblue: 0x191970,
2125   mintcream: 0xf5fffa,
2126   mistyrose: 0xffe4e1,
2127   moccasin: 0xffe4b5,
2128   navajowhite: 0xffdead,
2129   navy: 0x000080,
2130   oldlace: 0xfdf5e6,
2131   olive: 0x808000,
2132   olivedrab: 0x6b8e23,
2133   orange: 0xffa500,
2134   orangered: 0xff4500,
2135   orchid: 0xda70d6,
2136   palegoldenrod: 0xeee8aa,
2137   palegreen: 0x98fb98,
2138   paleturquoise: 0xafeeee,
2139   palevioletred: 0xdb7093,
2140   papayawhip: 0xffefd5,
2141   peachpuff: 0xffdab9,
2142   peru: 0xcd853f,
2143   pink: 0xffc0cb,
2144   plum: 0xdda0dd,
2145   powderblue: 0xb0e0e6,
2146   purple: 0x800080,
2147   rebeccapurple: 0x663399,
2148   red: 0xff0000,
2149   rosybrown: 0xbc8f8f,
2150   royalblue: 0x4169e1,
2151   saddlebrown: 0x8b4513,
2152   salmon: 0xfa8072,
2153   sandybrown: 0xf4a460,
2154   seagreen: 0x2e8b57,
2155   seashell: 0xfff5ee,
2156   sienna: 0xa0522d,
2157   silver: 0xc0c0c0,
2158   skyblue: 0x87ceeb,
2159   slateblue: 0x6a5acd,
2160   slategray: 0x708090,
2161   slategrey: 0x708090,
2162   snow: 0xfffafa,
2163   springgreen: 0x00ff7f,
2164   steelblue: 0x4682b4,
2165   tan: 0xd2b48c,
2166   teal: 0x008080,
2167   thistle: 0xd8bfd8,
2168   tomato: 0xff6347,
2169   turquoise: 0x40e0d0,
2170   violet: 0xee82ee,
2171   wheat: 0xf5deb3,
2172   white: 0xffffff,
2173   whitesmoke: 0xf5f5f5,
2174   yellow: 0xffff00,
2175   yellowgreen: 0x9acd32
2176 };
2177
2178 define(Color, color, {
2179   displayable: function() {
2180     return this.rgb().displayable();
2181   },
2182   toString: function() {
2183     return this.rgb() + "";
2184   }
2185 });
2186
2187 function color(format) {
2188   var m;
2189   format = (format + "").trim().toLowerCase();
2190   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
2191       : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000
2192       : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)
2193       : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)
2194       : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
2195       : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
2196       : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
2197       : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
2198       : named.hasOwnProperty(format) ? rgbn(named[format])
2199       : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0)
2200       : null;
2201 }
2202
2203 function rgbn(n) {
2204   return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
2205 }
2206
2207 function rgba(r, g, b, a) {
2208   if (a <= 0) r = g = b = NaN;
2209   return new Rgb(r, g, b, a);
2210 }
2211
2212 function rgbConvert(o) {
2213   if (!(o instanceof Color)) o = color(o);
2214   if (!o) return new Rgb;
2215   o = o.rgb();
2216   return new Rgb(o.r, o.g, o.b, o.opacity);
2217 }
2218
2219 function rgb(r, g, b, opacity) {
2220   return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
2221 }
2222
2223 function Rgb(r, g, b, opacity) {
2224   this.r = +r;
2225   this.g = +g;
2226   this.b = +b;
2227   this.opacity = +opacity;
2228 }
2229
2230 define(Rgb, rgb, extend(Color, {
2231   brighter: function(k) {
2232     k = k == null ? brighter : Math.pow(brighter, k);
2233     return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
2234   },
2235   darker: function(k) {
2236     k = k == null ? darker : Math.pow(darker, k);
2237     return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
2238   },
2239   rgb: function() {
2240     return this;
2241   },
2242   displayable: function() {
2243     return (0 <= this.r && this.r <= 255)
2244         && (0 <= this.g && this.g <= 255)
2245         && (0 <= this.b && this.b <= 255)
2246         && (0 <= this.opacity && this.opacity <= 1);
2247   },
2248   toString: function() {
2249     var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
2250     return (a === 1 ? "rgb(" : "rgba(")
2251         + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", "
2252         + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", "
2253         + Math.max(0, Math.min(255, Math.round(this.b) || 0))
2254         + (a === 1 ? ")" : ", " + a + ")");
2255   }
2256 }));
2257
2258 function hsla(h, s, l, a) {
2259   if (a <= 0) h = s = l = NaN;
2260   else if (l <= 0 || l >= 1) h = s = NaN;
2261   else if (s <= 0) h = NaN;
2262   return new Hsl(h, s, l, a);
2263 }
2264
2265 function hslConvert(o) {
2266   if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
2267   if (!(o instanceof Color)) o = color(o);
2268   if (!o) return new Hsl;
2269   if (o instanceof Hsl) return o;
2270   o = o.rgb();
2271   var r = o.r / 255,
2272       g = o.g / 255,
2273       b = o.b / 255,
2274       min = Math.min(r, g, b),
2275       max = Math.max(r, g, b),
2276       h = NaN,
2277       s = max - min,
2278       l = (max + min) / 2;
2279   if (s) {
2280     if (r === max) h = (g - b) / s + (g < b) * 6;
2281     else if (g === max) h = (b - r) / s + 2;
2282     else h = (r - g) / s + 4;
2283     s /= l < 0.5 ? max + min : 2 - max - min;
2284     h *= 60;
2285   } else {
2286     s = l > 0 && l < 1 ? 0 : h;
2287   }
2288   return new Hsl(h, s, l, o.opacity);
2289 }
2290
2291 function hsl(h, s, l, opacity) {
2292   return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
2293 }
2294
2295 function Hsl(h, s, l, opacity) {
2296   this.h = +h;
2297   this.s = +s;
2298   this.l = +l;
2299   this.opacity = +opacity;
2300 }
2301
2302 define(Hsl, hsl, extend(Color, {
2303   brighter: function(k) {
2304     k = k == null ? brighter : Math.pow(brighter, k);
2305     return new Hsl(this.h, this.s, this.l * k, this.opacity);
2306   },
2307   darker: function(k) {
2308     k = k == null ? darker : Math.pow(darker, k);
2309     return new Hsl(this.h, this.s, this.l * k, this.opacity);
2310   },
2311   rgb: function() {
2312     var h = this.h % 360 + (this.h < 0) * 360,
2313         s = isNaN(h) || isNaN(this.s) ? 0 : this.s,
2314         l = this.l,
2315         m2 = l + (l < 0.5 ? l : 1 - l) * s,
2316         m1 = 2 * l - m2;
2317     return new Rgb(
2318       hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),
2319       hsl2rgb(h, m1, m2),
2320       hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),
2321       this.opacity
2322     );
2323   },
2324   displayable: function() {
2325     return (0 <= this.s && this.s <= 1 || isNaN(this.s))
2326         && (0 <= this.l && this.l <= 1)
2327         && (0 <= this.opacity && this.opacity <= 1);
2328   }
2329 }));
2330
2331 /* From FvD 13.37, CSS Color Module Level 3 */
2332 function hsl2rgb(h, m1, m2) {
2333   return (h < 60 ? m1 + (m2 - m1) * h / 60
2334       : h < 180 ? m2
2335       : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60
2336       : m1) * 255;
2337 }
2338
2339 var deg2rad = Math.PI / 180;
2340 var rad2deg = 180 / Math.PI;
2341
2342 var Kn = 18,
2343     Xn = 0.950470, // D65 standard referent
2344     Yn = 1,
2345     Zn = 1.088830,
2346     t0 = 4 / 29,
2347     t1 = 6 / 29,
2348     t2 = 3 * t1 * t1,
2349     t3 = t1 * t1 * t1;
2350
2351 function labConvert(o) {
2352   if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);
2353   if (o instanceof Hcl) {
2354     var h = o.h * deg2rad;
2355     return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
2356   }
2357   if (!(o instanceof Rgb)) o = rgbConvert(o);
2358   var b = rgb2xyz(o.r),
2359       a = rgb2xyz(o.g),
2360       l = rgb2xyz(o.b),
2361       x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),
2362       y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),
2363       z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);
2364   return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);
2365 }
2366
2367 function lab(l, a, b, opacity) {
2368   return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);
2369 }
2370
2371 function Lab(l, a, b, opacity) {
2372   this.l = +l;
2373   this.a = +a;
2374   this.b = +b;
2375   this.opacity = +opacity;
2376 }
2377
2378 define(Lab, lab, extend(Color, {
2379   brighter: function(k) {
2380     return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);
2381   },
2382   darker: function(k) {
2383     return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);
2384   },
2385   rgb: function() {
2386     var y = (this.l + 16) / 116,
2387         x = isNaN(this.a) ? y : y + this.a / 500,
2388         z = isNaN(this.b) ? y : y - this.b / 200;
2389     y = Yn * lab2xyz(y);
2390     x = Xn * lab2xyz(x);
2391     z = Zn * lab2xyz(z);
2392     return new Rgb(
2393       xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB
2394       xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),
2395       xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z),
2396       this.opacity
2397     );
2398   }
2399 }));
2400
2401 function xyz2lab(t) {
2402   return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
2403 }
2404
2405 function lab2xyz(t) {
2406   return t > t1 ? t * t * t : t2 * (t - t0);
2407 }
2408
2409 function xyz2rgb(x) {
2410   return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
2411 }
2412
2413 function rgb2xyz(x) {
2414   return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
2415 }
2416
2417 function hclConvert(o) {
2418   if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);
2419   if (!(o instanceof Lab)) o = labConvert(o);
2420   var h = Math.atan2(o.b, o.a) * rad2deg;
2421   return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
2422 }
2423
2424 function hcl(h, c, l, opacity) {
2425   return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
2426 }
2427
2428 function Hcl(h, c, l, opacity) {
2429   this.h = +h;
2430   this.c = +c;
2431   this.l = +l;
2432   this.opacity = +opacity;
2433 }
2434
2435 define(Hcl, hcl, extend(Color, {
2436   brighter: function(k) {
2437     return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity);
2438   },
2439   darker: function(k) {
2440     return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity);
2441   },
2442   rgb: function() {
2443     return labConvert(this).rgb();
2444   }
2445 }));
2446
2447 var A = -0.14861,
2448     B = +1.78277,
2449     C = -0.29227,
2450     D = -0.90649,
2451     E = +1.97294,
2452     ED = E * D,
2453     EB = E * B,
2454     BC_DA = B * C - D * A;
2455
2456 function cubehelixConvert(o) {
2457   if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);
2458   if (!(o instanceof Rgb)) o = rgbConvert(o);
2459   var r = o.r / 255,
2460       g = o.g / 255,
2461       b = o.b / 255,
2462       l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),
2463       bl = b - l,
2464       k = (E * (g - l) - C * bl) / D,
2465       s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1
2466       h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;
2467   return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);
2468 }
2469
2470 function cubehelix(h, s, l, opacity) {
2471   return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);
2472 }
2473
2474 function Cubehelix(h, s, l, opacity) {
2475   this.h = +h;
2476   this.s = +s;
2477   this.l = +l;
2478   this.opacity = +opacity;
2479 }
2480
2481 define(Cubehelix, cubehelix, extend(Color, {
2482   brighter: function(k) {
2483     k = k == null ? brighter : Math.pow(brighter, k);
2484     return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
2485   },
2486   darker: function(k) {
2487     k = k == null ? darker : Math.pow(darker, k);
2488     return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
2489   },
2490   rgb: function() {
2491     var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,
2492         l = +this.l,
2493         a = isNaN(this.s) ? 0 : this.s * l * (1 - l),
2494         cosh = Math.cos(h),
2495         sinh = Math.sin(h);
2496     return new Rgb(
2497       255 * (l + a * (A * cosh + B * sinh)),
2498       255 * (l + a * (C * cosh + D * sinh)),
2499       255 * (l + a * (E * cosh)),
2500       this.opacity
2501     );
2502   }
2503 }));
2504
2505 function basis(t1, v0, v1, v2, v3) {
2506   var t2 = t1 * t1, t3 = t2 * t1;
2507   return ((1 - 3 * t1 + 3 * t2 - t3) * v0
2508       + (4 - 6 * t2 + 3 * t3) * v1
2509       + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2
2510       + t3 * v3) / 6;
2511 }
2512
2513 function basis$1(values) {
2514   var n = values.length - 1;
2515   return function(t) {
2516     var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),
2517         v1 = values[i],
2518         v2 = values[i + 1],
2519         v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,
2520         v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
2521     return basis((t - i / n) * n, v0, v1, v2, v3);
2522   };
2523 }
2524
2525 function basisClosed(values) {
2526   var n = values.length;
2527   return function(t) {
2528     var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),
2529         v0 = values[(i + n - 1) % n],
2530         v1 = values[i % n],
2531         v2 = values[(i + 1) % n],
2532         v3 = values[(i + 2) % n];
2533     return basis((t - i / n) * n, v0, v1, v2, v3);
2534   };
2535 }
2536
2537 function constant$3(x) {
2538   return function() {
2539     return x;
2540   };
2541 }
2542
2543 function linear(a, d) {
2544   return function(t) {
2545     return a + t * d;
2546   };
2547 }
2548
2549 function exponential(a, b, y) {
2550   return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
2551     return Math.pow(a + t * b, y);
2552   };
2553 }
2554
2555 function hue(a, b) {
2556   var d = b - a;
2557   return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);
2558 }
2559
2560 function gamma(y) {
2561   return (y = +y) === 1 ? nogamma : function(a, b) {
2562     return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a);
2563   };
2564 }
2565
2566 function nogamma(a, b) {
2567   var d = b - a;
2568   return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);
2569 }
2570
2571 var d3_interpolateRgb = (function rgbGamma(y) {
2572   var color$$1 = gamma(y);
2573
2574   function rgb$$1(start, end) {
2575     var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r),
2576         g = color$$1(start.g, end.g),
2577         b = color$$1(start.b, end.b),
2578         opacity = nogamma(start.opacity, end.opacity);
2579     return function(t) {
2580       start.r = r(t);
2581       start.g = g(t);
2582       start.b = b(t);
2583       start.opacity = opacity(t);
2584       return start + "";
2585     };
2586   }
2587
2588   rgb$$1.gamma = rgbGamma;
2589
2590   return rgb$$1;
2591 })(1);
2592
2593 function rgbSpline(spline) {
2594   return function(colors) {
2595     var n = colors.length,
2596         r = new Array(n),
2597         g = new Array(n),
2598         b = new Array(n),
2599         i, color$$1;
2600     for (i = 0; i < n; ++i) {
2601       color$$1 = rgb(colors[i]);
2602       r[i] = color$$1.r || 0;
2603       g[i] = color$$1.g || 0;
2604       b[i] = color$$1.b || 0;
2605     }
2606     r = spline(r);
2607     g = spline(g);
2608     b = spline(b);
2609     color$$1.opacity = 1;
2610     return function(t) {
2611       color$$1.r = r(t);
2612       color$$1.g = g(t);
2613       color$$1.b = b(t);
2614       return color$$1 + "";
2615     };
2616   };
2617 }
2618
2619 var rgbBasis = rgbSpline(basis$1);
2620 var rgbBasisClosed = rgbSpline(basisClosed);
2621
2622 function array$1(a, b) {
2623   var nb = b ? b.length : 0,
2624       na = a ? Math.min(nb, a.length) : 0,
2625       x = new Array(na),
2626       c = new Array(nb),
2627       i;
2628
2629   for (i = 0; i < na; ++i) x[i] = d3_interpolate(a[i], b[i]);
2630   for (; i < nb; ++i) c[i] = b[i];
2631
2632   return function(t) {
2633     for (i = 0; i < na; ++i) c[i] = x[i](t);
2634     return c;
2635   };
2636 }
2637
2638 function date(a, b) {
2639   var d = new Date;
2640   return a = +a, b -= a, function(t) {
2641     return d.setTime(a + b * t), d;
2642   };
2643 }
2644
2645 function d3_interpolateNumber(a, b) {
2646   return a = +a, b -= a, function(t) {
2647     return a + b * t;
2648   };
2649 }
2650
2651 function object(a, b) {
2652   var i = {},
2653       c = {},
2654       k;
2655
2656   if (a === null || typeof a !== "object") a = {};
2657   if (b === null || typeof b !== "object") b = {};
2658
2659   for (k in b) {
2660     if (k in a) {
2661       i[k] = d3_interpolate(a[k], b[k]);
2662     } else {
2663       c[k] = b[k];
2664     }
2665   }
2666
2667   return function(t) {
2668     for (k in i) c[k] = i[k](t);
2669     return c;
2670   };
2671 }
2672
2673 var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
2674     reB = new RegExp(reA.source, "g");
2675
2676 function zero(b) {
2677   return function() {
2678     return b;
2679   };
2680 }
2681
2682 function one(b) {
2683   return function(t) {
2684     return b(t) + "";
2685   };
2686 }
2687
2688 function interpolateString(a, b) {
2689   var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b
2690       am, // current match in a
2691       bm, // current match in b
2692       bs, // string preceding current number in b, if any
2693       i = -1, // index in s
2694       s = [], // string constants and placeholders
2695       q = []; // number interpolators
2696
2697   // Coerce inputs to strings.
2698   a = a + "", b = b + "";
2699
2700   // Interpolate pairs of numbers in a & b.
2701   while ((am = reA.exec(a))
2702       && (bm = reB.exec(b))) {
2703     if ((bs = bm.index) > bi) { // a string precedes the next number in b
2704       bs = b.slice(bi, bs);
2705       if (s[i]) s[i] += bs; // coalesce with previous string
2706       else s[++i] = bs;
2707     }
2708     if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match
2709       if (s[i]) s[i] += bm; // coalesce with previous string
2710       else s[++i] = bm;
2711     } else { // interpolate non-matching numbers
2712       s[++i] = null;
2713       q.push({i: i, x: d3_interpolateNumber(am, bm)});
2714     }
2715     bi = reB.lastIndex;
2716   }
2717
2718   // Add remains of b.
2719   if (bi < b.length) {
2720     bs = b.slice(bi);
2721     if (s[i]) s[i] += bs; // coalesce with previous string
2722     else s[++i] = bs;
2723   }
2724
2725   // Special optimization for only a single match.
2726   // Otherwise, interpolate each of the numbers and rejoin the string.
2727   return s.length < 2 ? (q[0]
2728       ? one(q[0].x)
2729       : zero(b))
2730       : (b = q.length, function(t) {
2731           for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
2732           return s.join("");
2733         });
2734 }
2735
2736 function d3_interpolate(a, b) {
2737   var t = typeof b, c;
2738   return b == null || t === "boolean" ? constant$3(b)
2739       : (t === "number" ? d3_interpolateNumber
2740       : t === "string" ? ((c = color(b)) ? (b = c, d3_interpolateRgb) : interpolateString)
2741       : b instanceof color ? d3_interpolateRgb
2742       : b instanceof Date ? date
2743       : Array.isArray(b) ? array$1
2744       : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object
2745       : d3_interpolateNumber)(a, b);
2746 }
2747
2748 function interpolateRound(a, b) {
2749   return a = +a, b -= a, function(t) {
2750     return Math.round(a + b * t);
2751   };
2752 }
2753
2754 var degrees = 180 / Math.PI;
2755
2756 var identity$2 = {
2757   translateX: 0,
2758   translateY: 0,
2759   rotate: 0,
2760   skewX: 0,
2761   scaleX: 1,
2762   scaleY: 1
2763 };
2764
2765 function decompose(a, b, c, d, e, f) {
2766   var scaleX, scaleY, skewX;
2767   if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;
2768   if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;
2769   if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;
2770   if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;
2771   return {
2772     translateX: e,
2773     translateY: f,
2774     rotate: Math.atan2(b, a) * degrees,
2775     skewX: Math.atan(skewX) * degrees,
2776     scaleX: scaleX,
2777     scaleY: scaleY
2778   };
2779 }
2780
2781 var cssNode,
2782     cssRoot,
2783     cssView,
2784     svgNode;
2785
2786 function parseCss(value) {
2787   if (value === "none") return identity$2;
2788   if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView;
2789   cssNode.style.transform = value;
2790   value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform");
2791   cssRoot.removeChild(cssNode);
2792   value = value.slice(7, -1).split(",");
2793   return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);
2794 }
2795
2796 function parseSvg(value) {
2797   if (value == null) return identity$2;
2798   if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
2799   svgNode.setAttribute("transform", value);
2800   if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2;
2801   value = value.matrix;
2802   return decompose(value.a, value.b, value.c, value.d, value.e, value.f);
2803 }
2804
2805 function interpolateTransform(parse, pxComma, pxParen, degParen) {
2806
2807   function pop(s) {
2808     return s.length ? s.pop() + " " : "";
2809   }
2810
2811   function translate(xa, ya, xb, yb, s, q) {
2812     if (xa !== xb || ya !== yb) {
2813       var i = s.push("translate(", null, pxComma, null, pxParen);
2814       q.push({i: i - 4, x: d3_interpolateNumber(xa, xb)}, {i: i - 2, x: d3_interpolateNumber(ya, yb)});
2815     } else if (xb || yb) {
2816       s.push("translate(" + xb + pxComma + yb + pxParen);
2817     }
2818   }
2819
2820   function rotate(a, b, s, q) {
2821     if (a !== b) {
2822       if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path
2823       q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: d3_interpolateNumber(a, b)});
2824     } else if (b) {
2825       s.push(pop(s) + "rotate(" + b + degParen);
2826     }
2827   }
2828
2829   function skewX(a, b, s, q) {
2830     if (a !== b) {
2831       q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: d3_interpolateNumber(a, b)});
2832     } else if (b) {
2833       s.push(pop(s) + "skewX(" + b + degParen);
2834     }
2835   }
2836
2837   function scale(xa, ya, xb, yb, s, q) {
2838     if (xa !== xb || ya !== yb) {
2839       var i = s.push(pop(s) + "scale(", null, ",", null, ")");
2840       q.push({i: i - 4, x: d3_interpolateNumber(xa, xb)}, {i: i - 2, x: d3_interpolateNumber(ya, yb)});
2841     } else if (xb !== 1 || yb !== 1) {
2842       s.push(pop(s) + "scale(" + xb + "," + yb + ")");
2843     }
2844   }
2845
2846   return function(a, b) {
2847     var s = [], // string constants and placeholders
2848         q = []; // number interpolators
2849     a = parse(a), b = parse(b);
2850     translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);
2851     rotate(a.rotate, b.rotate, s, q);
2852     skewX(a.skewX, b.skewX, s, q);
2853     scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);
2854     a = b = null; // gc
2855     return function(t) {
2856       var i = -1, n = q.length, o;
2857       while (++i < n) s[(o = q[i]).i] = o.x(t);
2858       return s.join("");
2859     };
2860   };
2861 }
2862
2863 var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)");
2864 var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
2865
2866 var rho = Math.SQRT2,
2867     rho2 = 2,
2868     rho4 = 4,
2869     epsilon2 = 1e-12;
2870
2871 function cosh(x) {
2872   return ((x = Math.exp(x)) + 1 / x) / 2;
2873 }
2874
2875 function sinh(x) {
2876   return ((x = Math.exp(x)) - 1 / x) / 2;
2877 }
2878
2879 function tanh(x) {
2880   return ((x = Math.exp(2 * x)) - 1) / (x + 1);
2881 }
2882
2883 // p0 = [ux0, uy0, w0]
2884 // p1 = [ux1, uy1, w1]
2885 function interpolateZoom(p0, p1) {
2886   var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],
2887       ux1 = p1[0], uy1 = p1[1], w1 = p1[2],
2888       dx = ux1 - ux0,
2889       dy = uy1 - uy0,
2890       d2 = dx * dx + dy * dy,
2891       i,
2892       S;
2893
2894   // Special case for u0 ≅ u1.
2895   if (d2 < epsilon2) {
2896     S = Math.log(w1 / w0) / rho;
2897     i = function(t) {
2898       return [
2899         ux0 + t * dx,
2900         uy0 + t * dy,
2901         w0 * Math.exp(rho * t * S)
2902       ];
2903     };
2904   }
2905
2906   // General case.
2907   else {
2908     var d1 = Math.sqrt(d2),
2909         b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),
2910         b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),
2911         r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),
2912         r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
2913     S = (r1 - r0) / rho;
2914     i = function(t) {
2915       var s = t * S,
2916           coshr0 = cosh(r0),
2917           u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));
2918       return [
2919         ux0 + u * dx,
2920         uy0 + u * dy,
2921         w0 * coshr0 / cosh(rho * s + r0)
2922       ];
2923     };
2924   }
2925
2926   i.duration = S * 1000;
2927
2928   return i;
2929 }
2930
2931 function hsl$1(hue$$1) {
2932   return function(start, end) {
2933     var h = hue$$1((start = hsl(start)).h, (end = hsl(end)).h),
2934         s = nogamma(start.s, end.s),
2935         l = nogamma(start.l, end.l),
2936         opacity = nogamma(start.opacity, end.opacity);
2937     return function(t) {
2938       start.h = h(t);
2939       start.s = s(t);
2940       start.l = l(t);
2941       start.opacity = opacity(t);
2942       return start + "";
2943     };
2944   }
2945 }
2946
2947 var hsl$2 = hsl$1(hue);
2948 var hslLong = hsl$1(nogamma);
2949
2950 function lab$1(start, end) {
2951   var l = nogamma((start = lab(start)).l, (end = lab(end)).l),
2952       a = nogamma(start.a, end.a),
2953       b = nogamma(start.b, end.b),
2954       opacity = nogamma(start.opacity, end.opacity);
2955   return function(t) {
2956     start.l = l(t);
2957     start.a = a(t);
2958     start.b = b(t);
2959     start.opacity = opacity(t);
2960     return start + "";
2961   };
2962 }
2963
2964 function hcl$1(hue$$1) {
2965   return function(start, end) {
2966     var h = hue$$1((start = hcl(start)).h, (end = hcl(end)).h),
2967         c = nogamma(start.c, end.c),
2968         l = nogamma(start.l, end.l),
2969         opacity = nogamma(start.opacity, end.opacity);
2970     return function(t) {
2971       start.h = h(t);
2972       start.c = c(t);
2973       start.l = l(t);
2974       start.opacity = opacity(t);
2975       return start + "";
2976     };
2977   }
2978 }
2979
2980 var hcl$2 = hcl$1(hue);
2981 var hclLong = hcl$1(nogamma);
2982
2983 function cubehelix$1(hue$$1) {
2984   return (function cubehelixGamma(y) {
2985     y = +y;
2986
2987     function cubehelix$$1(start, end) {
2988       var h = hue$$1((start = cubehelix(start)).h, (end = cubehelix(end)).h),
2989           s = nogamma(start.s, end.s),
2990           l = nogamma(start.l, end.l),
2991           opacity = nogamma(start.opacity, end.opacity);
2992       return function(t) {
2993         start.h = h(t);
2994         start.s = s(t);
2995         start.l = l(Math.pow(t, y));
2996         start.opacity = opacity(t);
2997         return start + "";
2998       };
2999     }
3000
3001     cubehelix$$1.gamma = cubehelixGamma;
3002
3003     return cubehelix$$1;
3004   })(1);
3005 }
3006
3007 var cubehelix$2 = cubehelix$1(hue);
3008 var cubehelixLong = cubehelix$1(nogamma);
3009
3010 function d3_quantize(interpolator, n) {
3011   var samples = new Array(n);
3012   for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));
3013   return samples;
3014 }
3015
3016 var frame = 0, // is an animation frame pending?
3017     timeout = 0, // is a timeout pending?
3018     interval = 0, // are any timers active?
3019     pokeDelay = 1000, // how frequently we check for clock skew
3020     taskHead,
3021     taskTail,
3022     clockLast = 0,
3023     clockNow = 0,
3024     clockSkew = 0,
3025     clock = typeof performance === "object" && performance.now ? performance : Date,
3026     setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); };
3027
3028 function now() {
3029   return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
3030 }
3031
3032 function clearNow() {
3033   clockNow = 0;
3034 }
3035
3036 function Timer() {
3037   this._call =
3038   this._time =
3039   this._next = null;
3040 }
3041
3042 Timer.prototype = timer.prototype = {
3043   constructor: Timer,
3044   restart: function(callback, delay, time) {
3045     if (typeof callback !== "function") throw new TypeError("callback is not a function");
3046     time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
3047     if (!this._next && taskTail !== this) {
3048       if (taskTail) taskTail._next = this;
3049       else taskHead = this;
3050       taskTail = this;
3051     }
3052     this._call = callback;
3053     this._time = time;
3054     sleep();
3055   },
3056   stop: function() {
3057     if (this._call) {
3058       this._call = null;
3059       this._time = Infinity;
3060       sleep();
3061     }
3062   }
3063 };
3064
3065 function timer(callback, delay, time) {
3066   var t = new Timer;
3067   t.restart(callback, delay, time);
3068   return t;
3069 }
3070
3071 function timerFlush() {
3072   now(); // Get the current time, if not already set.
3073   ++frame; // Pretend we’ve set an alarm, if we haven’t already.
3074   var t = taskHead, e;
3075   while (t) {
3076     if ((e = clockNow - t._time) >= 0) t._call.call(null, e);
3077     t = t._next;
3078   }
3079   --frame;
3080 }
3081
3082 function wake() {
3083   clockNow = (clockLast = clock.now()) + clockSkew;
3084   frame = timeout = 0;
3085   try {
3086     timerFlush();
3087   } finally {
3088     frame = 0;
3089     nap();
3090     clockNow = 0;
3091   }
3092 }
3093
3094 function poke() {
3095   var now = clock.now(), delay = now - clockLast;
3096   if (delay > pokeDelay) clockSkew -= delay, clockLast = now;
3097 }
3098
3099 function nap() {
3100   var t0, t1 = taskHead, t2, time = Infinity;
3101   while (t1) {
3102     if (t1._call) {
3103       if (time > t1._time) time = t1._time;
3104       t0 = t1, t1 = t1._next;
3105     } else {
3106       t2 = t1._next, t1._next = null;
3107       t1 = t0 ? t0._next = t2 : taskHead = t2;
3108     }
3109   }
3110   taskTail = t0;
3111   sleep(time);
3112 }
3113
3114 function sleep(time) {
3115   if (frame) return; // Soonest alarm already set, or will be.
3116   if (timeout) timeout = clearTimeout(timeout);
3117   var delay = time - clockNow; // Strictly less than if we recomputed clockNow.
3118   if (delay > 24) {
3119     if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);
3120     if (interval) interval = clearInterval(interval);
3121   } else {
3122     if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
3123     frame = 1, setFrame(wake);
3124   }
3125 }
3126
3127 function d3_timeout(callback, delay, time) {
3128   var t = new Timer;
3129   delay = delay == null ? 0 : +delay;
3130   t.restart(function(elapsed) {
3131     t.stop();
3132     callback(elapsed + delay);
3133   }, delay, time);
3134   return t;
3135 }
3136
3137 function interval$1(callback, delay, time) {
3138   var t = new Timer, total = delay;
3139   if (delay == null) return t.restart(callback, delay, time), t;
3140   delay = +delay, time = time == null ? now() : +time;
3141   t.restart(function tick(elapsed) {
3142     elapsed += total;
3143     t.restart(tick, total += delay, time);
3144     callback(elapsed);
3145   }, delay, time);
3146   return t;
3147 }
3148
3149 var emptyOn = dispatch("start", "end", "interrupt");
3150 var emptyTween = [];
3151
3152 var CREATED = 0;
3153 var SCHEDULED = 1;
3154 var STARTING = 2;
3155 var STARTED = 3;
3156 var RUNNING = 4;
3157 var ENDING = 5;
3158 var ENDED = 6;
3159
3160 function schedule(node, name, id, index, group, timing) {
3161   var schedules = node.__transition;
3162   if (!schedules) node.__transition = {};
3163   else if (id in schedules) return;
3164   create$1(node, id, {
3165     name: name,
3166     index: index, // For context during callback.
3167     group: group, // For context during callback.
3168     on: emptyOn,
3169     tween: emptyTween,
3170     time: timing.time,
3171     delay: timing.delay,
3172     duration: timing.duration,
3173     ease: timing.ease,
3174     timer: null,
3175     state: CREATED
3176   });
3177 }
3178
3179 function init(node, id) {
3180   var schedule = get$1(node, id);
3181   if (schedule.state > CREATED) throw new Error("too late; already scheduled");
3182   return schedule;
3183 }
3184
3185 function set$1(node, id) {
3186   var schedule = get$1(node, id);
3187   if (schedule.state > STARTING) throw new Error("too late; already started");
3188   return schedule;
3189 }
3190
3191 function get$1(node, id) {
3192   var schedule = node.__transition;
3193   if (!schedule || !(schedule = schedule[id])) throw new Error("transition not found");
3194   return schedule;
3195 }
3196
3197 function create$1(node, id, self) {
3198   var schedules = node.__transition,
3199       tween;
3200
3201   // Initialize the self timer when the transition is created.
3202   // Note the actual delay is not known until the first callback!
3203   schedules[id] = self;
3204   self.timer = timer(schedule, 0, self.time);
3205
3206   function schedule(elapsed) {
3207     self.state = SCHEDULED;
3208     self.timer.restart(start, self.delay, self.time);
3209
3210     // If the elapsed delay is less than our first sleep, start immediately.
3211     if (self.delay <= elapsed) start(elapsed - self.delay);
3212   }
3213
3214   function start(elapsed) {
3215     var i, j, n, o;
3216
3217     // If the state is not SCHEDULED, then we previously errored on start.
3218     if (self.state !== SCHEDULED) return stop();
3219
3220     for (i in schedules) {
3221       o = schedules[i];
3222       if (o.name !== self.name) continue;
3223
3224       // While this element already has a starting transition during this frame,
3225       // defer starting an interrupting transition until that transition has a
3226       // chance to tick (and possibly end); see d3/d3-transition#54!
3227       if (o.state === STARTED) return d3_timeout(start);
3228
3229       // Interrupt the active transition, if any.
3230       // Dispatch the interrupt event.
3231       if (o.state === RUNNING) {
3232         o.state = ENDED;
3233         o.timer.stop();
3234         o.on.call("interrupt", node, node.__data__, o.index, o.group);
3235         delete schedules[i];
3236       }
3237
3238       // Cancel any pre-empted transitions. No interrupt event is dispatched
3239       // because the cancelled transitions never started. Note that this also
3240       // removes this transition from the pending list!
3241       else if (+i < id) {
3242         o.state = ENDED;
3243         o.timer.stop();
3244         delete schedules[i];
3245       }
3246     }
3247
3248     // Defer the first tick to end of the current frame; see d3/d3#1576.
3249     // Note the transition may be canceled after start and before the first tick!
3250     // Note this must be scheduled before the start event; see d3/d3-transition#16!
3251     // Assuming this is successful, subsequent callbacks go straight to tick.
3252     d3_timeout(function() {
3253       if (self.state === STARTED) {
3254         self.state = RUNNING;
3255         self.timer.restart(tick, self.delay, self.time);
3256         tick(elapsed);
3257       }
3258     });
3259
3260     // Dispatch the start event.
3261     // Note this must be done before the tween are initialized.
3262     self.state = STARTING;
3263     self.on.call("start", node, node.__data__, self.index, self.group);
3264     if (self.state !== STARTING) return; // interrupted
3265     self.state = STARTED;
3266
3267     // Initialize the tween, deleting null tween.
3268     tween = new Array(n = self.tween.length);
3269     for (i = 0, j = -1; i < n; ++i) {
3270       if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {
3271         tween[++j] = o;
3272       }
3273     }
3274     tween.length = j + 1;
3275   }
3276
3277   function tick(elapsed) {
3278     var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1),
3279         i = -1,
3280         n = tween.length;
3281
3282     while (++i < n) {
3283       tween[i].call(null, t);
3284     }
3285
3286     // Dispatch the end event.
3287     if (self.state === ENDING) {
3288       self.on.call("end", node, node.__data__, self.index, self.group);
3289       stop();
3290     }
3291   }
3292
3293   function stop() {
3294     self.state = ENDED;
3295     self.timer.stop();
3296     delete schedules[id];
3297     for (var i in schedules) return; // eslint-disable-line no-unused-vars
3298     delete node.__transition;
3299   }
3300 }
3301
3302 function interrupt(node, name) {
3303   var schedules = node.__transition,
3304       schedule$$1,
3305       active,
3306       empty = true,
3307       i;
3308
3309   if (!schedules) return;
3310
3311   name = name == null ? null : name + "";
3312
3313   for (i in schedules) {
3314     if ((schedule$$1 = schedules[i]).name !== name) { empty = false; continue; }
3315     active = schedule$$1.state > STARTING && schedule$$1.state < ENDING;
3316     schedule$$1.state = ENDED;
3317     schedule$$1.timer.stop();
3318     if (active) schedule$$1.on.call("interrupt", node, node.__data__, schedule$$1.index, schedule$$1.group);
3319     delete schedules[i];
3320   }
3321
3322   if (empty) delete node.__transition;
3323 }
3324
3325 function selection_interrupt(name) {
3326   return this.each(function() {
3327     interrupt(this, name);
3328   });
3329 }
3330
3331 function tweenRemove(id, name) {
3332   var tween0, tween1;
3333   return function() {
3334     var schedule$$1 = set$1(this, id),
3335         tween = schedule$$1.tween;
3336
3337     // If this node shared tween with the previous node,
3338     // just assign the updated shared tween and we’re done!
3339     // Otherwise, copy-on-write.
3340     if (tween !== tween0) {
3341       tween1 = tween0 = tween;
3342       for (var i = 0, n = tween1.length; i < n; ++i) {
3343         if (tween1[i].name === name) {
3344           tween1 = tween1.slice();
3345           tween1.splice(i, 1);
3346           break;
3347         }
3348       }
3349     }
3350
3351     schedule$$1.tween = tween1;
3352   };
3353 }
3354
3355 function tweenFunction(id, name, value) {
3356   var tween0, tween1;
3357   if (typeof value !== "function") throw new Error;
3358   return function() {
3359     var schedule$$1 = set$1(this, id),
3360         tween = schedule$$1.tween;
3361
3362     // If this node shared tween with the previous node,
3363     // just assign the updated shared tween and we’re done!
3364     // Otherwise, copy-on-write.
3365     if (tween !== tween0) {
3366       tween1 = (tween0 = tween).slice();
3367       for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) {
3368         if (tween1[i].name === name) {
3369           tween1[i] = t;
3370           break;
3371         }
3372       }
3373       if (i === n) tween1.push(t);
3374     }
3375
3376     schedule$$1.tween = tween1;
3377   };
3378 }
3379
3380 function transition_tween(name, value) {
3381   var id = this._id;
3382
3383   name += "";
3384
3385   if (arguments.length < 2) {
3386     var tween = get$1(this.node(), id).tween;
3387     for (var i = 0, n = tween.length, t; i < n; ++i) {
3388       if ((t = tween[i]).name === name) {
3389         return t.value;
3390       }
3391     }
3392     return null;
3393   }
3394
3395   return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));
3396 }
3397
3398 function tweenValue(transition, name, value) {
3399   var id = transition._id;
3400
3401   transition.each(function() {
3402     var schedule$$1 = set$1(this, id);
3403     (schedule$$1.value || (schedule$$1.value = {}))[name] = value.apply(this, arguments);
3404   });
3405
3406   return function(node) {
3407     return get$1(node, id).value[name];
3408   };
3409 }
3410
3411 function interpolate(a, b) {
3412   var c;
3413   return (typeof b === "number" ? d3_interpolateNumber
3414       : b instanceof color ? d3_interpolateRgb
3415       : (c = color(b)) ? (b = c, d3_interpolateRgb)
3416       : interpolateString)(a, b);
3417 }
3418
3419 function attrRemove$1(name) {
3420   return function() {
3421     this.removeAttribute(name);
3422   };
3423 }
3424
3425 function attrRemoveNS$1(fullname) {
3426   return function() {
3427     this.removeAttributeNS(fullname.space, fullname.local);
3428   };
3429 }
3430
3431 function attrConstant$1(name, interpolate$$1, value1) {
3432   var value00,
3433       interpolate0;
3434   return function() {
3435     var value0 = this.getAttribute(name);
3436     return value0 === value1 ? null
3437         : value0 === value00 ? interpolate0
3438         : interpolate0 = interpolate$$1(value00 = value0, value1);
3439   };
3440 }
3441
3442 function attrConstantNS$1(fullname, interpolate$$1, value1) {
3443   var value00,
3444       interpolate0;
3445   return function() {
3446     var value0 = this.getAttributeNS(fullname.space, fullname.local);
3447     return value0 === value1 ? null
3448         : value0 === value00 ? interpolate0
3449         : interpolate0 = interpolate$$1(value00 = value0, value1);
3450   };
3451 }
3452
3453 function attrFunction$1(name, interpolate$$1, value) {
3454   var value00,
3455       value10,
3456       interpolate0;
3457   return function() {
3458     var value0, value1 = value(this);
3459     if (value1 == null) return void this.removeAttribute(name);
3460     value0 = this.getAttribute(name);
3461     return value0 === value1 ? null
3462         : value0 === value00 && value1 === value10 ? interpolate0
3463         : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);
3464   };
3465 }
3466
3467 function attrFunctionNS$1(fullname, interpolate$$1, value) {
3468   var value00,
3469       value10,
3470       interpolate0;
3471   return function() {
3472     var value0, value1 = value(this);
3473     if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);
3474     value0 = this.getAttributeNS(fullname.space, fullname.local);
3475     return value0 === value1 ? null
3476         : value0 === value00 && value1 === value10 ? interpolate0
3477         : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);
3478   };
3479 }
3480
3481 function transition_attr(name, value) {
3482   var fullname = namespace(name), i = fullname === "transform" ? interpolateTransformSvg : interpolate;
3483   return this.attrTween(name, typeof value === "function"
3484       ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, "attr." + name, value))
3485       : value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname)
3486       : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value + ""));
3487 }
3488
3489 function attrTweenNS(fullname, value) {
3490   function tween() {
3491     var node = this, i = value.apply(node, arguments);
3492     return i && function(t) {
3493       node.setAttributeNS(fullname.space, fullname.local, i(t));
3494     };
3495   }
3496   tween._value = value;
3497   return tween;
3498 }
3499
3500 function attrTween(name, value) {
3501   function tween() {
3502     var node = this, i = value.apply(node, arguments);
3503     return i && function(t) {
3504       node.setAttribute(name, i(t));
3505     };
3506   }
3507   tween._value = value;
3508   return tween;
3509 }
3510
3511 function transition_attrTween(name, value) {
3512   var key = "attr." + name;
3513   if (arguments.length < 2) return (key = this.tween(key)) && key._value;
3514   if (value == null) return this.tween(key, null);
3515   if (typeof value !== "function") throw new Error;
3516   var fullname = namespace(name);
3517   return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));
3518 }
3519
3520 function delayFunction(id, value) {
3521   return function() {
3522     init(this, id).delay = +value.apply(this, arguments);
3523   };
3524 }
3525
3526 function delayConstant(id, value) {
3527   return value = +value, function() {
3528     init(this, id).delay = value;
3529   };
3530 }
3531
3532 function transition_delay(value) {
3533   var id = this._id;
3534
3535   return arguments.length
3536       ? this.each((typeof value === "function"
3537           ? delayFunction
3538           : delayConstant)(id, value))
3539       : get$1(this.node(), id).delay;
3540 }
3541
3542 function durationFunction(id, value) {
3543   return function() {
3544     set$1(this, id).duration = +value.apply(this, arguments);
3545   };
3546 }
3547
3548 function durationConstant(id, value) {
3549   return value = +value, function() {
3550     set$1(this, id).duration = value;
3551   };
3552 }
3553
3554 function transition_duration(value) {
3555   var id = this._id;
3556
3557   return arguments.length
3558       ? this.each((typeof value === "function"
3559           ? durationFunction
3560           : durationConstant)(id, value))
3561       : get$1(this.node(), id).duration;
3562 }
3563
3564 function easeConstant(id, value) {
3565   if (typeof value !== "function") throw new Error;
3566   return function() {
3567     set$1(this, id).ease = value;
3568   };
3569 }
3570
3571 function transition_ease(value) {
3572   var id = this._id;
3573
3574   return arguments.length
3575       ? this.each(easeConstant(id, value))
3576       : get$1(this.node(), id).ease;
3577 }
3578
3579 function transition_filter(match) {
3580   if (typeof match !== "function") match = matcher$1(match);
3581
3582   for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
3583     for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
3584       if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
3585         subgroup.push(node);
3586       }
3587     }
3588   }
3589
3590   return new Transition(subgroups, this._parents, this._name, this._id);
3591 }
3592
3593 function transition_merge(transition$$1) {
3594   if (transition$$1._id !== this._id) throw new Error;
3595
3596   for (var groups0 = this._groups, groups1 = transition$$1._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
3597     for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
3598       if (node = group0[i] || group1[i]) {
3599         merge[i] = node;
3600       }
3601     }
3602   }
3603
3604   for (; j < m0; ++j) {
3605     merges[j] = groups0[j];
3606   }
3607
3608   return new Transition(merges, this._parents, this._name, this._id);
3609 }
3610
3611 function start(name) {
3612   return (name + "").trim().split(/^|\s+/).every(function(t) {
3613     var i = t.indexOf(".");
3614     if (i >= 0) t = t.slice(0, i);
3615     return !t || t === "start";
3616   });
3617 }
3618
3619 function onFunction(id, name, listener) {
3620   var on0, on1, sit = start(name) ? init : set$1;
3621   return function() {
3622     var schedule$$1 = sit(this, id),
3623         on = schedule$$1.on;
3624
3625     // If this node shared a dispatch with the previous node,
3626     // just assign the updated shared dispatch and we’re done!
3627     // Otherwise, copy-on-write.
3628     if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);
3629
3630     schedule$$1.on = on1;
3631   };
3632 }
3633
3634 function transition_on(name, listener) {
3635   var id = this._id;
3636
3637   return arguments.length < 2
3638       ? get$1(this.node(), id).on.on(name)
3639       : this.each(onFunction(id, name, listener));
3640 }
3641
3642 function removeFunction(id) {
3643   return function() {
3644     var parent = this.parentNode;
3645     for (var i in this.__transition) if (+i !== id) return;
3646     if (parent) parent.removeChild(this);
3647   };
3648 }
3649
3650 function transition_remove() {
3651   return this.on("end.remove", removeFunction(this._id));
3652 }
3653
3654 function transition_select(select) {
3655   var name = this._name,
3656       id = this._id;
3657
3658   if (typeof select !== "function") select = selector(select);
3659
3660   for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
3661     for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
3662       if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
3663         if ("__data__" in node) subnode.__data__ = node.__data__;
3664         subgroup[i] = subnode;
3665         schedule(subgroup[i], name, id, i, subgroup, get$1(node, id));
3666       }
3667     }
3668   }
3669
3670   return new Transition(subgroups, this._parents, name, id);
3671 }
3672
3673 function transition_selectAll(select) {
3674   var name = this._name,
3675       id = this._id;
3676
3677   if (typeof select !== "function") select = selectorAll(select);
3678
3679   for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
3680     for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
3681       if (node = group[i]) {
3682         for (var children = select.call(node, node.__data__, i, group), child, inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k) {
3683           if (child = children[k]) {
3684             schedule(child, name, id, k, children, inherit);
3685           }
3686         }
3687         subgroups.push(children);
3688         parents.push(node);
3689       }
3690     }
3691   }
3692
3693   return new Transition(subgroups, parents, name, id);
3694 }
3695
3696 var Selection$1 = selection.prototype.constructor;
3697
3698 function transition_selection() {
3699   return new Selection$1(this._groups, this._parents);
3700 }
3701
3702 function styleRemove$1(name, interpolate$$1) {
3703   var value00,
3704       value10,
3705       interpolate0;
3706   return function() {
3707     var value0 = styleValue(this, name),
3708         value1 = (this.style.removeProperty(name), styleValue(this, name));
3709     return value0 === value1 ? null
3710         : value0 === value00 && value1 === value10 ? interpolate0
3711         : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);
3712   };
3713 }
3714
3715 function styleRemoveEnd(name) {
3716   return function() {
3717     this.style.removeProperty(name);
3718   };
3719 }
3720
3721 function styleConstant$1(name, interpolate$$1, value1) {
3722   var value00,
3723       interpolate0;
3724   return function() {
3725     var value0 = styleValue(this, name);
3726     return value0 === value1 ? null
3727         : value0 === value00 ? interpolate0
3728         : interpolate0 = interpolate$$1(value00 = value0, value1);
3729   };
3730 }
3731
3732 function styleFunction$1(name, interpolate$$1, value) {
3733   var value00,
3734       value10,
3735       interpolate0;
3736   return function() {
3737     var value0 = styleValue(this, name),
3738         value1 = value(this);
3739     if (value1 == null) value1 = (this.style.removeProperty(name), styleValue(this, name));
3740     return value0 === value1 ? null
3741         : value0 === value00 && value1 === value10 ? interpolate0
3742         : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);
3743   };
3744 }
3745
3746 function transition_style(name, value, priority) {
3747   var i = (name += "") === "transform" ? interpolateTransformCss : interpolate;
3748   return value == null ? this
3749           .styleTween(name, styleRemove$1(name, i))
3750           .on("end.style." + name, styleRemoveEnd(name))
3751       : this.styleTween(name, typeof value === "function"
3752           ? styleFunction$1(name, i, tweenValue(this, "style." + name, value))
3753           : styleConstant$1(name, i, value + ""), priority);
3754 }
3755
3756 function styleTween(name, value, priority) {
3757   function tween() {
3758     var node = this, i = value.apply(node, arguments);
3759     return i && function(t) {
3760       node.style.setProperty(name, i(t), priority);
3761     };
3762   }
3763   tween._value = value;
3764   return tween;
3765 }
3766
3767 function transition_styleTween(name, value, priority) {
3768   var key = "style." + (name += "");
3769   if (arguments.length < 2) return (key = this.tween(key)) && key._value;
3770   if (value == null) return this.tween(key, null);
3771   if (typeof value !== "function") throw new Error;
3772   return this.tween(key, styleTween(name, value, priority == null ? "" : priority));
3773 }
3774
3775 function textConstant$1(value) {
3776   return function() {
3777     this.textContent = value;
3778   };
3779 }
3780
3781 function textFunction$1(value) {
3782   return function() {
3783     var value1 = value(this);
3784     this.textContent = value1 == null ? "" : value1;
3785   };
3786 }
3787
3788 function transition_text(value) {
3789   return this.tween("text", typeof value === "function"
3790       ? textFunction$1(tweenValue(this, "text", value))
3791       : textConstant$1(value == null ? "" : value + ""));
3792 }
3793
3794 function transition_transition() {
3795   var name = this._name,
3796       id0 = this._id,
3797       id1 = newId();
3798
3799   for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
3800     for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
3801       if (node = group[i]) {
3802         var inherit = get$1(node, id0);
3803         schedule(node, name, id1, i, group, {
3804           time: inherit.time + inherit.delay + inherit.duration,
3805           delay: 0,
3806           duration: inherit.duration,
3807           ease: inherit.ease
3808         });
3809       }
3810     }
3811   }
3812
3813   return new Transition(groups, this._parents, name, id1);
3814 }
3815
3816 var id = 0;
3817
3818 function Transition(groups, parents, name, id) {
3819   this._groups = groups;
3820   this._parents = parents;
3821   this._name = name;
3822   this._id = id;
3823 }
3824
3825 function transition(name) {
3826   return selection().transition(name);
3827 }
3828
3829 function newId() {
3830   return ++id;
3831 }
3832
3833 var selection_prototype = selection.prototype;
3834
3835 Transition.prototype = transition.prototype = {
3836   constructor: Transition,
3837   select: transition_select,
3838   selectAll: transition_selectAll,
3839   filter: transition_filter,
3840   merge: transition_merge,
3841   selection: transition_selection,
3842   transition: transition_transition,
3843   call: selection_prototype.call,
3844   nodes: selection_prototype.nodes,
3845   node: selection_prototype.node,
3846   size: selection_prototype.size,
3847   empty: selection_prototype.empty,
3848   each: selection_prototype.each,
3849   on: transition_on,
3850   attr: transition_attr,
3851   attrTween: transition_attrTween,
3852   style: transition_style,
3853   styleTween: transition_styleTween,
3854   text: transition_text,
3855   remove: transition_remove,
3856   tween: transition_tween,
3857   delay: transition_delay,
3858   duration: transition_duration,
3859   ease: transition_ease
3860 };
3861
3862 function linear$1(t) {
3863   return +t;
3864 }
3865
3866 function quadIn(t) {
3867   return t * t;
3868 }
3869
3870 function quadOut(t) {
3871   return t * (2 - t);
3872 }
3873
3874 function quadInOut(t) {
3875   return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;
3876 }
3877
3878 function cubicIn(t) {
3879   return t * t * t;
3880 }
3881
3882 function cubicOut(t) {
3883   return --t * t * t + 1;
3884 }
3885
3886 function cubicInOut(t) {
3887   return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
3888 }
3889
3890 var exponent = 3;
3891
3892 var polyIn = (function custom(e) {
3893   e = +e;
3894
3895   function polyIn(t) {
3896     return Math.pow(t, e);
3897   }
3898
3899   polyIn.exponent = custom;
3900
3901   return polyIn;
3902 })(exponent);
3903
3904 var polyOut = (function custom(e) {
3905   e = +e;
3906
3907   function polyOut(t) {
3908     return 1 - Math.pow(1 - t, e);
3909   }
3910
3911   polyOut.exponent = custom;
3912
3913   return polyOut;
3914 })(exponent);
3915
3916 var polyInOut = (function custom(e) {
3917   e = +e;
3918
3919   function polyInOut(t) {
3920     return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;
3921   }
3922
3923   polyInOut.exponent = custom;
3924
3925   return polyInOut;
3926 })(exponent);
3927
3928 var pi = Math.PI,
3929     halfPi = pi / 2;
3930
3931 function sinIn(t) {
3932   return 1 - Math.cos(t * halfPi);
3933 }
3934
3935 function sinOut(t) {
3936   return Math.sin(t * halfPi);
3937 }
3938
3939 function sinInOut(t) {
3940   return (1 - Math.cos(pi * t)) / 2;
3941 }
3942
3943 function expIn(t) {
3944   return Math.pow(2, 10 * t - 10);
3945 }
3946
3947 function expOut(t) {
3948   return 1 - Math.pow(2, -10 * t);
3949 }
3950
3951 function expInOut(t) {
3952   return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2;
3953 }
3954
3955 function circleIn(t) {
3956   return 1 - Math.sqrt(1 - t * t);
3957 }
3958
3959 function circleOut(t) {
3960   return Math.sqrt(1 - --t * t);
3961 }
3962
3963 function circleInOut(t) {
3964   return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2;
3965 }
3966
3967 var b1 = 4 / 11,
3968     b2 = 6 / 11,
3969     b3 = 8 / 11,
3970     b4 = 3 / 4,
3971     b5 = 9 / 11,
3972     b6 = 10 / 11,
3973     b7 = 15 / 16,
3974     b8 = 21 / 22,
3975     b9 = 63 / 64,
3976     b0 = 1 / b1 / b1;
3977
3978 function bounceIn(t) {
3979   return 1 - bounceOut(1 - t);
3980 }
3981
3982 function bounceOut(t) {
3983   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;
3984 }
3985
3986 function bounceInOut(t) {
3987   return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;
3988 }
3989
3990 var overshoot = 1.70158;
3991
3992 var backIn = (function custom(s) {
3993   s = +s;
3994
3995   function backIn(t) {
3996     return t * t * ((s + 1) * t - s);
3997   }
3998
3999   backIn.overshoot = custom;
4000
4001   return backIn;
4002 })(overshoot);
4003
4004 var backOut = (function custom(s) {
4005   s = +s;
4006
4007   function backOut(t) {
4008     return --t * t * ((s + 1) * t + s) + 1;
4009   }
4010
4011   backOut.overshoot = custom;
4012
4013   return backOut;
4014 })(overshoot);
4015
4016 var backInOut = (function custom(s) {
4017   s = +s;
4018
4019   function backInOut(t) {
4020     return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;
4021   }
4022
4023   backInOut.overshoot = custom;
4024
4025   return backInOut;
4026 })(overshoot);
4027
4028 var tau = 2 * Math.PI,
4029     amplitude = 1,
4030     period = 0.3;
4031
4032 var elasticIn = (function custom(a, p) {
4033   var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);
4034
4035   function elasticIn(t) {
4036     return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p);
4037   }
4038
4039   elasticIn.amplitude = function(a) { return custom(a, p * tau); };
4040   elasticIn.period = function(p) { return custom(a, p); };
4041
4042   return elasticIn;
4043 })(amplitude, period);
4044
4045 var elasticOut = (function custom(a, p) {
4046   var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);
4047
4048   function elasticOut(t) {
4049     return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p);
4050   }
4051
4052   elasticOut.amplitude = function(a) { return custom(a, p * tau); };
4053   elasticOut.period = function(p) { return custom(a, p); };
4054
4055   return elasticOut;
4056 })(amplitude, period);
4057
4058 var elasticInOut = (function custom(a, p) {
4059   var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);
4060
4061   function elasticInOut(t) {
4062     return ((t = t * 2 - 1) < 0
4063         ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p)
4064         : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2;
4065   }
4066
4067   elasticInOut.amplitude = function(a) { return custom(a, p * tau); };
4068   elasticInOut.period = function(p) { return custom(a, p); };
4069
4070   return elasticInOut;
4071 })(amplitude, period);
4072
4073 var defaultTiming = {
4074   time: null, // Set on use.
4075   delay: 0,
4076   duration: 250,
4077   ease: cubicInOut
4078 };
4079
4080 function inherit(node, id) {
4081   var timing;
4082   while (!(timing = node.__transition) || !(timing = timing[id])) {
4083     if (!(node = node.parentNode)) {
4084       return defaultTiming.time = now(), defaultTiming;
4085     }
4086   }
4087   return timing;
4088 }
4089
4090 function selection_transition(name) {
4091   var id,
4092       timing;
4093
4094   if (name instanceof Transition) {
4095     id = name._id, name = name._name;
4096   } else {
4097     id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + "";
4098   }
4099
4100   for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
4101     for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
4102       if (node = group[i]) {
4103         schedule(node, name, id, i, group, timing || inherit(node, id));
4104       }
4105     }
4106   }
4107
4108   return new Transition(groups, this._parents, name, id);
4109 }
4110
4111 selection.prototype.interrupt = selection_interrupt;
4112 selection.prototype.transition = selection_transition;
4113
4114 var root$1 = [null];
4115
4116 function active(node, name) {
4117   var schedules = node.__transition,
4118       schedule$$1,
4119       i;
4120
4121   if (schedules) {
4122     name = name == null ? null : name + "";
4123     for (i in schedules) {
4124       if ((schedule$$1 = schedules[i]).state > SCHEDULED && schedule$$1.name === name) {
4125         return new Transition([[node]], root$1, name, +i);
4126       }
4127     }
4128   }
4129
4130   return null;
4131 }
4132
4133 function constant$4(x) {
4134   return function() {
4135     return x;
4136   };
4137 }
4138
4139 function BrushEvent(target, type, selection) {
4140   this.target = target;
4141   this.type = type;
4142   this.selection = selection;
4143 }
4144
4145 function nopropagation$1() {
4146   event.stopImmediatePropagation();
4147 }
4148
4149 function noevent$1() {
4150   event.preventDefault();
4151   event.stopImmediatePropagation();
4152 }
4153
4154 var MODE_DRAG = {name: "drag"},
4155     MODE_SPACE = {name: "space"},
4156     MODE_HANDLE = {name: "handle"},
4157     MODE_CENTER = {name: "center"};
4158
4159 var X = {
4160   name: "x",
4161   handles: ["e", "w"].map(type),
4162   input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; },
4163   output: function(xy) { return xy && [xy[0][0], xy[1][0]]; }
4164 };
4165
4166 var Y = {
4167   name: "y",
4168   handles: ["n", "s"].map(type),
4169   input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; },
4170   output: function(xy) { return xy && [xy[0][1], xy[1][1]]; }
4171 };
4172
4173 var XY = {
4174   name: "xy",
4175   handles: ["n", "e", "s", "w", "nw", "ne", "se", "sw"].map(type),
4176   input: function(xy) { return xy; },
4177   output: function(xy) { return xy; }
4178 };
4179
4180 var cursors = {
4181   overlay: "crosshair",
4182   selection: "move",
4183   n: "ns-resize",
4184   e: "ew-resize",
4185   s: "ns-resize",
4186   w: "ew-resize",
4187   nw: "nwse-resize",
4188   ne: "nesw-resize",
4189   se: "nwse-resize",
4190   sw: "nesw-resize"
4191 };
4192
4193 var flipX = {
4194   e: "w",
4195   w: "e",
4196   nw: "ne",
4197   ne: "nw",
4198   se: "sw",
4199   sw: "se"
4200 };
4201
4202 var flipY = {
4203   n: "s",
4204   s: "n",
4205   nw: "sw",
4206   ne: "se",
4207   se: "ne",
4208   sw: "nw"
4209 };
4210
4211 var signsX = {
4212   overlay: +1,
4213   selection: +1,
4214   n: null,
4215   e: +1,
4216   s: null,
4217   w: -1,
4218   nw: -1,
4219   ne: +1,
4220   se: +1,
4221   sw: -1
4222 };
4223
4224 var signsY = {
4225   overlay: +1,
4226   selection: +1,
4227   n: -1,
4228   e: null,
4229   s: +1,
4230   w: null,
4231   nw: -1,
4232   ne: -1,
4233   se: +1,
4234   sw: +1
4235 };
4236
4237 function type(t) {
4238   return {type: t};
4239 }
4240
4241 // Ignore right-click, since that should open the context menu.
4242 function defaultFilter$1() {
4243   return !event.button;
4244 }
4245
4246 function defaultExtent() {
4247   var svg = this.ownerSVGElement || this;
4248   return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]];
4249 }
4250
4251 // Like d3.local, but with the name “__brush” rather than auto-generated.
4252 function local$1(node) {
4253   while (!node.__brush) if (!(node = node.parentNode)) return;
4254   return node.__brush;
4255 }
4256
4257 function empty$1(extent) {
4258   return extent[0][0] === extent[1][0]
4259       || extent[0][1] === extent[1][1];
4260 }
4261
4262 function brushSelection(node) {
4263   var state = node.__brush;
4264   return state ? state.dim.output(state.selection) : null;
4265 }
4266
4267 function brushX() {
4268   return brush$1(X);
4269 }
4270
4271 function brushY() {
4272   return brush$1(Y);
4273 }
4274
4275 function brush() {
4276   return brush$1(XY);
4277 }
4278
4279 function brush$1(dim) {
4280   var extent = defaultExtent,
4281       filter = defaultFilter$1,
4282       listeners = dispatch(brush, "start", "brush", "end"),
4283       handleSize = 6,
4284       touchending;
4285
4286   function brush(group) {
4287     var overlay = group
4288         .property("__brush", initialize)
4289       .selectAll(".overlay")
4290       .data([type("overlay")]);
4291
4292     overlay.enter().append("rect")
4293         .attr("class", "overlay")
4294         .attr("pointer-events", "all")
4295         .attr("cursor", cursors.overlay)
4296       .merge(overlay)
4297         .each(function() {
4298           var extent = local$1(this).extent;
4299           d3_select(this)
4300               .attr("x", extent[0][0])
4301               .attr("y", extent[0][1])
4302               .attr("width", extent[1][0] - extent[0][0])
4303               .attr("height", extent[1][1] - extent[0][1]);
4304         });
4305
4306     group.selectAll(".selection")
4307       .data([type("selection")])
4308       .enter().append("rect")
4309         .attr("class", "selection")
4310         .attr("cursor", cursors.selection)
4311         .attr("fill", "#777")
4312         .attr("fill-opacity", 0.3)
4313         .attr("stroke", "#fff")
4314         .attr("shape-rendering", "crispEdges");
4315
4316     var handle = group.selectAll(".handle")
4317       .data(dim.handles, function(d) { return d.type; });
4318
4319     handle.exit().remove();
4320
4321     handle.enter().append("rect")
4322         .attr("class", function(d) { return "handle handle--" + d.type; })
4323         .attr("cursor", function(d) { return cursors[d.type]; });
4324
4325     group
4326         .each(redraw)
4327         .attr("fill", "none")
4328         .attr("pointer-events", "all")
4329         .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)")
4330         .on("mousedown.brush touchstart.brush", started);
4331   }
4332
4333   brush.move = function(group, selection$$1) {
4334     if (group.selection) {
4335       group
4336           .on("start.brush", function() { emitter(this, arguments).beforestart().start(); })
4337           .on("interrupt.brush end.brush", function() { emitter(this, arguments).end(); })
4338           .tween("brush", function() {
4339             var that = this,
4340                 state = that.__brush,
4341                 emit = emitter(that, arguments),
4342                 selection0 = state.selection,
4343                 selection1 = dim.input(typeof selection$$1 === "function" ? selection$$1.apply(this, arguments) : selection$$1, state.extent),
4344                 i = d3_interpolate(selection0, selection1);
4345
4346             function tween(t) {
4347               state.selection = t === 1 && empty$1(selection1) ? null : i(t);
4348               redraw.call(that);
4349               emit.brush();
4350             }
4351
4352             return selection0 && selection1 ? tween : tween(1);
4353           });
4354     } else {
4355       group
4356           .each(function() {
4357             var that = this,
4358                 args = arguments,
4359                 state = that.__brush,
4360                 selection1 = dim.input(typeof selection$$1 === "function" ? selection$$1.apply(that, args) : selection$$1, state.extent),
4361                 emit = emitter(that, args).beforestart();
4362
4363             interrupt(that);
4364             state.selection = selection1 == null || empty$1(selection1) ? null : selection1;
4365             redraw.call(that);
4366             emit.start().brush().end();
4367           });
4368     }
4369   };
4370
4371   function redraw() {
4372     var group = d3_select(this),
4373         selection$$1 = local$1(this).selection;
4374
4375     if (selection$$1) {
4376       group.selectAll(".selection")
4377           .style("display", null)
4378           .attr("x", selection$$1[0][0])
4379           .attr("y", selection$$1[0][1])
4380           .attr("width", selection$$1[1][0] - selection$$1[0][0])
4381           .attr("height", selection$$1[1][1] - selection$$1[0][1]);
4382
4383       group.selectAll(".handle")
4384           .style("display", null)
4385           .attr("x", function(d) { return d.type[d.type.length - 1] === "e" ? selection$$1[1][0] - handleSize / 2 : selection$$1[0][0] - handleSize / 2; })
4386           .attr("y", function(d) { return d.type[0] === "s" ? selection$$1[1][1] - handleSize / 2 : selection$$1[0][1] - handleSize / 2; })
4387           .attr("width", function(d) { return d.type === "n" || d.type === "s" ? selection$$1[1][0] - selection$$1[0][0] + handleSize : handleSize; })
4388           .attr("height", function(d) { return d.type === "e" || d.type === "w" ? selection$$1[1][1] - selection$$1[0][1] + handleSize : handleSize; });
4389     }
4390
4391     else {
4392       group.selectAll(".selection,.handle")
4393           .style("display", "none")
4394           .attr("x", null)
4395           .attr("y", null)
4396           .attr("width", null)
4397           .attr("height", null);
4398     }
4399   }
4400
4401   function emitter(that, args) {
4402     return that.__brush.emitter || new Emitter(that, args);
4403   }
4404
4405   function Emitter(that, args) {
4406     this.that = that;
4407     this.args = args;
4408     this.state = that.__brush;
4409     this.active = 0;
4410   }
4411
4412   Emitter.prototype = {
4413     beforestart: function() {
4414       if (++this.active === 1) this.state.emitter = this, this.starting = true;
4415       return this;
4416     },
4417     start: function() {
4418       if (this.starting) this.starting = false, this.emit("start");
4419       return this;
4420     },
4421     brush: function() {
4422       this.emit("brush");
4423       return this;
4424     },
4425     end: function() {
4426       if (--this.active === 0) delete this.state.emitter, this.emit("end");
4427       return this;
4428     },
4429     emit: function(type) {
4430       customEvent(new BrushEvent(brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]);
4431     }
4432   };
4433
4434   function started() {
4435     if (event.touches) { if (event.changedTouches.length < event.touches.length) return noevent$1(); }
4436     else if (touchending) return;
4437     if (!filter.apply(this, arguments)) return;
4438
4439     var that = this,
4440         type = event.target.__data__.type,
4441         mode = (event.metaKey ? type = "overlay" : type) === "selection" ? MODE_DRAG : (event.altKey ? MODE_CENTER : MODE_HANDLE),
4442         signX = dim === Y ? null : signsX[type],
4443         signY = dim === X ? null : signsY[type],
4444         state = local$1(that),
4445         extent = state.extent,
4446         selection$$1 = state.selection,
4447         W = extent[0][0], w0, w1,
4448         N = extent[0][1], n0, n1,
4449         E = extent[1][0], e0, e1,
4450         S = extent[1][1], s0, s1,
4451         dx,
4452         dy,
4453         moving,
4454         shifting = signX && signY && event.shiftKey,
4455         lockX,
4456         lockY,
4457         point0 = d3_mouse(that),
4458         point$$1 = point0,
4459         emit = emitter(that, arguments).beforestart();
4460
4461     if (type === "overlay") {
4462       state.selection = selection$$1 = [
4463         [w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]],
4464         [e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0]
4465       ];
4466     } else {
4467       w0 = selection$$1[0][0];
4468       n0 = selection$$1[0][1];
4469       e0 = selection$$1[1][0];
4470       s0 = selection$$1[1][1];
4471     }
4472
4473     w1 = w0;
4474     n1 = n0;
4475     e1 = e0;
4476     s1 = s0;
4477
4478     var group = d3_select(that)
4479         .attr("pointer-events", "none");
4480
4481     var overlay = group.selectAll(".overlay")
4482         .attr("cursor", cursors[type]);
4483
4484     if (event.touches) {
4485       group
4486           .on("touchmove.brush", moved, true)
4487           .on("touchend.brush touchcancel.brush", ended, true);
4488     } else {
4489       var view = d3_select(event.view)
4490           .on("keydown.brush", keydowned, true)
4491           .on("keyup.brush", keyupped, true)
4492           .on("mousemove.brush", moved, true)
4493           .on("mouseup.brush", ended, true);
4494
4495       dragDisable(event.view);
4496     }
4497
4498     nopropagation$1();
4499     interrupt(that);
4500     redraw.call(that);
4501     emit.start();
4502
4503     function moved() {
4504       var point1 = d3_mouse(that);
4505       if (shifting && !lockX && !lockY) {
4506         if (Math.abs(point1[0] - point$$1[0]) > Math.abs(point1[1] - point$$1[1])) lockY = true;
4507         else lockX = true;
4508       }
4509       point$$1 = point1;
4510       moving = true;
4511       noevent$1();
4512       move();
4513     }
4514
4515     function move() {
4516       var t;
4517
4518       dx = point$$1[0] - point0[0];
4519       dy = point$$1[1] - point0[1];
4520
4521       switch (mode) {
4522         case MODE_SPACE:
4523         case MODE_DRAG: {
4524           if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx;
4525           if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy;
4526           break;
4527         }
4528         case MODE_HANDLE: {
4529           if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0;
4530           else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx;
4531           if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0;
4532           else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy;
4533           break;
4534         }
4535         case MODE_CENTER: {
4536           if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX));
4537           if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY));
4538           break;
4539         }
4540       }
4541
4542       if (e1 < w1) {
4543         signX *= -1;
4544         t = w0, w0 = e0, e0 = t;
4545         t = w1, w1 = e1, e1 = t;
4546         if (type in flipX) overlay.attr("cursor", cursors[type = flipX[type]]);
4547       }
4548
4549       if (s1 < n1) {
4550         signY *= -1;
4551         t = n0, n0 = s0, s0 = t;
4552         t = n1, n1 = s1, s1 = t;
4553         if (type in flipY) overlay.attr("cursor", cursors[type = flipY[type]]);
4554       }
4555
4556       if (state.selection) selection$$1 = state.selection; // May be set by brush.move!
4557       if (lockX) w1 = selection$$1[0][0], e1 = selection$$1[1][0];
4558       if (lockY) n1 = selection$$1[0][1], s1 = selection$$1[1][1];
4559
4560       if (selection$$1[0][0] !== w1
4561           || selection$$1[0][1] !== n1
4562           || selection$$1[1][0] !== e1
4563           || selection$$1[1][1] !== s1) {
4564         state.selection = [[w1, n1], [e1, s1]];
4565         redraw.call(that);
4566         emit.brush();
4567       }
4568     }
4569
4570     function ended() {
4571       nopropagation$1();
4572       if (event.touches) {
4573         if (event.touches.length) return;
4574         if (touchending) clearTimeout(touchending);
4575         touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!
4576         group.on("touchmove.brush touchend.brush touchcancel.brush", null);
4577       } else {
4578         yesdrag(event.view, moving);
4579         view.on("keydown.brush keyup.brush mousemove.brush mouseup.brush", null);
4580       }
4581       group.attr("pointer-events", "all");
4582       overlay.attr("cursor", cursors.overlay);
4583       if (state.selection) selection$$1 = state.selection; // May be set by brush.move (on start)!
4584       if (empty$1(selection$$1)) state.selection = null, redraw.call(that);
4585       emit.end();
4586     }
4587
4588     function keydowned() {
4589       switch (event.keyCode) {
4590         case 16: { // SHIFT
4591           shifting = signX && signY;
4592           break;
4593         }
4594         case 18: { // ALT
4595           if (mode === MODE_HANDLE) {
4596             if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;
4597             if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;
4598             mode = MODE_CENTER;
4599             move();
4600           }
4601           break;
4602         }
4603         case 32: { // SPACE; takes priority over ALT
4604           if (mode === MODE_HANDLE || mode === MODE_CENTER) {
4605             if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx;
4606             if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy;
4607             mode = MODE_SPACE;
4608             overlay.attr("cursor", cursors.selection);
4609             move();
4610           }
4611           break;
4612         }
4613         default: return;
4614       }
4615       noevent$1();
4616     }
4617
4618     function keyupped() {
4619       switch (event.keyCode) {
4620         case 16: { // SHIFT
4621           if (shifting) {
4622             lockX = lockY = shifting = false;
4623             move();
4624           }
4625           break;
4626         }
4627         case 18: { // ALT
4628           if (mode === MODE_CENTER) {
4629             if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;
4630             if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;
4631             mode = MODE_HANDLE;
4632             move();
4633           }
4634           break;
4635         }
4636         case 32: { // SPACE
4637           if (mode === MODE_SPACE) {
4638             if (event.altKey) {
4639               if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;
4640               if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;
4641               mode = MODE_CENTER;
4642             } else {
4643               if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;
4644               if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;
4645               mode = MODE_HANDLE;
4646             }
4647             overlay.attr("cursor", cursors[type]);
4648             move();
4649           }
4650           break;
4651         }
4652         default: return;
4653       }
4654       noevent$1();
4655     }
4656   }
4657
4658   function initialize() {
4659     var state = this.__brush || {selection: null};
4660     state.extent = extent.apply(this, arguments);
4661     state.dim = dim;
4662     return state;
4663   }
4664
4665   brush.extent = function(_) {
4666     return arguments.length ? (extent = typeof _ === "function" ? _ : constant$4([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent;
4667   };
4668
4669   brush.filter = function(_) {
4670     return arguments.length ? (filter = typeof _ === "function" ? _ : constant$4(!!_), brush) : filter;
4671   };
4672
4673   brush.handleSize = function(_) {
4674     return arguments.length ? (handleSize = +_, brush) : handleSize;
4675   };
4676
4677   brush.on = function() {
4678     var value = listeners.on.apply(listeners, arguments);
4679     return value === listeners ? brush : value;
4680   };
4681
4682   return brush;
4683 }
4684
4685 var cos = Math.cos;
4686 var sin = Math.sin;
4687 var pi$1 = Math.PI;
4688 var halfPi$1 = pi$1 / 2;
4689 var tau$1 = pi$1 * 2;
4690 var max$1 = Math.max;
4691
4692 function compareValue(compare) {
4693   return function(a, b) {
4694     return compare(
4695       a.source.value + a.target.value,
4696       b.source.value + b.target.value
4697     );
4698   };
4699 }
4700
4701 function chord() {
4702   var padAngle = 0,
4703       sortGroups = null,
4704       sortSubgroups = null,
4705       sortChords = null;
4706
4707   function chord(matrix) {
4708     var n = matrix.length,
4709         groupSums = [],
4710         groupIndex = d3_range(n),
4711         subgroupIndex = [],
4712         chords = [],
4713         groups = chords.groups = new Array(n),
4714         subgroups = new Array(n * n),
4715         k,
4716         x,
4717         x0,
4718         dx,
4719         i,
4720         j;
4721
4722     // Compute the sum.
4723     k = 0, i = -1; while (++i < n) {
4724       x = 0, j = -1; while (++j < n) {
4725         x += matrix[i][j];
4726       }
4727       groupSums.push(x);
4728       subgroupIndex.push(d3_range(n));
4729       k += x;
4730     }
4731
4732     // Sort groups…
4733     if (sortGroups) groupIndex.sort(function(a, b) {
4734       return sortGroups(groupSums[a], groupSums[b]);
4735     });
4736
4737     // Sort subgroups…
4738     if (sortSubgroups) subgroupIndex.forEach(function(d, i) {
4739       d.sort(function(a, b) {
4740         return sortSubgroups(matrix[i][a], matrix[i][b]);
4741       });
4742     });
4743
4744     // Convert the sum to scaling factor for [0, 2pi].
4745     // TODO Allow start and end angle to be specified?
4746     // TODO Allow padding to be specified as percentage?
4747     k = max$1(0, tau$1 - padAngle * n) / k;
4748     dx = k ? padAngle : tau$1 / n;
4749
4750     // Compute the start and end angle for each group and subgroup.
4751     // Note: Opera has a bug reordering object literal properties!
4752     x = 0, i = -1; while (++i < n) {
4753       x0 = x, j = -1; while (++j < n) {
4754         var di = groupIndex[i],
4755             dj = subgroupIndex[di][j],
4756             v = matrix[di][dj],
4757             a0 = x,
4758             a1 = x += v * k;
4759         subgroups[dj * n + di] = {
4760           index: di,
4761           subindex: dj,
4762           startAngle: a0,
4763           endAngle: a1,
4764           value: v
4765         };
4766       }
4767       groups[di] = {
4768         index: di,
4769         startAngle: x0,
4770         endAngle: x,
4771         value: groupSums[di]
4772       };
4773       x += dx;
4774     }
4775
4776     // Generate chords for each (non-empty) subgroup-subgroup link.
4777     i = -1; while (++i < n) {
4778       j = i - 1; while (++j < n) {
4779         var source = subgroups[j * n + i],
4780             target = subgroups[i * n + j];
4781         if (source.value || target.value) {
4782           chords.push(source.value < target.value
4783               ? {source: target, target: source}
4784               : {source: source, target: target});
4785         }
4786       }
4787     }
4788
4789     return sortChords ? chords.sort(sortChords) : chords;
4790   }
4791
4792   chord.padAngle = function(_) {
4793     return arguments.length ? (padAngle = max$1(0, _), chord) : padAngle;
4794   };
4795
4796   chord.sortGroups = function(_) {
4797     return arguments.length ? (sortGroups = _, chord) : sortGroups;
4798   };
4799
4800   chord.sortSubgroups = function(_) {
4801     return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups;
4802   };
4803
4804   chord.sortChords = function(_) {
4805     return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._;
4806   };
4807
4808   return chord;
4809 }
4810
4811 var slice$2 = Array.prototype.slice;
4812
4813 function constant$5(x) {
4814   return function() {
4815     return x;
4816   };
4817 }
4818
4819 var pi$2 = Math.PI,
4820     tau$2 = 2 * pi$2,
4821     epsilon$1 = 1e-6,
4822     tauEpsilon = tau$2 - epsilon$1;
4823
4824 function Path() {
4825   this._x0 = this._y0 = // start of current subpath
4826   this._x1 = this._y1 = null; // end of current subpath
4827   this._ = "";
4828 }
4829
4830 function path() {
4831   return new Path;
4832 }
4833
4834 Path.prototype = path.prototype = {
4835   constructor: Path,
4836   moveTo: function(x, y) {
4837     this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y);
4838   },
4839   closePath: function() {
4840     if (this._x1 !== null) {
4841       this._x1 = this._x0, this._y1 = this._y0;
4842       this._ += "Z";
4843     }
4844   },
4845   lineTo: function(x, y) {
4846     this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y);
4847   },
4848   quadraticCurveTo: function(x1, y1, x, y) {
4849     this._ += "Q" + (+x1) + "," + (+y1) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
4850   },
4851   bezierCurveTo: function(x1, y1, x2, y2, x, y) {
4852     this._ += "C" + (+x1) + "," + (+y1) + "," + (+x2) + "," + (+y2) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
4853   },
4854   arcTo: function(x1, y1, x2, y2, r) {
4855     x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
4856     var x0 = this._x1,
4857         y0 = this._y1,
4858         x21 = x2 - x1,
4859         y21 = y2 - y1,
4860         x01 = x0 - x1,
4861         y01 = y0 - y1,
4862         l01_2 = x01 * x01 + y01 * y01;
4863
4864     // Is the radius negative? Error.
4865     if (r < 0) throw new Error("negative radius: " + r);
4866
4867     // Is this path empty? Move to (x1,y1).
4868     if (this._x1 === null) {
4869       this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
4870     }
4871
4872     // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.
4873     else if (!(l01_2 > epsilon$1)) {}
4874
4875     // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
4876     // Equivalently, is (x1,y1) coincident with (x2,y2)?
4877     // Or, is the radius zero? Line to (x1,y1).
4878     else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$1) || !r) {
4879       this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
4880     }
4881
4882     // Otherwise, draw an arc!
4883     else {
4884       var x20 = x2 - x0,
4885           y20 = y2 - y0,
4886           l21_2 = x21 * x21 + y21 * y21,
4887           l20_2 = x20 * x20 + y20 * y20,
4888           l21 = Math.sqrt(l21_2),
4889           l01 = Math.sqrt(l01_2),
4890           l = r * Math.tan((pi$2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),
4891           t01 = l / l01,
4892           t21 = l / l21;
4893
4894       // If the start tangent is not coincident with (x0,y0), line to.
4895       if (Math.abs(t01 - 1) > epsilon$1) {
4896         this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01);
4897       }
4898
4899       this._ += "A" + r + "," + r + ",0,0," + (+(y01 * x20 > x01 * y20)) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21);
4900     }
4901   },
4902   arc: function(x, y, r, a0, a1, ccw) {
4903     x = +x, y = +y, r = +r;
4904     var dx = r * Math.cos(a0),
4905         dy = r * Math.sin(a0),
4906         x0 = x + dx,