Add v2 UI for the perf dashboard
[WebKit-https.git] / Websites / perf.webkit.org / public / v2 / js / d3 / d3.js
1 !function() {
2   var d3 = {
3     version: "3.4.11"
4   };
5   if (!Date.now) Date.now = function() {
6     return +new Date();
7   };
8   var d3_arraySlice = [].slice, d3_array = function(list) {
9     return d3_arraySlice.call(list);
10   };
11   var d3_document = document, d3_documentElement = d3_document.documentElement, d3_window = window;
12   try {
13     d3_array(d3_documentElement.childNodes)[0].nodeType;
14   } catch (e) {
15     d3_array = function(list) {
16       var i = list.length, array = new Array(i);
17       while (i--) array[i] = list[i];
18       return array;
19     };
20   }
21   try {
22     d3_document.createElement("div").style.setProperty("opacity", 0, "");
23   } catch (error) {
24     var d3_element_prototype = d3_window.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = d3_window.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;
25     d3_element_prototype.setAttribute = function(name, value) {
26       d3_element_setAttribute.call(this, name, value + "");
27     };
28     d3_element_prototype.setAttributeNS = function(space, local, value) {
29       d3_element_setAttributeNS.call(this, space, local, value + "");
30     };
31     d3_style_prototype.setProperty = function(name, value, priority) {
32       d3_style_setProperty.call(this, name, value + "", priority);
33     };
34   }
35   d3.ascending = d3_ascending;
36   function d3_ascending(a, b) {
37     return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
38   }
39   d3.descending = function(a, b) {
40     return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
41   };
42   d3.min = function(array, f) {
43     var i = -1, n = array.length, a, b;
44     if (arguments.length === 1) {
45       while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;
46       while (++i < n) if ((b = array[i]) != null && a > b) a = b;
47     } else {
48       while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;
49       while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
50     }
51     return a;
52   };
53   d3.max = function(array, f) {
54     var i = -1, n = array.length, a, b;
55     if (arguments.length === 1) {
56       while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;
57       while (++i < n) if ((b = array[i]) != null && b > a) a = b;
58     } else {
59       while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;
60       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
61     }
62     return a;
63   };
64   d3.extent = function(array, f) {
65     var i = -1, n = array.length, a, b, c;
66     if (arguments.length === 1) {
67       while (++i < n && !((a = c = array[i]) != null && a <= a)) a = c = undefined;
68       while (++i < n) if ((b = array[i]) != null) {
69         if (a > b) a = b;
70         if (c < b) c = b;
71       }
72     } else {
73       while (++i < n && !((a = c = f.call(array, array[i], i)) != null && a <= a)) a = undefined;
74       while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
75         if (a > b) a = b;
76         if (c < b) c = b;
77       }
78     }
79     return [ a, c ];
80   };
81   d3.sum = function(array, f) {
82     var s = 0, n = array.length, a, i = -1;
83     if (arguments.length === 1) {
84       while (++i < n) if (!isNaN(a = +array[i])) s += a;
85     } else {
86       while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;
87     }
88     return s;
89   };
90   function d3_number(x) {
91     return x != null && !isNaN(x);
92   }
93   d3.mean = function(array, f) {
94     var s = 0, n = array.length, a, i = -1, j = n;
95     if (arguments.length === 1) {
96       while (++i < n) if (d3_number(a = array[i])) s += a; else --j;
97     } else {
98       while (++i < n) if (d3_number(a = f.call(array, array[i], i))) s += a; else --j;
99     }
100     return j ? s / j : undefined;
101   };
102   d3.quantile = function(values, p) {
103     var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;
104     return e ? v + e * (values[h] - v) : v;
105   };
106   d3.median = function(array, f) {
107     if (arguments.length > 1) array = array.map(f);
108     array = array.filter(d3_number);
109     return array.length ? d3.quantile(array.sort(d3_ascending), .5) : undefined;
110   };
111   function d3_bisector(compare) {
112     return {
113       left: function(a, x, lo, hi) {
114         if (arguments.length < 3) lo = 0;
115         if (arguments.length < 4) hi = a.length;
116         while (lo < hi) {
117           var mid = lo + hi >>> 1;
118           if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid;
119         }
120         return lo;
121       },
122       right: function(a, x, lo, hi) {
123         if (arguments.length < 3) lo = 0;
124         if (arguments.length < 4) hi = a.length;
125         while (lo < hi) {
126           var mid = lo + hi >>> 1;
127           if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1;
128         }
129         return lo;
130       }
131     };
132   }
133   var d3_bisect = d3_bisector(d3_ascending);
134   d3.bisectLeft = d3_bisect.left;
135   d3.bisect = d3.bisectRight = d3_bisect.right;
136   d3.bisector = function(f) {
137     return d3_bisector(f.length === 1 ? function(d, x) {
138       return d3_ascending(f(d), x);
139     } : f);
140   };
141   d3.shuffle = function(array) {
142     var m = array.length, t, i;
143     while (m) {
144       i = Math.random() * m-- | 0;
145       t = array[m], array[m] = array[i], array[i] = t;
146     }
147     return array;
148   };
149   d3.permute = function(array, indexes) {
150     var i = indexes.length, permutes = new Array(i);
151     while (i--) permutes[i] = array[indexes[i]];
152     return permutes;
153   };
154   d3.pairs = function(array) {
155     var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);
156     while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];
157     return pairs;
158   };
159   d3.zip = function() {
160     if (!(n = arguments.length)) return [];
161     for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m; ) {
162       for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n; ) {
163         zip[j] = arguments[j][i];
164       }
165     }
166     return zips;
167   };
168   function d3_zipLength(d) {
169     return d.length;
170   }
171   d3.transpose = function(matrix) {
172     return d3.zip.apply(d3, matrix);
173   };
174   d3.keys = function(map) {
175     var keys = [];
176     for (var key in map) keys.push(key);
177     return keys;
178   };
179   d3.values = function(map) {
180     var values = [];
181     for (var key in map) values.push(map[key]);
182     return values;
183   };
184   d3.entries = function(map) {
185     var entries = [];
186     for (var key in map) entries.push({
187       key: key,
188       value: map[key]
189     });
190     return entries;
191   };
192   d3.merge = function(arrays) {
193     var n = arrays.length, m, i = -1, j = 0, merged, array;
194     while (++i < n) j += arrays[i].length;
195     merged = new Array(j);
196     while (--n >= 0) {
197       array = arrays[n];
198       m = array.length;
199       while (--m >= 0) {
200         merged[--j] = array[m];
201       }
202     }
203     return merged;
204   };
205   var abs = Math.abs;
206   d3.range = function(start, stop, step) {
207     if (arguments.length < 3) {
208       step = 1;
209       if (arguments.length < 2) {
210         stop = start;
211         start = 0;
212       }
213     }
214     if ((stop - start) / step === Infinity) throw new Error("infinite range");
215     var range = [], k = d3_range_integerScale(abs(step)), i = -1, j;
216     start *= k, stop *= k, step *= k;
217     if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);
218     return range;
219   };
220   function d3_range_integerScale(x) {
221     var k = 1;
222     while (x * k % 1) k *= 10;
223     return k;
224   }
225   function d3_class(ctor, properties) {
226     try {
227       for (var key in properties) {
228         Object.defineProperty(ctor.prototype, key, {
229           value: properties[key],
230           enumerable: false
231         });
232       }
233     } catch (e) {
234       ctor.prototype = properties;
235     }
236   }
237   d3.map = function(object) {
238     var map = new d3_Map();
239     if (object instanceof d3_Map) object.forEach(function(key, value) {
240       map.set(key, value);
241     }); else for (var key in object) map.set(key, object[key]);
242     return map;
243   };
244   function d3_Map() {}
245   d3_class(d3_Map, {
246     has: d3_map_has,
247     get: function(key) {
248       return this[d3_map_prefix + key];
249     },
250     set: function(key, value) {
251       return this[d3_map_prefix + key] = value;
252     },
253     remove: d3_map_remove,
254     keys: d3_map_keys,
255     values: function() {
256       var values = [];
257       this.forEach(function(key, value) {
258         values.push(value);
259       });
260       return values;
261     },
262     entries: function() {
263       var entries = [];
264       this.forEach(function(key, value) {
265         entries.push({
266           key: key,
267           value: value
268         });
269       });
270       return entries;
271     },
272     size: d3_map_size,
273     empty: d3_map_empty,
274     forEach: function(f) {
275       for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) f.call(this, key.substring(1), this[key]);
276     }
277   });
278   var d3_map_prefix = "\x00", d3_map_prefixCode = d3_map_prefix.charCodeAt(0);
279   function d3_map_has(key) {
280     return d3_map_prefix + key in this;
281   }
282   function d3_map_remove(key) {
283     key = d3_map_prefix + key;
284     return key in this && delete this[key];
285   }
286   function d3_map_keys() {
287     var keys = [];
288     this.forEach(function(key) {
289       keys.push(key);
290     });
291     return keys;
292   }
293   function d3_map_size() {
294     var size = 0;
295     for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) ++size;
296     return size;
297   }
298   function d3_map_empty() {
299     for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) return false;
300     return true;
301   }
302   d3.nest = function() {
303     var nest = {}, keys = [], sortKeys = [], sortValues, rollup;
304     function map(mapType, array, depth) {
305       if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;
306       var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;
307       while (++i < n) {
308         if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
309           values.push(object);
310         } else {
311           valuesByKey.set(keyValue, [ object ]);
312         }
313       }
314       if (mapType) {
315         object = mapType();
316         setter = function(keyValue, values) {
317           object.set(keyValue, map(mapType, values, depth));
318         };
319       } else {
320         object = {};
321         setter = function(keyValue, values) {
322           object[keyValue] = map(mapType, values, depth);
323         };
324       }
325       valuesByKey.forEach(setter);
326       return object;
327     }
328     function entries(map, depth) {
329       if (depth >= keys.length) return map;
330       var array = [], sortKey = sortKeys[depth++];
331       map.forEach(function(key, keyMap) {
332         array.push({
333           key: key,
334           values: entries(keyMap, depth)
335         });
336       });
337       return sortKey ? array.sort(function(a, b) {
338         return sortKey(a.key, b.key);
339       }) : array;
340     }
341     nest.map = function(array, mapType) {
342       return map(mapType, array, 0);
343     };
344     nest.entries = function(array) {
345       return entries(map(d3.map, array, 0), 0);
346     };
347     nest.key = function(d) {
348       keys.push(d);
349       return nest;
350     };
351     nest.sortKeys = function(order) {
352       sortKeys[keys.length - 1] = order;
353       return nest;
354     };
355     nest.sortValues = function(order) {
356       sortValues = order;
357       return nest;
358     };
359     nest.rollup = function(f) {
360       rollup = f;
361       return nest;
362     };
363     return nest;
364   };
365   d3.set = function(array) {
366     var set = new d3_Set();
367     if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);
368     return set;
369   };
370   function d3_Set() {}
371   d3_class(d3_Set, {
372     has: d3_map_has,
373     add: function(value) {
374       this[d3_map_prefix + value] = true;
375       return value;
376     },
377     remove: function(value) {
378       value = d3_map_prefix + value;
379       return value in this && delete this[value];
380     },
381     values: d3_map_keys,
382     size: d3_map_size,
383     empty: d3_map_empty,
384     forEach: function(f) {
385       for (var value in this) if (value.charCodeAt(0) === d3_map_prefixCode) f.call(this, value.substring(1));
386     }
387   });
388   d3.behavior = {};
389   d3.rebind = function(target, source) {
390     var i = 1, n = arguments.length, method;
391     while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
392     return target;
393   };
394   function d3_rebind(target, source, method) {
395     return function() {
396       var value = method.apply(source, arguments);
397       return value === source ? target : value;
398     };
399   }
400   function d3_vendorSymbol(object, name) {
401     if (name in object) return name;
402     name = name.charAt(0).toUpperCase() + name.substring(1);
403     for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {
404       var prefixName = d3_vendorPrefixes[i] + name;
405       if (prefixName in object) return prefixName;
406     }
407   }
408   var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ];
409   function d3_noop() {}
410   d3.dispatch = function() {
411     var dispatch = new d3_dispatch(), i = -1, n = arguments.length;
412     while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
413     return dispatch;
414   };
415   function d3_dispatch() {}
416   d3_dispatch.prototype.on = function(type, listener) {
417     var i = type.indexOf("."), name = "";
418     if (i >= 0) {
419       name = type.substring(i + 1);
420       type = type.substring(0, i);
421     }
422     if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);
423     if (arguments.length === 2) {
424       if (listener == null) for (type in this) {
425         if (this.hasOwnProperty(type)) this[type].on(name, null);
426       }
427       return this;
428     }
429   };
430   function d3_dispatch_event(dispatch) {
431     var listeners = [], listenerByName = new d3_Map();
432     function event() {
433       var z = listeners, i = -1, n = z.length, l;
434       while (++i < n) if (l = z[i].on) l.apply(this, arguments);
435       return dispatch;
436     }
437     event.on = function(name, listener) {
438       var l = listenerByName.get(name), i;
439       if (arguments.length < 2) return l && l.on;
440       if (l) {
441         l.on = null;
442         listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
443         listenerByName.remove(name);
444       }
445       if (listener) listeners.push(listenerByName.set(name, {
446         on: listener
447       }));
448       return dispatch;
449     };
450     return event;
451   }
452   d3.event = null;
453   function d3_eventPreventDefault() {
454     d3.event.preventDefault();
455   }
456   function d3_eventSource() {
457     var e = d3.event, s;
458     while (s = e.sourceEvent) e = s;
459     return e;
460   }
461   function d3_eventDispatch(target) {
462     var dispatch = new d3_dispatch(), i = 0, n = arguments.length;
463     while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
464     dispatch.of = function(thiz, argumentz) {
465       return function(e1) {
466         try {
467           var e0 = e1.sourceEvent = d3.event;
468           e1.target = target;
469           d3.event = e1;
470           dispatch[e1.type].apply(thiz, argumentz);
471         } finally {
472           d3.event = e0;
473         }
474       };
475     };
476     return dispatch;
477   }
478   d3.requote = function(s) {
479     return s.replace(d3_requote_re, "\\$&");
480   };
481   var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
482   var d3_subclass = {}.__proto__ ? function(object, prototype) {
483     object.__proto__ = prototype;
484   } : function(object, prototype) {
485     for (var property in prototype) object[property] = prototype[property];
486   };
487   function d3_selection(groups) {
488     d3_subclass(groups, d3_selectionPrototype);
489     return groups;
490   }
491   var d3_select = function(s, n) {
492     return n.querySelector(s);
493   }, d3_selectAll = function(s, n) {
494     return n.querySelectorAll(s);
495   }, d3_selectMatcher = d3_documentElement.matches || d3_documentElement[d3_vendorSymbol(d3_documentElement, "matchesSelector")], d3_selectMatches = function(n, s) {
496     return d3_selectMatcher.call(n, s);
497   };
498   if (typeof Sizzle === "function") {
499     d3_select = function(s, n) {
500       return Sizzle(s, n)[0] || null;
501     };
502     d3_selectAll = Sizzle;
503     d3_selectMatches = Sizzle.matchesSelector;
504   }
505   d3.selection = function() {
506     return d3_selectionRoot;
507   };
508   var d3_selectionPrototype = d3.selection.prototype = [];
509   d3_selectionPrototype.select = function(selector) {
510     var subgroups = [], subgroup, subnode, group, node;
511     selector = d3_selection_selector(selector);
512     for (var j = -1, m = this.length; ++j < m; ) {
513       subgroups.push(subgroup = []);
514       subgroup.parentNode = (group = this[j]).parentNode;
515       for (var i = -1, n = group.length; ++i < n; ) {
516         if (node = group[i]) {
517           subgroup.push(subnode = selector.call(node, node.__data__, i, j));
518           if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
519         } else {
520           subgroup.push(null);
521         }
522       }
523     }
524     return d3_selection(subgroups);
525   };
526   function d3_selection_selector(selector) {
527     return typeof selector === "function" ? selector : function() {
528       return d3_select(selector, this);
529     };
530   }
531   d3_selectionPrototype.selectAll = function(selector) {
532     var subgroups = [], subgroup, node;
533     selector = d3_selection_selectorAll(selector);
534     for (var j = -1, m = this.length; ++j < m; ) {
535       for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
536         if (node = group[i]) {
537           subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));
538           subgroup.parentNode = node;
539         }
540       }
541     }
542     return d3_selection(subgroups);
543   };
544   function d3_selection_selectorAll(selector) {
545     return typeof selector === "function" ? selector : function() {
546       return d3_selectAll(selector, this);
547     };
548   }
549   var d3_nsPrefix = {
550     svg: "http://www.w3.org/2000/svg",
551     xhtml: "http://www.w3.org/1999/xhtml",
552     xlink: "http://www.w3.org/1999/xlink",
553     xml: "http://www.w3.org/XML/1998/namespace",
554     xmlns: "http://www.w3.org/2000/xmlns/"
555   };
556   d3.ns = {
557     prefix: d3_nsPrefix,
558     qualify: function(name) {
559       var i = name.indexOf(":"), prefix = name;
560       if (i >= 0) {
561         prefix = name.substring(0, i);
562         name = name.substring(i + 1);
563       }
564       return d3_nsPrefix.hasOwnProperty(prefix) ? {
565         space: d3_nsPrefix[prefix],
566         local: name
567       } : name;
568     }
569   };
570   d3_selectionPrototype.attr = function(name, value) {
571     if (arguments.length < 2) {
572       if (typeof name === "string") {
573         var node = this.node();
574         name = d3.ns.qualify(name);
575         return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);
576       }
577       for (value in name) this.each(d3_selection_attr(value, name[value]));
578       return this;
579     }
580     return this.each(d3_selection_attr(name, value));
581   };
582   function d3_selection_attr(name, value) {
583     name = d3.ns.qualify(name);
584     function attrNull() {
585       this.removeAttribute(name);
586     }
587     function attrNullNS() {
588       this.removeAttributeNS(name.space, name.local);
589     }
590     function attrConstant() {
591       this.setAttribute(name, value);
592     }
593     function attrConstantNS() {
594       this.setAttributeNS(name.space, name.local, value);
595     }
596     function attrFunction() {
597       var x = value.apply(this, arguments);
598       if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);
599     }
600     function attrFunctionNS() {
601       var x = value.apply(this, arguments);
602       if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);
603     }
604     return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;
605   }
606   function d3_collapse(s) {
607     return s.trim().replace(/\s+/g, " ");
608   }
609   d3_selectionPrototype.classed = function(name, value) {
610     if (arguments.length < 2) {
611       if (typeof name === "string") {
612         var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1;
613         if (value = node.classList) {
614           while (++i < n) if (!value.contains(name[i])) return false;
615         } else {
616           value = node.getAttribute("class");
617           while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
618         }
619         return true;
620       }
621       for (value in name) this.each(d3_selection_classed(value, name[value]));
622       return this;
623     }
624     return this.each(d3_selection_classed(name, value));
625   };
626   function d3_selection_classedRe(name) {
627     return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
628   }
629   function d3_selection_classes(name) {
630     return (name + "").trim().split(/^|\s+/);
631   }
632   function d3_selection_classed(name, value) {
633     name = d3_selection_classes(name).map(d3_selection_classedName);
634     var n = name.length;
635     function classedConstant() {
636       var i = -1;
637       while (++i < n) name[i](this, value);
638     }
639     function classedFunction() {
640       var i = -1, x = value.apply(this, arguments);
641       while (++i < n) name[i](this, x);
642     }
643     return typeof value === "function" ? classedFunction : classedConstant;
644   }
645   function d3_selection_classedName(name) {
646     var re = d3_selection_classedRe(name);
647     return function(node, value) {
648       if (c = node.classList) return value ? c.add(name) : c.remove(name);
649       var c = node.getAttribute("class") || "";
650       if (value) {
651         re.lastIndex = 0;
652         if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
653       } else {
654         node.setAttribute("class", d3_collapse(c.replace(re, " ")));
655       }
656     };
657   }
658   d3_selectionPrototype.style = function(name, value, priority) {
659     var n = arguments.length;
660     if (n < 3) {
661       if (typeof name !== "string") {
662         if (n < 2) value = "";
663         for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
664         return this;
665       }
666       if (n < 2) return d3_window.getComputedStyle(this.node(), null).getPropertyValue(name);
667       priority = "";
668     }
669     return this.each(d3_selection_style(name, value, priority));
670   };
671   function d3_selection_style(name, value, priority) {
672     function styleNull() {
673       this.style.removeProperty(name);
674     }
675     function styleConstant() {
676       this.style.setProperty(name, value, priority);
677     }
678     function styleFunction() {
679       var x = value.apply(this, arguments);
680       if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);
681     }
682     return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;
683   }
684   d3_selectionPrototype.property = function(name, value) {
685     if (arguments.length < 2) {
686       if (typeof name === "string") return this.node()[name];
687       for (value in name) this.each(d3_selection_property(value, name[value]));
688       return this;
689     }
690     return this.each(d3_selection_property(name, value));
691   };
692   function d3_selection_property(name, value) {
693     function propertyNull() {
694       delete this[name];
695     }
696     function propertyConstant() {
697       this[name] = value;
698     }
699     function propertyFunction() {
700       var x = value.apply(this, arguments);
701       if (x == null) delete this[name]; else this[name] = x;
702     }
703     return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;
704   }
705   d3_selectionPrototype.text = function(value) {
706     return arguments.length ? this.each(typeof value === "function" ? function() {
707       var v = value.apply(this, arguments);
708       this.textContent = v == null ? "" : v;
709     } : value == null ? function() {
710       this.textContent = "";
711     } : function() {
712       this.textContent = value;
713     }) : this.node().textContent;
714   };
715   d3_selectionPrototype.html = function(value) {
716     return arguments.length ? this.each(typeof value === "function" ? function() {
717       var v = value.apply(this, arguments);
718       this.innerHTML = v == null ? "" : v;
719     } : value == null ? function() {
720       this.innerHTML = "";
721     } : function() {
722       this.innerHTML = value;
723     }) : this.node().innerHTML;
724   };
725   d3_selectionPrototype.append = function(name) {
726     name = d3_selection_creator(name);
727     return this.select(function() {
728       return this.appendChild(name.apply(this, arguments));
729     });
730   };
731   function d3_selection_creator(name) {
732     return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? function() {
733       return this.ownerDocument.createElementNS(name.space, name.local);
734     } : function() {
735       return this.ownerDocument.createElementNS(this.namespaceURI, name);
736     };
737   }
738   d3_selectionPrototype.insert = function(name, before) {
739     name = d3_selection_creator(name);
740     before = d3_selection_selector(before);
741     return this.select(function() {
742       return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);
743     });
744   };
745   d3_selectionPrototype.remove = function() {
746     return this.each(function() {
747       var parent = this.parentNode;
748       if (parent) parent.removeChild(this);
749     });
750   };
751   d3_selectionPrototype.data = function(value, key) {
752     var i = -1, n = this.length, group, node;
753     if (!arguments.length) {
754       value = new Array(n = (group = this[0]).length);
755       while (++i < n) {
756         if (node = group[i]) {
757           value[i] = node.__data__;
758         }
759       }
760       return value;
761     }
762     function bind(group, groupData) {
763       var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;
764       if (key) {
765         var nodeByKeyValue = new d3_Map(), dataByKeyValue = new d3_Map(), keyValues = [], keyValue;
766         for (i = -1; ++i < n; ) {
767           keyValue = key.call(node = group[i], node.__data__, i);
768           if (nodeByKeyValue.has(keyValue)) {
769             exitNodes[i] = node;
770           } else {
771             nodeByKeyValue.set(keyValue, node);
772           }
773           keyValues.push(keyValue);
774         }
775         for (i = -1; ++i < m; ) {
776           keyValue = key.call(groupData, nodeData = groupData[i], i);
777           if (node = nodeByKeyValue.get(keyValue)) {
778             updateNodes[i] = node;
779             node.__data__ = nodeData;
780           } else if (!dataByKeyValue.has(keyValue)) {
781             enterNodes[i] = d3_selection_dataNode(nodeData);
782           }
783           dataByKeyValue.set(keyValue, nodeData);
784           nodeByKeyValue.remove(keyValue);
785         }
786         for (i = -1; ++i < n; ) {
787           if (nodeByKeyValue.has(keyValues[i])) {
788             exitNodes[i] = group[i];
789           }
790         }
791       } else {
792         for (i = -1; ++i < n0; ) {
793           node = group[i];
794           nodeData = groupData[i];
795           if (node) {
796             node.__data__ = nodeData;
797             updateNodes[i] = node;
798           } else {
799             enterNodes[i] = d3_selection_dataNode(nodeData);
800           }
801         }
802         for (;i < m; ++i) {
803           enterNodes[i] = d3_selection_dataNode(groupData[i]);
804         }
805         for (;i < n; ++i) {
806           exitNodes[i] = group[i];
807         }
808       }
809       enterNodes.update = updateNodes;
810       enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;
811       enter.push(enterNodes);
812       update.push(updateNodes);
813       exit.push(exitNodes);
814     }
815     var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);
816     if (typeof value === "function") {
817       while (++i < n) {
818         bind(group = this[i], value.call(group, group.parentNode.__data__, i));
819       }
820     } else {
821       while (++i < n) {
822         bind(group = this[i], value);
823       }
824     }
825     update.enter = function() {
826       return enter;
827     };
828     update.exit = function() {
829       return exit;
830     };
831     return update;
832   };
833   function d3_selection_dataNode(data) {
834     return {
835       __data__: data
836     };
837   }
838   d3_selectionPrototype.datum = function(value) {
839     return arguments.length ? this.property("__data__", value) : this.property("__data__");
840   };
841   d3_selectionPrototype.filter = function(filter) {
842     var subgroups = [], subgroup, group, node;
843     if (typeof filter !== "function") filter = d3_selection_filter(filter);
844     for (var j = 0, m = this.length; j < m; j++) {
845       subgroups.push(subgroup = []);
846       subgroup.parentNode = (group = this[j]).parentNode;
847       for (var i = 0, n = group.length; i < n; i++) {
848         if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
849           subgroup.push(node);
850         }
851       }
852     }
853     return d3_selection(subgroups);
854   };
855   function d3_selection_filter(selector) {
856     return function() {
857       return d3_selectMatches(this, selector);
858     };
859   }
860   d3_selectionPrototype.order = function() {
861     for (var j = -1, m = this.length; ++j < m; ) {
862       for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
863         if (node = group[i]) {
864           if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
865           next = node;
866         }
867       }
868     }
869     return this;
870   };
871   d3_selectionPrototype.sort = function(comparator) {
872     comparator = d3_selection_sortComparator.apply(this, arguments);
873     for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator);
874     return this.order();
875   };
876   function d3_selection_sortComparator(comparator) {
877     if (!arguments.length) comparator = d3_ascending;
878     return function(a, b) {
879       return a && b ? comparator(a.__data__, b.__data__) : !a - !b;
880     };
881   }
882   d3_selectionPrototype.each = function(callback) {
883     return d3_selection_each(this, function(node, i, j) {
884       callback.call(node, node.__data__, i, j);
885     });
886   };
887   function d3_selection_each(groups, callback) {
888     for (var j = 0, m = groups.length; j < m; j++) {
889       for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {
890         if (node = group[i]) callback(node, i, j);
891       }
892     }
893     return groups;
894   }
895   d3_selectionPrototype.call = function(callback) {
896     var args = d3_array(arguments);
897     callback.apply(args[0] = this, args);
898     return this;
899   };
900   d3_selectionPrototype.empty = function() {
901     return !this.node();
902   };
903   d3_selectionPrototype.node = function() {
904     for (var j = 0, m = this.length; j < m; j++) {
905       for (var group = this[j], i = 0, n = group.length; i < n; i++) {
906         var node = group[i];
907         if (node) return node;
908       }
909     }
910     return null;
911   };
912   d3_selectionPrototype.size = function() {
913     var n = 0;
914     this.each(function() {
915       ++n;
916     });
917     return n;
918   };
919   function d3_selection_enter(selection) {
920     d3_subclass(selection, d3_selection_enterPrototype);
921     return selection;
922   }
923   var d3_selection_enterPrototype = [];
924   d3.selection.enter = d3_selection_enter;
925   d3.selection.enter.prototype = d3_selection_enterPrototype;
926   d3_selection_enterPrototype.append = d3_selectionPrototype.append;
927   d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
928   d3_selection_enterPrototype.node = d3_selectionPrototype.node;
929   d3_selection_enterPrototype.call = d3_selectionPrototype.call;
930   d3_selection_enterPrototype.size = d3_selectionPrototype.size;
931   d3_selection_enterPrototype.select = function(selector) {
932     var subgroups = [], subgroup, subnode, upgroup, group, node;
933     for (var j = -1, m = this.length; ++j < m; ) {
934       upgroup = (group = this[j]).update;
935       subgroups.push(subgroup = []);
936       subgroup.parentNode = group.parentNode;
937       for (var i = -1, n = group.length; ++i < n; ) {
938         if (node = group[i]) {
939           subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j));
940           subnode.__data__ = node.__data__;
941         } else {
942           subgroup.push(null);
943         }
944       }
945     }
946     return d3_selection(subgroups);
947   };
948   d3_selection_enterPrototype.insert = function(name, before) {
949     if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);
950     return d3_selectionPrototype.insert.call(this, name, before);
951   };
952   function d3_selection_enterInsertBefore(enter) {
953     var i0, j0;
954     return function(d, i, j) {
955       var group = enter[j].update, n = group.length, node;
956       if (j != j0) j0 = j, i0 = 0;
957       if (i >= i0) i0 = i + 1;
958       while (!(node = group[i0]) && ++i0 < n) ;
959       return node;
960     };
961   }
962   d3_selectionPrototype.transition = function() {
963     var id = d3_transitionInheritId || ++d3_transitionId, subgroups = [], subgroup, node, transition = d3_transitionInherit || {
964       time: Date.now(),
965       ease: d3_ease_cubicInOut,
966       delay: 0,
967       duration: 250
968     };
969     for (var j = -1, m = this.length; ++j < m; ) {
970       subgroups.push(subgroup = []);
971       for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
972         if (node = group[i]) d3_transitionNode(node, i, id, transition);
973         subgroup.push(node);
974       }
975     }
976     return d3_transition(subgroups, id);
977   };
978   d3_selectionPrototype.interrupt = function() {
979     return this.each(d3_selection_interrupt);
980   };
981   function d3_selection_interrupt() {
982     var lock = this.__transition__;
983     if (lock) ++lock.active;
984   }
985   d3.select = function(node) {
986     var group = [ typeof node === "string" ? d3_select(node, d3_document) : node ];
987     group.parentNode = d3_documentElement;
988     return d3_selection([ group ]);
989   };
990   d3.selectAll = function(nodes) {
991     var group = d3_array(typeof nodes === "string" ? d3_selectAll(nodes, d3_document) : nodes);
992     group.parentNode = d3_documentElement;
993     return d3_selection([ group ]);
994   };
995   var d3_selectionRoot = d3.select(d3_documentElement);
996   d3_selectionPrototype.on = function(type, listener, capture) {
997     var n = arguments.length;
998     if (n < 3) {
999       if (typeof type !== "string") {
1000         if (n < 2) listener = false;
1001         for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
1002         return this;
1003       }
1004       if (n < 2) return (n = this.node()["__on" + type]) && n._;
1005       capture = false;
1006     }
1007     return this.each(d3_selection_on(type, listener, capture));
1008   };
1009   function d3_selection_on(type, listener, capture) {
1010     var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener;
1011     if (i > 0) type = type.substring(0, i);
1012     var filter = d3_selection_onFilters.get(type);
1013     if (filter) type = filter, wrap = d3_selection_onFilter;
1014     function onRemove() {
1015       var l = this[name];
1016       if (l) {
1017         this.removeEventListener(type, l, l.$);
1018         delete this[name];
1019       }
1020     }
1021     function onAdd() {
1022       var l = wrap(listener, d3_array(arguments));
1023       onRemove.call(this);
1024       this.addEventListener(type, this[name] = l, l.$ = capture);
1025       l._ = listener;
1026     }
1027     function removeAll() {
1028       var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;
1029       for (var name in this) {
1030         if (match = name.match(re)) {
1031           var l = this[name];
1032           this.removeEventListener(match[1], l, l.$);
1033           delete this[name];
1034         }
1035       }
1036     }
1037     return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;
1038   }
1039   var d3_selection_onFilters = d3.map({
1040     mouseenter: "mouseover",
1041     mouseleave: "mouseout"
1042   });
1043   d3_selection_onFilters.forEach(function(k) {
1044     if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
1045   });
1046   function d3_selection_onListener(listener, argumentz) {
1047     return function(e) {
1048       var o = d3.event;
1049       d3.event = e;
1050       argumentz[0] = this.__data__;
1051       try {
1052         listener.apply(this, argumentz);
1053       } finally {
1054         d3.event = o;
1055       }
1056     };
1057   }
1058   function d3_selection_onFilter(listener, argumentz) {
1059     var l = d3_selection_onListener(listener, argumentz);
1060     return function(e) {
1061       var target = this, related = e.relatedTarget;
1062       if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {
1063         l.call(target, e);
1064       }
1065     };
1066   }
1067   var d3_event_dragSelect = "onselectstart" in d3_document ? null : d3_vendorSymbol(d3_documentElement.style, "userSelect"), d3_event_dragId = 0;
1068   function d3_event_dragSuppress() {
1069     var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault);
1070     if (d3_event_dragSelect) {
1071       var style = d3_documentElement.style, select = style[d3_event_dragSelect];
1072       style[d3_event_dragSelect] = "none";
1073     }
1074     return function(suppressClick) {
1075       w.on(name, null);
1076       if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
1077       if (suppressClick) {
1078         function off() {
1079           w.on(click, null);
1080         }
1081         w.on(click, function() {
1082           d3_eventPreventDefault();
1083           off();
1084         }, true);
1085         setTimeout(off, 0);
1086       }
1087     };
1088   }
1089   d3.mouse = function(container) {
1090     return d3_mousePoint(container, d3_eventSource());
1091   };
1092   var d3_mouse_bug44083 = /WebKit/.test(d3_window.navigator.userAgent) ? -1 : 0;
1093   function d3_mousePoint(container, e) {
1094     if (e.changedTouches) e = e.changedTouches[0];
1095     var svg = container.ownerSVGElement || container;
1096     if (svg.createSVGPoint) {
1097       var point = svg.createSVGPoint();
1098       if (d3_mouse_bug44083 < 0 && (d3_window.scrollX || d3_window.scrollY)) {
1099         svg = d3.select("body").append("svg").style({
1100           position: "absolute",
1101           top: 0,
1102           left: 0,
1103           margin: 0,
1104           padding: 0,
1105           border: "none"
1106         }, "important");
1107         var ctm = svg[0][0].getScreenCTM();
1108         d3_mouse_bug44083 = !(ctm.f || ctm.e);
1109         svg.remove();
1110       }
1111       if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX, 
1112       point.y = e.clientY;
1113       point = point.matrixTransform(container.getScreenCTM().inverse());
1114       return [ point.x, point.y ];
1115     }
1116     var rect = container.getBoundingClientRect();
1117     return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ];
1118   }
1119   d3.touches = function(container, touches) {
1120     if (arguments.length < 2) touches = d3_eventSource().touches;
1121     return touches ? d3_array(touches).map(function(touch) {
1122       var point = d3_mousePoint(container, touch);
1123       point.identifier = touch.identifier;
1124       return point;
1125     }) : [];
1126   };
1127   d3.behavior.drag = function() {
1128     var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_behavior_dragMouseSubject, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_behavior_dragTouchSubject, "touchmove", "touchend");
1129     function drag() {
1130       this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);
1131     }
1132     function dragstart(id, position, subject, move, end) {
1133       return function() {
1134         var that = this, target = d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject()).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(), position0 = position(parent, dragId);
1135         if (origin) {
1136           dragOffset = origin.apply(that, arguments);
1137           dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ];
1138         } else {
1139           dragOffset = [ 0, 0 ];
1140         }
1141         dispatch({
1142           type: "dragstart"
1143         });
1144         function moved() {
1145           var position1 = position(parent, dragId), dx, dy;
1146           if (!position1) return;
1147           dx = position1[0] - position0[0];
1148           dy = position1[1] - position0[1];
1149           dragged |= dx | dy;
1150           position0 = position1;
1151           dispatch({
1152             type: "drag",
1153             x: position1[0] + dragOffset[0],
1154             y: position1[1] + dragOffset[1],
1155             dx: dx,
1156             dy: dy
1157           });
1158         }
1159         function ended() {
1160           if (!position(parent, dragId)) return;
1161           dragSubject.on(move + dragName, null).on(end + dragName, null);
1162           dragRestore(dragged && d3.event.target === target);
1163           dispatch({
1164             type: "dragend"
1165           });
1166         }
1167       };
1168     }
1169     drag.origin = function(x) {
1170       if (!arguments.length) return origin;
1171       origin = x;
1172       return drag;
1173     };
1174     return d3.rebind(drag, event, "on");
1175   };
1176   function d3_behavior_dragTouchId() {
1177     return d3.event.changedTouches[0].identifier;
1178   }
1179   function d3_behavior_dragTouchSubject() {
1180     return d3.event.target;
1181   }
1182   function d3_behavior_dragMouseSubject() {
1183     return d3_window;
1184   }
1185   var π = Math.PI, τ = 2 * π, halfπ = π / 2, ε = 1e-6, ε2 = ε * ε, d3_radians = π / 180, d3_degrees = 180 / π;
1186   function d3_sgn(x) {
1187     return x > 0 ? 1 : x < 0 ? -1 : 0;
1188   }
1189   function d3_cross2d(a, b, c) {
1190     return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
1191   }
1192   function d3_acos(x) {
1193     return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
1194   }
1195   function d3_asin(x) {
1196     return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);
1197   }
1198   function d3_sinh(x) {
1199     return ((x = Math.exp(x)) - 1 / x) / 2;
1200   }
1201   function d3_cosh(x) {
1202     return ((x = Math.exp(x)) + 1 / x) / 2;
1203   }
1204   function d3_tanh(x) {
1205     return ((x = Math.exp(2 * x)) - 1) / (x + 1);
1206   }
1207   function d3_haversin(x) {
1208     return (x = Math.sin(x / 2)) * x;
1209   }
1210   var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;
1211   d3.interpolateZoom = function(p0, p1) {
1212     var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2];
1213     var dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1), dr = r1 - r0, S = (dr || Math.log(w1 / w0)) / ρ;
1214     function interpolate(t) {
1215       var s = t * S;
1216       if (dr) {
1217         var coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0));
1218         return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ];
1219       }
1220       return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * s) ];
1221     }
1222     interpolate.duration = S * 1e3;
1223     return interpolate;
1224   };
1225   d3.behavior.zoom = function() {
1226     var view = {
1227       x: 0,
1228       y: 0,
1229       k: 1
1230     }, translate0, center0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1;
1231     function zoom(g) {
1232       g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted);
1233     }
1234     zoom.event = function(g) {
1235       g.each(function() {
1236         var dispatch = event.of(this, arguments), view1 = view;
1237         if (d3_transitionInheritId) {
1238           d3.select(this).transition().each("start.zoom", function() {
1239             view = this.__chart__ || {
1240               x: 0,
1241               y: 0,
1242               k: 1
1243             };
1244             zoomstarted(dispatch);
1245           }).tween("zoom:zoom", function() {
1246             var dx = size[0], dy = size[1], cx = dx / 2, cy = dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]);
1247             return function(t) {
1248               var l = i(t), k = dx / l[2];
1249               this.__chart__ = view = {
1250                 x: cx - l[0] * k,
1251                 y: cy - l[1] * k,
1252                 k: k
1253               };
1254               zoomed(dispatch);
1255             };
1256           }).each("end.zoom", function() {
1257             zoomended(dispatch);
1258           });
1259         } else {
1260           this.__chart__ = view;
1261           zoomstarted(dispatch);
1262           zoomed(dispatch);
1263           zoomended(dispatch);
1264         }
1265       });
1266     };
1267     zoom.translate = function(_) {
1268       if (!arguments.length) return [ view.x, view.y ];
1269       view = {
1270         x: +_[0],
1271         y: +_[1],
1272         k: view.k
1273       };
1274       rescale();
1275       return zoom;
1276     };
1277     zoom.scale = function(_) {
1278       if (!arguments.length) return view.k;
1279       view = {
1280         x: view.x,
1281         y: view.y,
1282         k: +_
1283       };
1284       rescale();
1285       return zoom;
1286     };
1287     zoom.scaleExtent = function(_) {
1288       if (!arguments.length) return scaleExtent;
1289       scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ];
1290       return zoom;
1291     };
1292     zoom.center = function(_) {
1293       if (!arguments.length) return center;
1294       center = _ && [ +_[0], +_[1] ];
1295       return zoom;
1296     };
1297     zoom.size = function(_) {
1298       if (!arguments.length) return size;
1299       size = _ && [ +_[0], +_[1] ];
1300       return zoom;
1301     };
1302     zoom.x = function(z) {
1303       if (!arguments.length) return x1;
1304       x1 = z;
1305       x0 = z.copy();
1306       view = {
1307         x: 0,
1308         y: 0,
1309         k: 1
1310       };
1311       return zoom;
1312     };
1313     zoom.y = function(z) {
1314       if (!arguments.length) return y1;
1315       y1 = z;
1316       y0 = z.copy();
1317       view = {
1318         x: 0,
1319         y: 0,
1320         k: 1
1321       };
1322       return zoom;
1323     };
1324     function location(p) {
1325       return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ];
1326     }
1327     function point(l) {
1328       return [ l[0] * view.k + view.x, l[1] * view.k + view.y ];
1329     }
1330     function scaleTo(s) {
1331       view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
1332     }
1333     function translateTo(p, l) {
1334       l = point(l);
1335       view.x += p[0] - l[0];
1336       view.y += p[1] - l[1];
1337     }
1338     function rescale() {
1339       if (x1) x1.domain(x0.range().map(function(x) {
1340         return (x - view.x) / view.k;
1341       }).map(x0.invert));
1342       if (y1) y1.domain(y0.range().map(function(y) {
1343         return (y - view.y) / view.k;
1344       }).map(y0.invert));
1345     }
1346     function zoomstarted(dispatch) {
1347       dispatch({
1348         type: "zoomstart"
1349       });
1350     }
1351     function zoomed(dispatch) {
1352       rescale();
1353       dispatch({
1354         type: "zoom",
1355         scale: view.k,
1356         translate: [ view.x, view.y ]
1357       });
1358     }
1359     function zoomended(dispatch) {
1360       dispatch({
1361         type: "zoomend"
1362       });
1363     }
1364     function mousedowned() {
1365       var that = this, target = d3.event.target, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress();
1366       d3_selection_interrupt.call(that);
1367       zoomstarted(dispatch);
1368       function moved() {
1369         dragged = 1;
1370         translateTo(d3.mouse(that), location0);
1371         zoomed(dispatch);
1372       }
1373       function ended() {
1374         subject.on(mousemove, null).on(mouseup, null);
1375         dragRestore(dragged && d3.event.target === target);
1376         zoomended(dispatch);
1377       }
1378     }
1379     function touchstarted() {
1380       var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that).on(mousedown, null).on(touchstart, started), dragRestore = d3_event_dragSuppress();
1381       d3_selection_interrupt.call(that);
1382       started();
1383       zoomstarted(dispatch);
1384       function relocate() {
1385         var touches = d3.touches(that);
1386         scale0 = view.k;
1387         touches.forEach(function(t) {
1388           if (t.identifier in locations0) locations0[t.identifier] = location(t);
1389         });
1390         return touches;
1391       }
1392       function started() {
1393         var target = d3.event.target;
1394         d3.select(target).on(touchmove, moved).on(touchend, ended);
1395         targets.push(target);
1396         var changed = d3.event.changedTouches;
1397         for (var i = 0, n = changed.length; i < n; ++i) {
1398           locations0[changed[i].identifier] = null;
1399         }
1400         var touches = relocate(), now = Date.now();
1401         if (touches.length === 1) {
1402           if (now - touchtime < 500) {
1403             var p = touches[0], l = locations0[p.identifier];
1404             scaleTo(view.k * 2);
1405             translateTo(p, l);
1406             d3_eventPreventDefault();
1407             zoomed(dispatch);
1408           }
1409           touchtime = now;
1410         } else if (touches.length > 1) {
1411           var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1];
1412           distance0 = dx * dx + dy * dy;
1413         }
1414       }
1415       function moved() {
1416         var touches = d3.touches(that), p0, l0, p1, l1;
1417         for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {
1418           p1 = touches[i];
1419           if (l1 = locations0[p1.identifier]) {
1420             if (l0) break;
1421             p0 = p1, l0 = l1;
1422           }
1423         }
1424         if (l1) {
1425           var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0);
1426           p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ];
1427           l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ];
1428           scaleTo(scale1 * scale0);
1429         }
1430         touchtime = null;
1431         translateTo(p0, l0);
1432         zoomed(dispatch);
1433       }
1434       function ended() {
1435         if (d3.event.touches.length) {
1436           var changed = d3.event.changedTouches;
1437           for (var i = 0, n = changed.length; i < n; ++i) {
1438             delete locations0[changed[i].identifier];
1439           }
1440           for (var identifier in locations0) {
1441             return void relocate();
1442           }
1443         }
1444         d3.selectAll(targets).on(zoomName, null);
1445         subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
1446         dragRestore();
1447         zoomended(dispatch);
1448       }
1449     }
1450     function mousewheeled() {
1451       var dispatch = event.of(this, arguments);
1452       if (mousewheelTimer) clearTimeout(mousewheelTimer); else translate0 = location(center0 = center || d3.mouse(this)), 
1453       d3_selection_interrupt.call(this), zoomstarted(dispatch);
1454       mousewheelTimer = setTimeout(function() {
1455         mousewheelTimer = null;
1456         zoomended(dispatch);
1457       }, 50);
1458       d3_eventPreventDefault();
1459       scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);
1460       translateTo(center0, translate0);
1461       zoomed(dispatch);
1462     }
1463     function dblclicked() {
1464       var dispatch = event.of(this, arguments), p = d3.mouse(this), l = location(p), k = Math.log(view.k) / Math.LN2;
1465       zoomstarted(dispatch);
1466       scaleTo(Math.pow(2, d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1));
1467       translateTo(p, l);
1468       zoomed(dispatch);
1469       zoomended(dispatch);
1470     }
1471     return d3.rebind(zoom, event, "on");
1472   };
1473   var d3_behavior_zoomInfinity = [ 0, Infinity ];
1474   var d3_behavior_zoomDelta, d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {
1475     return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);
1476   }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {
1477     return d3.event.wheelDelta;
1478   }, "mousewheel") : (d3_behavior_zoomDelta = function() {
1479     return -d3.event.detail;
1480   }, "MozMousePixelScroll");
1481   d3.color = d3_color;
1482   function d3_color() {}
1483   d3_color.prototype.toString = function() {
1484     return this.rgb() + "";
1485   };
1486   d3.hsl = d3_hsl;
1487   function d3_hsl(h, s, l) {
1488     return this instanceof d3_hsl ? void (this.h = +h, this.s = +s, this.l = +l) : arguments.length < 2 ? h instanceof d3_hsl ? new d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : new d3_hsl(h, s, l);
1489   }
1490   var d3_hslPrototype = d3_hsl.prototype = new d3_color();
1491   d3_hslPrototype.brighter = function(k) {
1492     k = Math.pow(.7, arguments.length ? k : 1);
1493     return new d3_hsl(this.h, this.s, this.l / k);
1494   };
1495   d3_hslPrototype.darker = function(k) {
1496     k = Math.pow(.7, arguments.length ? k : 1);
1497     return new d3_hsl(this.h, this.s, k * this.l);
1498   };
1499   d3_hslPrototype.rgb = function() {
1500     return d3_hsl_rgb(this.h, this.s, this.l);
1501   };
1502   function d3_hsl_rgb(h, s, l) {
1503     var m1, m2;
1504     h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h;
1505     s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s;
1506     l = l < 0 ? 0 : l > 1 ? 1 : l;
1507     m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
1508     m1 = 2 * l - m2;
1509     function v(h) {
1510       if (h > 360) h -= 360; else if (h < 0) h += 360;
1511       if (h < 60) return m1 + (m2 - m1) * h / 60;
1512       if (h < 180) return m2;
1513       if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
1514       return m1;
1515     }
1516     function vv(h) {
1517       return Math.round(v(h) * 255);
1518     }
1519     return new d3_rgb(vv(h + 120), vv(h), vv(h - 120));
1520   }
1521   d3.hcl = d3_hcl;
1522   function d3_hcl(h, c, l) {
1523     return this instanceof d3_hcl ? void (this.h = +h, this.c = +c, this.l = +l) : arguments.length < 2 ? h instanceof d3_hcl ? new d3_hcl(h.h, h.c, h.l) : h instanceof d3_lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : new d3_hcl(h, c, l);
1524   }
1525   var d3_hclPrototype = d3_hcl.prototype = new d3_color();
1526   d3_hclPrototype.brighter = function(k) {
1527     return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));
1528   };
1529   d3_hclPrototype.darker = function(k) {
1530     return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));
1531   };
1532   d3_hclPrototype.rgb = function() {
1533     return d3_hcl_lab(this.h, this.c, this.l).rgb();
1534   };
1535   function d3_hcl_lab(h, c, l) {
1536     if (isNaN(h)) h = 0;
1537     if (isNaN(c)) c = 0;
1538     return new d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);
1539   }
1540   d3.lab = d3_lab;
1541   function d3_lab(l, a, b) {
1542     return this instanceof d3_lab ? void (this.l = +l, this.a = +a, this.b = +b) : arguments.length < 2 ? l instanceof d3_lab ? new d3_lab(l.l, l.a, l.b) : l instanceof d3_hcl ? d3_hcl_lab(l.l, l.c, l.h) : d3_rgb_lab((l = d3_rgb(l)).r, l.g, l.b) : new d3_lab(l, a, b);
1543   }
1544   var d3_lab_K = 18;
1545   var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;
1546   var d3_labPrototype = d3_lab.prototype = new d3_color();
1547   d3_labPrototype.brighter = function(k) {
1548     return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
1549   };
1550   d3_labPrototype.darker = function(k) {
1551     return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
1552   };
1553   d3_labPrototype.rgb = function() {
1554     return d3_lab_rgb(this.l, this.a, this.b);
1555   };
1556   function d3_lab_rgb(l, a, b) {
1557     var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;
1558     x = d3_lab_xyz(x) * d3_lab_X;
1559     y = d3_lab_xyz(y) * d3_lab_Y;
1560     z = d3_lab_xyz(z) * d3_lab_Z;
1561     return new d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z));
1562   }
1563   function d3_lab_hcl(l, a, b) {
1564     return l > 0 ? new d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : new d3_hcl(NaN, NaN, l);
1565   }
1566   function d3_lab_xyz(x) {
1567     return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
1568   }
1569   function d3_xyz_lab(x) {
1570     return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
1571   }
1572   function d3_xyz_rgb(r) {
1573     return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055));
1574   }
1575   d3.rgb = d3_rgb;
1576   function d3_rgb(r, g, b) {
1577     return this instanceof d3_rgb ? void (this.r = ~~r, this.g = ~~g, this.b = ~~b) : arguments.length < 2 ? r instanceof d3_rgb ? new d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : new d3_rgb(r, g, b);
1578   }
1579   function d3_rgbNumber(value) {
1580     return new d3_rgb(value >> 16, value >> 8 & 255, value & 255);
1581   }
1582   function d3_rgbString(value) {
1583     return d3_rgbNumber(value) + "";
1584   }
1585   var d3_rgbPrototype = d3_rgb.prototype = new d3_color();
1586   d3_rgbPrototype.brighter = function(k) {
1587     k = Math.pow(.7, arguments.length ? k : 1);
1588     var r = this.r, g = this.g, b = this.b, i = 30;
1589     if (!r && !g && !b) return new d3_rgb(i, i, i);
1590     if (r && r < i) r = i;
1591     if (g && g < i) g = i;
1592     if (b && b < i) b = i;
1593     return new d3_rgb(Math.min(255, r / k), Math.min(255, g / k), Math.min(255, b / k));
1594   };
1595   d3_rgbPrototype.darker = function(k) {
1596     k = Math.pow(.7, arguments.length ? k : 1);
1597     return new d3_rgb(k * this.r, k * this.g, k * this.b);
1598   };
1599   d3_rgbPrototype.hsl = function() {
1600     return d3_rgb_hsl(this.r, this.g, this.b);
1601   };
1602   d3_rgbPrototype.toString = function() {
1603     return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
1604   };
1605   function d3_rgb_hex(v) {
1606     return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);
1607   }
1608   function d3_rgb_parse(format, rgb, hsl) {
1609     var r = 0, g = 0, b = 0, m1, m2, color;
1610     m1 = /([a-z]+)\((.*)\)/i.exec(format);
1611     if (m1) {
1612       m2 = m1[2].split(",");
1613       switch (m1[1]) {
1614        case "hsl":
1615         {
1616           return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);
1617         }
1618
1619        case "rgb":
1620         {
1621           return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));
1622         }
1623       }
1624     }
1625     if (color = d3_rgb_names.get(format)) return rgb(color.r, color.g, color.b);
1626     if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.substring(1), 16))) {
1627       if (format.length === 4) {
1628         r = (color & 3840) >> 4;
1629         r = r >> 4 | r;
1630         g = color & 240;
1631         g = g >> 4 | g;
1632         b = color & 15;
1633         b = b << 4 | b;
1634       } else if (format.length === 7) {
1635         r = (color & 16711680) >> 16;
1636         g = (color & 65280) >> 8;
1637         b = color & 255;
1638       }
1639     }
1640     return rgb(r, g, b);
1641   }
1642   function d3_rgb_hsl(r, g, b) {
1643     var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2;
1644     if (d) {
1645       s = l < .5 ? d / (max + min) : d / (2 - max - min);
1646       if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4;
1647       h *= 60;
1648     } else {
1649       h = NaN;
1650       s = l > 0 && l < 1 ? 0 : h;
1651     }
1652     return new d3_hsl(h, s, l);
1653   }
1654   function d3_rgb_lab(r, g, b) {
1655     r = d3_rgb_xyz(r);
1656     g = d3_rgb_xyz(g);
1657     b = d3_rgb_xyz(b);
1658     var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z);
1659     return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z));
1660   }
1661   function d3_rgb_xyz(r) {
1662     return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4);
1663   }
1664   function d3_rgb_parseNumber(c) {
1665     var f = parseFloat(c);
1666     return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
1667   }
1668   var d3_rgb_names = d3.map({
1669     aliceblue: 15792383,
1670     antiquewhite: 16444375,
1671     aqua: 65535,
1672     aquamarine: 8388564,
1673     azure: 15794175,
1674     beige: 16119260,
1675     bisque: 16770244,
1676     black: 0,
1677     blanchedalmond: 16772045,
1678     blue: 255,
1679     blueviolet: 9055202,
1680     brown: 10824234,
1681     burlywood: 14596231,
1682     cadetblue: 6266528,
1683     chartreuse: 8388352,
1684     chocolate: 13789470,
1685     coral: 16744272,
1686     cornflowerblue: 6591981,
1687     cornsilk: 16775388,
1688     crimson: 14423100,
1689     cyan: 65535,
1690     darkblue: 139,
1691     darkcyan: 35723,
1692     darkgoldenrod: 12092939,
1693     darkgray: 11119017,
1694     darkgreen: 25600,
1695     darkgrey: 11119017,
1696     darkkhaki: 12433259,
1697     darkmagenta: 9109643,
1698     darkolivegreen: 5597999,
1699     darkorange: 16747520,
1700     darkorchid: 10040012,
1701     darkred: 9109504,
1702     darksalmon: 15308410,
1703     darkseagreen: 9419919,
1704     darkslateblue: 4734347,
1705     darkslategray: 3100495,
1706     darkslategrey: 3100495,
1707     darkturquoise: 52945,
1708     darkviolet: 9699539,
1709     deeppink: 16716947,
1710     deepskyblue: 49151,
1711     dimgray: 6908265,
1712     dimgrey: 6908265,
1713     dodgerblue: 2003199,
1714     firebrick: 11674146,
1715     floralwhite: 16775920,
1716     forestgreen: 2263842,
1717     fuchsia: 16711935,
1718     gainsboro: 14474460,
1719     ghostwhite: 16316671,
1720     gold: 16766720,
1721     goldenrod: 14329120,
1722     gray: 8421504,
1723     green: 32768,
1724     greenyellow: 11403055,
1725     grey: 8421504,
1726     honeydew: 15794160,
1727     hotpink: 16738740,
1728     indianred: 13458524,
1729     indigo: 4915330,
1730     ivory: 16777200,
1731     khaki: 15787660,
1732     lavender: 15132410,
1733     lavenderblush: 16773365,
1734     lawngreen: 8190976,
1735     lemonchiffon: 16775885,
1736     lightblue: 11393254,
1737     lightcoral: 15761536,
1738     lightcyan: 14745599,
1739     lightgoldenrodyellow: 16448210,
1740     lightgray: 13882323,
1741     lightgreen: 9498256,
1742     lightgrey: 13882323,
1743     lightpink: 16758465,
1744     lightsalmon: 16752762,
1745     lightseagreen: 2142890,
1746     lightskyblue: 8900346,
1747     lightslategray: 7833753,
1748     lightslategrey: 7833753,
1749     lightsteelblue: 11584734,
1750     lightyellow: 16777184,
1751     lime: 65280,
1752     limegreen: 3329330,
1753     linen: 16445670,
1754     magenta: 16711935,
1755     maroon: 8388608,
1756     mediumaquamarine: 6737322,
1757     mediumblue: 205,
1758     mediumorchid: 12211667,
1759     mediumpurple: 9662683,
1760     mediumseagreen: 3978097,
1761     mediumslateblue: 8087790,
1762     mediumspringgreen: 64154,
1763     mediumturquoise: 4772300,
1764     mediumvioletred: 13047173,
1765     midnightblue: 1644912,
1766     mintcream: 16121850,
1767     mistyrose: 16770273,
1768     moccasin: 16770229,
1769     navajowhite: 16768685,
1770     navy: 128,
1771     oldlace: 16643558,
1772     olive: 8421376,
1773     olivedrab: 7048739,
1774     orange: 16753920,
1775     orangered: 16729344,
1776     orchid: 14315734,
1777     palegoldenrod: 15657130,
1778     palegreen: 10025880,
1779     paleturquoise: 11529966,
1780     palevioletred: 14381203,
1781     papayawhip: 16773077,
1782     peachpuff: 16767673,
1783     peru: 13468991,
1784     pink: 16761035,
1785     plum: 14524637,
1786     powderblue: 11591910,
1787     purple: 8388736,
1788     red: 16711680,
1789     rosybrown: 12357519,
1790     royalblue: 4286945,
1791     saddlebrown: 9127187,
1792     salmon: 16416882,
1793     sandybrown: 16032864,
1794     seagreen: 3050327,
1795     seashell: 16774638,
1796     sienna: 10506797,
1797     silver: 12632256,
1798     skyblue: 8900331,
1799     slateblue: 6970061,
1800     slategray: 7372944,
1801     slategrey: 7372944,
1802     snow: 16775930,
1803     springgreen: 65407,
1804     steelblue: 4620980,
1805     tan: 13808780,
1806     teal: 32896,
1807     thistle: 14204888,
1808     tomato: 16737095,
1809     turquoise: 4251856,
1810     violet: 15631086,
1811     wheat: 16113331,
1812     white: 16777215,
1813     whitesmoke: 16119285,
1814     yellow: 16776960,
1815     yellowgreen: 10145074
1816   });
1817   d3_rgb_names.forEach(function(key, value) {
1818     d3_rgb_names.set(key, d3_rgbNumber(value));
1819   });
1820   function d3_functor(v) {
1821     return typeof v === "function" ? v : function() {
1822       return v;
1823     };
1824   }
1825   d3.functor = d3_functor;
1826   function d3_identity(d) {
1827     return d;
1828   }
1829   d3.xhr = d3_xhrType(d3_identity);
1830   function d3_xhrType(response) {
1831     return function(url, mimeType, callback) {
1832       if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, 
1833       mimeType = null;
1834       return d3_xhr(url, mimeType, response, callback);
1835     };
1836   }
1837   function d3_xhr(url, mimeType, response, callback) {
1838     var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null;
1839     if (d3_window.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();
1840     "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {
1841       request.readyState > 3 && respond();
1842     };
1843     function respond() {
1844       var status = request.status, result;
1845       if (!status && request.responseText || status >= 200 && status < 300 || status === 304) {
1846         try {
1847           result = response.call(xhr, request);
1848         } catch (e) {
1849           dispatch.error.call(xhr, e);
1850           return;
1851         }
1852         dispatch.load.call(xhr, result);
1853       } else {
1854         dispatch.error.call(xhr, request);
1855       }
1856     }
1857     request.onprogress = function(event) {
1858       var o = d3.event;
1859       d3.event = event;
1860       try {
1861         dispatch.progress.call(xhr, request);
1862       } finally {
1863         d3.event = o;
1864       }
1865     };
1866     xhr.header = function(name, value) {
1867       name = (name + "").toLowerCase();
1868       if (arguments.length < 2) return headers[name];
1869       if (value == null) delete headers[name]; else headers[name] = value + "";
1870       return xhr;
1871     };
1872     xhr.mimeType = function(value) {
1873       if (!arguments.length) return mimeType;
1874       mimeType = value == null ? null : value + "";
1875       return xhr;
1876     };
1877     xhr.responseType = function(value) {
1878       if (!arguments.length) return responseType;
1879       responseType = value;
1880       return xhr;
1881     };
1882     xhr.response = function(value) {
1883       response = value;
1884       return xhr;
1885     };
1886     [ "get", "post" ].forEach(function(method) {
1887       xhr[method] = function() {
1888         return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));
1889       };
1890     });
1891     xhr.send = function(method, data, callback) {
1892       if (arguments.length === 2 && typeof data === "function") callback = data, data = null;
1893       request.open(method, url, true);
1894       if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
1895       if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);
1896       if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
1897       if (responseType != null) request.responseType = responseType;
1898       if (callback != null) xhr.on("error", callback).on("load", function(request) {
1899         callback(null, request);
1900       });
1901       dispatch.beforesend.call(xhr, request);
1902       request.send(data == null ? null : data);
1903       return xhr;
1904     };
1905     xhr.abort = function() {
1906       request.abort();
1907       return xhr;
1908     };
1909     d3.rebind(xhr, dispatch, "on");
1910     return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
1911   }
1912   function d3_xhr_fixCallback(callback) {
1913     return callback.length === 1 ? function(error, request) {
1914       callback(error == null ? request : null);
1915     } : callback;
1916   }
1917   d3.dsv = function(delimiter, mimeType) {
1918     var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);
1919     function dsv(url, row, callback) {
1920       if (arguments.length < 3) callback = row, row = null;
1921       var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);
1922       xhr.row = function(_) {
1923         return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row;
1924       };
1925       return xhr;
1926     }
1927     function response(request) {
1928       return dsv.parse(request.responseText);
1929     }
1930     function typedResponse(f) {
1931       return function(request) {
1932         return dsv.parse(request.responseText, f);
1933       };
1934     }
1935     dsv.parse = function(text, f) {
1936       var o;
1937       return dsv.parseRows(text, function(row, i) {
1938         if (o) return o(row, i - 1);
1939         var a = new Function("d", "return {" + row.map(function(name, i) {
1940           return JSON.stringify(name) + ": d[" + i + "]";
1941         }).join(",") + "}");
1942         o = f ? function(row, i) {
1943           return f(a(row), i);
1944         } : a;
1945       });
1946     };
1947     dsv.parseRows = function(text, f) {
1948       var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol;
1949       function token() {
1950         if (I >= N) return EOF;
1951         if (eol) return eol = false, EOL;
1952         var j = I;
1953         if (text.charCodeAt(j) === 34) {
1954           var i = j;
1955           while (i++ < N) {
1956             if (text.charCodeAt(i) === 34) {
1957               if (text.charCodeAt(i + 1) !== 34) break;
1958               ++i;
1959             }
1960           }
1961           I = i + 2;
1962           var c = text.charCodeAt(i + 1);
1963           if (c === 13) {
1964             eol = true;
1965             if (text.charCodeAt(i + 2) === 10) ++I;
1966           } else if (c === 10) {
1967             eol = true;
1968           }
1969           return text.substring(j + 1, i).replace(/""/g, '"');
1970         }
1971         while (I < N) {
1972           var c = text.charCodeAt(I++), k = 1;
1973           if (c === 10) eol = true; else if (c === 13) {
1974             eol = true;
1975             if (text.charCodeAt(I) === 10) ++I, ++k;
1976           } else if (c !== delimiterCode) continue;
1977           return text.substring(j, I - k);
1978         }
1979         return text.substring(j);
1980       }
1981       while ((t = token()) !== EOF) {
1982         var a = [];
1983         while (t !== EOL && t !== EOF) {
1984           a.push(t);
1985           t = token();
1986         }
1987         if (f && !(a = f(a, n++))) continue;
1988         rows.push(a);
1989       }
1990       return rows;
1991     };
1992     dsv.format = function(rows) {
1993       if (Array.isArray(rows[0])) return dsv.formatRows(rows);
1994       var fieldSet = new d3_Set(), fields = [];
1995       rows.forEach(function(row) {
1996         for (var field in row) {
1997           if (!fieldSet.has(field)) {
1998             fields.push(fieldSet.add(field));
1999           }
2000         }
2001       });
2002       return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) {
2003         return fields.map(function(field) {
2004           return formatValue(row[field]);
2005         }).join(delimiter);
2006       })).join("\n");
2007     };
2008     dsv.formatRows = function(rows) {
2009       return rows.map(formatRow).join("\n");
2010     };
2011     function formatRow(row) {
2012       return row.map(formatValue).join(delimiter);
2013     }
2014     function formatValue(text) {
2015       return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;
2016     }
2017     return dsv;
2018   };
2019   d3.csv = d3.dsv(",", "text/csv");
2020   d3.tsv = d3.dsv("    ", "text/tab-separated-values");
2021   d3.touch = function(container, touches, identifier) {
2022     if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
2023     if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) {
2024       if ((touch = touches[i]).identifier === identifier) {
2025         return d3_mousePoint(container, touch);
2026       }
2027     }
2028   };
2029   var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_active, d3_timer_frame = d3_window[d3_vendorSymbol(d3_window, "requestAnimationFrame")] || function(callback) {
2030     setTimeout(callback, 17);
2031   };
2032   d3.timer = function(callback, delay, then) {
2033     var n = arguments.length;
2034     if (n < 2) delay = 0;
2035     if (n < 3) then = Date.now();
2036     var time = then + delay, timer = {
2037       c: callback,
2038       t: time,
2039       f: false,
2040       n: null
2041     };
2042     if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer;
2043     d3_timer_queueTail = timer;
2044     if (!d3_timer_interval) {
2045       d3_timer_timeout = clearTimeout(d3_timer_timeout);
2046       d3_timer_interval = 1;
2047       d3_timer_frame(d3_timer_step);
2048     }
2049   };
2050   function d3_timer_step() {
2051     var now = d3_timer_mark(), delay = d3_timer_sweep() - now;
2052     if (delay > 24) {
2053       if (isFinite(delay)) {
2054         clearTimeout(d3_timer_timeout);
2055         d3_timer_timeout = setTimeout(d3_timer_step, delay);
2056       }
2057       d3_timer_interval = 0;
2058     } else {
2059       d3_timer_interval = 1;
2060       d3_timer_frame(d3_timer_step);
2061     }
2062   }
2063   d3.timer.flush = function() {
2064     d3_timer_mark();
2065     d3_timer_sweep();
2066   };
2067   function d3_timer_mark() {
2068     var now = Date.now();
2069     d3_timer_active = d3_timer_queueHead;
2070     while (d3_timer_active) {
2071       if (now >= d3_timer_active.t) d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t);
2072       d3_timer_active = d3_timer_active.n;
2073     }
2074     return now;
2075   }
2076   function d3_timer_sweep() {
2077     var t0, t1 = d3_timer_queueHead, time = Infinity;
2078     while (t1) {
2079       if (t1.f) {
2080         t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
2081       } else {
2082         if (t1.t < time) time = t1.t;
2083         t1 = (t0 = t1).n;
2084       }
2085     }
2086     d3_timer_queueTail = t0;
2087     return time;
2088   }
2089   function d3_format_precision(x, p) {
2090     return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1);
2091   }
2092   d3.round = function(x, n) {
2093     return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);
2094   };
2095   var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);
2096   d3.formatPrefix = function(value, precision) {
2097     var i = 0;
2098     if (value) {
2099       if (value < 0) value *= -1;
2100       if (precision) value = d3.round(value, d3_format_precision(value, precision));
2101       i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
2102       i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3));
2103     }
2104     return d3_formatPrefixes[8 + i / 3];
2105   };
2106   function d3_formatPrefix(d, i) {
2107     var k = Math.pow(10, abs(8 - i) * 3);
2108     return {
2109       scale: i > 8 ? function(d) {
2110         return d / k;
2111       } : function(d) {
2112         return d * k;
2113       },
2114       symbol: d
2115     };
2116   }
2117   function d3_locale_numberFormat(locale) {
2118     var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping ? function(value) {
2119       var i = value.length, t = [], j = 0, g = locale_grouping[0];
2120       while (i > 0 && g > 0) {
2121         t.push(value.substring(i -= g, i + g));
2122         g = locale_grouping[j = (j + 1) % locale_grouping.length];
2123       }
2124       return t.reverse().join(locale_thousands);
2125     } : d3_identity;
2126     return function(specifier) {
2127       var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false;
2128       if (precision) precision = +precision.substring(1);
2129       if (zfill || fill === "0" && align === "=") {
2130         zfill = fill = "0";
2131         align = "=";
2132         if (comma) width -= Math.floor((width - 1) / 4);
2133       }
2134       switch (type) {
2135        case "n":
2136         comma = true;
2137         type = "g";
2138         break;
2139
2140        case "%":
2141         scale = 100;
2142         suffix = "%";
2143         type = "f";
2144         break;
2145
2146        case "p":
2147         scale = 100;
2148         suffix = "%";
2149         type = "r";
2150         break;
2151
2152        case "b":
2153        case "o":
2154        case "x":
2155        case "X":
2156         if (symbol === "#") prefix = "0" + type.toLowerCase();
2157
2158        case "c":
2159        case "d":
2160         integer = true;
2161         precision = 0;
2162         break;
2163
2164        case "s":
2165         scale = -1;
2166         type = "r";
2167         break;
2168       }
2169       if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1];
2170       if (type == "r" && !precision) type = "g";
2171       if (precision != null) {
2172         if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision));
2173       }
2174       type = d3_format_types.get(type) || d3_format_typeDefault;
2175       var zcomma = zfill && comma;
2176       return function(value) {
2177         var fullSuffix = suffix;
2178         if (integer && value % 1) return "";
2179         var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign;
2180         if (scale < 0) {
2181           var unit = d3.formatPrefix(value, precision);
2182           value = unit.scale(value);
2183           fullSuffix = unit.symbol + suffix;
2184         } else {
2185           value *= scale;
2186         }
2187         value = type(value, precision);
2188         var i = value.lastIndexOf("."), before = i < 0 ? value : value.substring(0, i), after = i < 0 ? "" : locale_decimal + value.substring(i + 1);
2189         if (!zfill && comma) before = formatGroup(before);
2190         var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";
2191         if (zcomma) before = formatGroup(padding + before);
2192         negative += prefix;
2193         value = before + after;
2194         return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix;
2195       };
2196     };
2197   }
2198   var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i;
2199   var d3_format_types = d3.map({
2200     b: function(x) {
2201       return x.toString(2);
2202     },
2203     c: function(x) {
2204       return String.fromCharCode(x);
2205     },
2206     o: function(x) {
2207       return x.toString(8);
2208     },
2209     x: function(x) {
2210       return x.toString(16);
2211     },
2212     X: function(x) {
2213       return x.toString(16).toUpperCase();
2214     },
2215     g: function(x, p) {
2216       return x.toPrecision(p);
2217     },
2218     e: function(x, p) {
2219       return x.toExponential(p);
2220     },
2221     f: function(x, p) {
2222       return x.toFixed(p);
2223     },
2224     r: function(x, p) {
2225       return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p))));
2226     }
2227   });
2228   function d3_format_typeDefault(x) {
2229     return x + "";
2230   }
2231   var d3_time = d3.time = {}, d3_date = Date;
2232   function d3_date_utc() {
2233     this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]);
2234   }
2235   d3_date_utc.prototype = {
2236     getDate: function() {
2237       return this._.getUTCDate();
2238     },
2239     getDay: function() {
2240       return this._.getUTCDay();
2241     },
2242     getFullYear: function() {
2243       return this._.getUTCFullYear();
2244     },
2245     getHours: function() {
2246       return this._.getUTCHours();
2247     },
2248     getMilliseconds: function() {
2249       return this._.getUTCMilliseconds();
2250     },
2251     getMinutes: function() {
2252       return this._.getUTCMinutes();
2253     },
2254     getMonth: function() {
2255       return this._.getUTCMonth();
2256     },
2257     getSeconds: function() {
2258       return this._.getUTCSeconds();
2259     },
2260     getTime: function() {
2261       return this._.getTime();
2262     },
2263     getTimezoneOffset: function() {
2264       return 0;
2265     },
2266     valueOf: function() {
2267       return this._.valueOf();
2268     },
2269     setDate: function() {
2270       d3_time_prototype.setUTCDate.apply(this._, arguments);
2271     },
2272     setDay: function() {
2273       d3_time_prototype.setUTCDay.apply(this._, arguments);
2274     },
2275     setFullYear: function() {
2276       d3_time_prototype.setUTCFullYear.apply(this._, arguments);
2277     },
2278     setHours: function() {
2279       d3_time_prototype.setUTCHours.apply(this._, arguments);
2280     },
2281     setMilliseconds: function() {
2282       d3_time_prototype.setUTCMilliseconds.apply(this._, arguments);
2283     },
2284     setMinutes: function() {
2285       d3_time_prototype.setUTCMinutes.apply(this._, arguments);
2286     },
2287     setMonth: function() {
2288       d3_time_prototype.setUTCMonth.apply(this._, arguments);
2289     },
2290     setSeconds: function() {
2291       d3_time_prototype.setUTCSeconds.apply(this._, arguments);
2292     },
2293     setTime: function() {
2294       d3_time_prototype.setTime.apply(this._, arguments);
2295     }
2296   };
2297   var d3_time_prototype = Date.prototype;
2298   function d3_time_interval(local, step, number) {
2299     function round(date) {
2300       var d0 = local(date), d1 = offset(d0, 1);
2301       return date - d0 < d1 - date ? d0 : d1;
2302     }
2303     function ceil(date) {
2304       step(date = local(new d3_date(date - 1)), 1);
2305       return date;
2306     }
2307     function offset(date, k) {
2308       step(date = new d3_date(+date), k);
2309       return date;
2310     }
2311     function range(t0, t1, dt) {
2312       var time = ceil(t0), times = [];
2313       if (dt > 1) {
2314         while (time < t1) {
2315           if (!(number(time) % dt)) times.push(new Date(+time));
2316           step(time, 1);
2317         }
2318       } else {
2319         while (time < t1) times.push(new Date(+time)), step(time, 1);
2320       }
2321       return times;
2322     }
2323     function range_utc(t0, t1, dt) {
2324       try {
2325         d3_date = d3_date_utc;
2326         var utc = new d3_date_utc();
2327         utc._ = t0;
2328         return range(utc, t1, dt);
2329       } finally {
2330         d3_date = Date;
2331       }
2332     }
2333     local.floor = local;
2334     local.round = round;
2335     local.ceil = ceil;
2336     local.offset = offset;
2337     local.range = range;
2338     var utc = local.utc = d3_time_interval_utc(local);
2339     utc.floor = utc;
2340     utc.round = d3_time_interval_utc(round);
2341     utc.ceil = d3_time_interval_utc(ceil);
2342     utc.offset = d3_time_interval_utc(offset);
2343     utc.range = range_utc;
2344     return local;
2345   }
2346   function d3_time_interval_utc(method) {
2347     return function(date, k) {
2348       try {
2349         d3_date = d3_date_utc;
2350         var utc = new d3_date_utc();
2351         utc._ = date;
2352         return method(utc, k)._;
2353       } finally {
2354         d3_date = Date;
2355       }
2356     };
2357   }
2358   d3_time.year = d3_time_interval(function(date) {
2359     date = d3_time.day(date);
2360     date.setMonth(0, 1);
2361     return date;
2362   }, function(date, offset) {
2363     date.setFullYear(date.getFullYear() + offset);
2364   }, function(date) {
2365     return date.getFullYear();
2366   });
2367   d3_time.years = d3_time.year.range;
2368   d3_time.years.utc = d3_time.year.utc.range;
2369   d3_time.day = d3_time_interval(function(date) {
2370     var day = new d3_date(2e3, 0);
2371     day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
2372     return day;
2373   }, function(date, offset) {
2374     date.setDate(date.getDate() + offset);
2375   }, function(date) {
2376     return date.getDate() - 1;
2377   });
2378   d3_time.days = d3_time.day.range;
2379   d3_time.days.utc = d3_time.day.utc.range;
2380   d3_time.dayOfYear = function(date) {
2381     var year = d3_time.year(date);
2382     return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5);
2383   };
2384   [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) {
2385     i = 7 - i;
2386     var interval = d3_time[day] = d3_time_interval(function(date) {
2387       (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7);
2388       return date;
2389     }, function(date, offset) {
2390       date.setDate(date.getDate() + Math.floor(offset) * 7);
2391     }, function(date) {
2392       var day = d3_time.year(date).getDay();
2393       return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i);
2394     });
2395     d3_time[day + "s"] = interval.range;
2396     d3_time[day + "s"].utc = interval.utc.range;
2397     d3_time[day + "OfYear"] = function(date) {
2398       var day = d3_time.year(date).getDay();
2399       return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7);
2400     };
2401   });
2402   d3_time.week = d3_time.sunday;
2403   d3_time.weeks = d3_time.sunday.range;
2404   d3_time.weeks.utc = d3_time.sunday.utc.range;
2405   d3_time.weekOfYear = d3_time.sundayOfYear;
2406   function d3_locale_timeFormat(locale) {
2407     var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;
2408     function d3_time_format(template) {
2409       var n = template.length;
2410       function format(date) {
2411         var string = [], i = -1, j = 0, c, p, f;
2412         while (++i < n) {
2413           if (template.charCodeAt(i) === 37) {
2414             string.push(template.substring(j, i));
2415             if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i);
2416             if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p);
2417             string.push(c);
2418             j = i + 1;
2419           }
2420         }
2421         string.push(template.substring(j, i));
2422         return string.join("");
2423       }
2424       format.parse = function(string) {
2425         var d = {
2426           y: 1900,
2427           m: 0,
2428           d: 1,
2429           H: 0,
2430           M: 0,
2431           S: 0,
2432           L: 0,
2433           Z: null
2434         }, i = d3_time_parse(d, template, string, 0);
2435         if (i != string.length) return null;
2436         if ("p" in d) d.H = d.H % 12 + d.p * 12;
2437         var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)();
2438         if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("w" in d && ("W" in d || "U" in d)) {
2439           date.setFullYear(d.y, 0, 1);
2440           date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7);
2441         } else date.setFullYear(d.y, d.m, d.d);
2442         date.setHours(d.H + Math.floor(d.Z / 100), d.M + d.Z % 100, d.S, d.L);
2443         return localZ ? date._ : date;
2444       };
2445       format.toString = function() {
2446         return template;
2447       };
2448       return format;
2449     }
2450     function d3_time_parse(date, template, string, j) {
2451       var c, p, t, i = 0, n = template.length, m = string.length;
2452       while (i < n) {
2453         if (j >= m) return -1;
2454         c = template.charCodeAt(i++);
2455         if (c === 37) {
2456           t = template.charAt(i++);
2457           p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t];
2458           if (!p || (j = p(date, string, j)) < 0) return -1;
2459         } else if (c != string.charCodeAt(j++)) {
2460           return -1;
2461         }
2462       }
2463       return j;
2464     }
2465     d3_time_format.utc = function(template) {
2466       var local = d3_time_format(template);
2467       function format(date) {
2468         try {
2469           d3_date = d3_date_utc;
2470           var utc = new d3_date();
2471           utc._ = date;
2472           return local(utc);
2473         } finally {
2474           d3_date = Date;
2475         }
2476       }
2477       format.parse = function(string) {
2478         try {
2479           d3_date = d3_date_utc;
2480           var date = local.parse(string);
2481           return date && date._;
2482         } finally {
2483           d3_date = Date;
2484         }
2485       };
2486       format.toString = local.toString;
2487       return format;
2488     };
2489     d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti;
2490     var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(locale_shortMonths);
2491     locale_periods.forEach(function(p, i) {
2492       d3_time_periodLookup.set(p.toLowerCase(), i);
2493     });
2494     var d3_time_formats = {
2495       a: function(d) {
2496         return locale_shortDays[d.getDay()];
2497       },
2498       A: function(d) {
2499         return locale_days[d.getDay()];
2500       },
2501       b: function(d) {
2502         return locale_shortMonths[d.getMonth()];
2503       },
2504       B: function(d) {
2505         return locale_months[d.getMonth()];
2506       },
2507       c: d3_time_format(locale_dateTime),
2508       d: function(d, p) {
2509         return d3_time_formatPad(d.getDate(), p, 2);
2510       },
2511       e: function(d, p) {
2512         return d3_time_formatPad(d.getDate(), p, 2);
2513       },
2514       H: function(d, p) {
2515         return d3_time_formatPad(d.getHours(), p, 2);
2516       },
2517       I: function(d, p) {
2518         return d3_time_formatPad(d.getHours() % 12 || 12, p, 2);
2519       },
2520       j: function(d, p) {
2521         return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3);
2522       },
2523       L: function(d, p) {
2524         return d3_time_formatPad(d.getMilliseconds(), p, 3);
2525       },
2526       m: function(d, p) {
2527         return d3_time_formatPad(d.getMonth() + 1, p, 2);
2528       },
2529       M: function(d, p) {
2530         return d3_time_formatPad(d.getMinutes(), p, 2);
2531       },
2532       p: function(d) {
2533         return locale_periods[+(d.getHours() >= 12)];
2534       },
2535       S: function(d, p) {
2536         return d3_time_formatPad(d.getSeconds(), p, 2);
2537       },
2538       U: function(d, p) {
2539         return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2);
2540       },
2541       w: function(d) {
2542         return d.getDay();
2543       },
2544       W: function(d, p) {
2545         return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2);
2546       },
2547       x: d3_time_format(locale_date),
2548       X: d3_time_format(locale_time),
2549       y: function(d, p) {
2550         return d3_time_formatPad(d.getFullYear() % 100, p, 2);
2551       },
2552       Y: function(d, p) {
2553         return d3_time_formatPad(d.getFullYear() % 1e4, p, 4);
2554       },
2555       Z: d3_time_zone,
2556       "%": function() {
2557         return "%";
2558       }
2559     };
2560     var d3_time_parsers = {
2561       a: d3_time_parseWeekdayAbbrev,
2562       A: d3_time_parseWeekday,
2563       b: d3_time_parseMonthAbbrev,
2564       B: d3_time_parseMonth,
2565       c: d3_time_parseLocaleFull,
2566       d: d3_time_parseDay,
2567       e: d3_time_parseDay,
2568       H: d3_time_parseHour24,
2569       I: d3_time_parseHour24,
2570       j: d3_time_parseDayOfYear,
2571       L: d3_time_parseMilliseconds,
2572       m: d3_time_parseMonthNumber,
2573       M: d3_time_parseMinutes,
2574       p: d3_time_parseAmPm,
2575       S: d3_time_parseSeconds,
2576       U: d3_time_parseWeekNumberSunday,
2577       w: d3_time_parseWeekdayNumber,
2578       W: d3_time_parseWeekNumberMonday,
2579       x: d3_time_parseLocaleDate,
2580       X: d3_time_parseLocaleTime,
2581       y: d3_time_parseYear,
2582       Y: d3_time_parseFullYear,
2583       Z: d3_time_parseZone,
2584       "%": d3_time_parseLiteralPercent
2585     };
2586     function d3_time_parseWeekdayAbbrev(date, string, i) {
2587       d3_time_dayAbbrevRe.lastIndex = 0;
2588       var n = d3_time_dayAbbrevRe.exec(string.substring(i));
2589       return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
2590     }
2591     function d3_time_parseWeekday(date, string, i) {
2592       d3_time_dayRe.lastIndex = 0;
2593       var n = d3_time_dayRe.exec(string.substring(i));
2594       return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
2595     }
2596     function d3_time_parseMonthAbbrev(date, string, i) {
2597       d3_time_monthAbbrevRe.lastIndex = 0;
2598       var n = d3_time_monthAbbrevRe.exec(string.substring(i));
2599       return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
2600     }
2601     function d3_time_parseMonth(date, string, i) {
2602       d3_time_monthRe.lastIndex = 0;
2603       var n = d3_time_monthRe.exec(string.substring(i));
2604       return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
2605     }
2606     function d3_time_parseLocaleFull(date, string, i) {
2607       return d3_time_parse(date, d3_time_formats.c.toString(), string, i);
2608     }
2609     function d3_time_parseLocaleDate(date, string, i) {
2610       return d3_time_parse(date, d3_time_formats.x.toString(), string, i);
2611     }
2612     function d3_time_parseLocaleTime(date, string, i) {
2613       return d3_time_parse(date, d3_time_formats.X.toString(), string, i);
2614     }
2615     function d3_time_parseAmPm(date, string, i) {
2616       var n = d3_time_periodLookup.get(string.substring(i, i += 2).toLowerCase());
2617       return n == null ? -1 : (date.p = n, i);
2618     }
2619     return d3_time_format;
2620   }
2621   var d3_time_formatPads = {
2622     "-": "",
2623     _: " ",
2624     "0": "0"
2625   }, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/;
2626   function d3_time_formatPad(value, fill, width) {
2627     var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
2628     return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
2629   }
2630   function d3_time_formatRe(names) {
2631     return new RegExp("^(?:" + names.map(d3.requote).join("|") + ")", "i");
2632   }
2633   function d3_time_formatLookup(names) {
2634     var map = new d3_Map(), i = -1, n = names.length;
2635     while (++i < n) map.set(names[i].toLowerCase(), i);
2636     return map;
2637   }
2638   function d3_time_parseWeekdayNumber(date, string, i) {
2639     d3_time_numberRe.lastIndex = 0;
2640     var n = d3_time_numberRe.exec(string.substring(i, i + 1));
2641     return n ? (date.w = +n[0], i + n[0].length) : -1;
2642   }
2643   function d3_time_parseWeekNumberSunday(date, string, i) {
2644     d3_time_numberRe.lastIndex = 0;
2645     var n = d3_time_numberRe.exec(string.substring(i));
2646     return n ? (date.U = +n[0], i + n[0].length) : -1;
2647   }
2648   function d3_time_parseWeekNumberMonday(date, string, i) {
2649     d3_time_numberRe.lastIndex = 0;
2650     var n = d3_time_numberRe.exec(string.substring(i));
2651     return n ? (date.W = +n[0], i + n[0].length) : -1;
2652   }
2653   function d3_time_parseFullYear(date, string, i) {
2654     d3_time_numberRe.lastIndex = 0;
2655     var n = d3_time_numberRe.exec(string.substring(i, i + 4));
2656     return n ? (date.y = +n[0], i + n[0].length) : -1;
2657   }
2658   function d3_time_parseYear(date, string, i) {
2659     d3_time_numberRe.lastIndex = 0;
2660     var n = d3_time_numberRe.exec(string.substring(i, i + 2));
2661     return n ? (date.y = d3_time_expandYear(+n[0]), i + n[0].length) : -1;
2662   }
2663   function d3_time_parseZone(date, string, i) {
2664     return /^[+-]\d{4}$/.test(string = string.substring(i, i + 5)) ? (date.Z = -string, 
2665     i + 5) : -1;
2666   }
2667   function d3_time_expandYear(d) {
2668     return d + (d > 68 ? 1900 : 2e3);
2669   }
2670   function d3_time_parseMonthNumber(date, string, i) {
2671     d3_time_numberRe.lastIndex = 0;
2672     var n = d3_time_numberRe.exec(string.substring(i, i + 2));
2673     return n ? (date.m = n[0] - 1, i + n[0].length) : -1;
2674   }
2675   function d3_time_parseDay(date, string, i) {
2676     d3_time_numberRe.lastIndex = 0;
2677     var n = d3_time_numberRe.exec(string.substring(i, i + 2));
2678     return n ? (date.d = +n[0], i + n[0].length) : -1;
2679   }
2680   function d3_time_parseDayOfYear(date, string, i) {
2681     d3_time_numberRe.lastIndex = 0;
2682     var n = d3_time_numberRe.exec(string.substring(i, i + 3));
2683     return n ? (date.j = +n[0], i + n[0].length) : -1;
2684   }
2685   function d3_time_parseHour24(date, string, i) {
2686     d3_time_numberRe.lastIndex = 0;
2687     var n = d3_time_numberRe.exec(string.substring(i, i + 2));
2688     return n ? (date.H = +n[0], i + n[0].length) : -1;
2689   }
2690   function d3_time_parseMinutes(date, string, i) {
2691     d3_time_numberRe.lastIndex = 0;
2692     var n = d3_time_numberRe.exec(string.substring(i, i + 2));
2693     return n ? (date.M = +n[0], i + n[0].length) : -1;
2694   }
2695   function d3_time_parseSeconds(date, string, i) {
2696     d3_time_numberRe.lastIndex = 0;
2697     var n = d3_time_numberRe.exec(string.substring(i, i + 2));
2698     return n ? (date.S = +n[0], i + n[0].length) : -1;
2699   }
2700   function d3_time_parseMilliseconds(date, string, i) {
2701     d3_time_numberRe.lastIndex = 0;
2702     var n = d3_time_numberRe.exec(string.substring(i, i + 3));
2703     return n ? (date.L = +n[0], i + n[0].length) : -1;
2704   }
2705   function d3_time_zone(d) {
2706     var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = ~~(abs(z) / 60), zm = abs(z) % 60;
2707     return zs + d3_time_formatPad(zh, "0", 2) + d3_time_formatPad(zm, "0", 2);
2708   }
2709   function d3_time_parseLiteralPercent(date, string, i) {
2710     d3_time_percentRe.lastIndex = 0;
2711     var n = d3_time_percentRe.exec(string.substring(i, i + 1));
2712     return n ? i + n[0].length : -1;
2713   }
2714   function d3_time_formatMulti(formats) {
2715     var n = formats.length, i = -1;
2716     while (++i < n) formats[i][0] = this(formats[i][0]);
2717     return function(date) {
2718       var i = 0, f = formats[i];
2719       while (!f[1](date)) f = formats[++i];
2720       return f[0](date);
2721     };
2722   }
2723   d3.locale = function(locale) {
2724     return {
2725       numberFormat: d3_locale_numberFormat(locale),
2726       timeFormat: d3_locale_timeFormat(locale)
2727     };
2728   };
2729   var d3_locale_enUS = d3.locale({
2730     decimal: ".",
2731     thousands: ",",
2732     grouping: [ 3 ],
2733     currency: [ "$", "" ],
2734     dateTime: "%a %b %e %X %Y",
2735     date: "%m/%d/%Y",
2736     time: "%H:%M:%S",
2737     periods: [ "AM", "PM" ],
2738     days: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ],
2739     shortDays: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ],
2740     months: [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ],
2741     shortMonths: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
2742   });
2743   d3.format = d3_locale_enUS.numberFormat;
2744   d3.geo = {};
2745   function d3_adder() {}
2746   d3_adder.prototype = {
2747     s: 0,
2748     t: 0,
2749     add: function(y) {
2750       d3_adderSum(y, this.t, d3_adderTemp);
2751       d3_adderSum(d3_adderTemp.s, this.s, this);
2752       if (this.s) this.t += d3_adderTemp.t; else this.s = d3_adderTemp.t;
2753     },
2754     reset: function() {
2755       this.s = this.t = 0;
2756     },
2757     valueOf: function() {
2758       return this.s;
2759     }
2760   };
2761   var d3_adderTemp = new d3_adder();
2762   function d3_adderSum(a, b, o) {
2763     var x = o.s = a + b, bv = x - a, av = x - bv;
2764     o.t = a - av + (b - bv);
2765   }
2766   d3.geo.stream = function(object, listener) {
2767     if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
2768       d3_geo_streamObjectType[object.type](object, listener);
2769     } else {
2770       d3_geo_streamGeometry(object, listener);
2771     }
2772   };
2773   function d3_geo_streamGeometry(geometry, listener) {
2774     if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
2775       d3_geo_streamGeometryType[geometry.type](geometry, listener);
2776     }
2777   }
2778   var d3_geo_streamObjectType = {
2779     Feature: function(feature, listener) {
2780       d3_geo_streamGeometry(feature.geometry, listener);
2781     },
2782     FeatureCollection: function(object, listener) {
2783       var features = object.features, i = -1, n = features.length;
2784       while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
2785     }
2786   };
2787   var d3_geo_streamGeometryType = {
2788     Sphere: function(object, listener) {
2789       listener.sphere();
2790     },
2791     Point: function(object, listener) {
2792       object = object.coordinates;
2793       listener.point(object[0], object[1], object[2]);
2794     },
2795     MultiPoint: function(object, listener) {
2796       var coordinates = object.coordinates, i = -1, n = coordinates.length;
2797       while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]);
2798     },
2799     LineString: function(object, listener) {
2800       d3_geo_streamLine(object.coordinates, listener, 0);
2801     },
2802     MultiLineString: function(object, listener) {
2803       var coordinates = object.coordinates, i = -1, n = coordinates.length;
2804       while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
2805     },
2806     Polygon: function(object, listener) {
2807       d3_geo_streamPolygon(object.coordinates, listener);
2808     },
2809     MultiPolygon: function(object, listener) {
2810       var coordinates = object.coordinates, i = -1, n = coordinates.length;
2811       while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
2812     },
2813     GeometryCollection: function(object, listener) {
2814       var geometries = object.geometries, i = -1, n = geometries.length;
2815       while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
2816     }
2817   };
2818   function d3_geo_streamLine(coordinates, listener, closed) {
2819     var i = -1, n = coordinates.length - closed, coordinate;
2820     listener.lineStart();
2821     while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]);
2822     listener.lineEnd();
2823   }
2824   function d3_geo_streamPolygon(coordinates, listener) {
2825     var i = -1, n = coordinates.length;
2826     listener.polygonStart();
2827     while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
2828     listener.polygonEnd();
2829   }
2830   d3.geo.area = function(object) {
2831     d3_geo_areaSum = 0;
2832     d3.geo.stream(object, d3_geo_area);
2833     return d3_geo_areaSum;
2834   };
2835   var d3_geo_areaSum, d3_geo_areaRingSum = new d3_adder();
2836   var d3_geo_area = {
2837     sphere: function() {
2838       d3_geo_areaSum += 4 * π;
2839     },
2840     point: d3_noop,
2841     lineStart: d3_noop,
2842     lineEnd: d3_noop,
2843     polygonStart: function() {
2844       d3_geo_areaRingSum.reset();
2845       d3_geo_area.lineStart = d3_geo_areaRingStart;
2846     },
2847     polygonEnd: function() {
2848       var area = 2 * d3_geo_areaRingSum;
2849       d3_geo_areaSum += area < 0 ? 4 * π + area : area;
2850       d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
2851     }
2852   };
2853   function d3_geo_areaRingStart() {
2854     var λ00, φ00, λ0, cosφ0, sinφ0;
2855     d3_geo_area.point = function(λ, φ) {
2856       d3_geo_area.point = nextPoint;
2857       λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), 
2858       sinφ0 = Math.sin(φ);
2859     };
2860     function nextPoint(λ, φ) {
2861       λ *= d3_radians;
2862       φ = φ * d3_radians / 2 + π / 4;
2863       var dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u = cosφ0 * cosφ + k * Math.cos(adλ), v = k * sdλ * Math.sin(adλ);
2864       d3_geo_areaRingSum.add(Math.atan2(v, u));
2865       λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
2866     }
2867     d3_geo_area.lineEnd = function() {
2868       nextPoint(λ00, φ00);
2869     };
2870   }
2871   function d3_geo_cartesian(spherical) {
2872     var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ);
2873     return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ];
2874   }
2875   function d3_geo_cartesianDot(a, b) {
2876     return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2877   }
2878   function d3_geo_cartesianCross(a, b) {
2879     return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ];
2880   }
2881   function d3_geo_cartesianAdd(a, b) {
2882     a[0] += b[0];
2883     a[1] += b[1];
2884     a[2] += b[2];
2885   }
2886   function d3_geo_cartesianScale(vector, k) {
2887     return [ vector[0] * k, vector[1] * k, vector[2] * k ];
2888   }
2889   function d3_geo_cartesianNormalize(d) {
2890     var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
2891     d[0] /= l;
2892     d[1] /= l;
2893     d[2] /= l;
2894   }
2895   function d3_geo_spherical(cartesian) {
2896     return [ Math.atan2(cartesian[1], cartesian[0]), d3_asin(cartesian[2]) ];
2897   }
2898   function d3_geo_sphericalEqual(a, b) {
2899     return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε;
2900   }
2901   d3.geo.bounds = function() {
2902     var λ0, φ0, λ1, φ1, λ_, λ__, φ__, p0, dλSum, ranges, range;
2903     var bound = {
2904       point: point,
2905       lineStart: lineStart,
2906       lineEnd: lineEnd,
2907       polygonStart: function() {
2908         bound.point = ringPoint;
2909         bound.lineStart = ringStart;
2910         bound.lineEnd = ringEnd;
2911         dλSum = 0;
2912         d3_geo_area.polygonStart();
2913       },
2914       polygonEnd: function() {
2915         d3_geo_area.polygonEnd();
2916         bound.point = point;
2917         bound.lineStart = lineStart;
2918         bound.lineEnd = lineEnd;
2919         if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90); else if (dλSum > ε) φ1 = 90; else if (dλSum < -ε) φ0 = -90;
2920         range[0] = λ0, range[1] = λ1;
2921       }
2922     };
2923     function point(λ, φ) {
2924       ranges.push(range = [ λ0 = λ, λ1 = λ ]);
2925       if (φ < φ0) φ0 = φ;
2926       if (φ > φ1) φ1 = φ;
2927     }
2928     function linePoint(λ, φ) {
2929       var p = d3_geo_cartesian([ λ * d3_radians, φ * d3_radians ]);
2930       if (p0) {
2931         var normal = d3_geo_cartesianCross(p0, p), equatorial = [ normal[1], -normal[0], 0 ], inflection = d3_geo_cartesianCross(equatorial, normal);
2932         d3_geo_cartesianNormalize(inflection);
2933         inflection = d3_geo_spherical(inflection);
2934         var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, antimeridian = abs(dλ) > 180;
2935         if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
2936           var φi = inflection[1] * d3_degrees;
2937           if (φi > φ1) φ1 = φi;
2938         } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
2939           var φi = -inflection[1] * d3_degrees;
2940           if (φi < φ0) φ0 = φi;
2941         } else {
2942           if (φ < φ0) φ0 = φ;
2943           if (φ > φ1) φ1 = φ;
2944         }
2945         if (antimeridian) {
2946           if (λ < λ_) {
2947             if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
2948           } else {
2949             if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
2950           }
2951         } else {
2952           if (λ1 >= λ0) {
2953             if (λ < λ0) λ0 = λ;
2954             if (λ > λ1) λ1 = λ;
2955           } else {
2956             if (λ > λ_) {
2957               if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
2958             } else {
2959               if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
2960             }
2961           }
2962         }
2963       } else {
2964         point(λ, φ);
2965       }
2966       p0 = p, λ_ = λ;
2967     }
2968     function lineStart() {
2969       bound.point = linePoint;
2970     }
2971     function lineEnd() {
2972       range[0] = λ0, range[1] = λ1;
2973       bound.point = point;
2974       p0 = null;
2975     }
2976     function ringPoint(λ, φ) {
2977       if (p0) {
2978         var dλ = λ - λ_;
2979         dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
2980       } else λ__ = λ, φ__ = φ;
2981       d3_geo_area.point(λ, φ);
2982       linePoint(λ, φ);
2983     }
2984     function ringStart() {
2985       d3_geo_area.lineStart();
2986     }
2987     function ringEnd() {
2988       ringPoint(λ__, φ__);
2989       d3_geo_area.lineEnd();
2990       if (abs(dλSum) > ε) λ0 = -(λ1 = 180);
2991       range[0] = λ0, range[1] = λ1;
2992       p0 = null;
2993     }
2994     function angle(λ0, λ1) {
2995       return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1;
2996     }
2997     function compareRanges(a, b) {
2998       return a[0] - b[0];
2999     }
3000     function withinRange(x, range) {
3001       return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
3002     }
3003     return function(feature) {
3004       φ1 = λ1 = -(λ0 = φ0 = Infinity);
3005       ranges = [];
3006       d3.geo.stream(feature, bound);
3007       var n = ranges.length;
3008       if (n) {
3009         ranges.sort(compareRanges);
3010         for (var i = 1, a = ranges[0], b, merged = [ a ]; i < n; ++i) {
3011           b = ranges[i];
3012           if (withinRange(b[0], a) || withinRange(b[1], a)) {
3013             if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
3014             if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
3015           } else {
3016             merged.push(a = b);
3017           }
3018         }
3019         var best = -Infinity, dλ;
3020         for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
3021           b = merged[i];
3022           if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
3023         }
3024       }
3025       ranges = range = null;
3026       return λ0 === Infinity || φ0 === Infinity ? [ [ NaN, NaN ], [ NaN, NaN ] ] : [ [ λ0, φ0 ], [ λ1, φ1 ] ];
3027     };
3028   }();
3029   d3.geo.centroid = function(object) {
3030     d3_geo_centroidW0 = d3_geo_centroidW1 = d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
3031     d3.geo.stream(object, d3_geo_centroid);
3032     var x = d3_geo_centroidX2, y = d3_geo_centroidY2, z = d3_geo_centroidZ2, m = x * x + y * y + z * z;
3033     if (m < ε2) {
3034       x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
3035       if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
3036       m = x * x + y * y + z * z;
3037       if (m < ε2) return [ NaN, NaN ];
3038     }
3039     return [ Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees ];
3040   };
3041   var d3_geo_centroidW0, d3_geo_centroidW1, d3_geo_centroidX0, d3_geo_centroidY0, d3_geo_centroidZ0, d3_geo_centroidX1, d3_geo_centroidY1, d3_geo_centroidZ1, d3_geo_centroidX2, d3_geo_centroidY2, d3_geo_centroidZ2;
3042   var d3_geo_centroid = {
3043     sphere: d3_noop,
3044     point: d3_geo_centroidPoint,
3045     lineStart: d3_geo_centroidLineStart,
3046     lineEnd: d3_geo_centroidLineEnd,
3047     polygonStart: function() {
3048       d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
3049     },
3050     polygonEnd: function() {
3051       d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
3052     }
3053   };
3054   function d3_geo_centroidPoint(λ, φ) {
3055     λ *= d3_radians;
3056     var cosφ = Math.cos(φ *= d3_radians);
3057     d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
3058   }
3059   function d3_geo_centroidPointXYZ(x, y, z) {
3060     ++d3_geo_centroidW0;
3061     d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
3062     d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
3063     d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
3064   }
3065   function d3_geo_centroidLineStart() {
3066     var x0, y0, z0;
3067     d3_geo_centroid.point = function(λ, φ) {
3068       λ *= d3_radians;
3069       var cosφ = Math.cos(φ *= d3_radians);
3070       x0 = cosφ * Math.cos(λ);
3071       y0 = cosφ * Math.sin(λ);
3072       z0 = Math.sin(φ);
3073       d3_geo_centroid.point = nextPoint;
3074       d3_geo_centroidPointXYZ(x0, y0, z0);
3075     };
3076     function nextPoint(λ, φ) {
3077       λ *= d3_radians;
3078       var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
3079       d3_geo_centroidW1 += w;
3080       d3_geo_centroidX1 += w * (x0 + (x0 = x));
3081       d3_geo_centroidY1 += w * (y0 + (y0 = y));
3082       d3_geo_centroidZ1 += w * (z0 + (z0 = z));
3083       d3_geo_centroidPointXYZ(x0, y0, z0);
3084     }
3085   }
3086   function d3_geo_centroidLineEnd() {
3087     d3_geo_centroid.point = d3_geo_centroidPoint;
3088   }
3089   function d3_geo_centroidRingStart() {
3090     var λ00, φ00, x0, y0, z0;
3091     d3_geo_centroid.point = function(λ, φ) {
3092       λ00 = λ, φ00 = φ;
3093       d3_geo_centroid.point = nextPoint;
3094       λ *= d3_radians;
3095       var cosφ = Math.cos(φ *= d3_radians);
3096       x0 = cosφ * Math.cos(λ);
3097       y0 = cosφ * Math.sin(λ);
3098       z0 = Math.sin(φ);
3099       d3_geo_centroidPointXYZ(x0, y0, z0);
3100     };
3101     d3_geo_centroid.lineEnd = function() {
3102       nextPoint(λ00, φ00);
3103       d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
3104       d3_geo_centroid.point = d3_geo_centroidPoint;
3105     };
3106     function nextPoint(λ, φ) {
3107       λ *= d3_radians;
3108       var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = Math.sqrt(cx * cx + cy * cy + cz * cz), u = x0 * x + y0 * y + z0 * z, v = m && -d3_acos(u) / m, w = Math.atan2(m, u);
3109       d3_geo_centroidX2 += v * cx;
3110       d3_geo_centroidY2 += v * cy;
3111       d3_geo_centroidZ2 += v * cz;
3112       d3_geo_centroidW1 += w;
3113       d3_geo_centroidX1 += w * (x0 + (x0 = x));
3114       d3_geo_centroidY1 += w * (y0 + (y0 = y));
3115       d3_geo_centroidZ1 += w * (z0 + (z0 = z));
3116       d3_geo_centroidPointXYZ(x0, y0, z0);
3117     }
3118   }
3119   function d3_true() {
3120     return true;
3121   }
3122   function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
3123     var subject = [], clip = [];
3124     segments.forEach(function(segment) {
3125       if ((n = segment.length - 1) <= 0) return;
3126       var n, p0 = segment[0], p1 = segment[n];
3127       if (d3_geo_sphericalEqual(p0, p1)) {
3128         listener.lineStart();
3129         for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
3130         listener.lineEnd();
3131         return;
3132       }
3133       var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
3134       a.o = b;
3135       subject.push(a);
3136       clip.push(b);
3137       a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
3138       b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
3139       a.o = b;
3140       subject.push(a);
3141       clip.push(b);
3142     });
3143     clip.sort(compare);
3144     d3_geo_clipPolygonLinkCircular(subject);
3145     d3_geo_clipPolygonLinkCircular(clip);
3146     if (!subject.length) return;
3147     for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
3148       clip[i].e = entry = !entry;
3149     }
3150     var start = subject[0], points, point;
3151     while (1) {
3152       var current = start, isSubject = true;
3153       while (current.v) if ((current = current.n) === start) return;
3154       points = current.z;
3155       listener.lineStart();
3156       do {
3157         current.v = current.o.v = true;
3158         if (current.e) {
3159           if (isSubject) {
3160             for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
3161           } else {
3162             interpolate(current.x, current.n.x, 1, listener);
3163           }
3164           current = current.n;
3165         } else {
3166           if (isSubject) {
3167             points = current.p.z;
3168             for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
3169           } else {
3170             interpolate(current.x, current.p.x, -1, listener);
3171           }
3172           current = current.p;
3173         }
3174         current = current.o;
3175         points = current.z;
3176         isSubject = !isSubject;
3177       } while (!current.v);
3178       listener.lineEnd();
3179     }
3180   }
3181   function d3_geo_clipPolygonLinkCircular(array) {
3182     if (!(n = array.length)) return;
3183     var n, i = 0, a = array[0], b;
3184     while (++i < n) {
3185       a.n = b = array[i];
3186       b.p = a;
3187       a = b;
3188     }
3189     a.n = b = array[0];
3190     b.p = a;
3191   }
3192   function d3_geo_clipPolygonIntersection(point, points, other, entry) {
3193     this.x = point;
3194     this.z = points;
3195     this.o = other;
3196     this.e = entry;
3197     this.v = false;
3198     this.n = this.p = null;
3199   }
3200   function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
3201     return function(rotate, listener) {
3202       var line = clipLine(listener), rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
3203       var clip = {
3204         point: point,
3205         lineStart: lineStart,
3206         lineEnd: lineEnd,
3207         polygonStart: function() {
3208           clip.point = pointRing;
3209           clip.lineStart = ringStart;
3210           clip.lineEnd = ringEnd;
3211           segments = [];
3212           polygon = [];
3213         },
3214         polygonEnd: function() {
3215           clip.point = point;
3216           clip.lineStart = lineStart;
3217           clip.lineEnd = lineEnd;
3218           segments = d3.merge(segments);
3219           var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
3220           if (segments.length) {
3221             if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
3222             d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
3223           } else if (clipStartInside) {
3224             if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
3225             listener.lineStart();
3226             interpolate(null, null, 1, listener);
3227             listener.lineEnd();
3228           }
3229           if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
3230           segments = polygon = null;
3231         },
3232         sphere: function() {
3233           listener.polygonStart();
3234           listener.lineStart();
3235           interpolate(null, null, 1, listener);
3236           listener.lineEnd();
3237           listener.polygonEnd();
3238         }
3239       };
3240       function point(λ, φ) {
3241         var point = rotate(λ, φ);
3242         if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
3243       }
3244       function pointLine(λ, φ) {
3245         var point = rotate(λ, φ);
3246         line.point(point[0], point[1]);
3247       }
3248       function lineStart() {
3249         clip.point = pointLine;
3250         line.lineStart();
3251       }
3252       function lineEnd() {
3253         clip.point = point;
3254         line.lineEnd();
3255       }
3256       var segments;
3257       var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), polygonStarted = false, polygon, ring;
3258       function pointRing(λ, φ) {
3259         ring.push([ λ, φ ]);
3260         var point = rotate(λ, φ);
3261         ringListener.point(point[0], point[1]);
3262       }
3263       function ringStart() {
3264         ringListener.lineStart();
3265         ring = [];
3266       }
3267       function ringEnd() {
3268         pointRing(ring[0][0], ring[0][1]);
3269         ringListener.lineEnd();
3270         var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length;
3271         ring.pop();
3272         polygon.push(ring);
3273         ring = null;
3274         if (!n) return;
3275         if (clean & 1) {
3276           segment = ringSegments[0];
3277           var n = segment.length - 1, i = -1, point;
3278           if (n > 0) {
3279             if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
3280             listener.lineStart();
3281             while (++i < n) listener.point((point = segment[i])[0], point[1]);
3282             listener.lineEnd();
3283           }
3284           return;
3285         }
3286         if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
3287         segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
3288       }
3289       return clip;
3290<