b80275e1bfac981468c94816d0902f7678ae9427
[rails.git] / vendor / assets / iD / iD.js
1 (function () {
2   var version = "4.13.0";
3
4   function ascending(a, b) {
5     return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
6   }
7
8   function 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 ascending(f(d), x);
37     };
38   }
39
40   var ascendingBisect = bisector(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 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 = 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 quantile(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(ascending);
325     return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(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 quantile(numbers.sort(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 = 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$1;
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$1(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 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 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 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 = 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 = 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 d3_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), mouse, this, arguments);
1883       if (!gesture) return;
1884       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       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 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] = 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 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] = 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: 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 interpolate(a, b) {
2737     var t = typeof b, c;
2738     return b == null || t === "boolean" ? constant$3(b)
2739         : (t === "number" ? interpolateNumber
2740         : t === "string" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString)
2741         : b instanceof color ? 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         : 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: interpolateNumber(xa, xb)}, {i: i - 2, x: 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: 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: 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: interpolateNumber(xa, xb)}, {i: i - 2, x: 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 timeout$1(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 timeout$1(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       timeout$1(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$1(a, b) {
3412     var c;
3413     return (typeof b === "number" ? interpolateNumber
3414         : b instanceof color ? interpolateRgb
3415         : (c = color(b)) ? (b = c, 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$1;
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$$1) {
3655     var name = this._name,
3656         id = this._id;
3657
3658     if (typeof select$$1 !== "function") select$$1 = selector(select$$1);
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$$1.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$$1) {
3674     var name = this._name,
3675         id = this._id;
3676
3677     if (typeof select$$1 !== "function") select$$1 = selectorAll(select$$1);
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$$1.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$1;
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             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 = 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 = 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 = 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 = 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 = 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 = 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.tar