8f8f661ac4877350c1c158ac9d109bdf6fcd095b
[rails.git] / vendor / assets / iD / iD.js
1 (function(exports) {
2
3   var bootstrap = (typeof exports.bootstrap === "object") ?
4     exports.bootstrap :
5     (exports.bootstrap = {});
6
7   bootstrap.tooltip = function() {
8
9     var tooltip = function(selection) {
10         selection.each(setup);
11       },
12       animation = d3.functor(false),
13       html = d3.functor(false),
14       title = function() {
15         var title = this.getAttribute("data-original-title");
16         if (title) {
17           return title;
18         } else {
19           title = this.getAttribute("title");
20           this.removeAttribute("title");
21           this.setAttribute("data-original-title", title);
22         }
23         return title;
24       },
25       over = "mouseenter.tooltip",
26       out = "mouseleave.tooltip",
27       placements = "top left bottom right".split(" "),
28       placement = d3.functor("top");
29
30     tooltip.title = function(_) {
31       if (arguments.length) {
32         title = d3.functor(_);
33         return tooltip;
34       } else {
35         return title;
36       }
37     };
38
39     tooltip.html = function(_) {
40       if (arguments.length) {
41         html = d3.functor(_);
42         return tooltip;
43       } else {
44         return html;
45       }
46     };
47
48     tooltip.placement = function(_) {
49       if (arguments.length) {
50         placement = d3.functor(_);
51         return tooltip;
52       } else {
53         return placement;
54       }
55     };
56
57     tooltip.show = function(selection) {
58       selection.each(show);
59     };
60
61     tooltip.hide = function(selection) {
62       selection.each(hide);
63     };
64
65     tooltip.toggle = function(selection) {
66       selection.each(toggle);
67     };
68
69     tooltip.destroy = function(selection) {
70       selection
71         .on(over, null)
72         .on(out, null)
73         .attr("title", function() {
74           return this.getAttribute("data-original-title") || this.getAttribute("title");
75         })
76         .attr("data-original-title", null)
77         .select(".tooltip")
78         .remove();
79     };
80
81     function setup() {
82       var root = d3.select(this),
83           animate = animation.apply(this, arguments),
84           tip = root.append("div")
85             .attr("class", "tooltip");
86
87       if (animate) {
88         tip.classed("fade", true);
89       }
90
91       // TODO "inside" checks?
92
93       tip.append("div")
94         .attr("class", "tooltip-arrow");
95       tip.append("div")
96         .attr("class", "tooltip-inner");
97
98       var place = placement.apply(this, arguments);
99       tip.classed(place, true);
100
101       root.on(over, show);
102       root.on(out, hide);
103     }
104
105     function show() {
106       var root = d3.select(this),
107           content = title.apply(this, arguments),
108           tip = root.select(".tooltip")
109             .classed("in", true),
110           markup = html.apply(this, arguments),
111           innercontent = tip.select(".tooltip-inner")[markup ? "html" : "text"](content),
112           place = placement.apply(this, arguments),
113           outer = getPosition(root.node()),
114           inner = getPosition(tip.node()),
115           pos;
116
117       switch (place) {
118         case "top":
119           pos = {x: outer.x + (outer.w - inner.w) / 2, y: outer.y - inner.h};
120           break;
121         case "right":
122           pos = {x: outer.x + outer.w, y: outer.y + (outer.h - inner.h) / 2};
123           break;
124         case "left":
125           pos = {x: outer.x - inner.w, y: outer.y + (outer.h - inner.h) / 2};
126           break;
127         case "bottom":
128           pos = {x: Math.max(0, outer.x + (outer.w - inner.w) / 2), y: outer.y + outer.h};
129           break;
130       }
131
132       tip.style(pos ?
133         {left: ~~pos.x + "px", top: ~~pos.y + "px"} :
134         {left: null, top: null});
135
136       this.tooltipVisible = true;
137     }
138
139     function hide() {
140       d3.select(this).select(".tooltip")
141         .classed("in", false);
142
143       this.tooltipVisible = false;
144     }
145
146     function toggle() {
147       if (this.tooltipVisible) {
148         hide.apply(this, arguments);
149       } else {
150         show.apply(this, arguments);
151       }
152     }
153
154     return tooltip;
155   };
156
157   function getPosition(node) {
158     var mode = d3.select(node).style('position');
159     if (mode === 'absolute' || mode === 'static') {
160       return {
161         x: node.offsetLeft,
162         y: node.offsetTop,
163         w: node.offsetWidth,
164         h: node.offsetHeight
165       };
166     } else {
167       return {
168         x: 0,
169         y: 0,
170         w: node.offsetWidth,
171         h: node.offsetHeight
172       };
173     }
174   }
175
176 })(this);
177 !function(){
178   var d3 = {version: "3.5.5"}; // semver
179 d3.ascending = d3_ascending;
180
181 function d3_ascending(a, b) {
182   return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
183 }
184 d3.descending = function(a, b) {
185   return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
186 };
187 d3.min = function(array, f) {
188   var i = -1,
189       n = array.length,
190       a,
191       b;
192   if (arguments.length === 1) {
193     while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }
194     while (++i < n) if ((b = array[i]) != null && a > b) a = b;
195   } else {
196     while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) { a = b; break; }
197     while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
198   }
199   return a;
200 };
201 d3.max = function(array, f) {
202   var i = -1,
203       n = array.length,
204       a,
205       b;
206   if (arguments.length === 1) {
207     while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }
208     while (++i < n) if ((b = array[i]) != null && b > a) a = b;
209   } else {
210     while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) { a = b; break; }
211     while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
212   }
213   return a;
214 };
215 d3.extent = function(array, f) {
216   var i = -1,
217       n = array.length,
218       a,
219       b,
220       c;
221   if (arguments.length === 1) {
222     while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; }
223     while (++i < n) if ((b = array[i]) != null) {
224       if (a > b) a = b;
225       if (c < b) c = b;
226     }
227   } else {
228     while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) { a = c = b; break; }
229     while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
230       if (a > b) a = b;
231       if (c < b) c = b;
232     }
233   }
234   return [a, c];
235 };
236 function d3_number(x) {
237   return x === null ? NaN : +x;
238 }
239
240 function d3_numeric(x) {
241   return !isNaN(x);
242 }
243
244 d3.sum = function(array, f) {
245   var s = 0,
246       n = array.length,
247       a,
248       i = -1;
249   if (arguments.length === 1) {
250     while (++i < n) if (d3_numeric(a = +array[i])) s += a; // zero and null are equivalent
251   } else {
252     while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a;
253   }
254   return s;
255 };
256
257 d3.mean = function(array, f) {
258   var s = 0,
259       n = array.length,
260       a,
261       i = -1,
262       j = n;
263   if (arguments.length === 1) {
264     while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;
265   } else {
266     while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j;
267   }
268   if (j) return s / j;
269 };
270 // R-7 per <http://en.wikipedia.org/wiki/Quantile>
271 d3.quantile = function(values, p) {
272   var H = (values.length - 1) * p + 1,
273       h = Math.floor(H),
274       v = +values[h - 1],
275       e = H - h;
276   return e ? v + e * (values[h] - v) : v;
277 };
278
279 d3.median = function(array, f) {
280   var numbers = [],
281       n = array.length,
282       a,
283       i = -1;
284   if (arguments.length === 1) {
285     while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);
286   } else {
287     while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);
288   }
289   if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5);
290 };
291
292 d3.variance = function(array, f) {
293   var n = array.length,
294       m = 0,
295       a,
296       d,
297       s = 0,
298       i = -1,
299       j = 0;
300   if (arguments.length === 1) {
301     while (++i < n) {
302       if (d3_numeric(a = d3_number(array[i]))) {
303         d = a - m;
304         m += d / ++j;
305         s += d * (a - m);
306       }
307     }
308   } else {
309     while (++i < n) {
310       if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {
311         d = a - m;
312         m += d / ++j;
313         s += d * (a - m);
314       }
315     }
316   }
317   if (j > 1) return s / (j - 1);
318 };
319
320 d3.deviation = function() {
321   var v = d3.variance.apply(this, arguments);
322   return v ? Math.sqrt(v) : v;
323 };
324
325 function d3_bisector(compare) {
326   return {
327     left: function(a, x, lo, hi) {
328       if (arguments.length < 3) lo = 0;
329       if (arguments.length < 4) hi = a.length;
330       while (lo < hi) {
331         var mid = lo + hi >>> 1;
332         if (compare(a[mid], x) < 0) lo = mid + 1;
333         else hi = mid;
334       }
335       return lo;
336     },
337     right: function(a, x, lo, hi) {
338       if (arguments.length < 3) lo = 0;
339       if (arguments.length < 4) hi = a.length;
340       while (lo < hi) {
341         var mid = lo + hi >>> 1;
342         if (compare(a[mid], x) > 0) hi = mid;
343         else lo = mid + 1;
344       }
345       return lo;
346     }
347   };
348 }
349
350 var d3_bisect = d3_bisector(d3_ascending);
351 d3.bisectLeft = d3_bisect.left;
352 d3.bisect = d3.bisectRight = d3_bisect.right;
353
354 d3.bisector = function(f) {
355   return d3_bisector(f.length === 1
356       ? function(d, x) { return d3_ascending(f(d), x); }
357       : f);
358 };
359 d3.shuffle = function(array, i0, i1) {
360   if ((m = arguments.length) < 3) { i1 = array.length; if (m < 2) i0 = 0; }
361   var m = i1 - i0, t, i;
362   while (m) {
363     i = Math.random() * m-- | 0;
364     t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t;
365   }
366   return array;
367 };
368 d3.permute = function(array, indexes) {
369   var i = indexes.length, permutes = new Array(i);
370   while (i--) permutes[i] = array[indexes[i]];
371   return permutes;
372 };
373 d3.pairs = function(array) {
374   var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);
375   while (i < n) pairs[i] = [p0 = p1, p1 = array[++i]];
376   return pairs;
377 };
378
379 d3.zip = function() {
380   if (!(n = arguments.length)) return [];
381   for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) {
382     for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) {
383       zip[j] = arguments[j][i];
384     }
385   }
386   return zips;
387 };
388
389 function d3_zipLength(d) {
390   return d.length;
391 }
392
393 d3.transpose = function(matrix) {
394   return d3.zip.apply(d3, matrix);
395 };
396 d3.keys = function(map) {
397   var keys = [];
398   for (var key in map) keys.push(key);
399   return keys;
400 };
401 d3.values = function(map) {
402   var values = [];
403   for (var key in map) values.push(map[key]);
404   return values;
405 };
406 d3.entries = function(map) {
407   var entries = [];
408   for (var key in map) entries.push({key: key, value: map[key]});
409   return entries;
410 };
411 d3.merge = function(arrays) {
412   var n = arrays.length,
413       m,
414       i = -1,
415       j = 0,
416       merged,
417       array;
418
419   while (++i < n) j += arrays[i].length;
420   merged = new Array(j);
421
422   while (--n >= 0) {
423     array = arrays[n];
424     m = array.length;
425     while (--m >= 0) {
426       merged[--j] = array[m];
427     }
428   }
429
430   return merged;
431 };
432 var abs = Math.abs;
433
434 d3.range = function(start, stop, step) {
435   if (arguments.length < 3) {
436     step = 1;
437     if (arguments.length < 2) {
438       stop = start;
439       start = 0;
440     }
441   }
442   if ((stop - start) / step === Infinity) throw new Error("infinite range");
443   var range = [],
444        k = d3_range_integerScale(abs(step)),
445        i = -1,
446        j;
447   start *= k, stop *= k, step *= k;
448   if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k);
449   else while ((j = start + step * ++i) < stop) range.push(j / k);
450   return range;
451 };
452
453 function d3_range_integerScale(x) {
454   var k = 1;
455   while (x * k % 1) k *= 10;
456   return k;
457 }
458 function d3_class(ctor, properties) {
459   for (var key in properties) {
460     Object.defineProperty(ctor.prototype, key, {
461       value: properties[key],
462       enumerable: false
463     });
464   }
465 }
466
467 d3.map = function(object, f) {
468   var map = new d3_Map;
469   if (object instanceof d3_Map) {
470     object.forEach(function(key, value) { map.set(key, value); });
471   } else if (Array.isArray(object)) {
472     var i = -1,
473         n = object.length,
474         o;
475     if (arguments.length === 1) while (++i < n) map.set(i, object[i]);
476     else while (++i < n) map.set(f.call(object, o = object[i], i), o);
477   } else {
478     for (var key in object) map.set(key, object[key]);
479   }
480   return map;
481 };
482
483 function d3_Map() {
484   this._ = Object.create(null);
485 }
486
487 var d3_map_proto = "__proto__",
488     d3_map_zero = "\0";
489
490 d3_class(d3_Map, {
491   has: d3_map_has,
492   get: function(key) {
493     return this._[d3_map_escape(key)];
494   },
495   set: function(key, value) {
496     return this._[d3_map_escape(key)] = value;
497   },
498   remove: d3_map_remove,
499   keys: d3_map_keys,
500   values: function() {
501     var values = [];
502     for (var key in this._) values.push(this._[key]);
503     return values;
504   },
505   entries: function() {
506     var entries = [];
507     for (var key in this._) entries.push({key: d3_map_unescape(key), value: this._[key]});
508     return entries;
509   },
510   size: d3_map_size,
511   empty: d3_map_empty,
512   forEach: function(f) {
513     for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]);
514   }
515 });
516
517 function d3_map_escape(key) {
518   return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;
519 }
520
521 function d3_map_unescape(key) {
522   return (key += "")[0] === d3_map_zero ? key.slice(1) : key;
523 }
524
525 function d3_map_has(key) {
526   return d3_map_escape(key) in this._;
527 }
528
529 function d3_map_remove(key) {
530   return (key = d3_map_escape(key)) in this._ && delete this._[key];
531 }
532
533 function d3_map_keys() {
534   var keys = [];
535   for (var key in this._) keys.push(d3_map_unescape(key));
536   return keys;
537 }
538
539 function d3_map_size() {
540   var size = 0;
541   for (var key in this._) ++size;
542   return size;
543 }
544
545 function d3_map_empty() {
546   for (var key in this._) return false;
547   return true;
548 }
549
550 d3.nest = function() {
551   var nest = {},
552       keys = [],
553       sortKeys = [],
554       sortValues,
555       rollup;
556
557   function map(mapType, array, depth) {
558     if (depth >= keys.length) return rollup
559         ? rollup.call(nest, array) : (sortValues
560         ? array.sort(sortValues)
561         : array);
562
563     var i = -1,
564         n = array.length,
565         key = keys[depth++],
566         keyValue,
567         object,
568         setter,
569         valuesByKey = new d3_Map,
570         values;
571
572     while (++i < n) {
573       if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
574         values.push(object);
575       } else {
576         valuesByKey.set(keyValue, [object]);
577       }
578     }
579
580     if (mapType) {
581       object = mapType();
582       setter = function(keyValue, values) {
583         object.set(keyValue, map(mapType, values, depth));
584       };
585     } else {
586       object = {};
587       setter = function(keyValue, values) {
588         object[keyValue] = map(mapType, values, depth);
589       };
590     }
591
592     valuesByKey.forEach(setter);
593     return object;
594   }
595
596   function entries(map, depth) {
597     if (depth >= keys.length) return map;
598
599     var array = [],
600         sortKey = sortKeys[depth++];
601
602     map.forEach(function(key, keyMap) {
603       array.push({key: key, values: entries(keyMap, depth)});
604     });
605
606     return sortKey
607         ? array.sort(function(a, b) { return sortKey(a.key, b.key); })
608         : array;
609   }
610
611   nest.map = function(array, mapType) {
612     return map(mapType, array, 0);
613   };
614
615   nest.entries = function(array) {
616     return entries(map(d3.map, array, 0), 0);
617   };
618
619   nest.key = function(d) {
620     keys.push(d);
621     return nest;
622   };
623
624   // Specifies the order for the most-recently specified key.
625   // Note: only applies to entries. Map keys are unordered!
626   nest.sortKeys = function(order) {
627     sortKeys[keys.length - 1] = order;
628     return nest;
629   };
630
631   // Specifies the order for leaf values.
632   // Applies to both maps and entries array.
633   nest.sortValues = function(order) {
634     sortValues = order;
635     return nest;
636   };
637
638   nest.rollup = function(f) {
639     rollup = f;
640     return nest;
641   };
642
643   return nest;
644 };
645
646 d3.set = function(array) {
647   var set = new d3_Set;
648   if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);
649   return set;
650 };
651
652 function d3_Set() {
653   this._ = Object.create(null);
654 }
655
656 d3_class(d3_Set, {
657   has: d3_map_has,
658   add: function(key) {
659     this._[d3_map_escape(key += "")] = true;
660     return key;
661   },
662   remove: d3_map_remove,
663   values: d3_map_keys,
664   size: d3_map_size,
665   empty: d3_map_empty,
666   forEach: function(f) {
667     for (var key in this._) f.call(this, d3_map_unescape(key));
668   }
669 });
670 d3.behavior = {};
671 var d3_document = this.document;
672
673 function d3_documentElement(node) {
674   return node
675       && (node.ownerDocument // node is a Node
676       || node.document // node is a Window
677       || node).documentElement; // node is a Document
678 }
679
680 function d3_window(node) {
681   return node
682       && ((node.ownerDocument && node.ownerDocument.defaultView) // node is a Node
683         || (node.document && node) // node is a Window
684         || node.defaultView); // node is a Document
685 }
686 // Copies a variable number of methods from source to target.
687 d3.rebind = function(target, source) {
688   var i = 1, n = arguments.length, method;
689   while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
690   return target;
691 };
692
693 // Method is assumed to be a standard D3 getter-setter:
694 // If passed with no arguments, gets the value.
695 // If passed with arguments, sets the value and returns the target.
696 function d3_rebind(target, source, method) {
697   return function() {
698     var value = method.apply(source, arguments);
699     return value === source ? target : value;
700   };
701 }
702 function d3_vendorSymbol(object, name) {
703   if (name in object) return name;
704   name = name.charAt(0).toUpperCase() + name.slice(1);
705   for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {
706     var prefixName = d3_vendorPrefixes[i] + name;
707     if (prefixName in object) return prefixName;
708   }
709 }
710
711 var d3_vendorPrefixes = ["webkit", "ms", "moz", "Moz", "o", "O"];
712 var d3_arraySlice = [].slice,
713     d3_array = function(list) { return d3_arraySlice.call(list); }; // conversion for NodeLists
714 function d3_noop() {}
715
716 d3.dispatch = function() {
717   var dispatch = new d3_dispatch,
718       i = -1,
719       n = arguments.length;
720   while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
721   return dispatch;
722 };
723
724 function d3_dispatch() {}
725
726 d3_dispatch.prototype.on = function(type, listener) {
727   var i = type.indexOf("."),
728       name = "";
729
730   // Extract optional namespace, e.g., "click.foo"
731   if (i >= 0) {
732     name = type.slice(i + 1);
733     type = type.slice(0, i);
734   }
735
736   if (type) return arguments.length < 2
737       ? this[type].on(name)
738       : this[type].on(name, listener);
739
740   if (arguments.length === 2) {
741     if (listener == null) for (type in this) {
742       if (this.hasOwnProperty(type)) this[type].on(name, null);
743     }
744     return this;
745   }
746 };
747
748 function d3_dispatch_event(dispatch) {
749   var listeners = [],
750       listenerByName = new d3_Map;
751
752   function event() {
753     var z = listeners, // defensive reference
754         i = -1,
755         n = z.length,
756         l;
757     while (++i < n) if (l = z[i].on) l.apply(this, arguments);
758     return dispatch;
759   }
760
761   event.on = function(name, listener) {
762     var l = listenerByName.get(name),
763         i;
764
765     // return the current listener, if any
766     if (arguments.length < 2) return l && l.on;
767
768     // remove the old listener, if any (with copy-on-write)
769     if (l) {
770       l.on = null;
771       listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
772       listenerByName.remove(name);
773     }
774
775     // add the new listener, if any
776     if (listener) listeners.push(listenerByName.set(name, {on: listener}));
777
778     return dispatch;
779   };
780
781   return event;
782 }
783
784 d3.event = null;
785
786 function d3_eventPreventDefault() {
787   d3.event.preventDefault();
788 }
789
790 function d3_eventCancel() {
791   d3.event.preventDefault();
792   d3.event.stopPropagation();
793 }
794
795 function d3_eventSource() {
796   var e = d3.event, s;
797   while (s = e.sourceEvent) e = s;
798   return e;
799 }
800
801 // Like d3.dispatch, but for custom events abstracting native UI events. These
802 // events have a target component (such as a brush), a target element (such as
803 // the svg:g element containing the brush) and the standard arguments `d` (the
804 // target element's data) and `i` (the selection index of the target element).
805 function d3_eventDispatch(target) {
806   var dispatch = new d3_dispatch,
807       i = 0,
808       n = arguments.length;
809
810   while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
811
812   // Creates a dispatch context for the specified `thiz` (typically, the target
813   // DOM element that received the source event) and `argumentz` (typically, the
814   // data `d` and index `i` of the target element). The returned function can be
815   // used to dispatch an event to any registered listeners; the function takes a
816   // single argument as input, being the event to dispatch. The event must have
817   // a "type" attribute which corresponds to a type registered in the
818   // constructor. This context will automatically populate the "sourceEvent" and
819   // "target" attributes of the event, as well as setting the `d3.event` global
820   // for the duration of the notification.
821   dispatch.of = function(thiz, argumentz) {
822     return function(e1) {
823       try {
824         var e0 =
825         e1.sourceEvent = d3.event;
826         e1.target = target;
827         d3.event = e1;
828         dispatch[e1.type].apply(thiz, argumentz);
829       } finally {
830         d3.event = e0;
831       }
832     };
833   };
834
835   return dispatch;
836 }
837 d3.requote = function(s) {
838   return s.replace(d3_requote_re, "\\$&");
839 };
840
841 var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
842 var d3_subclass = {}.__proto__?
843
844 // Until ECMAScript supports array subclassing, prototype injection works well.
845 function(object, prototype) {
846   object.__proto__ = prototype;
847 }:
848
849 // And if your browser doesn't support __proto__, we'll use direct extension.
850 function(object, prototype) {
851   for (var property in prototype) object[property] = prototype[property];
852 };
853
854 function d3_selection(groups) {
855   d3_subclass(groups, d3_selectionPrototype);
856   return groups;
857 }
858
859 var d3_select = function(s, n) { return n.querySelector(s); },
860     d3_selectAll = function(s, n) { return n.querySelectorAll(s); },
861     d3_selectMatches = function(n, s) {
862       var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")];
863       d3_selectMatches = function(n, s) {
864         return d3_selectMatcher.call(n, s);
865       };
866       return d3_selectMatches(n, s);
867     };
868
869 // Prefer Sizzle, if available.
870 if (typeof Sizzle === "function") {
871   d3_select = function(s, n) { return Sizzle(s, n)[0] || null; };
872   d3_selectAll = Sizzle;
873   d3_selectMatches = Sizzle.matchesSelector;
874 }
875
876 d3.selection = function() {
877   return d3.select(d3_document.documentElement);
878 };
879
880 var d3_selectionPrototype = d3.selection.prototype = [];
881
882
883 d3_selectionPrototype.select = function(selector) {
884   var subgroups = [],
885       subgroup,
886       subnode,
887       group,
888       node;
889
890   selector = d3_selection_selector(selector);
891
892   for (var j = -1, m = this.length; ++j < m;) {
893     subgroups.push(subgroup = []);
894     subgroup.parentNode = (group = this[j]).parentNode;
895     for (var i = -1, n = group.length; ++i < n;) {
896       if (node = group[i]) {
897         subgroup.push(subnode = selector.call(node, node.__data__, i, j));
898         if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
899       } else {
900         subgroup.push(null);
901       }
902     }
903   }
904
905   return d3_selection(subgroups);
906 };
907
908 function d3_selection_selector(selector) {
909   return typeof selector === "function" ? selector : function() {
910     return d3_select(selector, this);
911   };
912 }
913
914 d3_selectionPrototype.selectAll = function(selector) {
915   var subgroups = [],
916       subgroup,
917       node;
918
919   selector = d3_selection_selectorAll(selector);
920
921   for (var j = -1, m = this.length; ++j < m;) {
922     for (var group = this[j], i = -1, n = group.length; ++i < n;) {
923       if (node = group[i]) {
924         subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));
925         subgroup.parentNode = node;
926       }
927     }
928   }
929
930   return d3_selection(subgroups);
931 };
932
933 function d3_selection_selectorAll(selector) {
934   return typeof selector === "function" ? selector : function() {
935     return d3_selectAll(selector, this);
936   };
937 }
938 var d3_nsPrefix = {
939   svg: "http://www.w3.org/2000/svg",
940   xhtml: "http://www.w3.org/1999/xhtml",
941   xlink: "http://www.w3.org/1999/xlink",
942   xml: "http://www.w3.org/XML/1998/namespace",
943   xmlns: "http://www.w3.org/2000/xmlns/"
944 };
945
946 d3.ns = {
947   prefix: d3_nsPrefix,
948   qualify: function(name) {
949     var i = name.indexOf(":"),
950         prefix = name;
951     if (i >= 0) {
952       prefix = name.slice(0, i);
953       name = name.slice(i + 1);
954     }
955     return d3_nsPrefix.hasOwnProperty(prefix)
956         ? {space: d3_nsPrefix[prefix], local: name}
957         : name;
958   }
959 };
960
961 d3_selectionPrototype.attr = function(name, value) {
962   if (arguments.length < 2) {
963
964     // For attr(string), return the attribute value for the first node.
965     if (typeof name === "string") {
966       var node = this.node();
967       name = d3.ns.qualify(name);
968       return name.local
969           ? node.getAttributeNS(name.space, name.local)
970           : node.getAttribute(name);
971     }
972
973     // For attr(object), the object specifies the names and values of the
974     // attributes to set or remove. The values may be functions that are
975     // evaluated for each element.
976     for (value in name) this.each(d3_selection_attr(value, name[value]));
977     return this;
978   }
979
980   return this.each(d3_selection_attr(name, value));
981 };
982
983 function d3_selection_attr(name, value) {
984   name = d3.ns.qualify(name);
985
986   // For attr(string, null), remove the attribute with the specified name.
987   function attrNull() {
988     this.removeAttribute(name);
989   }
990   function attrNullNS() {
991     this.removeAttributeNS(name.space, name.local);
992   }
993
994   // For attr(string, string), set the attribute with the specified name.
995   function attrConstant() {
996     this.setAttribute(name, value);
997   }
998   function attrConstantNS() {
999     this.setAttributeNS(name.space, name.local, value);
1000   }
1001
1002   // For attr(string, function), evaluate the function for each element, and set
1003   // or remove the attribute as appropriate.
1004   function attrFunction() {
1005     var x = value.apply(this, arguments);
1006     if (x == null) this.removeAttribute(name);
1007     else this.setAttribute(name, x);
1008   }
1009   function attrFunctionNS() {
1010     var x = value.apply(this, arguments);
1011     if (x == null) this.removeAttributeNS(name.space, name.local);
1012     else this.setAttributeNS(name.space, name.local, x);
1013   }
1014
1015   return value == null
1016       ? (name.local ? attrNullNS : attrNull) : (typeof value === "function"
1017       ? (name.local ? attrFunctionNS : attrFunction)
1018       : (name.local ? attrConstantNS : attrConstant));
1019 }
1020 function d3_collapse(s) {
1021   return s.trim().replace(/\s+/g, " ");
1022 }
1023
1024 d3_selectionPrototype.classed = function(name, value) {
1025   if (arguments.length < 2) {
1026
1027     // For classed(string), return true only if the first node has the specified
1028     // class or classes. Note that even if the browser supports DOMTokenList, it
1029     // probably doesn't support it on SVG elements (which can be animated).
1030     if (typeof name === "string") {
1031       var node = this.node(),
1032           n = (name = d3_selection_classes(name)).length,
1033           i = -1;
1034       if (value = node.classList) {
1035         while (++i < n) if (!value.contains(name[i])) return false;
1036       } else {
1037         value = node.getAttribute("class");
1038         while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
1039       }
1040       return true;
1041     }
1042
1043     // For classed(object), the object specifies the names of classes to add or
1044     // remove. The values may be functions that are evaluated for each element.
1045     for (value in name) this.each(d3_selection_classed(value, name[value]));
1046     return this;
1047   }
1048
1049   // Otherwise, both a name and a value are specified, and are handled as below.
1050   return this.each(d3_selection_classed(name, value));
1051 };
1052
1053 function d3_selection_classedRe(name) {
1054   return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
1055 }
1056
1057 function d3_selection_classes(name) {
1058   return (name + "").trim().split(/^|\s+/);
1059 }
1060
1061 // Multiple class names are allowed (e.g., "foo bar").
1062 function d3_selection_classed(name, value) {
1063   name = d3_selection_classes(name).map(d3_selection_classedName);
1064   var n = name.length;
1065
1066   function classedConstant() {
1067     var i = -1;
1068     while (++i < n) name[i](this, value);
1069   }
1070
1071   // When the value is a function, the function is still evaluated only once per
1072   // element even if there are multiple class names.
1073   function classedFunction() {
1074     var i = -1, x = value.apply(this, arguments);
1075     while (++i < n) name[i](this, x);
1076   }
1077
1078   return typeof value === "function"
1079       ? classedFunction
1080       : classedConstant;
1081 }
1082
1083 function d3_selection_classedName(name) {
1084   var re = d3_selection_classedRe(name);
1085   return function(node, value) {
1086     if (c = node.classList) return value ? c.add(name) : c.remove(name);
1087     var c = node.getAttribute("class") || "";
1088     if (value) {
1089       re.lastIndex = 0;
1090       if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
1091     } else {
1092       node.setAttribute("class", d3_collapse(c.replace(re, " ")));
1093     }
1094   };
1095 }
1096
1097 d3_selectionPrototype.style = function(name, value, priority) {
1098   var n = arguments.length;
1099   if (n < 3) {
1100
1101     // For style(object) or style(object, string), the object specifies the
1102     // names and values of the attributes to set or remove. The values may be
1103     // functions that are evaluated for each element. The optional string
1104     // specifies the priority.
1105     if (typeof name !== "string") {
1106       if (n < 2) value = "";
1107       for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
1108       return this;
1109     }
1110
1111     // For style(string), return the computed style value for the first node.
1112     if (n < 2) {
1113       var node = this.node();
1114       return d3_window(node).getComputedStyle(node, null).getPropertyValue(name);
1115     }
1116
1117     // For style(string, string) or style(string, function), use the default
1118     // priority. The priority is ignored for style(string, null).
1119     priority = "";
1120   }
1121
1122   // Otherwise, a name, value and priority are specified, and handled as below.
1123   return this.each(d3_selection_style(name, value, priority));
1124 };
1125
1126 function d3_selection_style(name, value, priority) {
1127
1128   // For style(name, null) or style(name, null, priority), remove the style
1129   // property with the specified name. The priority is ignored.
1130   function styleNull() {
1131     this.style.removeProperty(name);
1132   }
1133
1134   // For style(name, string) or style(name, string, priority), set the style
1135   // property with the specified name, using the specified priority.
1136   function styleConstant() {
1137     this.style.setProperty(name, value, priority);
1138   }
1139
1140   // For style(name, function) or style(name, function, priority), evaluate the
1141   // function for each element, and set or remove the style property as
1142   // appropriate. When setting, use the specified priority.
1143   function styleFunction() {
1144     var x = value.apply(this, arguments);
1145     if (x == null) this.style.removeProperty(name);
1146     else this.style.setProperty(name, x, priority);
1147   }
1148
1149   return value == null
1150       ? styleNull : (typeof value === "function"
1151       ? styleFunction : styleConstant);
1152 }
1153
1154 d3_selectionPrototype.property = function(name, value) {
1155   if (arguments.length < 2) {
1156
1157     // For property(string), return the property value for the first node.
1158     if (typeof name === "string") return this.node()[name];
1159
1160     // For property(object), the object specifies the names and values of the
1161     // properties to set or remove. The values may be functions that are
1162     // evaluated for each element.
1163     for (value in name) this.each(d3_selection_property(value, name[value]));
1164     return this;
1165   }
1166
1167   // Otherwise, both a name and a value are specified, and are handled as below.
1168   return this.each(d3_selection_property(name, value));
1169 };
1170
1171 function d3_selection_property(name, value) {
1172
1173   // For property(name, null), remove the property with the specified name.
1174   function propertyNull() {
1175     delete this[name];
1176   }
1177
1178   // For property(name, string), set the property with the specified name.
1179   function propertyConstant() {
1180     this[name] = value;
1181   }
1182
1183   // For property(name, function), evaluate the function for each element, and
1184   // set or remove the property as appropriate.
1185   function propertyFunction() {
1186     var x = value.apply(this, arguments);
1187     if (x == null) delete this[name];
1188     else this[name] = x;
1189   }
1190
1191   return value == null
1192       ? propertyNull : (typeof value === "function"
1193       ? propertyFunction : propertyConstant);
1194 }
1195
1196 d3_selectionPrototype.text = function(value) {
1197   return arguments.length
1198       ? this.each(typeof value === "function"
1199       ? function() { var v = value.apply(this, arguments); this.textContent = v == null ? "" : v; } : value == null
1200       ? function() { if (this.textContent !== "") this.textContent = ""; }
1201       : function() { if (this.textContent !== value) this.textContent = value; })
1202       : this.node().textContent;
1203 };
1204
1205 d3_selectionPrototype.html = function(value) {
1206   return arguments.length
1207       ? this.each(typeof value === "function"
1208       ? function() { var v = value.apply(this, arguments); this.innerHTML = v == null ? "" : v; } : value == null
1209       ? function() { this.innerHTML = ""; }
1210       : function() { this.innerHTML = value; })
1211       : this.node().innerHTML;
1212 };
1213
1214 d3_selectionPrototype.append = function(name) {
1215   name = d3_selection_creator(name);
1216   return this.select(function() {
1217     return this.appendChild(name.apply(this, arguments));
1218   });
1219 };
1220
1221 function d3_selection_creator(name) {
1222
1223   function create() {
1224     var document = this.ownerDocument,
1225         namespace = this.namespaceURI;
1226     return namespace
1227         ? document.createElementNS(namespace, name)
1228         : document.createElement(name);
1229   }
1230
1231   function createNS() {
1232     return this.ownerDocument.createElementNS(name.space, name.local);
1233   }
1234
1235   return typeof name === "function" ? name
1236       : (name = d3.ns.qualify(name)).local ? createNS
1237       : create;
1238 }
1239
1240 d3_selectionPrototype.insert = function(name, before) {
1241   name = d3_selection_creator(name);
1242   before = d3_selection_selector(before);
1243   return this.select(function() {
1244     return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);
1245   });
1246 };
1247
1248 // TODO remove(selector)?
1249 // TODO remove(node)?
1250 // TODO remove(function)?
1251 d3_selectionPrototype.remove = function() {
1252   return this.each(d3_selectionRemove);
1253 };
1254
1255 function d3_selectionRemove() {
1256   var parent = this.parentNode;
1257   if (parent) parent.removeChild(this);
1258 }
1259
1260 d3_selectionPrototype.data = function(value, key) {
1261   var i = -1,
1262       n = this.length,
1263       group,
1264       node;
1265
1266   // If no value is specified, return the first value.
1267   if (!arguments.length) {
1268     value = new Array(n = (group = this[0]).length);
1269     while (++i < n) {
1270       if (node = group[i]) {
1271         value[i] = node.__data__;
1272       }
1273     }
1274     return value;
1275   }
1276
1277   function bind(group, groupData) {
1278     var i,
1279         n = group.length,
1280         m = groupData.length,
1281         n0 = Math.min(n, m),
1282         updateNodes = new Array(m),
1283         enterNodes = new Array(m),
1284         exitNodes = new Array(n),
1285         node,
1286         nodeData;
1287
1288     if (key) {
1289       var nodeByKeyValue = new d3_Map,
1290           keyValues = new Array(n),
1291           keyValue;
1292
1293       for (i = -1; ++i < n;) {
1294         if (nodeByKeyValue.has(keyValue = key.call(node = group[i], node.__data__, i))) {
1295           exitNodes[i] = node; // duplicate selection key
1296         } else {
1297           nodeByKeyValue.set(keyValue, node);
1298         }
1299         keyValues[i] = keyValue;
1300       }
1301
1302       for (i = -1; ++i < m;) {
1303         if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) {
1304           enterNodes[i] = d3_selection_dataNode(nodeData);
1305         } else if (node !== true) { // no duplicate data key
1306           updateNodes[i] = node;
1307           node.__data__ = nodeData;
1308         }
1309         nodeByKeyValue.set(keyValue, true);
1310       }
1311
1312       for (i = -1; ++i < n;) {
1313         if (nodeByKeyValue.get(keyValues[i]) !== true) {
1314           exitNodes[i] = group[i];
1315         }
1316       }
1317     } else {
1318       for (i = -1; ++i < n0;) {
1319         node = group[i];
1320         nodeData = groupData[i];
1321         if (node) {
1322           node.__data__ = nodeData;
1323           updateNodes[i] = node;
1324         } else {
1325           enterNodes[i] = d3_selection_dataNode(nodeData);
1326         }
1327       }
1328       for (; i < m; ++i) {
1329         enterNodes[i] = d3_selection_dataNode(groupData[i]);
1330       }
1331       for (; i < n; ++i) {
1332         exitNodes[i] = group[i];
1333       }
1334     }
1335
1336     enterNodes.update
1337         = updateNodes;
1338
1339     enterNodes.parentNode
1340         = updateNodes.parentNode
1341         = exitNodes.parentNode
1342         = group.parentNode;
1343
1344     enter.push(enterNodes);
1345     update.push(updateNodes);
1346     exit.push(exitNodes);
1347   }
1348
1349   var enter = d3_selection_enter([]),
1350       update = d3_selection([]),
1351       exit = d3_selection([]);
1352
1353   if (typeof value === "function") {
1354     while (++i < n) {
1355       bind(group = this[i], value.call(group, group.parentNode.__data__, i));
1356     }
1357   } else {
1358     while (++i < n) {
1359       bind(group = this[i], value);
1360     }
1361   }
1362
1363   update.enter = function() { return enter; };
1364   update.exit = function() { return exit; };
1365   return update;
1366 };
1367
1368 function d3_selection_dataNode(data) {
1369   return {__data__: data};
1370 }
1371
1372 d3_selectionPrototype.datum = function(value) {
1373   return arguments.length
1374       ? this.property("__data__", value)
1375       : this.property("__data__");
1376 };
1377
1378 d3_selectionPrototype.filter = function(filter) {
1379   var subgroups = [],
1380       subgroup,
1381       group,
1382       node;
1383
1384   if (typeof filter !== "function") filter = d3_selection_filter(filter);
1385
1386   for (var j = 0, m = this.length; j < m; j++) {
1387     subgroups.push(subgroup = []);
1388     subgroup.parentNode = (group = this[j]).parentNode;
1389     for (var i = 0, n = group.length; i < n; i++) {
1390       if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
1391         subgroup.push(node);
1392       }
1393     }
1394   }
1395
1396   return d3_selection(subgroups);
1397 };
1398
1399 function d3_selection_filter(selector) {
1400   return function() {
1401     return d3_selectMatches(this, selector);
1402   };
1403 }
1404
1405 d3_selectionPrototype.order = function() {
1406   for (var j = -1, m = this.length; ++j < m;) {
1407     for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
1408       if (node = group[i]) {
1409         if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
1410         next = node;
1411       }
1412     }
1413   }
1414   return this;
1415 };
1416
1417 d3_selectionPrototype.sort = function(comparator) {
1418   comparator = d3_selection_sortComparator.apply(this, arguments);
1419   for (var j = -1, m = this.length; ++j < m;) this[j].sort(comparator);
1420   return this.order();
1421 };
1422
1423 function d3_selection_sortComparator(comparator) {
1424   if (!arguments.length) comparator = d3_ascending;
1425   return function(a, b) {
1426     return a && b ? comparator(a.__data__, b.__data__) : !a - !b;
1427   };
1428 }
1429
1430 d3_selectionPrototype.each = function(callback) {
1431   return d3_selection_each(this, function(node, i, j) {
1432     callback.call(node, node.__data__, i, j);
1433   });
1434 };
1435
1436 function d3_selection_each(groups, callback) {
1437   for (var j = 0, m = groups.length; j < m; j++) {
1438     for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {
1439       if (node = group[i]) callback(node, i, j);
1440     }
1441   }
1442   return groups;
1443 }
1444
1445 d3_selectionPrototype.call = function(callback) {
1446   var args = d3_array(arguments);
1447   callback.apply(args[0] = this, args);
1448   return this;
1449 };
1450
1451 d3_selectionPrototype.empty = function() {
1452   return !this.node();
1453 };
1454
1455 d3_selectionPrototype.node = function() {
1456   for (var j = 0, m = this.length; j < m; j++) {
1457     for (var group = this[j], i = 0, n = group.length; i < n; i++) {
1458       var node = group[i];
1459       if (node) return node;
1460     }
1461   }
1462   return null;
1463 };
1464
1465 d3_selectionPrototype.size = function() {
1466   var n = 0;
1467   d3_selection_each(this, function() { ++n; });
1468   return n;
1469 };
1470
1471 function d3_selection_enter(selection) {
1472   d3_subclass(selection, d3_selection_enterPrototype);
1473   return selection;
1474 }
1475
1476 var d3_selection_enterPrototype = [];
1477
1478 d3.selection.enter = d3_selection_enter;
1479 d3.selection.enter.prototype = d3_selection_enterPrototype;
1480
1481 d3_selection_enterPrototype.append = d3_selectionPrototype.append;
1482 d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
1483 d3_selection_enterPrototype.node = d3_selectionPrototype.node;
1484 d3_selection_enterPrototype.call = d3_selectionPrototype.call;
1485 d3_selection_enterPrototype.size = d3_selectionPrototype.size;
1486
1487
1488 d3_selection_enterPrototype.select = function(selector) {
1489   var subgroups = [],
1490       subgroup,
1491       subnode,
1492       upgroup,
1493       group,
1494       node;
1495
1496   for (var j = -1, m = this.length; ++j < m;) {
1497     upgroup = (group = this[j]).update;
1498     subgroups.push(subgroup = []);
1499     subgroup.parentNode = group.parentNode;
1500     for (var i = -1, n = group.length; ++i < n;) {
1501       if (node = group[i]) {
1502         subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j));
1503         subnode.__data__ = node.__data__;
1504       } else {
1505         subgroup.push(null);
1506       }
1507     }
1508   }
1509
1510   return d3_selection(subgroups);
1511 };
1512
1513 d3_selection_enterPrototype.insert = function(name, before) {
1514   if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);
1515   return d3_selectionPrototype.insert.call(this, name, before);
1516 };
1517
1518 function d3_selection_enterInsertBefore(enter) {
1519   var i0, j0;
1520   return function(d, i, j) {
1521     var group = enter[j].update,
1522         n = group.length,
1523         node;
1524     if (j != j0) j0 = j, i0 = 0;
1525     if (i >= i0) i0 = i + 1;
1526     while (!(node = group[i0]) && ++i0 < n);
1527     return node;
1528   };
1529 }
1530
1531 // TODO fast singleton implementation?
1532 d3.select = function(node) {
1533   var group;
1534   if (typeof node === "string") {
1535     group = [d3_select(node, d3_document)];
1536     group.parentNode = d3_document.documentElement;
1537   } else {
1538     group = [node];
1539     group.parentNode = d3_documentElement(node);
1540   }
1541   return d3_selection([group]);
1542 };
1543
1544 d3.selectAll = function(nodes) {
1545   var group;
1546   if (typeof nodes === "string") {
1547     group = d3_array(d3_selectAll(nodes, d3_document));
1548     group.parentNode = d3_document.documentElement;
1549   } else {
1550     group = nodes;
1551     group.parentNode = null;
1552   }
1553   return d3_selection([group]);
1554 };
1555
1556 d3_selectionPrototype.on = function(type, listener, capture) {
1557   var n = arguments.length;
1558   if (n < 3) {
1559
1560     // For on(object) or on(object, boolean), the object specifies the event
1561     // types and listeners to add or remove. The optional boolean specifies
1562     // whether the listener captures events.
1563     if (typeof type !== "string") {
1564       if (n < 2) listener = false;
1565       for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
1566       return this;
1567     }
1568
1569     // For on(string), return the listener for the first node.
1570     if (n < 2) return (n = this.node()["__on" + type]) && n._;
1571
1572     // For on(string, function), use the default capture.
1573     capture = false;
1574   }
1575
1576   // Otherwise, a type, listener and capture are specified, and handled as below.
1577   return this.each(d3_selection_on(type, listener, capture));
1578 };
1579
1580 function d3_selection_on(type, listener, capture) {
1581   var name = "__on" + type,
1582       i = type.indexOf("."),
1583       wrap = d3_selection_onListener;
1584
1585   if (i > 0) type = type.slice(0, i);
1586   var filter = d3_selection_onFilters.get(type);
1587   if (filter) type = filter, wrap = d3_selection_onFilter;
1588
1589   function onRemove() {
1590     var l = this[name];
1591     if (l) {
1592       this.removeEventListener(type, l, l.$);
1593       delete this[name];
1594     }
1595   }
1596
1597   function onAdd() {
1598     var l = wrap(listener, d3_array(arguments));
1599     if (typeof Raven !== 'undefined') l = Raven.wrap(l);
1600     onRemove.call(this);
1601     this.addEventListener(type, this[name] = l, l.$ = capture);
1602     l._ = listener;
1603   }
1604
1605   function removeAll() {
1606     var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"),
1607         match;
1608     for (var name in this) {
1609       if (match = name.match(re)) {
1610         var l = this[name];
1611         this.removeEventListener(match[1], l, l.$);
1612         delete this[name];
1613       }
1614     }
1615   }
1616
1617   return i
1618       ? listener ? onAdd : onRemove
1619       : listener ? d3_noop : removeAll;
1620 }
1621
1622 var d3_selection_onFilters = d3.map({
1623   mouseenter: "mouseover",
1624   mouseleave: "mouseout"
1625 });
1626
1627 if (d3_document) {
1628   d3_selection_onFilters.forEach(function(k) {
1629     if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
1630   });
1631 }
1632
1633 function d3_selection_onListener(listener, argumentz) {
1634   return function(e) {
1635     var o = d3.event; // Events can be reentrant (e.g., focus).
1636     d3.event = e;
1637     argumentz[0] = this.__data__;
1638     try {
1639       listener.apply(this, argumentz);
1640     } finally {
1641       d3.event = o;
1642     }
1643   };
1644 }
1645
1646 function d3_selection_onFilter(listener, argumentz) {
1647   var l = d3_selection_onListener(listener, argumentz);
1648   return function(e) {
1649     var target = this, related = e.relatedTarget;
1650     if (!related || (related !== target && !(related.compareDocumentPosition(target) & 8))) {
1651       l.call(target, e);
1652     }
1653   };
1654 }
1655
1656 var d3_event_dragSelect,
1657     d3_event_dragId = 0;
1658
1659 function d3_event_dragSuppress(node) {
1660   var name = ".dragsuppress-" + ++d3_event_dragId,
1661       click = "click" + name,
1662       w = d3.select(d3_window(node))
1663           .on("touchmove" + name, d3_eventPreventDefault)
1664           .on("dragstart" + name, d3_eventPreventDefault)
1665           .on("selectstart" + name, d3_eventPreventDefault);
1666
1667   if (d3_event_dragSelect == null) {
1668     d3_event_dragSelect = "onselectstart" in node ? false
1669         : d3_vendorSymbol(node.style, "userSelect");
1670   }
1671
1672   if (d3_event_dragSelect) {
1673     var style = d3_documentElement(node).style,
1674         select = style[d3_event_dragSelect];
1675     style[d3_event_dragSelect] = "none";
1676   }
1677
1678   return function(suppressClick) {
1679     w.on(name, null);
1680     if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
1681     if (suppressClick) { // suppress the next click, but only if it’s immediate
1682       var off = function() { w.on(click, null); };
1683       w.on(click, function() { d3_eventCancel(); off(); }, true);
1684       setTimeout(off, 0);
1685     }
1686   };
1687 }
1688
1689 d3.mouse = function(container) {
1690   return d3_mousePoint(container, d3_eventSource());
1691 };
1692
1693 // https://bugs.webkit.org/show_bug.cgi?id=44083
1694 var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;
1695
1696 function d3_mousePoint(container, e) {
1697   if (e.changedTouches) e = e.changedTouches[0];
1698   var svg = container.ownerSVGElement || container;
1699   if (svg.createSVGPoint) {
1700     var point = svg.createSVGPoint();
1701     if (d3_mouse_bug44083 < 0) {
1702       var window = d3_window(container);
1703       if (window.scrollX || window.scrollY) {
1704         svg = d3.select("body").append("svg").style({
1705           position: "absolute",
1706           top: 0,
1707           left: 0,
1708           margin: 0,
1709           padding: 0,
1710           border: "none"
1711         }, "important");
1712         var ctm = svg[0][0].getScreenCTM();
1713         d3_mouse_bug44083 = !(ctm.f || ctm.e);
1714         svg.remove();
1715       }
1716     }
1717     if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY;
1718     else point.x = e.clientX, point.y = e.clientY;
1719     point = point.matrixTransform(container.getScreenCTM().inverse());
1720     return [point.x, point.y];
1721   }
1722   var rect = container.getBoundingClientRect();
1723   return [e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop];
1724 };
1725
1726 d3.touches = function(container, touches) {
1727   if (arguments.length < 2) touches = d3_eventSource().touches;
1728   return touches ? d3_array(touches).map(function(touch) {
1729     var point = d3_mousePoint(container, touch);
1730     point.identifier = touch.identifier;
1731     return point;
1732   }) : [];
1733 };
1734 var ε = 1e-6,
1735     ε2 = ε * ε,
1736     π = Math.PI,
1737     τ = 2 * π,
1738     τε = τ - ε,
1739     halfπ = π / 2,
1740     d3_radians = π / 180,
1741     d3_degrees = 180 / π;
1742
1743 function d3_sgn(x) {
1744   return x > 0 ? 1 : x < 0 ? -1 : 0;
1745 }
1746
1747 // Returns the 2D cross product of AB and AC vectors, i.e., the z-component of
1748 // the 3D cross product in a quadrant I Cartesian coordinate system (+x is
1749 // right, +y is up). Returns a positive value if ABC is counter-clockwise,
1750 // negative if clockwise, and zero if the points are collinear.
1751 function d3_cross2d(a, b, c) {
1752   return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
1753 }
1754
1755 function d3_acos(x) {
1756   return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
1757 }
1758
1759 function d3_asin(x) {
1760   return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);
1761 }
1762
1763 function d3_sinh(x) {
1764   return ((x = Math.exp(x)) - 1 / x) / 2;
1765 }
1766
1767 function d3_cosh(x) {
1768   return ((x = Math.exp(x)) + 1 / x) / 2;
1769 }
1770
1771 function d3_tanh(x) {
1772   return ((x = Math.exp(2 * x)) - 1) / (x + 1);
1773 }
1774
1775 function d3_haversin(x) {
1776   return (x = Math.sin(x / 2)) * x;
1777 }
1778
1779 var ρ = Math.SQRT2,
1780     ρ2 = 2,
1781     ρ4 = 4;
1782
1783 // p0 = [ux0, uy0, w0]
1784 // p1 = [ux1, uy1, w1]
1785 d3.interpolateZoom = function(p0, p1) {
1786   var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],
1787       ux1 = p1[0], uy1 = p1[1], w1 = p1[2];
1788
1789   var dx = ux1 - ux0,
1790       dy = uy1 - uy0,
1791       d2 = dx * dx + dy * dy,
1792       d1 = Math.sqrt(d2),
1793       b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1),
1794       b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1),
1795       r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),
1796       r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1),
1797       dr = r1 - r0,
1798       S = (dr || Math.log(w1 / w0)) / ρ;
1799
1800   function interpolate(t) {
1801     var s = t * S;
1802     if (dr) {
1803       // General case.
1804       var coshr0 = d3_cosh(r0),
1805           u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0));
1806       return [
1807         ux0 + u * dx,
1808         uy0 + u * dy,
1809         w0 * coshr0 / d3_cosh(ρ * s + r0)
1810       ];
1811     }
1812     // Special case for u0 ~= u1.
1813     return [
1814       ux0 + t * dx,
1815       uy0 + t * dy,
1816       w0 * Math.exp(ρ * s)
1817     ];
1818   }
1819
1820   interpolate.duration = S * 1000;
1821
1822   return interpolate;
1823 };
1824
1825 d3.behavior.zoom = function() {
1826   var view = {x: 0, y: 0, k: 1},
1827       translate0, // translate when we started zooming (to avoid drift)
1828       center0, // implicit desired position of translate0 after zooming
1829       center, // explicit desired position of translate0 after zooming
1830       size = [960, 500], // viewport size; required for zoom interpolation
1831       scaleExtent = d3_behavior_zoomInfinity,
1832       duration = 250,
1833       zooming = 0,
1834       mousedown = "mousedown.zoom",
1835       mousemove = "mousemove.zoom",
1836       mouseup = "mouseup.zoom",
1837       mousewheelTimer,
1838       touchstart = "touchstart.zoom",
1839       touchtime, // time of last touchstart (to detect double-tap)
1840       event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"),
1841       x0,
1842       x1,
1843       y0,
1844       y1;
1845
1846   // Lazily determine the DOM’s support for Wheel events.
1847   // https://developer.mozilla.org/en-US/docs/Mozilla_event_reference/wheel
1848   if (!d3_behavior_zoomWheel) {
1849     d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() { return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1); }, "wheel")
1850         : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() { return d3.event.wheelDelta; }, "mousewheel")
1851         : (d3_behavior_zoomDelta = function() { return -d3.event.detail; }, "MozMousePixelScroll");
1852   }
1853
1854   function zoom(g) {
1855     g   .on(mousedown, mousedowned)
1856         .on(d3_behavior_zoomWheel + ".zoom", mousewheeled)
1857         .on("dblclick.zoom", dblclicked)
1858         .on(touchstart, touchstarted);
1859   }
1860
1861   zoom.event = function(g) {
1862     g.each(function() {
1863       var dispatch = event.of(this, arguments),
1864           view1 = view;
1865       if (d3_transitionInheritId) {
1866         d3.select(this).transition()
1867             .each("start.zoom", function() {
1868               view = this.__chart__ || {x: 0, y: 0, k: 1}; // pre-transition state
1869               zoomstarted(dispatch);
1870             })
1871             .tween("zoom:zoom", function() {
1872               var dx = size[0],
1873                   dy = size[1],
1874                   cx = center0 ? center0[0] : dx / 2,
1875                   cy = center0 ? center0[1] : dy / 2,
1876                   i = d3.interpolateZoom(
1877                     [(cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k],
1878                     [(cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k]
1879                   );
1880               return function(t) {
1881                 var l = i(t), k = dx / l[2];
1882                 this.__chart__ = view = {x: cx - l[0] * k, y: cy - l[1] * k, k: k};
1883                 zoomed(dispatch);
1884               };
1885             })
1886             .each("interrupt.zoom", function() {
1887               zoomended(dispatch);
1888             })
1889             .each("end.zoom", function() {
1890               zoomended(dispatch);
1891             });
1892       } else {
1893         this.__chart__ = view;
1894         zoomstarted(dispatch);
1895         zoomed(dispatch);
1896         zoomended(dispatch);
1897       }
1898     });
1899   }
1900
1901   zoom.translate = function(_) {
1902     if (!arguments.length) return [view.x, view.y];
1903     view = {x: +_[0], y: +_[1], k: view.k}; // copy-on-write
1904     rescale();
1905     return zoom;
1906   };
1907
1908   zoom.scale = function(_) {
1909     if (!arguments.length) return view.k;
1910     view = {x: view.x, y: view.y, k: +_}; // copy-on-write
1911     rescale();
1912     return zoom;
1913   };
1914
1915   zoom.scaleExtent = function(_) {
1916     if (!arguments.length) return scaleExtent;
1917     scaleExtent = _ == null ? d3_behavior_zoomInfinity : [+_[0], +_[1]];
1918     return zoom;
1919   };
1920
1921   zoom.center = function(_) {
1922     if (!arguments.length) return center;
1923     center = _ && [+_[0], +_[1]];
1924     return zoom;
1925   };
1926
1927   zoom.size = function(_) {
1928     if (!arguments.length) return size;
1929     size = _ && [+_[0], +_[1]];
1930     return zoom;
1931   };
1932
1933   zoom.duration = function(_) {
1934     if (!arguments.length) return duration;
1935     duration = +_; // TODO function based on interpolateZoom distance?
1936     return zoom;
1937   };
1938
1939   zoom.x = function(z) {
1940     if (!arguments.length) return x1;
1941     x1 = z;
1942     x0 = z.copy();
1943     view = {x: 0, y: 0, k: 1}; // copy-on-write
1944     return zoom;
1945   };
1946
1947   zoom.y = function(z) {
1948     if (!arguments.length) return y1;
1949     y1 = z;
1950     y0 = z.copy();
1951     view = {x: 0, y: 0, k: 1}; // copy-on-write
1952     return zoom;
1953   };
1954
1955   function location(p) {
1956     return [(p[0] - view.x) / view.k, (p[1] - view.y) / view.k];
1957   }
1958
1959   function point(l) {
1960     return [l[0] * view.k + view.x, l[1] * view.k + view.y];
1961   }
1962
1963   function scaleTo(s) {
1964     view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
1965   }
1966
1967   function translateTo(p, l) {
1968     l = point(l);
1969     view.x += p[0] - l[0];
1970     view.y += p[1] - l[1];
1971   }
1972
1973   function zoomTo(that, p, l, k) {
1974     that.__chart__ = {x: view.x, y: view.y, k: view.k};
1975
1976     scaleTo(Math.pow(2, k));
1977     translateTo(center0 = p, l);
1978
1979     that = d3.select(that);
1980     if (duration > 0) that = that.transition().duration(duration);
1981     that.call(zoom.event);
1982   }
1983
1984   function rescale() {
1985     if (x1) x1.domain(x0.range().map(function(x) { return (x - view.x) / view.k; }).map(x0.invert));
1986     if (y1) y1.domain(y0.range().map(function(y) { return (y - view.y) / view.k; }).map(y0.invert));
1987   }
1988
1989   function zoomstarted(dispatch) {
1990     if (!zooming++) dispatch({type: "zoomstart"});
1991   }
1992
1993   function zoomed(dispatch) {
1994     rescale();
1995     dispatch({type: "zoom", scale: view.k, translate: [view.x, view.y]});
1996   }
1997
1998   function zoomended(dispatch) {
1999     if (!--zooming) dispatch({type: "zoomend"}), center0 = null;
2000   }
2001
2002   function mousedowned() {
2003     var that = this,
2004         target = d3.event.target,
2005         dispatch = event.of(that, arguments),
2006         dragged = 0,
2007         subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended),
2008         location0 = location(d3.mouse(that)),
2009         dragRestore = d3_event_dragSuppress(that);
2010
2011     d3_selection_interrupt.call(that);
2012     zoomstarted(dispatch);
2013
2014     function moved() {
2015       dragged = 1;
2016       translateTo(d3.mouse(that), location0);
2017       zoomed(dispatch);
2018     }
2019
2020     function ended() {
2021       subject.on(mousemove, null).on(mouseup, null);
2022       dragRestore(dragged && d3.event.target === target);
2023       zoomended(dispatch);
2024     }
2025   }
2026
2027   // These closures persist for as long as at least one touch is active.
2028   function touchstarted() {
2029     var that = this,
2030         dispatch = event.of(that, arguments),
2031         locations0 = {}, // touchstart locations
2032         distance0 = 0, // distance² between initial touches
2033         scale0, // scale when we started touching
2034         zoomName = ".zoom-" + d3.event.changedTouches[0].identifier,
2035         touchmove = "touchmove" + zoomName,
2036         touchend = "touchend" + zoomName,
2037         targets = [],
2038         subject = d3.select(that),
2039         dragRestore = d3_event_dragSuppress(that);
2040
2041     started();
2042     zoomstarted(dispatch);
2043
2044     // Workaround for Chrome issue 412723: the touchstart listener must be set
2045     // after the touchmove listener.
2046     subject.on(mousedown, null).on(touchstart, started); // prevent duplicate events
2047
2048     // Updates locations of any touches in locations0.
2049     function relocate() {
2050       var touches = d3.touches(that);
2051       scale0 = view.k;
2052       touches.forEach(function(t) {
2053         if (t.identifier in locations0) locations0[t.identifier] = location(t);
2054       });
2055       return touches;
2056     }
2057
2058     // Temporarily override touchstart while gesture is active.
2059     function started() {
2060
2061       // Listen for touchmove and touchend on the target of touchstart.
2062       var target = d3.event.target;
2063       d3.select(target).on(touchmove, moved).on(touchend, ended);
2064       targets.push(target);
2065
2066       // Only track touches started on the same subject element.
2067       var changed = d3.event.changedTouches;
2068       for (var i = 0, n = changed.length; i < n; ++i) {
2069         locations0[changed[i].identifier] = null;
2070       }
2071
2072       var touches = relocate(),
2073           now = Date.now();
2074
2075       if (touches.length === 1) {
2076         if (now - touchtime < 500) { // dbltap
2077           var p = touches[0];
2078           zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1);
2079           d3_eventPreventDefault();
2080         }
2081         touchtime = now;
2082       } else if (touches.length > 1) {
2083         var p = touches[0], q = touches[1],
2084             dx = p[0] - q[0], dy = p[1] - q[1];
2085         distance0 = dx * dx + dy * dy;
2086       }
2087     }
2088
2089     function moved() {
2090       var touches = d3.touches(that),
2091           p0, l0,
2092           p1, l1;
2093
2094       d3_selection_interrupt.call(that);
2095
2096       for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {
2097         p1 = touches[i];
2098         if (l1 = locations0[p1.identifier]) {
2099           if (l0) break;
2100           p0 = p1, l0 = l1;
2101         }
2102       }
2103
2104       if (l1) {
2105         var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1,
2106             scale1 = distance0 && Math.sqrt(distance1 / distance0);
2107         p0 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
2108         l0 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];
2109         scaleTo(scale1 * scale0);
2110       }
2111
2112       touchtime = null;
2113       translateTo(p0, l0);
2114       zoomed(dispatch);
2115     }
2116
2117     function ended() {
2118       // If there are any globally-active touches remaining, remove the ended
2119       // touches from locations0.
2120       if (d3.event.touches.length) {
2121         var changed = d3.event.changedTouches;
2122         for (var i = 0, n = changed.length; i < n; ++i) {
2123           delete locations0[changed[i].identifier];
2124         }
2125         // If locations0 is not empty, then relocate and continue listening for
2126         // touchmove and touchend.
2127         for (var identifier in locations0) {
2128           return void relocate(); // locations may have detached due to rotation
2129         }
2130       }
2131       // Otherwise, remove touchmove and touchend listeners.
2132       d3.selectAll(targets).on(zoomName, null);
2133       subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
2134       dragRestore();
2135       zoomended(dispatch);
2136     }
2137   }
2138
2139   function mousewheeled() {
2140     var dispatch = event.of(this, arguments);
2141     if (mousewheelTimer) clearTimeout(mousewheelTimer);
2142     else d3_selection_interrupt.call(this), translate0 = location(center0 = center || d3.mouse(this)), zoomstarted(dispatch);
2143     mousewheelTimer = setTimeout(function() { mousewheelTimer = null; zoomended(dispatch); }, 50);
2144     d3_eventPreventDefault();
2145     scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);
2146     translateTo(center0, translate0);
2147     zoomed(dispatch);
2148   }
2149
2150   function dblclicked() {
2151     var p = d3.mouse(this),
2152         k = Math.log(view.k) / Math.LN2;
2153
2154     zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1);
2155   }
2156
2157   return d3.rebind(zoom, event, "on");
2158 };
2159
2160 var d3_behavior_zoomInfinity = [0, Infinity], // default scale extent
2161     d3_behavior_zoomDelta, // initialized lazily
2162     d3_behavior_zoomWheel;
2163 function d3_functor(v) {
2164   return typeof v === "function" ? v : function() { return v; };
2165 }
2166
2167 d3.functor = d3_functor;
2168
2169 d3.touch = function(container, touches, identifier) {
2170   if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
2171   if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) {
2172     if ((touch = touches[i]).identifier === identifier) {
2173       return d3_mousePoint(container, touch);
2174     }
2175   }
2176 };
2177
2178 var d3_timer_queueHead,
2179     d3_timer_queueTail,
2180     d3_timer_interval, // is an interval (or frame) active?
2181     d3_timer_timeout, // is a timeout active?
2182     d3_timer_active, // active timer object
2183     d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) { setTimeout(callback, 17); };
2184
2185 // The timer will continue to fire until callback returns true.
2186 d3.timer = function(callback, delay, then) {
2187   var n = arguments.length;
2188   if (n < 2) delay = 0;
2189   if (n < 3) then = Date.now();
2190
2191   // Add the callback to the tail of the queue.
2192   var time = then + delay, timer = {c: callback, t: time, f: false, n: null};
2193   if (d3_timer_queueTail) d3_timer_queueTail.n = timer;
2194   else d3_timer_queueHead = timer;
2195   d3_timer_queueTail = timer;
2196
2197   // Start animatin'!
2198   if (!d3_timer_interval) {
2199     d3_timer_timeout = clearTimeout(d3_timer_timeout);
2200     d3_timer_interval = 1;
2201     d3_timer_frame(d3_timer_step);
2202   }
2203 };
2204
2205 function d3_timer_step() {
2206   var now = d3_timer_mark(),
2207       delay = d3_timer_sweep() - now;
2208   if (delay > 24) {
2209     if (isFinite(delay)) {
2210       clearTimeout(d3_timer_timeout);
2211       d3_timer_timeout = setTimeout(d3_timer_step, delay);
2212     }
2213     d3_timer_interval = 0;
2214   } else {
2215     d3_timer_interval = 1;
2216     d3_timer_frame(d3_timer_step);
2217   }
2218 }
2219
2220 d3.timer.flush = function() {
2221   d3_timer_mark();
2222   d3_timer_sweep();
2223 };
2224
2225 function d3_timer_mark() {
2226   var now = Date.now();
2227   d3_timer_active = d3_timer_queueHead;
2228   while (d3_timer_active) {
2229     if (now >= d3_timer_active.t) d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t);
2230     d3_timer_active = d3_timer_active.n;
2231   }
2232   return now;
2233 }
2234
2235 // Flush after callbacks to avoid concurrent queue modification.
2236 // Returns the time of the earliest active timer, post-sweep.
2237 function d3_timer_sweep() {
2238   var t0,
2239       t1 = d3_timer_queueHead,
2240       time = Infinity;
2241   while (t1) {
2242     if (t1.f) {
2243       t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
2244     } else {
2245       if (t1.t < time) time = t1.t;
2246       t1 = (t0 = t1).n;
2247     }
2248   }
2249   d3_timer_queueTail = t0;
2250   return time;
2251 }
2252 d3.geo = {};
2253
2254 d3.geo.stream = function(object, listener) {
2255   if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
2256     d3_geo_streamObjectType[object.type](object, listener);
2257   } else {
2258     d3_geo_streamGeometry(object, listener);
2259   }
2260 };
2261
2262 function d3_geo_streamGeometry(geometry, listener) {
2263   if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
2264     d3_geo_streamGeometryType[geometry.type](geometry, listener);
2265   }
2266 }
2267
2268 var d3_geo_streamObjectType = {
2269   Feature: function(feature, listener) {
2270     d3_geo_streamGeometry(feature.geometry, listener);
2271   },
2272   FeatureCollection: function(object, listener) {
2273     var features = object.features, i = -1, n = features.length;
2274     while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
2275   }
2276 };
2277
2278 var d3_geo_streamGeometryType = {
2279   Sphere: function(object, listener) {
2280     listener.sphere();
2281   },
2282   Point: function(object, listener) {
2283     object = object.coordinates;
2284     listener.point(object[0], object[1], object[2]);
2285   },
2286   MultiPoint: function(object, listener) {
2287     var coordinates = object.coordinates, i = -1, n = coordinates.length;
2288     while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]);
2289   },
2290   LineString: function(object, listener) {
2291     d3_geo_streamLine(object.coordinates, listener, 0);
2292   },
2293   MultiLineString: function(object, listener) {
2294     var coordinates = object.coordinates, i = -1, n = coordinates.length;
2295     while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
2296   },
2297   Polygon: function(object, listener) {
2298     d3_geo_streamPolygon(object.coordinates, listener);
2299   },
2300   MultiPolygon: function(object, listener) {
2301     var coordinates = object.coordinates, i = -1, n = coordinates.length;
2302     while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
2303   },
2304   GeometryCollection: function(object, listener) {
2305     var geometries = object.geometries, i = -1, n = geometries.length;
2306     while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
2307   }
2308 };
2309
2310 function d3_geo_streamLine(coordinates, listener, closed) {
2311   var i = -1, n = coordinates.length - closed, coordinate;
2312   listener.lineStart();
2313   while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]);
2314   listener.lineEnd();
2315 }
2316
2317 function d3_geo_streamPolygon(coordinates, listener) {
2318   var i = -1, n = coordinates.length;
2319   listener.polygonStart();
2320   while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
2321   listener.polygonEnd();
2322 }
2323
2324 d3.geo.length = function(object) {
2325   d3_geo_lengthSum = 0;
2326   d3.geo.stream(object, d3_geo_length);
2327   return d3_geo_lengthSum;
2328 };
2329
2330 var d3_geo_lengthSum;
2331
2332 var d3_geo_length = {
2333   sphere: d3_noop,
2334   point: d3_noop,
2335   lineStart: d3_geo_lengthLineStart,
2336   lineEnd: d3_noop,
2337   polygonStart: d3_noop,
2338   polygonEnd: d3_noop
2339 };
2340
2341 function d3_geo_lengthLineStart() {
2342   var λ0, sinφ0, cosφ0;
2343
2344   d3_geo_length.point = function(λ, φ) {
2345     λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ);
2346     d3_geo_length.point = nextPoint;
2347   };
2348
2349   d3_geo_length.lineEnd = function() {
2350     d3_geo_length.point = d3_geo_length.lineEnd = d3_noop;
2351   };
2352
2353   function nextPoint(λ, φ) {
2354     var sinφ = Math.sin(φ *= d3_radians),
2355         cosφ = Math.cos(φ),
2356         t = abs((λ *= d3_radians) - λ0),
2357         cosΔλ = Math.cos(t);
2358     d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ);
2359     λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ;
2360   }
2361 }
2362 function d3_identity(d) {
2363   return d;
2364 }
2365 function d3_true() {
2366   return true;
2367 }
2368
2369 function d3_geo_spherical(cartesian) {
2370   return [
2371     Math.atan2(cartesian[1], cartesian[0]),
2372     d3_asin(cartesian[2])
2373   ];
2374 }
2375
2376 function d3_geo_sphericalEqual(a, b) {
2377   return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε;
2378 }
2379
2380 // General spherical polygon clipping algorithm: takes a polygon, cuts it into
2381 // visible line segments and rejoins the segments by interpolating along the
2382 // clip edge.
2383 function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
2384   var subject = [],
2385       clip = [];
2386
2387   segments.forEach(function(segment) {
2388     if ((n = segment.length - 1) <= 0) return;
2389     var n, p0 = segment[0], p1 = segment[n];
2390
2391     // If the first and last points of a segment are coincident, then treat as
2392     // a closed ring.
2393     // TODO if all rings are closed, then the winding order of the exterior
2394     // ring should be checked.
2395     if (d3_geo_sphericalEqual(p0, p1)) {
2396       listener.lineStart();
2397       for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
2398       listener.lineEnd();
2399       return;
2400     }
2401
2402     var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true),
2403         b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
2404     a.o = b;
2405     subject.push(a);
2406     clip.push(b);
2407     a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
2408     b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
2409     a.o = b;
2410     subject.push(a);
2411     clip.push(b);
2412   });
2413   clip.sort(compare);
2414   d3_geo_clipPolygonLinkCircular(subject);
2415   d3_geo_clipPolygonLinkCircular(clip);
2416   if (!subject.length) return;
2417
2418   for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
2419     clip[i].e = entry = !entry;
2420   }
2421
2422   var start = subject[0],
2423       points,
2424       point;
2425   while (1) {
2426     // Find first unvisited intersection.
2427     var current = start,
2428         isSubject = true;
2429     while (current.v) if ((current = current.n) === start) return;
2430     points = current.z;
2431     listener.lineStart();
2432     do {
2433       current.v = current.o.v = true;
2434       if (current.e) {
2435         if (isSubject) {
2436           for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
2437         } else {
2438           interpolate(current.x, current.n.x, 1, listener);
2439         }
2440         current = current.n;
2441       } else {
2442         if (isSubject) {
2443           points = current.p.z;
2444           for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
2445         } else {
2446           interpolate(current.x, current.p.x, -1, listener);
2447         }
2448         current = current.p;
2449       }
2450       current = current.o;
2451       points = current.z;
2452       isSubject = !isSubject;
2453     } while (!current.v);
2454     listener.lineEnd();
2455   }
2456 }
2457
2458 function d3_geo_clipPolygonLinkCircular(array) {
2459   if (!(n = array.length)) return;
2460   var n,
2461       i = 0,
2462       a = array[0],
2463       b;
2464   while (++i < n) {
2465     a.n = b = array[i];
2466     b.p = a;
2467     a = b;
2468   }
2469   a.n = b = array[0];
2470   b.p = a;
2471 }
2472
2473 function d3_geo_clipPolygonIntersection(point, points, other, entry) {
2474   this.x = point;
2475   this.z = points;
2476   this.o = other; // another intersection
2477   this.e = entry; // is an entry?
2478   this.v = false; // visited
2479   this.n = this.p = null; // next & previous
2480 }
2481
2482 function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
2483   return function(rotate, listener) {
2484     var line = clipLine(listener),
2485         rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
2486
2487     var clip = {
2488       point: point,
2489       lineStart: lineStart,
2490       lineEnd: lineEnd,
2491       polygonStart: function() {
2492         clip.point = pointRing;
2493         clip.lineStart = ringStart;
2494         clip.lineEnd = ringEnd;
2495         segments = [];
2496         polygon = [];
2497       },
2498       polygonEnd: function() {
2499         clip.point = point;
2500         clip.lineStart = lineStart;
2501         clip.lineEnd = lineEnd;
2502
2503         segments = d3.merge(segments);
2504         var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
2505         if (segments.length) {
2506           if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
2507           d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
2508         } else if (clipStartInside) {
2509           if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
2510           listener.lineStart();
2511           interpolate(null, null, 1, listener);
2512           listener.lineEnd();
2513         }
2514         if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
2515         segments = polygon = null;
2516       },
2517       sphere: function() {
2518         listener.polygonStart();
2519         listener.lineStart();
2520         interpolate(null, null, 1, listener);
2521         listener.lineEnd();
2522         listener.polygonEnd();
2523       }
2524     };
2525
2526     function point(λ, φ) {
2527       var point = rotate(λ, φ);
2528       if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
2529     }
2530     function pointLine(λ, φ) {
2531       var point = rotate(λ, φ);
2532       line.point(point[0], point[1]);
2533     }
2534     function lineStart() { clip.point = pointLine; line.lineStart(); }
2535     function lineEnd() { clip.point = point; line.lineEnd(); }
2536
2537     var segments;
2538
2539     var buffer = d3_geo_clipBufferListener(),
2540         ringListener = clipLine(buffer),
2541         polygonStarted = false,
2542         polygon,
2543         ring;
2544
2545     function pointRing(λ, φ) {
2546       ring.push([λ, φ]);
2547       var point = rotate(λ, φ);
2548       ringListener.point(point[0], point[1]);
2549     }
2550
2551     function ringStart() {
2552       ringListener.lineStart();
2553       ring = [];
2554     }
2555
2556     function ringEnd() {
2557       pointRing(ring[0][0], ring[0][1]);
2558       ringListener.lineEnd();
2559
2560       var clean = ringListener.clean(),
2561           ringSegments = buffer.buffer(),
2562           segment,
2563           n = ringSegments.length;
2564
2565       ring.pop();
2566       polygon.push(ring);
2567       ring = null;
2568
2569       if (!n) return;
2570
2571       // No intersections.
2572       if (clean & 1) {
2573         segment = ringSegments[0];
2574         var n = segment.length - 1,
2575             i = -1,
2576             point;
2577         if (n > 0) {
2578           if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
2579           listener.lineStart();
2580           while (++i < n) listener.point((point = segment[i])[0], point[1]);
2581           listener.lineEnd();
2582         }
2583         return;
2584       }
2585
2586       // Rejoin connected segments.
2587       // TODO reuse bufferListener.rejoin()?
2588       if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
2589
2590       segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
2591     }
2592
2593     return clip;
2594   };
2595 }
2596
2597 function d3_geo_clipSegmentLength1(segment) {
2598   return segment.length > 1;
2599 }
2600
2601 function d3_geo_clipBufferListener() {
2602   var lines = [],
2603       line;
2604   return {
2605     lineStart: function() { lines.push(line = []); },
2606     point: function(λ, φ) { line.push([λ, φ]); },
2607     lineEnd: d3_noop,
2608     buffer: function() {
2609       var buffer = lines;
2610       lines = [];
2611       line = null;
2612       return buffer;
2613     },
2614     rejoin: function() {
2615       if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
2616     }
2617   };
2618 }
2619
2620 // Intersection points are sorted along the clip edge. For both antimeridian
2621 // cutting and circle clipping, the same comparison is used.
2622 function d3_geo_clipSort(a, b) {
2623   return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1])
2624        - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]);
2625 }
2626
2627 var d3_geo_clipAntimeridian = d3_geo_clip(
2628     d3_true,
2629     d3_geo_clipAntimeridianLine,
2630     d3_geo_clipAntimeridianInterpolate,
2631     [-π, -π / 2]);
2632
2633 // Takes a line and cuts into visible segments. Return values:
2634 //   0: there were intersections or the line was empty.
2635 //   1: no intersections.
2636 //   2: there were intersections, and the first and last segments should be
2637 //      rejoined.
2638 function d3_geo_clipAntimeridianLine(listener) {
2639   var λ0 = NaN,
2640       φ0 = NaN,
2641       sλ0 = NaN,
2642       clean; // no intersections
2643
2644   return {
2645     lineStart: function() {
2646       listener.lineStart();
2647       clean = 1;
2648     },
2649     point: function(λ1, φ1) {
2650       var sλ1 = λ1 > 0 ? π : -π,
2651           dλ = abs(λ1 - λ0);
2652       if (abs(dλ - π) < ε) { // line crosses a pole
2653         listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ);
2654         listener.point(sλ0, φ0);
2655         listener.lineEnd();
2656         listener.lineStart();
2657         listener.point(sλ1, φ0);
2658         listener.point(λ1, φ0);
2659         clean = 0;
2660       } else if (sλ0 !== sλ1 && dλ >= π) { // line crosses antimeridian
2661         // handle degeneracies
2662         if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
2663         if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
2664         φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
2665         listener.point(sλ0, φ0);
2666         listener.lineEnd();
2667         listener.lineStart();
2668         listener.point(sλ1, φ0);
2669         clean = 0;
2670       }
2671       listener.point(λ0 = λ1, φ0 = φ1);
2672       sλ0 = sλ1;
2673     },
2674     lineEnd: function() {
2675       listener.lineEnd();
2676       λ0 = φ0 = NaN;
2677     },
2678     // if there are intersections, we always rejoin the first and last segments.
2679     clean: function() { return 2 - clean; }
2680   };
2681 }
2682
2683 function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
2684   var cosφ0,
2685       cosφ1,
2686       sinλ0_λ1 = Math.sin(λ0 - λ1);
2687   return abs(sinλ0_λ1) > ε
2688       ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1)
2689                  - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0))
2690                  / (cosφ0 * cosφ1 * sinλ0_λ1))
2691       : (φ0 + φ1) / 2;
2692 }
2693
2694 function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
2695   var φ;
2696   if (from == null) {
2697     φ = direction * halfπ;
2698     listener.point(-π,  φ);
2699     listener.point( 0,  φ);
2700     listener.point( π,  φ);
2701     listener.point( π,  0);
2702     listener.point( π, -φ);
2703     listener.point( 0, -φ);
2704     listener.point(-π, -φ);
2705     listener.point(-π,  0);
2706     listener.point(-π,  φ);
2707   } else if (abs(from[0] - to[0]) > ε) {
2708     var s = from[0] < to[0] ? π : -π;
2709     φ = direction * s / 2;
2710     listener.point(-s, φ);
2711     listener.point( 0, φ);
2712     listener.point( s, φ);
2713   } else {
2714     listener.point(to[0], to[1]);
2715   }
2716 }
2717 // TODO
2718 // cross and scale return new vectors,
2719 // whereas add and normalize operate in-place
2720
2721 function d3_geo_cartesian(spherical) {
2722   var λ = spherical[0],
2723       φ = spherical[1],
2724       cosφ = Math.cos(φ);
2725   return [
2726     cosφ * Math.cos(λ),
2727     cosφ * Math.sin(λ),
2728     Math.sin(φ)
2729   ];
2730 }
2731
2732 function d3_geo_cartesianDot(a, b) {
2733   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2734 }
2735
2736 function d3_geo_cartesianCross(a, b) {
2737   return [
2738     a[1] * b[2] - a[2] * b[1],
2739     a[2] * b[0] - a[0] * b[2],
2740     a[0] * b[1] - a[1] * b[0]
2741   ];
2742 }
2743
2744 function d3_geo_cartesianAdd(a, b) {
2745   a[0] += b[0];
2746   a[1] += b[1];
2747   a[2] += b[2];
2748 }
2749
2750 function d3_geo_cartesianScale(vector, k) {
2751   return [
2752     vector[0] * k,
2753     vector[1] * k,
2754     vector[2] * k
2755   ];
2756 }
2757
2758 function d3_geo_cartesianNormalize(d) {
2759   var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
2760   d[0] /= l;
2761   d[1] /= l;
2762   d[2] /= l;
2763 }
2764 function d3_geo_compose(a, b) {
2765
2766   function compose(x, y) {
2767     return x = a(x, y), b(x[0], x[1]);
2768   }
2769
2770   if (a.invert && b.invert) compose.invert = function(x, y) {
2771     return x = b.invert(x, y), x && a.invert(x[0], x[1]);
2772   };
2773
2774   return compose;
2775 }
2776
2777 function d3_geo_equirectangular(λ, φ) {
2778   return [λ, φ];
2779 }
2780
2781 (d3.geo.equirectangular = function() {
2782   return d3_geo_projection(d3_geo_equirectangular);
2783 }).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;
2784
2785 d3.geo.rotation = function(rotate) {
2786   rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0);
2787
2788   function forward(coordinates) {
2789     coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
2790     return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
2791   }
2792
2793   forward.invert = function(coordinates) {
2794     coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
2795     return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
2796   };
2797
2798   return forward;
2799 };
2800
2801 function d3_geo_identityRotation(λ, φ) {
2802   return [λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ];
2803 }
2804
2805 d3_geo_identityRotation.invert = d3_geo_equirectangular;
2806
2807 // Note: |δλ| must be < 2π
2808 function d3_geo_rotation(δλ, δφ, δγ) {
2809   return δλ ? (δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ))
2810     : d3_geo_rotationλ(δλ))
2811     : (δφ || δγ ? d3_geo_rotationφγ(δφ, δγ)
2812     : d3_geo_identityRotation);
2813 }
2814
2815 function d3_geo_forwardRotationλ(δλ) {
2816   return function(λ, φ) {
2817     return λ += δλ, [λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ];
2818   };
2819 }
2820
2821 function d3_geo_rotationλ(δλ) {
2822   var rotation = d3_geo_forwardRotationλ(δλ);
2823   rotation.invert = d3_geo_forwardRotationλ(-δλ);
2824   return rotation;
2825 }
2826
2827 function d3_geo_rotationφγ(δφ, δγ) {
2828   var cosδφ = Math.cos(δφ),
2829       sinδφ = Math.sin(δφ),
2830       cosδγ = Math.cos(δγ),
2831       sinδγ = Math.sin(δγ);
2832
2833   function rotation(λ, φ) {
2834     var cosφ = Math.cos(φ),
2835         x = Math.cos(λ) * cosφ,
2836         y = Math.sin(λ) * cosφ,
2837         z = Math.sin(φ),
2838         k = z * cosδφ + x * sinδφ;
2839     return [
2840       Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ),
2841       d3_asin(k * cosδγ + y * sinδγ)
2842     ];
2843   }
2844
2845   rotation.invert = function(λ, φ) {
2846     var cosφ = Math.cos(φ),
2847         x = Math.cos(λ) * cosφ,
2848         y = Math.sin(λ) * cosφ,
2849         z = Math.sin(φ),
2850         k = z * cosδγ - y * sinδγ;
2851     return [
2852       Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ),
2853       d3_asin(k * cosδφ - x * sinδφ)
2854     ];
2855   };
2856
2857   return rotation;
2858 }
2859
2860 d3.geo.circle = function() {
2861   var origin = [0, 0],
2862       angle,
2863       precision = 6,
2864       interpolate;
2865
2866   function circle() {
2867     var center = typeof origin === "function" ? origin.apply(this, arguments) : origin,
2868         rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert,
2869         ring = [];
2870
2871     interpolate(null, null, 1, {
2872       point: function(x, y) {
2873         ring.push(x = rotate(x, y));
2874         x[0] *= d3_degrees, x[1] *= d3_degrees;
2875       }
2876     });
2877
2878     return {type: "Polygon", coordinates: [ring]};
2879   }
2880
2881   circle.origin = function(x) {
2882     if (!arguments.length) return origin;
2883     origin = x;
2884     return circle;
2885   };
2886
2887   circle.angle = function(x) {
2888     if (!arguments.length) return angle;
2889     interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians);
2890     return circle;
2891   };
2892
2893   circle.precision = function(_) {
2894     if (!arguments.length) return precision;
2895     interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians);
2896     return circle;
2897   };
2898
2899   return circle.angle(90);
2900 };
2901
2902 // Interpolates along a circle centered at [0°, 0°], with a given radius and
2903 // precision.
2904 function d3_geo_circleInterpolate(radius, precision) {
2905   var cr = Math.cos(radius),
2906       sr = Math.sin(radius);
2907   return function(from, to, direction, listener) {
2908     var step = direction * precision;
2909     if (from != null) {
2910       from = d3_geo_circleAngle(cr, from);
2911       to = d3_geo_circleAngle(cr, to);
2912       if (direction > 0 ? from < to: from > to) from += direction * τ;
2913     } else {
2914       from = radius + direction * τ;
2915       to = radius - .5 * step;
2916     }
2917     for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) {
2918       listener.point((point = d3_geo_spherical([
2919         cr,
2920         -sr * Math.cos(t),
2921         -sr * Math.sin(t)
2922       ]))[0], point[1]);
2923     }
2924   };
2925 }
2926
2927 // Signed angle of a cartesian point relative to [cr, 0, 0].
2928 function d3_geo_circleAngle(cr, point) {
2929   var a = d3_geo_cartesian(point);
2930   a[0] -= cr;
2931   d3_geo_cartesianNormalize(a);
2932   var angle = d3_acos(-a[1]);
2933   return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI);
2934 }
2935 // Adds floating point numbers with twice the normal precision.
2936 // Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and
2937 // Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)
2938 // 305–363 (1997).
2939 // Code adapted from GeographicLib by Charles F. F. Karney,
2940 // http://geographiclib.sourceforge.net/
2941 // See lib/geographiclib/LICENSE for details.
2942
2943 function d3_adder() {}
2944
2945 d3_adder.prototype = {
2946   s: 0, // rounded value
2947   t: 0, // exact error
2948   add: function(y) {
2949     d3_adderSum(y, this.t, d3_adderTemp);
2950     d3_adderSum(d3_adderTemp.s, this.s, this);
2951     if (this.s) this.t += d3_adderTemp.t;
2952     else this.s = d3_adderTemp.t;
2953   },
2954   reset: function() {
2955     this.s = this.t = 0;
2956   },
2957   valueOf: function() {
2958     return this.s;
2959   }
2960 };
2961
2962 var d3_adderTemp = new d3_adder;
2963
2964 function d3_adderSum(a, b, o) {
2965   var x = o.s = a + b, // a + b
2966       bv = x - a, av = x - bv; // b_virtual & a_virtual
2967   o.t = (a - av) + (b - bv); // a_roundoff + b_roundoff
2968 }
2969
2970 d3.geo.area = function(object) {
2971   d3_geo_areaSum = 0;
2972   d3.geo.stream(object, d3_geo_area);
2973   return d3_geo_areaSum;
2974 };
2975
2976 var d3_geo_areaSum,
2977     d3_geo_areaRingSum = new d3_adder;
2978
2979 var d3_geo_area = {
2980   sphere: function() { d3_geo_areaSum += 4 * π; },
2981   point: d3_noop,
2982   lineStart: d3_noop,
2983   lineEnd: d3_noop,
2984
2985   // Only count area for polygon rings.
2986   polygonStart: function() {
2987     d3_geo_areaRingSum.reset();
2988     d3_geo_area.lineStart = d3_geo_areaRingStart;
2989   },
2990   polygonEnd: function() {
2991     var area = 2 * d3_geo_areaRingSum;
2992     d3_geo_areaSum += area < 0 ? 4 * π + area : area;
2993     d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
2994   }
2995 };
2996
2997 function d3_geo_areaRingStart() {
2998   var λ00, φ00, λ0, cosφ0, sinφ0; // start point and previous point
2999
3000   // For the first point, …
3001   d3_geo_area.point = function(λ, φ) {
3002     d3_geo_area.point = nextPoint;
3003     λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), sinφ0 = Math.sin(φ);
3004   };
3005
3006   // For subsequent points, …
3007   function nextPoint(λ, φ) {
3008     λ *= d3_radians;
3009     φ = φ * d3_radians / 2 + π / 4; // half the angular distance from south pole
3010
3011     // Spherical excess E for a spherical triangle with vertices: south pole,
3012     // previous point, current point.  Uses a formula derived from Cagnoli’s
3013     // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).
3014     var dλ = λ - λ0,
3015         sdλ = dλ >= 0 ? 1 : -1,
3016         adλ = sdλ * dλ,
3017         cosφ = Math.cos(φ),
3018         sinφ = Math.sin(φ),
3019         k = sinφ0 * sinφ,
3020         u = cosφ0 * cosφ + k * Math.cos(adλ),
3021         v = k * sdλ * Math.sin(adλ);
3022     d3_geo_areaRingSum.add(Math.atan2(v, u));
3023
3024     // Advance the previous points.
3025     λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
3026   }
3027
3028   // For the last point, return to the start.
3029   d3_geo_area.lineEnd = function() {
3030     nextPoint(λ00, φ00);
3031   };
3032 }
3033
3034 function d3_geo_pointInPolygon(point, polygon) {
3035   var meridian = point[0],
3036       parallel = point[1],
3037       meridianNormal = [Math.sin(meridian), -Math.cos(meridian), 0],
3038       polarAngle = 0,
3039       winding = 0;
3040   d3_geo_areaRingSum.reset();
3041
3042   for (var i = 0, n = polygon.length; i < n; ++i) {
3043     var ring = polygon[i],
3044         m = ring.length;
3045     if (!m) continue;
3046     var point0 = ring[0],
3047         λ0 = point0[0],
3048         φ0 = point0[1] / 2 + π / 4,
3049         sinφ0 = Math.sin(φ0),
3050         cosφ0 = Math.cos(φ0),
3051         j = 1;
3052
3053     while (true) {
3054       if (j === m) j = 0;
3055       point = ring[j];
3056       var λ = point[0],
3057           φ = point[1] / 2 + π / 4,
3058           sinφ = Math.sin(φ),
3059           cosφ = Math.cos(φ),
3060           dλ = λ - λ0,
3061           sdλ = dλ >= 0 ? 1 : -1,
3062           adλ = sdλ * dλ,
3063           antimeridian = adλ > π,
3064           k = sinφ0 * sinφ;
3065       d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ)));
3066
3067       polarAngle += antimeridian ? dλ + sdλ * τ : dλ;
3068
3069       // Are the longitudes either side of the point's meridian, and are the
3070       // latitudes smaller than the parallel?
3071       if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) {
3072         var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point));
3073         d3_geo_cartesianNormalize(arc);
3074         var intersection = d3_geo_cartesianCross(meridianNormal, arc);
3075         d3_geo_cartesianNormalize(intersection);
3076         var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]);
3077         if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) {
3078           winding += antimeridian ^ dλ >= 0 ? 1 : -1;
3079         }
3080       }
3081       if (!j++) break;
3082       λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;
3083     }
3084   }
3085
3086   // First, determine whether the South pole is inside or outside:
3087   //
3088   // It is inside if:
3089   // * the polygon winds around it in a clockwise direction.
3090   // * the polygon does not (cumulatively) wind around it, but has a negative
3091   //   (counter-clockwise) area.
3092   //
3093   // Second, count the (signed) number of times a segment crosses a meridian
3094   // from the point to the South pole.  If it is zero, then the point is the
3095   // same side as the South pole.
3096
3097   return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < 0) ^ (winding & 1);
3098 }
3099
3100 // Clip features against a small circle centered at [0°, 0°].
3101 function d3_geo_clipCircle(radius) {
3102   var cr = Math.cos(radius),
3103       smallRadius = cr > 0,
3104       notHemisphere = abs(cr) > ε, // TODO optimise for this common case
3105       interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
3106
3107   return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-π, radius - π]);
3108
3109   function visible(λ, φ) {
3110     return Math.cos(λ) * Math.cos(φ) > cr;
3111   }
3112
3113   // Takes a line and cuts into visible segments. Return values used for
3114   // polygon clipping:
3115   //   0: there were intersections or the line was empty.
3116   //   1: no intersections.
3117   //   2: there were intersections, and the first and last segments should be
3118   //      rejoined.
3119   function clipLine(listener) {
3120     var point0, // previous point
3121         c0, // code for previous point
3122         v0, // visibility of previous point
3123         v00, // visibility of first point
3124         clean; // no intersections
3125     return {
3126       lineStart: function() {
3127         v00 = v0 = false;
3128         clean = 1;
3129       },
3130       point: function(λ, φ) {
3131         var point1 = [λ, φ],
3132             point2,
3133             v = visible(λ, φ),
3134             c = smallRadius
3135               ? v ? 0 : code(λ, φ)
3136               : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
3137         if (!point0 && (v00 = v0 = v)) listener.lineStart();
3138         // Handle degeneracies.
3139         // TODO ignore if not clipping polygons.
3140         if (v !== v0) {
3141           point2 = intersect(point0, point1);
3142           if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
3143             point1[0] += ε;
3144             point1[1] += ε;
3145             v = visible(point1[0], point1[1]);
3146           }
3147         }
3148         if (v !== v0) {
3149           clean = 0;
3150           if (v) {
3151             // outside going in
3152             listener.lineStart();
3153             point2 = intersect(point1, point0);
3154             listener.point(point2[0], point2[1]);
3155           } else {
3156             // inside going out
3157             point2 = intersect(point0, point1);
3158             listener.point(point2[0], point2[1]);
3159             listener.lineEnd();
3160           }
3161           point0 = point2;
3162         } else if (notHemisphere && point0 && smallRadius ^ v) {
3163           var t;
3164           // If the codes for two points are different, or are both zero,
3165           // and there this segment intersects with the small circle.
3166           if (!(c & c0) && (t = intersect(point1, point0, true))) {
3167             clean = 0;
3168             if (smallRadius) {
3169               listener.lineStart();
3170               listener.point(t[0][0], t[0][1]);
3171               listener.point(t[1][0], t[1][1]);
3172               listener.lineEnd();
3173             } else {
3174               listener.point(t[1][0], t[1][1]);
3175               listener.lineEnd();
3176               listener.lineStart();
3177               listener.point(t[0][0], t[0][1]);
3178             }
3179           }
3180         }
3181         if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
3182           listener.point(point1[0], point1[1]);
3183         }
3184         point0 = point1, v0 = v, c0 = c;
3185       },
3186       lineEnd: function() {
3187         if (v0) listener.lineEnd();
3188         point0 = null;
3189       },
3190       // Rejoin first and last segments if there were intersections and the first
3191       // and last points were visible.
3192       clean: function() { return clean | ((v00 && v0) << 1); }
3193     };
3194   }
3195
3196   // Intersects the great circle between a and b with the clip circle.
3197   function intersect(a, b, two) {
3198     var pa = d3_geo_cartesian(a),
3199         pb = d3_geo_cartesian(b);
3200
3201     // We have two planes, n1.p = d1 and n2.p = d2.
3202     // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).
3203     var n1 = [1, 0, 0], // normal
3204         n2 = d3_geo_cartesianCross(pa, pb),
3205         n2n2 = d3_geo_cartesianDot(n2, n2),
3206         n1n2 = n2[0], // d3_geo_cartesianDot(n1, n2),
3207         determinant = n2n2 - n1n2 * n1n2;
3208
3209     // Two polar points.
3210     if (!determinant) return !two && a;
3211
3212     var c1 =  cr * n2n2 / determinant,
3213         c2 = -cr * n1n2 / determinant,
3214         n1xn2 = d3_geo_cartesianCross(n1, n2),
3215         A = d3_geo_cartesianScale(n1, c1),
3216         B = d3_geo_cartesianScale(n2, c2);
3217     d3_geo_cartesianAdd(A, B);
3218
3219     // Solve |p(t)|^2 = 1.
3220     var u = n1xn2,
3221         w = d3_geo_cartesianDot(A, u),
3222         uu = d3_geo_cartesianDot(u, u),
3223         t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
3224
3225     if (t2 < 0) return;
3226
3227     var t = Math.sqrt(t2),
3228         q = d3_geo_cartesianScale(u, (-w - t) / uu);
3229     d3_geo_cartesianAdd(q, A);
3230     q = d3_geo_spherical(q);
3231     if (!two) return q;
3232
3233     // Two intersection points.
3234     var λ0 = a[0],
3235         λ1 = b[0],
3236         φ0 = a[1],
3237         φ1 = b[1],
3238         z;
3239     if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
3240     var δλ = λ1 - λ0,
3241         polar = abs(δλ - π) < ε,
3242         meridian = polar || δλ < ε;
3243
3244     if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
3245
3246     // Check that the first point is between a and b.
3247     if (meridian
3248         ? polar
3249           ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1)
3250           : φ0 <= q[1] && q[1] <= φ1
3251         : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
3252       var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
3253       d3_geo_cartesianAdd(q1, A);
3254       return [q, d3_geo_spherical(q1)];
3255     }
3256   }
3257
3258   // Generates a 4-bit vector representing the location of a point relative to
3259   // the small circle's bounding box.
3260   function code(λ, φ) {
3261     var r = smallRadius ? radius : π - radius,
3262         code = 0;
3263     if (λ < -r) code |= 1; // left
3264     else if (λ > r) code |= 2; // right
3265     if (φ < -r) code |= 4; // below
3266     else if (φ > r) code |= 8; // above
3267     return code;
3268   }
3269 }
3270
3271 // Liang–Barsky line clipping.
3272 function d3_geom_clipLine(x0, y0, x1, y1) {
3273   return function(line) {
3274     var a = line.a,
3275         b = line.b,
3276         ax = a.x,
3277         ay = a.y,
3278         bx = b.x,
3279         by = b.y,
3280         t0 = 0,
3281         t1 = 1,
3282         dx = bx - ax,
3283         dy = by - ay,
3284         r;
3285
3286     r = x0 - ax;
3287     if (!dx && r > 0) return;
3288     r /= dx;
3289     if (dx < 0) {
3290       if (r < t0) return;
3291       if (r < t1) t1 = r;
3292     } else if (dx > 0) {
3293       if (r > t1) return;
3294       if (r > t0) t0 = r;
3295     }
3296
3297     r = x1 - ax;
3298     if (!dx && r < 0) return;
3299     r /= dx;
3300     if (dx < 0) {
3301       if (r > t1) return;
3302       if (r > t0) t0 = r;
3303     } else if (dx > 0) {
3304       if (r < t0) return;
3305       if (r < t1) t1 = r;
3306     }
3307
3308     r = y0 - ay;
3309     if (!dy && r > 0) return;
3310     r /= dy;
3311     if (dy < 0) {
3312       if (r < t0) return;
3313       if (r < t1) t1 = r;
3314     } else if (dy > 0) {
3315       if (r > t1) return;
3316       if (r > t0) t0 = r;
3317     }
3318
3319     r = y1 - ay;
3320     if (!dy && r < 0) return;
3321     r /= dy;
3322     if (dy < 0) {
3323       if (r > t1) return;
3324       if (r > t0) t0 = r;
3325     } else if (dy > 0) {
3326       if (r < t0) return;
3327       if (r < t1) t1 = r;
3328     }
3329
3330     if (t0 > 0) line.a = {x: ax + t0 * dx, y: ay + t0 * dy};
3331     if (t1 < 1) line.b = {x: ax + t1 * dx, y: ay + t1 * dy};
3332     return line;
3333   };
3334 }
3335
3336 var d3_geo_clipExtentMAX = 1e9;
3337
3338 d3.geo.clipExtent = function() {
3339   var x0, y0, x1, y1,
3340       stream,
3341       clip,
3342       clipExtent = {
3343         stream: function(output) {
3344           if (stream) stream.valid = false;
3345           stream = clip(output);
3346           stream.valid = true; // allow caching by d3.geo.path
3347           return stream;
3348         },
3349         extent: function(_) {
3350           if (!arguments.length) return [[x0, y0], [x1, y1]];
3351           clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]);
3352           if (stream) stream.valid = false, stream = null;
3353           return clipExtent;
3354         }
3355       };
3356   return clipExtent.extent([[0, 0], [960, 500]]);
3357 };
3358
3359 function d3_geo_clipExtent(x0, y0, x1, y1) {
3360   return function(listener) {
3361     var listener_ = listener,
3362         bufferListener = d3_geo_clipBufferListener(),
3363         clipLine = d3_geom_clipLine(x0, y0, x1, y1),
3364         segments,
3365         polygon,
3366         ring;
3367
3368     var clip = {
3369       point: point,
3370       lineStart: lineStart,
3371       lineEnd: lineEnd,
3372       polygonStart: function() {
3373         listener = bufferListener;
3374         segments = [];
3375         polygon = [];
3376         clean = true;
3377       },
3378       polygonEnd: function() {
3379         listener = listener_;
3380         segments = d3.merge(segments);
3381         var clipStartInside = insidePolygon([x0, y1]),
3382             inside = clean && clipStartInside,
3383             visible = segments.length;
3384         if (inside || visible) {
3385           listener.polygonStart();
3386           if (inside) {
3387             listener.lineStart();
3388             interpolate(null, null, 1, listener);
3389             listener.lineEnd();
3390           }
3391           if (visible) {
3392             d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener);
3393           }
3394           listener.polygonEnd();
3395         }
3396         segments = polygon = ring = null;
3397       }
3398     };
3399
3400     function insidePolygon(p) {
3401       var wn = 0, // the winding number counter
3402           n = polygon.length,
3403           y = p[1];
3404
3405       for (var i = 0; i < n; ++i) {
3406         for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) {
3407           b = v[j];
3408           if (a[1] <= y) {
3409             if (b[1] >  y && d3_cross2d(a, b, p) > 0) ++wn;
3410           } else {
3411             if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn;
3412           }
3413           a = b;
3414         }
3415       }
3416       return wn !== 0;
3417     }
3418
3419     function interpolate(from, to, direction, listener) {
3420       var a = 0, a1 = 0;
3421       if (from == null ||
3422           (a = corner(from, direction)) !== (a1 = corner(to, direction)) ||
3423           comparePoints(from, to) < 0 ^ direction > 0) {
3424         do {
3425           listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
3426         } while ((a = (a + direction + 4) % 4) !== a1);
3427       } else {
3428         listener.point(to[0], to[1]);
3429       }
3430     }
3431
3432     function pointVisible(x, y) {
3433       return x0 <= x && x <= x1 && y0 <= y && y <= y1;
3434     }
3435
3436     function point(x, y) {
3437       if (pointVisible(x, y)) listener.point(x, y);
3438     }
3439
3440     var x__, y__, v__, // first point
3441         x_, y_, v_, // previous point
3442         first,
3443         clean;
3444
3445     function lineStart() {
3446       clip.point = linePoint;
3447       if (polygon) polygon.push(ring = []);
3448       first = true;
3449       v_ = false;
3450       x_ = y_ = NaN;
3451     }
3452
3453     function lineEnd() {
3454       // TODO rather than special-case polygons, simply handle them separately.
3455       // Ideally, coincident intersection points should be jittered to avoid
3456       // clipping issues.
3457       if (segments) {
3458         linePoint(x__, y__);
3459         if (v__ && v_) bufferListener.rejoin();
3460         segments.push(bufferListener.buffer());
3461       }
3462       clip.point = point;
3463       if (v_) listener.lineEnd();
3464     }
3465
3466     function linePoint(x, y) {
3467       x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x));
3468       y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y));
3469       var v = pointVisible(x, y);
3470       if (polygon) ring.push([x, y]);
3471       if (first) {
3472         x__ = x, y__ = y, v__ = v;
3473         first = false;
3474         if (v) {
3475           listener.lineStart();
3476           listener.point(x, y);
3477         }
3478       } else {
3479         if (v && v_) listener.point(x, y);
3480         else {
3481           var l = {a: {x: x_, y: y_}, b: {x: x, y: y}};
3482           if (clipLine(l)) {
3483             if (!v_) {
3484               listener.lineStart();
3485               listener.point(l.a.x, l.a.y);
3486             }
3487             listener.point(l.b.x, l.b.y);
3488             if (!v) listener.lineEnd();
3489             clean = false;
3490           } else if (v) {
3491             listener.lineStart();
3492             listener.point(x, y);
3493             clean = false;
3494           }
3495         }
3496       }
3497       x_ = x, y_ = y, v_ = v;
3498     }
3499
3500     return clip;
3501   };
3502
3503   function corner(p, direction) {
3504     return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3
3505         : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1
3506         : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0
3507         : direction > 0 ? 3 : 2; // abs(p[1] - y1) < ε
3508   }
3509
3510   function compare(a, b) {
3511     return comparePoints(a.x, b.x);
3512   }
3513
3514   function comparePoints(a, b) {
3515     var ca = corner(a, 1),
3516         cb = corner(b, 1);
3517     return ca !== cb ? ca - cb
3518         : ca === 0 ? b[1] - a[1]
3519         : ca === 1 ? a[0] - b[0]
3520         : ca === 2 ? a[1] - b[1]
3521         : b[0] - a[0];
3522   }
3523 }
3524
3525 function d3_geo_conic(projectAt) {
3526   var φ0 = 0,
3527       φ1 = π / 3,
3528       m = d3_geo_projectionMutator(projectAt),
3529       p = m(φ0, φ1);
3530
3531   p.parallels = function(_) {
3532     if (!arguments.length) return [φ0 / π * 180, φ1 / π * 180];
3533     return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
3534   };
3535
3536   return p;
3537 }
3538
3539 function d3_geo_conicEqualArea(φ0, φ1) {
3540   var sinφ0 = Math.sin(φ0),
3541       n = (sinφ0 + Math.sin(φ1)) / 2,
3542       C = 1 + sinφ0 * (2 * n - sinφ0),
3543       ρ0 = Math.sqrt(C) / n;
3544
3545   function forward(λ, φ) {
3546     var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
3547     return [
3548       ρ * Math.sin(λ *= n),
3549       ρ0 - ρ * Math.cos(λ)
3550     ];
3551   }
3552
3553   forward.invert = function(x, y) {
3554     var ρ0_y = ρ0 - y;
3555     return [
3556       Math.atan2(x, ρ0_y) / n,
3557       d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n))
3558     ];
3559   };
3560
3561   return forward;
3562 }
3563
3564 (d3.geo.conicEqualArea = function() {
3565   return d3_geo_conic(d3_geo_conicEqualArea);
3566 }).raw = d3_geo_conicEqualArea;
3567
3568 // ESRI:102003
3569 d3.geo.albers = function() {
3570   return d3.geo.conicEqualArea()
3571       .rotate([96, 0])
3572       .center([-.6, 38.7])
3573       .parallels([29.5, 45.5])
3574       .scale(1070);
3575 };
3576
3577 // A composite projection for the United States, configured by default for
3578 // 960×500. Also works quite well at 960×600 with scale 1285. The set of
3579 // standard parallels for each region comes from USGS, which is published here:
3580 // http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers
3581 d3.geo.albersUsa = function() {
3582   var lower48 = d3.geo.albers();
3583
3584   // EPSG:3338
3585   var alaska = d3.geo.conicEqualArea()
3586       .rotate([154, 0])
3587       .center([-2, 58.5])
3588       .parallels([55, 65]);
3589
3590   // ESRI:102007
3591   var hawaii = d3.geo.conicEqualArea()
3592       .rotate([157, 0])
3593       .center([-3, 19.9])
3594       .parallels([8, 18]);
3595
3596   var point,
3597       pointStream = {point: function(x, y) { point = [x, y]; }},
3598       lower48Point,
3599       alaskaPoint,
3600       hawaiiPoint;
3601
3602   function albersUsa(coordinates) {
3603     var x = coordinates[0], y = coordinates[1];
3604     point = null;
3605     (lower48Point(x, y), point)
3606         || (alaskaPoint(x, y), point)
3607         || hawaiiPoint(x, y);
3608     return point;
3609   }
3610
3611   albersUsa.invert = function(coordinates) {
3612     var k = lower48.scale(),
3613         t = lower48.translate(),
3614         x = (coordinates[0] - t[0]) / k,
3615         y = (coordinates[1] - t[1]) / k;
3616     return (y >= .120 && y < .234 && x >= -.425 && x < -.214 ? alaska
3617         : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii
3618         : lower48).invert(coordinates);
3619   };
3620
3621   // A naïve multi-projection stream.
3622   // The projections must have mutually exclusive clip regions on the sphere,
3623   // as this will avoid emitting interleaving lines and polygons.
3624   albersUsa.stream = function(stream) {
3625     var lower48Stream = lower48.stream(stream),
3626         alaskaStream = alaska.stream(stream),
3627         hawaiiStream = hawaii.stream(stream);
3628     return {
3629       point: function(x, y) {
3630         lower48Stream.point(x, y);
3631         alaskaStream.point(x, y);
3632         hawaiiStream.point(x, y);
3633       },
3634       sphere: function() {
3635         lower48Stream.sphere();
3636         alaskaStream.sphere();
3637         hawaiiStream.sphere();
3638       },
3639       lineStart: function() {
3640         lower48Stream.lineStart();
3641         alaskaStream.lineStart();
3642         hawaiiStream.lineStart();
3643       },
3644       lineEnd: function() {
3645         lower48Stream.lineEnd();
3646         alaskaStream.lineEnd();
3647         hawaiiStream.lineEnd();
3648       },
3649       polygonStart: function() {
3650         lower48Stream.polygonStart();
3651         alaskaStream.polygonStart();
3652         hawaiiStream.polygonStart();
3653       },
3654       polygonEnd: function() {
3655         lower48Stream.polygonEnd();
3656         alaskaStream.polygonEnd();
3657         hawaiiStream.polygonEnd();
3658       }
3659     };
3660   };
3661
3662   albersUsa.precision = function(_) {
3663     if (!arguments.length) return lower48.precision();
3664     lower48.precision(_);
3665     alaska.precision(_);
3666     hawaii.precision(_);
3667     return albersUsa;
3668   };
3669
3670   albersUsa.scale = function(_) {
3671     if (!arguments.length) return lower48.scale();
3672     lower48.scale(_);
3673     alaska.scale(_ * .35);
3674     hawaii.scale(_);
3675     return albersUsa.translate(lower48.translate());
3676   };
3677
3678   albersUsa.translate = function(_) {
3679     if (!arguments.length) return lower48.translate();
3680     var k = lower48.scale(), x = +_[0], y = +_[1];
3681
3682     lower48Point = lower48
3683         .translate(_)
3684         .clipExtent([[x - .455 * k, y - .238 * k], [x + .455 * k, y + .238 * k]])
3685         .stream(pointStream).point;
3686
3687     alaskaPoint = alaska
3688         .translate([x - .307 * k, y + .201 * k])
3689         .clipExtent([[x - .425 * k + ε, y + .120 * k + ε], [x - .214 * k - ε, y + .234 * k - ε]])
3690         .stream(pointStream).point;
3691
3692     hawaiiPoint = hawaii
3693         .translate([x - .205 * k, y + .212 * k])
3694         .clipExtent([[x - .214 * k + ε, y + .166 * k + ε], [x - .115 * k - ε, y + .234 * k - ε]])
3695         .stream(pointStream).point;
3696
3697     return albersUsa;
3698   };
3699
3700   return albersUsa.scale(1070);
3701 };
3702
3703 d3.geo.bounds = (function() {
3704   var λ0, φ0, λ1, φ1, // bounds
3705       λ_, // previous λ-coordinate
3706       λ__, φ__, // first point
3707       p0, // previous 3D point
3708       dλSum,
3709       ranges,
3710       range;
3711
3712   var bound = {
3713     point: point,
3714     lineStart: lineStart,
3715     lineEnd: lineEnd,
3716
3717     polygonStart: function() {
3718       bound.point = ringPoint;
3719       bound.lineStart = ringStart;
3720       bound.lineEnd = ringEnd;
3721       dλSum = 0;
3722       d3_geo_area.polygonStart();
3723     },
3724     polygonEnd: function() {
3725       d3_geo_area.polygonEnd();
3726       bound.point = point;
3727       bound.lineStart = lineStart;
3728       bound.lineEnd = lineEnd;
3729       if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90);
3730       else if (dλSum > ε) φ1 = 90;
3731       else if (dλSum < -ε) φ0 = -90;
3732       range[0] = λ0, range[1] = λ1;
3733     }
3734   };
3735
3736   function point(λ, φ) {
3737     ranges.push(range = [λ0 = λ, λ1 = λ]);
3738     if (φ < φ0) φ0 = φ;
3739     if (φ > φ1) φ1 = φ;
3740   }
3741
3742   function linePoint(λ, φ) {
3743     var p = d3_geo_cartesian([λ * d3_radians, φ * d3_radians]);
3744     if (p0) {
3745       var normal = d3_geo_cartesianCross(p0, p),
3746           equatorial = [normal[1], -normal[0], 0],
3747           inflection = d3_geo_cartesianCross(equatorial, normal);
3748       d3_geo_cartesianNormalize(inflection);
3749       inflection = d3_geo_spherical(inflection);
3750       var dλ = λ - λ_,
3751           s = dλ > 0 ? 1 : -1,
3752           λi = inflection[0] * d3_degrees * s,
3753           antimeridian = abs(dλ) > 180;
3754       if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
3755         var φi = inflection[1] * d3_degrees;
3756         if (φi > φ1) φ1 = φi;
3757       } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
3758         var φi = -inflection[1] * d3_degrees;
3759         if (φi < φ0) φ0 = φi;
3760       } else {
3761         if (φ < φ0) φ0 = φ;
3762         if (φ > φ1) φ1 = φ;
3763       }
3764       if (antimeridian) {
3765         if (λ < λ_) {
3766           if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
3767         } else {
3768           if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
3769         }
3770       } else {
3771         if (λ1 >= λ0) {
3772           if (λ < λ0) λ0 = λ;
3773           if (λ > λ1) λ1 = λ;
3774         } else {
3775           if (λ > λ_) {
3776             if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
3777           } else {
3778             if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
3779           }
3780         }
3781       }
3782     } else {
3783       point(λ, φ);
3784     }
3785     p0 = p, λ_ = λ;
3786   }
3787
3788   function lineStart() { bound.point = linePoint; }
3789   function lineEnd() {
3790     range[0] = λ0, range[1] = λ1;
3791     bound.point = point;
3792     p0 = null;
3793   }
3794
3795   function ringPoint(λ, φ) {
3796     if (p0) {
3797       var dλ = λ - λ_;
3798       dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
3799     } else λ__ = λ, φ__ = φ;
3800     d3_geo_area.point(λ, φ);
3801     linePoint(λ, φ);
3802   }
3803
3804   function ringStart() {
3805     d3_geo_area.lineStart();
3806   }
3807
3808   function ringEnd() {
3809     ringPoint(λ__, φ__);
3810     d3_geo_area.lineEnd();
3811     if (abs(dλSum) > ε) λ0 = -(λ1 = 180);
3812     range[0] = λ0, range[1] = λ1;
3813     p0 = null;
3814   }
3815
3816   // Finds the left-right distance between two longitudes.
3817   // This is almost the same as (λ1 - λ0 + 360°) % 360°, except that we want
3818   // the distance between ±180° to be 360°.
3819   function angle(λ0, λ1) { return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1; }
3820
3821   function compareRanges(a, b) { return a[0] - b[0]; }
3822
3823   function withinRange(x, range) {
3824     return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
3825   }
3826
3827   return function(feature) {
3828     φ1 = λ1 = -(λ0 = φ0 = Infinity);
3829     ranges = [];
3830
3831     d3.geo.stream(feature, bound);
3832
3833     var n = ranges.length;
3834     if (n) {
3835       // First, sort ranges by their minimum longitudes.
3836       ranges.sort(compareRanges);
3837
3838       // Then, merge any ranges that overlap.
3839       for (var i = 1, a = ranges[0], b, merged = [a]; i < n; ++i) {
3840         b = ranges[i];
3841         if (withinRange(b[0], a) || withinRange(b[1], a)) {
3842           if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
3843           if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
3844         } else {
3845           merged.push(a = b);
3846         }
3847       }
3848
3849       // Finally, find the largest gap between the merged ranges.
3850       // The final bounding box will be the inverse of this gap.
3851       var best = -Infinity, dλ;
3852       for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
3853         b = merged[i];
3854         if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
3855       }
3856     }
3857     ranges = range = null;
3858
3859     return λ0 === Infinity || φ0 === Infinity
3860         ? [[NaN, NaN], [NaN, NaN]]
3861         : [[λ0, φ0], [λ1, φ1]];
3862   };
3863 })();
3864
3865 d3.geo.centroid = function(object) {
3866   d3_geo_centroidW0 = d3_geo_centroidW1 =
3867   d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 =
3868   d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 =
3869   d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
3870   d3.geo.stream(object, d3_geo_centroid);
3871
3872   var x = d3_geo_centroidX2,
3873       y = d3_geo_centroidY2,
3874       z = d3_geo_centroidZ2,
3875       m = x * x + y * y + z * z;
3876
3877   // If the area-weighted centroid is undefined, fall back to length-weighted centroid.
3878   if (m < ε2) {
3879     x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
3880     // If the feature has zero length, fall back to arithmetic mean of point vectors.
3881     if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
3882     m = x * x + y * y + z * z;
3883     // If the feature still has an undefined centroid, then return.
3884     if (m < ε2) return [NaN, NaN];
3885   }
3886
3887   return [Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees];
3888 };
3889
3890 var d3_geo_centroidW0,
3891     d3_geo_centroidW1,
3892     d3_geo_centroidX0,
3893     d3_geo_centroidY0,
3894     d3_geo_centroidZ0,
3895     d3_geo_centroidX1,
3896     d3_geo_centroidY1,
3897     d3_geo_centroidZ1,
3898     d3_geo_centroidX2,
3899     d3_geo_centroidY2,
3900     d3_geo_centroidZ2;
3901
3902 var d3_geo_centroid = {
3903   sphere: d3_noop,
3904   point: d3_geo_centroidPoint,
3905   lineStart: d3_geo_centroidLineStart,
3906   lineEnd: d3_geo_centroidLineEnd,
3907   polygonStart: function() {
3908     d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
3909   },
3910   polygonEnd: function() {
3911     d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
3912   }
3913 };
3914
3915 // Arithmetic mean of Cartesian vectors.
3916 function d3_geo_centroidPoint(λ, φ) {
3917   λ *= d3_radians;
3918   var cosφ = Math.cos(φ *= d3_radians);
3919   d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
3920 }
3921
3922 function d3_geo_centroidPointXYZ(x, y, z) {
3923   ++d3_geo_centroidW0;
3924   d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
3925   d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
3926   d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
3927 }
3928
3929 function d3_geo_centroidLineStart() {
3930   var x0, y0, z0; // previous point
3931
3932   d3_geo_centroid.point = function(λ, φ) {
3933     λ *= d3_radians;
3934     var cosφ = Math.cos(φ *= d3_radians);
3935     x0 = cosφ * Math.cos(λ);
3936     y0 = cosφ * Math.sin(λ);
3937     z0 = Math.sin(φ);
3938     d3_geo_centroid.point = nextPoint;
3939     d3_geo_centroidPointXYZ(x0, y0, z0);
3940   };
3941
3942   function nextPoint(λ, φ) {
3943     λ *= d3_radians;
3944     var cosφ = Math.cos(φ *= d3_radians),
3945         x = cosφ * Math.cos(λ),
3946         y = cosφ * Math.sin(λ),
3947         z = Math.sin(φ),
3948         w = Math.atan2(
3949           Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w),
3950           x0 * x + y0 * y + z0 * z);
3951     d3_geo_centroidW1 += w;
3952     d3_geo_centroidX1 += w * (x0 + (x0 = x));
3953     d3_geo_centroidY1 += w * (y0 + (y0 = y));
3954     d3_geo_centroidZ1 += w * (z0 + (z0 = z));
3955     d3_geo_centroidPointXYZ(x0, y0, z0);
3956   }
3957 }
3958
3959 function d3_geo_centroidLineEnd() {
3960   d3_geo_centroid.point = d3_geo_centroidPoint;
3961 }
3962
3963 // See J. E. Brock, The Inertia Tensor for a Spherical Triangle,
3964 // J. Applied Mechanics 42, 239 (1975).
3965 function d3_geo_centroidRingStart() {
3966   var λ00, φ00, // first point
3967       x0, y0, z0; // previous point
3968
3969   d3_geo_centroid.point = function(λ, φ) {
3970     λ00 = λ, φ00 = φ;
3971     d3_geo_centroid.point = nextPoint;
3972     λ *= d3_radians;
3973     var cosφ = Math.cos(φ *= d3_radians);
3974     x0 = cosφ * Math.cos(λ);
3975     y0 = cosφ * Math.sin(λ);
3976     z0 = Math.sin(φ);
3977     d3_geo_centroidPointXYZ(x0, y0, z0);
3978   };
3979
3980   d3_geo_centroid.lineEnd = function() {
3981     nextPoint(λ00, φ00);
3982     d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
3983     d3_geo_centroid.point = d3_geo_centroidPoint;
3984   };
3985
3986   function nextPoint(λ, φ) {
3987     λ *= d3_radians;
3988     var cosφ = Math.cos(φ *= d3_radians),
3989         x = cosφ * Math.cos(λ),
3990         y = cosφ * Math.sin(λ),
3991         z = Math.sin(φ),
3992         cx = y0 * z - z0 * y,
3993         cy = z0 * x - x0 * z,
3994         cz = x0 * y - y0 * x,
3995         m = Math.sqrt(cx * cx + cy * cy + cz * cz),
3996         u = x0 * x + y0 * y + z0 * z,
3997         v = m && -d3_acos(u) / m, // area weight
3998         w = Math.atan2(m, u); // line weight
3999     d3_geo_centroidX2 += v * cx;
4000     d3_geo_centroidY2 += v * cy;
4001     d3_geo_centroidZ2 += v * cz;
4002     d3_geo_centroidW1 += w;
4003     d3_geo_centroidX1 += w * (x0 + (x0 = x));
4004     d3_geo_centroidY1 += w * (y0 + (y0 = y));
4005     d3_geo_centroidZ1 += w * (z0 + (z0 = z));
4006     d3_geo_centroidPointXYZ(x0, y0, z0);
4007   }
4008 }
4009
4010 // TODO Unify this code with d3.geom.polygon area?
4011
4012 var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
4013   point: d3_noop,
4014   lineStart: d3_noop,
4015   lineEnd: d3_noop,
4016
4017   // Only count area for polygon rings.
4018   polygonStart: function() {
4019     d3_geo_pathAreaPolygon = 0;
4020     d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
4021   },
4022   polygonEnd: function() {
4023     d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
4024     d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
4025   }
4026 };
4027
4028 function d3_geo_pathAreaRingStart() {
4029   var x00, y00, x0, y0;
4030
4031   // For the first point, …
4032   d3_geo_pathArea.point = function(x, y) {
4033     d3_geo_pathArea.point = nextPoint;
4034     x00 = x0 = x, y00 = y0 = y;
4035   };
4036
4037   // For subsequent points, …
4038   function nextPoint(x, y) {
4039     d3_geo_pathAreaPolygon += y0 * x - x0 * y;
4040     x0 = x, y0 = y;
4041   }
4042
4043   // For the last point, return to the start.
4044   d3_geo_pathArea.lineEnd = function() {
4045     nextPoint(x00, y00);
4046   };
4047 }
4048
4049 var d3_geo_pathBoundsX0,
4050     d3_geo_pathBoundsY0,
4051     d3_geo_pathBoundsX1,
4052     d3_geo_pathBoundsY1;
4053
4054 var d3_geo_pathBounds = {
4055   point: d3_geo_pathBoundsPoint,
4056   lineStart: d3_noop,
4057   lineEnd: d3_noop,
4058   polygonStart: d3_noop,
4059   polygonEnd: d3_noop
4060 };
4061
4062 function d3_geo_pathBoundsPoint(x, y) {
4063   if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
4064   if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
4065   if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
4066   if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
4067 }
4068 function d3_geo_pathBuffer() {
4069   var pointCircle = d3_geo_pathBufferCircle(4.5),
4070       buffer = [];
4071
4072   var stream = {
4073     point: point,
4074
4075     // While inside a line, override point to moveTo then lineTo.
4076     lineStart: function() { stream.point = pointLineStart; },
4077     lineEnd: lineEnd,
4078
4079     // While inside a polygon, override lineEnd to closePath.
4080     polygonStart: function() { stream.lineEnd = lineEndPolygon; },
4081     polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
4082
4083     pointRadius: function(_) {
4084       pointCircle = d3_geo_pathBufferCircle(_);
4085       return stream;
4086     },
4087
4088     result: function() {
4089       if (buffer.length) {
4090         var result = buffer.join("");
4091         buffer = [];
4092         return result;
4093       }
4094     }
4095   };
4096
4097   function point(x, y) {
4098     buffer.push("M", x, ",", y, pointCircle);
4099   }
4100
4101   function pointLineStart(x, y) {
4102     buffer.push("M", x, ",", y);
4103     stream.point = pointLine;
4104   }
4105
4106   function pointLine(x, y) {
4107     buffer.push("L", x, ",", y);
4108   }
4109
4110   function lineEnd() {
4111     stream.point = point;
4112   }
4113
4114   function lineEndPolygon() {
4115     buffer.push("Z");
4116   }
4117
4118   return stream;
4119 }
4120
4121 function d3_geo_pathBufferCircle(radius) {
4122   return "m0," + radius
4123       + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius
4124       + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius
4125       + "z";
4126 }
4127
4128 // TODO Unify this code with d3.geom.polygon centroid?
4129 // TODO Enforce positive area for exterior, negative area for interior?
4130
4131 var d3_geo_pathCentroid = {
4132   point: d3_geo_pathCentroidPoint,
4133
4134   // For lines, weight by length.
4135   lineStart: d3_geo_pathCentroidLineStart,
4136   lineEnd: d3_geo_pathCentroidLineEnd,
4137
4138   // For polygons, weight by area.
4139   polygonStart: function() {
4140     d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
4141   },
4142   polygonEnd: function() {
4143     d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
4144     d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
4145     d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
4146   }
4147 };
4148
4149 function d3_geo_pathCentroidPoint(x, y) {
4150   d3_geo_centroidX0 += x;
4151   d3_geo_centroidY0 += y;
4152   ++d3_geo_centroidZ0;
4153 }
4154
4155 function d3_geo_pathCentroidLineStart() {
4156   var x0, y0;
4157
4158   d3_geo_pathCentroid.point = function(x, y) {
4159     d3_geo_pathCentroid.point = nextPoint;
4160     d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4161   };
4162
4163   function nextPoint(x, y) {
4164     var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
4165     d3_geo_centroidX1 += z * (x0 + x) / 2;
4166     d3_geo_centroidY1 += z * (y0 + y) / 2;
4167     d3_geo_centroidZ1 += z;
4168     d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4169   }
4170 }
4171
4172 function d3_geo_pathCentroidLineEnd() {
4173   d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
4174 }
4175
4176 function d3_geo_pathCentroidRingStart() {
4177   var x00, y00, x0, y0;
4178
4179   // For the first point, …
4180   d3_geo_pathCentroid.point = function(x, y) {
4181     d3_geo_pathCentroid.point = nextPoint;
4182     d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
4183   };
4184
4185   // For subsequent points, …
4186   function nextPoint(x, y) {
4187     var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
4188     d3_geo_centroidX1 += z * (x0 + x) / 2;
4189     d3_geo_centroidY1 += z * (y0 + y) / 2;
4190     d3_geo_centroidZ1 += z;
4191
4192     z = y0 * x - x0 * y;
4193     d3_geo_centroidX2 += z * (x0 + x);
4194     d3_geo_centroidY2 += z * (y0 + y);
4195     d3_geo_centroidZ2 += z * 3;
4196     d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4197   }
4198
4199   // For the last point, return to the start.
4200   d3_geo_pathCentroid.lineEnd = function() {
4201     nextPoint(x00, y00);
4202   };
4203 }
4204
4205 function d3_geo_pathContext(context) {
4206   var pointRadius = 4.5;
4207
4208   var stream = {
4209     point: point,
4210
4211     // While inside a line, override point to moveTo then lineTo.
4212     lineStart: function() { stream.point = pointLineStart; },
4213     lineEnd: lineEnd,
4214
4215     // While inside a polygon, override lineEnd to closePath.
4216     polygonStart: function() { stream.lineEnd = lineEndPolygon; },
4217     polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
4218
4219     pointRadius: function(_) {
4220       pointRadius = _;
4221       return stream;
4222     },
4223
4224     result: d3_noop
4225   };
4226
4227   function point(x, y) {
4228     context.moveTo(x + pointRadius, y);
4229     context.arc(x, y, pointRadius, 0, τ);
4230   }
4231
4232   function pointLineStart(x, y) {
4233     context.moveTo(x, y);
4234     stream.point = pointLine;
4235   }
4236
4237   function pointLine(x, y) {
4238     context.lineTo(x, y);
4239   }
4240
4241   function lineEnd() {
4242     stream.point = point;
4243   }
4244
4245   function lineEndPolygon() {
4246     context.closePath();
4247   }
4248
4249   return stream;
4250 }
4251
4252 function d3_geo_resample(project) {
4253   var δ2 = .5, // precision, px²
4254       cosMinDistance = Math.cos(30 * d3_radians), // cos(minimum angular distance)
4255       maxDepth = 16;
4256
4257   function resample(stream) {
4258     return (maxDepth ? resampleRecursive : resampleNone)(stream);
4259   }
4260
4261   function resampleNone(stream) {
4262     return d3_geo_transformPoint(stream, function(x, y) {
4263       x = project(x, y);
4264       stream.point(x[0], x[1]);
4265     });
4266   }
4267
4268   function resampleRecursive(stream) {
4269     var λ00, φ00, x00, y00, a00, b00, c00, // first point
4270         λ0, x0, y0, a0, b0, c0; // previous point
4271
4272     var resample = {
4273       point: point,
4274       lineStart: lineStart,
4275       lineEnd: lineEnd,
4276       polygonStart: function() { stream.polygonStart(); resample.lineStart = ringStart; },
4277       polygonEnd: function() { stream.polygonEnd(); resample.lineStart = lineStart; }
4278     };
4279
4280     function point(x, y) {
4281       x = project(x, y);
4282       stream.point(x[0], x[1]);
4283     }
4284
4285     function lineStart() {
4286       x0 = NaN;
4287       resample.point = linePoint;
4288       stream.lineStart();
4289     }
4290
4291     function linePoint(λ, φ) {
4292       var c = d3_geo_cartesian([λ, φ]), p = project(λ, φ);
4293       resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
4294       stream.point(x0, y0);
4295     }
4296
4297     function lineEnd() {
4298       resample.point = point;
4299       stream.lineEnd();
4300     }
4301
4302     function ringStart() {
4303       lineStart();
4304       resample.point = ringPoint;
4305       resample.lineEnd = ringEnd;
4306     }
4307
4308     function ringPoint(λ, φ) {
4309       linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
4310       resample.point = linePoint;
4311     }
4312
4313     function ringEnd() {
4314       resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream);
4315       resample.lineEnd = lineEnd;
4316       lineEnd();
4317     }
4318
4319     return resample;
4320   }
4321
4322   function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) {
4323     var dx = x1 - x0,
4324         dy = y1 - y0,
4325         d2 = dx * dx + dy * dy;
4326     if (d2 > 4 * δ2 && depth--) {
4327       var a = a0 + a1,
4328           b = b0 + b1,
4329           c = c0 + c1,
4330           m = Math.sqrt(a * a + b * b + c * c),
4331           φ2 = Math.asin(c /= m),
4332           λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a),
4333           p = project(λ2, φ2),
4334           x2 = p[0],
4335           y2 = p[1],
4336           dx2 = x2 - x0,
4337           dy2 = y2 - y0,
4338           dz = dy * dx2 - dx * dy2;
4339       if (dz * dz / d2 > δ2 // perpendicular projected distance
4340           || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 // midpoint close to an end
4341           || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance
4342         resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream);
4343         stream.point(x2, y2);
4344         resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream);
4345       }
4346     }
4347   }
4348
4349   resample.precision = function(_) {
4350     if (!arguments.length) return Math.sqrt(δ2);
4351     maxDepth = (δ2 = _ * _) > 0 && 16;
4352     return resample;
4353   };
4354
4355   return resample;
4356 }
4357
4358 d3.geo.path = function() {
4359   var pointRadius = 4.5,
4360       projection,
4361       context,
4362       projectStream,
4363       contextStream,
4364       cacheStream;
4365
4366   function path(object) {
4367     if (object) {
4368       if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
4369       if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
4370       d3.geo.stream(object, cacheStream);
4371     }
4372     return contextStream.result();
4373   }
4374
4375   path.area = function(object) {
4376     d3_geo_pathAreaSum = 0;
4377     d3.geo.stream(object, projectStream(d3_geo_pathArea));
4378     return d3_geo_pathAreaSum;
4379   };
4380
4381   path.centroid = function(object) {
4382     d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 =
4383     d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 =
4384     d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
4385     d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4386     return d3_geo_centroidZ2 ? [d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2]
4387         : d3_geo_centroidZ1 ? [d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1]
4388         : d3_geo_centroidZ0 ? [d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0]
4389         : [NaN, NaN];
4390   };
4391
4392   path.bounds = function(object) {
4393     d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
4394     d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4395     return [[d3_geo_pathBoundsX0, d3_geo_pathBoundsY0], [d3_geo_pathBoundsX1, d3_geo_pathBoundsY1]];
4396   };
4397
4398   path.projection = function(_) {
4399     if (!arguments.length) return projection;
4400     projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
4401     return reset();
4402   };
4403
4404   path.context = function(_) {
4405     if (!arguments.length) return context;
4406     contextStream = (context = _) == null ? new d3_geo_pathBuffer : new d3_geo_pathContext(_);
4407     if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
4408     return reset();
4409   };
4410
4411   path.pointRadius = function(_) {
4412     if (!arguments.length) return pointRadius;
4413     pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
4414     return path;
4415   };
4416
4417   function reset() {
4418     cacheStream = null;
4419     return path;
4420   }
4421
4422   return path.projection(d3.geo.albersUsa()).context(null);
4423 };
4424
4425 function d3_geo_pathProjectStream(project) {
4426   var resample = d3_geo_resample(function(x, y) { return project([x * d3_degrees, y * d3_degrees]); });
4427   return function(stream) { return d3_geo_projectionRadians(resample(stream)); };
4428 }
4429
4430 d3.geo.transform = function(methods) {
4431   return {
4432     stream: function(stream) {
4433       var transform = new d3_geo_transform(stream);
4434       for (var k in methods) transform[k] = methods[k];
4435       return transform;
4436     }
4437   };
4438 };
4439
4440 function d3_geo_transform(stream) {
4441   this.stream = stream;
4442 }
4443
4444 d3_geo_transform.prototype = {
4445   point: function(x, y) { this.stream.point(x, y); },
4446   sphere: function() { this.stream.sphere(); },
4447   lineStart: function() { this.stream.lineStart(); },
4448   lineEnd: function() { this.stream.lineEnd(); },
4449   polygonStart: function() { this.stream.polygonStart(); },
4450   polygonEnd: function() { this.stream.polygonEnd(); }
4451 };
4452
4453 function d3_geo_transformPoint(stream, point) {
4454   return {
4455     point: point,
4456     sphere: function() { stream.sphere(); },
4457     lineStart: function() { stream.lineStart(); },
4458     lineEnd: function() { stream.lineEnd(); },
4459     polygonStart: function() { stream.polygonStart(); },
4460     polygonEnd: function() { stream.polygonEnd(); },
4461   };
4462 }
4463
4464 d3.geo.projection = d3_geo_projection;
4465 d3.geo.projectionMutator = d3_geo_projectionMutator;
4466
4467 function d3_geo_projection(project) {
4468   return d3_geo_projectionMutator(function() { return project; })();
4469 }
4470
4471 function d3_geo_projectionMutator(projectAt) {
4472   var project,
4473       rotate,
4474       projectRotate,
4475       projectResample = d3_geo_resample(function(x, y) { x = project(x, y); return [x[0] * k + δx, δy - x[1] * k]; }),
4476       k = 150, // scale
4477       x = 480, y = 250, // translate
4478       λ = 0, φ = 0, // center
4479       δλ = 0, δφ = 0, δγ = 0, // rotate
4480       δx, δy, // center
4481       preclip = d3_geo_clipAntimeridian,
4482       postclip = d3_identity,
4483       clipAngle = null,
4484       clipExtent = null,
4485       stream;
4486
4487   function projection(point) {
4488     point = projectRotate(point[0] * d3_radians, point[1] * d3_radians);
4489     return [point[0] * k + δx, δy - point[1] * k];
4490   }
4491
4492   function invert(point) {
4493     point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k);
4494     return point && [point[0] * d3_degrees, point[1] * d3_degrees];
4495   }
4496
4497   projection.stream = function(output) {
4498     if (stream) stream.valid = false;
4499     stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output))));
4500     stream.valid = true; // allow caching by d3.geo.path
4501     return stream;
4502   };
4503
4504   projection.clipAngle = function(_) {
4505     if (!arguments.length) return clipAngle;
4506     preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians);
4507     return invalidate();
4508   };
4509
4510   projection.clipExtent = function(_) {
4511     if (!arguments.length) return clipExtent;
4512     clipExtent = _;
4513     postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity;
4514     return invalidate();
4515   };
4516
4517   projection.scale = function(_) {
4518     if (!arguments.length) return k;
4519     k = +_;
4520     return reset();
4521   };
4522
4523   projection.translate = function(_) {
4524     if (!arguments.length) return [x, y];
4525     x = +_[0];
4526     y = +_[1];
4527     return reset();
4528   };
4529
4530   projection.center = function(_) {
4531     if (!arguments.length) return [λ * d3_degrees, φ * d3_degrees];
4532     λ = _[0] % 360 * d3_radians;
4533     φ = _[1] % 360 * d3_radians;
4534     return reset();
4535   };
4536
4537   projection.rotate = function(_) {
4538     if (!arguments.length) return [δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees];
4539     δλ = _[0] % 360 * d3_radians;
4540     δφ = _[1] % 360 * d3_radians;
4541     δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0;
4542     return reset();
4543   };
4544
4545   d3.rebind(projection, projectResample, "precision");
4546
4547   function reset() {
4548     projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project);
4549     var center = project(λ, φ);
4550     δx = x - center[0] * k;
4551     δy = y + center[1] * k;
4552     return invalidate();
4553   }
4554
4555   function invalidate() {
4556     if (stream) stream.valid = false, stream = null;
4557     return projection;
4558   }
4559
4560   return function() {
4561     project = projectAt.apply(this, arguments);
4562     projection.invert = project.invert && invert;
4563     return reset();
4564   };
4565 }
4566
4567 function d3_geo_projectionRadians(stream) {
4568   return d3_geo_transformPoint(stream, function(x, y) {
4569     stream.point(x * d3_radians, y * d3_radians);
4570   });
4571 }
4572
4573 function d3_geo_mercator(λ, φ) {
4574   return [λ, Math.log(Math.tan(π / 4 + φ / 2))];
4575 }
4576
4577 d3_geo_mercator.invert = function(x, y) {
4578   return [x, 2 * Math.atan(Math.exp(y)) - halfπ];
4579 };
4580
4581 function d3_geo_mercatorProjection(project) {
4582   var m = d3_geo_projection(project),
4583       scale = m.scale,
4584       translate = m.translate,
4585       clipExtent = m.clipExtent,
4586       clipAuto;
4587
4588   m.scale = function() {
4589     var v = scale.apply(m, arguments);
4590     return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
4591   };
4592
4593   m.translate = function() {
4594     var v = translate.apply(m, arguments);
4595     return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
4596   };
4597
4598   m.clipExtent = function(_) {
4599     var v = clipExtent.apply(m, arguments);
4600     if (v === m) {
4601       if (clipAuto = _ == null) {
4602         var k = π * scale(), t = translate();
4603         clipExtent([[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]]);
4604       }
4605     } else if (clipAuto) {
4606       v = null;
4607     }
4608     return v;
4609   };
4610
4611   return m.clipExtent(null);
4612 }
4613
4614 (d3.geo.mercator = function() {
4615   return d3_geo_mercatorProjection(d3_geo_mercator);
4616 }).raw = d3_geo_mercator;
4617 d3.geom = {};
4618
4619 d3.geom.polygon = function(coordinates) {
4620   d3_subclass(coordinates, d3_geom_polygonPrototype);
4621   return coordinates;
4622 };
4623
4624 var d3_geom_polygonPrototype = d3.geom.polygon.prototype = [];
4625
4626 d3_geom_polygonPrototype.area = function() {
4627   var i = -1,
4628       n = this.length,
4629       a,
4630       b = this[n - 1],
4631       area = 0;
4632
4633   while (++i < n) {
4634     a = b;
4635     b = this[i];
4636     area += a[1] * b[0] - a[0] * b[1];
4637   }
4638
4639   return area * .5;
4640 };
4641
4642 d3_geom_polygonPrototype.centroid = function(k) {
4643   var i = -1,
4644       n = this.length,
4645       x = 0,
4646       y = 0,
4647       a,
4648       b = this[n - 1],
4649       c;
4650
4651   if (!arguments.length) k = -1 / (6 * this.area());
4652
4653   while (++i < n) {
4654     a = b;
4655     b = this[i];
4656     c = a[0] * b[1] - b[0] * a[1];
4657     x += (a[0] + b[0]) * c;
4658     y += (a[1] + b[1]) * c;
4659   }
4660
4661   return [x * k, y * k];
4662 };
4663
4664 // The Sutherland-Hodgman clipping algorithm.
4665 // Note: requires the clip polygon to be counterclockwise and convex.
4666 d3_geom_polygonPrototype.clip = function(subject) {
4667   var input,
4668       closed = d3_geom_polygonClosed(subject),
4669       i = -1,
4670       n = this.length - d3_geom_polygonClosed(this),
4671       j,
4672       m,
4673       a = this[n - 1],
4674       b,
4675       c,
4676       d;
4677
4678   while (++i < n) {
4679     input = subject.slice();
4680     subject.length = 0;
4681     b = this[i];
4682     c = input[(m = input.length - closed) - 1];
4683     j = -1;
4684     while (++j < m) {
4685       d = input[j];
4686       if (d3_geom_polygonInside(d, a, b)) {
4687         if (!d3_geom_polygonInside(c, a, b)) {
4688           subject.push(d3_geom_polygonIntersect(c, d, a, b));
4689         }
4690         subject.push(d);
4691       } else if (d3_geom_polygonInside(c, a, b)) {
4692         subject.push(d3_geom_polygonIntersect(c, d, a, b));
4693       }
4694       c = d;
4695     }
4696     if (closed) subject.push(subject[0]);
4697     a = b;
4698   }
4699
4700   return subject;
4701 };
4702
4703 function d3_geom_polygonInside(p, a, b) {
4704   return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]);
4705 }
4706
4707 // Intersect two infinite lines cd and ab.
4708 function d3_geom_polygonIntersect(c, d, a, b) {
4709   var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3,
4710       y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3,
4711       ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
4712   return [x1 + ua * x21, y1 + ua * y21];
4713 }
4714
4715 // Returns true if the polygon is closed.
4716 function d3_geom_polygonClosed(coordinates) {
4717   var a = coordinates[0],
4718       b = coordinates[coordinates.length - 1];
4719   return !(a[0] - b[0] || a[1] - b[1]);
4720 }
4721 function d3_geom_pointX(d) {
4722   return d[0];
4723 }
4724
4725 function d3_geom_pointY(d) {
4726   return d[1];
4727 }
4728
4729 /**
4730  * Computes the 2D convex hull of a set of points using the monotone chain
4731  * algorithm:
4732  * http://en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Convex_hull/Monotone_chain)
4733  *
4734  * The runtime of this algorithm is O(n log n), where n is the number of input
4735  * points. However in practice it outperforms other O(n log n) hulls.
4736  *
4737  * @param vertices [[x1, y1], [x2, y2], ...]
4738  * @returns polygon [[x1, y1], [x2, y2], ...]
4739  */
4740 d3.geom.hull = function(vertices) {
4741   var x = d3_geom_pointX,
4742       y = d3_geom_pointY;
4743
4744   if (arguments.length) return hull(vertices);
4745
4746   function hull(data) {
4747     // Hull of < 3 points is not well-defined
4748     if (data.length < 3) return [];
4749
4750     var fx = d3_functor(x),
4751         fy = d3_functor(y),
4752         i,
4753         n = data.length,
4754         points = [], // of the form [[x0, y0, 0], ..., [xn, yn, n]]
4755         flippedPoints = [];
4756
4757     for (i = 0 ; i < n; i++) {
4758       points.push([+fx.call(this, data[i], i), +fy.call(this, data[i], i), i]);
4759     }
4760
4761     // sort ascending by x-coord first, y-coord second
4762     points.sort(d3_geom_hullOrder);
4763
4764     // we flip bottommost points across y axis so we can use the upper hull routine on both
4765     for (i = 0; i < n; i++) flippedPoints.push([points[i][0], -points[i][1]]);
4766
4767     var upper = d3_geom_hullUpper(points),
4768         lower = d3_geom_hullUpper(flippedPoints);
4769
4770     // construct the polygon, removing possible duplicate endpoints
4771     var skipLeft = lower[0] === upper[0],
4772         skipRight  = lower[lower.length - 1] === upper[upper.length - 1],
4773         polygon = [];
4774
4775     // add upper hull in r->l order
4776     // then add lower hull in l->r order
4777     for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]);
4778     for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]);
4779
4780     return polygon;
4781   }
4782
4783   hull.x = function(_) {
4784     return arguments.length ? (x = _, hull) : x;
4785   };
4786
4787   hull.y = function(_) {
4788     return arguments.length ? (y = _, hull) : y;
4789   };
4790
4791   return hull;
4792 };
4793
4794 // finds the 'upper convex hull' (see wiki link above)
4795 // assumes points arg has >=3 elements, is sorted by x, unique in y
4796 // returns array of indices into points in left to right order
4797 function d3_geom_hullUpper(points) {
4798   var n = points.length,
4799       hull = [0, 1],
4800       hs = 2; // hull size
4801
4802   for (var i = 2; i < n; i++) {
4803     while (hs > 1 && d3_cross2d(points[hull[hs-2]], points[hull[hs-1]], points[i]) <= 0) --hs;
4804     hull[hs++] = i;
4805   }
4806
4807   // we slice to make sure that the points we 'popped' from hull don't stay behind
4808   return hull.slice(0, hs);
4809 }
4810
4811 // comparator for ascending sort by x-coord first, y-coord second
4812 function d3_geom_hullOrder(a, b) {
4813   return a[0] - b[0] || a[1] - b[1];
4814 }