47393cad242d022a1cef40465fc176f39888e906
[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"});
2000     center0 = null;
2001   }
2002
2003   function mousedowned() {
2004     var that = this,
2005         target = d3.event.target,
2006         dispatch = event.of(that, arguments),
2007         dragged = 0,
2008         subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended),
2009         location0 = location(d3.mouse(that)),
2010         dragRestore = d3_event_dragSuppress(that);
2011
2012     d3_selection_interrupt.call(that);
2013     zoomstarted(dispatch);
2014
2015     function moved() {
2016       dragged = 1;
2017       translateTo(d3.mouse(that), location0);
2018       zoomed(dispatch);
2019     }
2020
2021     function ended() {
2022       subject.on(mousemove, null).on(mouseup, null);
2023       dragRestore(dragged && d3.event.target === target);
2024       zoomended(dispatch);
2025     }
2026   }
2027
2028   // These closures persist for as long as at least one touch is active.
2029   function touchstarted() {
2030     var that = this,
2031         dispatch = event.of(that, arguments),
2032         locations0 = {}, // touchstart locations
2033         distance0 = 0, // distance² between initial touches
2034         scale0, // scale when we started touching
2035         zoomName = ".zoom-" + d3.event.changedTouches[0].identifier,
2036         touchmove = "touchmove" + zoomName,
2037         touchend = "touchend" + zoomName,
2038         targets = [],
2039         subject = d3.select(that),
2040         dragRestore = d3_event_dragSuppress(that);
2041
2042     started();
2043     zoomstarted(dispatch);
2044
2045     // Workaround for Chrome issue 412723: the touchstart listener must be set
2046     // after the touchmove listener.
2047     subject.on(mousedown, null).on(touchstart, started); // prevent duplicate events
2048
2049     // Updates locations of any touches in locations0.
2050     function relocate() {
2051       var touches = d3.touches(that);
2052       scale0 = view.k;
2053       touches.forEach(function(t) {
2054         if (t.identifier in locations0) locations0[t.identifier] = location(t);
2055       });
2056       return touches;
2057     }
2058
2059     // Temporarily override touchstart while gesture is active.
2060     function started() {
2061
2062       // Listen for touchmove and touchend on the target of touchstart.
2063       var target = d3.event.target;
2064       d3.select(target).on(touchmove, moved).on(touchend, ended);
2065       targets.push(target);
2066
2067       // Only track touches started on the same subject element.
2068       var changed = d3.event.changedTouches;
2069       for (var i = 0, n = changed.length; i < n; ++i) {
2070         locations0[changed[i].identifier] = null;
2071       }
2072
2073       var touches = relocate(),
2074           now = Date.now();
2075
2076       if (touches.length === 1) {
2077         if (now - touchtime < 500) { // dbltap
2078           var p = touches[0];
2079           zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1);
2080           d3_eventPreventDefault();
2081         }
2082         touchtime = now;
2083       } else if (touches.length > 1) {
2084         var p = touches[0], q = touches[1],
2085             dx = p[0] - q[0], dy = p[1] - q[1];
2086         distance0 = dx * dx + dy * dy;
2087       }
2088     }
2089
2090     function moved() {
2091       var touches = d3.touches(that),
2092           p0, l0,
2093           p1, l1;
2094
2095       d3_selection_interrupt.call(that);
2096
2097       for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {
2098         p1 = touches[i];
2099         if (l1 = locations0[p1.identifier]) {
2100           if (l0) break;
2101           p0 = p1, l0 = l1;
2102         }
2103       }
2104
2105       if (l1) {
2106         var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1,
2107             scale1 = distance0 && Math.sqrt(distance1 / distance0);
2108         p0 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
2109         l0 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];
2110         scaleTo(scale1 * scale0);
2111       }
2112
2113       touchtime = null;
2114       translateTo(p0, l0);
2115       zoomed(dispatch);
2116     }
2117
2118     function ended() {
2119       // If there are any globally-active touches remaining, remove the ended
2120       // touches from locations0.
2121       if (d3.event.touches.length) {
2122         var changed = d3.event.changedTouches;
2123         for (var i = 0, n = changed.length; i < n; ++i) {
2124           delete locations0[changed[i].identifier];
2125         }
2126         // If locations0 is not empty, then relocate and continue listening for
2127         // touchmove and touchend.
2128         for (var identifier in locations0) {
2129           return void relocate(); // locations may have detached due to rotation
2130         }
2131       }
2132       // Otherwise, remove touchmove and touchend listeners.
2133       d3.selectAll(targets).on(zoomName, null);
2134       subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
2135       dragRestore();
2136       zoomended(dispatch);
2137     }
2138   }
2139
2140   function mousewheeled() {
2141     var dispatch = event.of(this, arguments);
2142     if (mousewheelTimer) clearTimeout(mousewheelTimer);
2143     else translate0 = location(center0 = center || d3.mouse(this)), d3_selection_interrupt.call(this), zoomstarted(dispatch);
2144     mousewheelTimer = setTimeout(function() { mousewheelTimer = null; zoomended(dispatch); }, 50);
2145     d3_eventPreventDefault();
2146     scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);
2147     translateTo(center0, translate0);
2148     zoomed(dispatch);
2149   }
2150
2151   function dblclicked() {
2152     var p = d3.mouse(this),
2153         k = Math.log(view.k) / Math.LN2;
2154
2155     zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1);
2156   }
2157
2158   return d3.rebind(zoom, event, "on");
2159 };
2160
2161 var d3_behavior_zoomInfinity = [0, Infinity], // default scale extent
2162     d3_behavior_zoomDelta, // initialized lazily
2163     d3_behavior_zoomWheel;
2164 function d3_functor(v) {
2165   return typeof v === "function" ? v : function() { return v; };
2166 }
2167
2168 d3.functor = d3_functor;
2169
2170 d3.touch = function(container, touches, identifier) {
2171   if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
2172   if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) {
2173     if ((touch = touches[i]).identifier === identifier) {
2174       return d3_mousePoint(container, touch);
2175     }
2176   }
2177 };
2178
2179 var d3_timer_queueHead,
2180     d3_timer_queueTail,
2181     d3_timer_interval, // is an interval (or frame) active?
2182     d3_timer_timeout, // is a timeout active?
2183     d3_timer_active, // active timer object
2184     d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) { setTimeout(callback, 17); };
2185
2186 // The timer will continue to fire until callback returns true.
2187 d3.timer = function(callback, delay, then) {
2188   var n = arguments.length;
2189   if (n < 2) delay = 0;
2190   if (n < 3) then = Date.now();
2191
2192   // Add the callback to the tail of the queue.
2193   var time = then + delay, timer = {c: callback, t: time, f: false, n: null};
2194   if (d3_timer_queueTail) d3_timer_queueTail.n = timer;
2195   else d3_timer_queueHead = timer;
2196   d3_timer_queueTail = timer;
2197
2198   // Start animatin'!
2199   if (!d3_timer_interval) {
2200     d3_timer_timeout = clearTimeout(d3_timer_timeout);
2201     d3_timer_interval = 1;
2202     d3_timer_frame(d3_timer_step);
2203   }
2204 };
2205
2206 function d3_timer_step() {
2207   var now = d3_timer_mark(),
2208       delay = d3_timer_sweep() - now;
2209   if (delay > 24) {
2210     if (isFinite(delay)) {
2211       clearTimeout(d3_timer_timeout);
2212       d3_timer_timeout = setTimeout(d3_timer_step, delay);
2213     }
2214     d3_timer_interval = 0;
2215   } else {
2216     d3_timer_interval = 1;
2217     d3_timer_frame(d3_timer_step);
2218   }
2219 }
2220
2221 d3.timer.flush = function() {
2222   d3_timer_mark();
2223   d3_timer_sweep();
2224 };
2225
2226 function d3_timer_mark() {
2227   var now = Date.now();
2228   d3_timer_active = d3_timer_queueHead;
2229   while (d3_timer_active) {
2230     if (now >= d3_timer_active.t) d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t);
2231     d3_timer_active = d3_timer_active.n;
2232   }
2233   return now;
2234 }
2235
2236 // Flush after callbacks to avoid concurrent queue modification.
2237 // Returns the time of the earliest active timer, post-sweep.
2238 function d3_timer_sweep() {
2239   var t0,
2240       t1 = d3_timer_queueHead,
2241       time = Infinity;
2242   while (t1) {
2243     if (t1.f) {
2244       t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
2245     } else {
2246       if (t1.t < time) time = t1.t;
2247       t1 = (t0 = t1).n;
2248     }
2249   }
2250   d3_timer_queueTail = t0;
2251   return time;
2252 }
2253 d3.geo = {};
2254 function d3_identity(d) {
2255   return d;
2256 }
2257 function d3_true() {
2258   return true;
2259 }
2260
2261 function d3_geo_spherical(cartesian) {
2262   return [
2263     Math.atan2(cartesian[1], cartesian[0]),
2264     d3_asin(cartesian[2])
2265   ];
2266 }
2267
2268 function d3_geo_sphericalEqual(a, b) {
2269   return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε;
2270 }
2271
2272 // General spherical polygon clipping algorithm: takes a polygon, cuts it into
2273 // visible line segments and rejoins the segments by interpolating along the
2274 // clip edge.
2275 function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
2276   var subject = [],
2277       clip = [];
2278
2279   segments.forEach(function(segment) {
2280     if ((n = segment.length - 1) <= 0) return;
2281     var n, p0 = segment[0], p1 = segment[n];
2282
2283     // If the first and last points of a segment are coincident, then treat as
2284     // a closed ring.
2285     // TODO if all rings are closed, then the winding order of the exterior
2286     // ring should be checked.
2287     if (d3_geo_sphericalEqual(p0, p1)) {
2288       listener.lineStart();
2289       for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
2290       listener.lineEnd();
2291       return;
2292     }
2293
2294     var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true),
2295         b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
2296     a.o = b;
2297     subject.push(a);
2298     clip.push(b);
2299     a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
2300     b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
2301     a.o = b;
2302     subject.push(a);
2303     clip.push(b);
2304   });
2305   clip.sort(compare);
2306   d3_geo_clipPolygonLinkCircular(subject);
2307   d3_geo_clipPolygonLinkCircular(clip);
2308   if (!subject.length) return;
2309
2310   for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
2311     clip[i].e = entry = !entry;
2312   }
2313
2314   var start = subject[0],
2315       points,
2316       point;
2317   while (1) {
2318     // Find first unvisited intersection.
2319     var current = start,
2320         isSubject = true;
2321     while (current.v) if ((current = current.n) === start) return;
2322     points = current.z;
2323     listener.lineStart();
2324     do {
2325       current.v = current.o.v = true;
2326       if (current.e) {
2327         if (isSubject) {
2328           for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
2329         } else {
2330           interpolate(current.x, current.n.x, 1, listener);
2331         }
2332         current = current.n;
2333       } else {
2334         if (isSubject) {
2335           points = current.p.z;
2336           for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
2337         } else {
2338           interpolate(current.x, current.p.x, -1, listener);
2339         }
2340         current = current.p;
2341       }
2342       current = current.o;
2343       points = current.z;
2344       isSubject = !isSubject;
2345     } while (!current.v);
2346     listener.lineEnd();
2347   }
2348 }
2349
2350 function d3_geo_clipPolygonLinkCircular(array) {
2351   if (!(n = array.length)) return;
2352   var n,
2353       i = 0,
2354       a = array[0],
2355       b;
2356   while (++i < n) {
2357     a.n = b = array[i];
2358     b.p = a;
2359     a = b;
2360   }
2361   a.n = b = array[0];
2362   b.p = a;
2363 }
2364
2365 function d3_geo_clipPolygonIntersection(point, points, other, entry) {
2366   this.x = point;
2367   this.z = points;
2368   this.o = other; // another intersection
2369   this.e = entry; // is an entry?
2370   this.v = false; // visited
2371   this.n = this.p = null; // next & previous
2372 }
2373
2374 function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
2375   return function(rotate, listener) {
2376     var line = clipLine(listener),
2377         rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
2378
2379     var clip = {
2380       point: point,
2381       lineStart: lineStart,
2382       lineEnd: lineEnd,
2383       polygonStart: function() {
2384         clip.point = pointRing;
2385         clip.lineStart = ringStart;
2386         clip.lineEnd = ringEnd;
2387         segments = [];
2388         polygon = [];
2389       },
2390       polygonEnd: function() {
2391         clip.point = point;
2392         clip.lineStart = lineStart;
2393         clip.lineEnd = lineEnd;
2394
2395         segments = d3.merge(segments);
2396         var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
2397         if (segments.length) {
2398           if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
2399           d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
2400         } else if (clipStartInside) {
2401           if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
2402           listener.lineStart();
2403           interpolate(null, null, 1, listener);
2404           listener.lineEnd();
2405         }
2406         if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
2407         segments = polygon = null;
2408       },
2409       sphere: function() {
2410         listener.polygonStart();
2411         listener.lineStart();
2412         interpolate(null, null, 1, listener);
2413         listener.lineEnd();
2414         listener.polygonEnd();
2415       }
2416     };
2417
2418     function point(λ, φ) {
2419       var point = rotate(λ, φ);
2420       if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
2421     }
2422     function pointLine(λ, φ) {
2423       var point = rotate(λ, φ);
2424       line.point(point[0], point[1]);
2425     }
2426     function lineStart() { clip.point = pointLine; line.lineStart(); }
2427     function lineEnd() { clip.point = point; line.lineEnd(); }
2428
2429     var segments;
2430
2431     var buffer = d3_geo_clipBufferListener(),
2432         ringListener = clipLine(buffer),
2433         polygonStarted = false,
2434         polygon,
2435         ring;
2436
2437     function pointRing(λ, φ) {
2438       ring.push([λ, φ]);
2439       var point = rotate(λ, φ);
2440       ringListener.point(point[0], point[1]);
2441     }
2442
2443     function ringStart() {
2444       ringListener.lineStart();
2445       ring = [];
2446     }
2447
2448     function ringEnd() {
2449       pointRing(ring[0][0], ring[0][1]);
2450       ringListener.lineEnd();
2451
2452       var clean = ringListener.clean(),
2453           ringSegments = buffer.buffer(),
2454           segment,
2455           n = ringSegments.length;
2456
2457       ring.pop();
2458       polygon.push(ring);
2459       ring = null;
2460
2461       if (!n) return;
2462
2463       // No intersections.
2464       if (clean & 1) {
2465         segment = ringSegments[0];
2466         var n = segment.length - 1,
2467             i = -1,
2468             point;
2469         if (n > 0) {
2470           if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
2471           listener.lineStart();
2472           while (++i < n) listener.point((point = segment[i])[0], point[1]);
2473           listener.lineEnd();
2474         }
2475         return;
2476       }
2477
2478       // Rejoin connected segments.
2479       // TODO reuse bufferListener.rejoin()?
2480       if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
2481
2482       segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
2483     }
2484
2485     return clip;
2486   };
2487 }
2488
2489 function d3_geo_clipSegmentLength1(segment) {
2490   return segment.length > 1;
2491 }
2492
2493 function d3_geo_clipBufferListener() {
2494   var lines = [],
2495       line;
2496   return {
2497     lineStart: function() { lines.push(line = []); },
2498     point: function(λ, φ) { line.push([λ, φ]); },
2499     lineEnd: d3_noop,
2500     buffer: function() {
2501       var buffer = lines;
2502       lines = [];
2503       line = null;
2504       return buffer;
2505     },
2506     rejoin: function() {
2507       if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
2508     }
2509   };
2510 }
2511
2512 // Intersection points are sorted along the clip edge. For both antimeridian
2513 // cutting and circle clipping, the same comparison is used.
2514 function d3_geo_clipSort(a, b) {
2515   return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1])
2516        - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]);
2517 }
2518
2519 var d3_geo_clipAntimeridian = d3_geo_clip(
2520     d3_true,
2521     d3_geo_clipAntimeridianLine,
2522     d3_geo_clipAntimeridianInterpolate,
2523     [-π, -π / 2]);
2524
2525 // Takes a line and cuts into visible segments. Return values:
2526 //   0: there were intersections or the line was empty.
2527 //   1: no intersections.
2528 //   2: there were intersections, and the first and last segments should be
2529 //      rejoined.
2530 function d3_geo_clipAntimeridianLine(listener) {
2531   var λ0 = NaN,
2532       φ0 = NaN,
2533       sλ0 = NaN,
2534       clean; // no intersections
2535
2536   return {
2537     lineStart: function() {
2538       listener.lineStart();
2539       clean = 1;
2540     },
2541     point: function(λ1, φ1) {
2542       var sλ1 = λ1 > 0 ? π : -π,
2543           dλ = abs(λ1 - λ0);
2544       if (abs(dλ - π) < ε) { // line crosses a pole
2545         listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ);
2546         listener.point(sλ0, φ0);
2547         listener.lineEnd();
2548         listener.lineStart();
2549         listener.point(sλ1, φ0);
2550         listener.point(λ1, φ0);
2551         clean = 0;
2552       } else if (sλ0 !== sλ1 && dλ >= π) { // line crosses antimeridian
2553         // handle degeneracies
2554         if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
2555         if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
2556         φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
2557         listener.point(sλ0, φ0);
2558         listener.lineEnd();
2559         listener.lineStart();
2560         listener.point(sλ1, φ0);
2561         clean = 0;
2562       }
2563       listener.point(λ0 = λ1, φ0 = φ1);
2564       sλ0 = sλ1;
2565     },
2566     lineEnd: function() {
2567       listener.lineEnd();
2568       λ0 = φ0 = NaN;
2569     },
2570     // if there are intersections, we always rejoin the first and last segments.
2571     clean: function() { return 2 - clean; }
2572   };
2573 }
2574
2575 function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
2576   var cosφ0,
2577       cosφ1,
2578       sinλ0_λ1 = Math.sin(λ0 - λ1);
2579   return abs(sinλ0_λ1) > ε
2580       ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1)
2581                  - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0))
2582                  / (cosφ0 * cosφ1 * sinλ0_λ1))
2583       : (φ0 + φ1) / 2;
2584 }
2585
2586 function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
2587   var φ;
2588   if (from == null) {
2589     φ = direction * halfπ;
2590     listener.point(-π,  φ);
2591     listener.point( 0,  φ);
2592     listener.point( π,  φ);
2593     listener.point( π,  0);
2594     listener.point( π, -φ);
2595     listener.point( 0, -φ);
2596     listener.point(-π, -φ);
2597     listener.point(-π,  0);
2598     listener.point(-π,  φ);
2599   } else if (abs(from[0] - to[0]) > ε) {
2600     var s = from[0] < to[0] ? π : -π;
2601     φ = direction * s / 2;
2602     listener.point(-s, φ);
2603     listener.point( 0, φ);
2604     listener.point( s, φ);
2605   } else {
2606     listener.point(to[0], to[1]);
2607   }
2608 }
2609 // TODO
2610 // cross and scale return new vectors,
2611 // whereas add and normalize operate in-place
2612
2613 function d3_geo_cartesian(spherical) {
2614   var λ = spherical[0],
2615       φ = spherical[1],
2616       cosφ = Math.cos(φ);
2617   return [
2618     cosφ * Math.cos(λ),
2619     cosφ * Math.sin(λ),
2620     Math.sin(φ)
2621   ];
2622 }
2623
2624 function d3_geo_cartesianDot(a, b) {
2625   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2626 }
2627
2628 function d3_geo_cartesianCross(a, b) {
2629   return [
2630     a[1] * b[2] - a[2] * b[1],
2631     a[2] * b[0] - a[0] * b[2],
2632     a[0] * b[1] - a[1] * b[0]
2633   ];
2634 }
2635
2636 function d3_geo_cartesianAdd(a, b) {
2637   a[0] += b[0];
2638   a[1] += b[1];
2639   a[2] += b[2];
2640 }
2641
2642 function d3_geo_cartesianScale(vector, k) {
2643   return [
2644     vector[0] * k,
2645     vector[1] * k,
2646     vector[2] * k
2647   ];
2648 }
2649
2650 function d3_geo_cartesianNormalize(d) {
2651   var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
2652   d[0] /= l;
2653   d[1] /= l;
2654   d[2] /= l;
2655 }
2656 function d3_geo_compose(a, b) {
2657
2658   function compose(x, y) {
2659     return x = a(x, y), b(x[0], x[1]);
2660   }
2661
2662   if (a.invert && b.invert) compose.invert = function(x, y) {
2663     return x = b.invert(x, y), x && a.invert(x[0], x[1]);
2664   };
2665
2666   return compose;
2667 }
2668
2669 function d3_geo_equirectangular(λ, φ) {
2670   return [λ, φ];
2671 }
2672
2673 (d3.geo.equirectangular = function() {
2674   return d3_geo_projection(d3_geo_equirectangular);
2675 }).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;
2676
2677 d3.geo.rotation = function(rotate) {
2678   rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0);
2679
2680   function forward(coordinates) {
2681     coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
2682     return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
2683   }
2684
2685   forward.invert = function(coordinates) {
2686     coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
2687     return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
2688   };
2689
2690   return forward;
2691 };
2692
2693 function d3_geo_identityRotation(λ, φ) {
2694   return [λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ];
2695 }
2696
2697 d3_geo_identityRotation.invert = d3_geo_equirectangular;
2698
2699 // Note: |δλ| must be < 2π
2700 function d3_geo_rotation(δλ, δφ, δγ) {
2701   return δλ ? (δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ))
2702     : d3_geo_rotationλ(δλ))
2703     : (δφ || δγ ? d3_geo_rotationφγ(δφ, δγ)
2704     : d3_geo_identityRotation);
2705 }
2706
2707 function d3_geo_forwardRotationλ(δλ) {
2708   return function(λ, φ) {
2709     return λ += δλ, [λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ];
2710   };
2711 }
2712
2713 function d3_geo_rotationλ(δλ) {
2714   var rotation = d3_geo_forwardRotationλ(δλ);
2715   rotation.invert = d3_geo_forwardRotationλ(-δλ);
2716   return rotation;
2717 }
2718
2719 function d3_geo_rotationφγ(δφ, δγ) {
2720   var cosδφ = Math.cos(δφ),
2721       sinδφ = Math.sin(δφ),
2722       cosδγ = Math.cos(δγ),
2723       sinδγ = Math.sin(δγ);
2724
2725   function rotation(λ, φ) {
2726     var cosφ = Math.cos(φ),
2727         x = Math.cos(λ) * cosφ,
2728         y = Math.sin(λ) * cosφ,
2729         z = Math.sin(φ),
2730         k = z * cosδφ + x * sinδφ;
2731     return [
2732       Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ),
2733       d3_asin(k * cosδγ + y * sinδγ)
2734     ];
2735   }
2736
2737   rotation.invert = function(λ, φ) {
2738     var cosφ = Math.cos(φ),
2739         x = Math.cos(λ) * cosφ,
2740         y = Math.sin(λ) * cosφ,
2741         z = Math.sin(φ),
2742         k = z * cosδγ - y * sinδγ;
2743     return [
2744       Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ),
2745       d3_asin(k * cosδφ - x * sinδφ)
2746     ];
2747   };
2748
2749   return rotation;
2750 }
2751
2752 d3.geo.circle = function() {
2753   var origin = [0, 0],
2754       angle,
2755       precision = 6,
2756       interpolate;
2757
2758   function circle() {
2759     var center = typeof origin === "function" ? origin.apply(this, arguments) : origin,
2760         rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert,
2761         ring = [];
2762
2763     interpolate(null, null, 1, {
2764       point: function(x, y) {
2765         ring.push(x = rotate(x, y));
2766         x[0] *= d3_degrees, x[1] *= d3_degrees;
2767       }
2768     });
2769
2770     return {type: "Polygon", coordinates: [ring]};
2771   }
2772
2773   circle.origin = function(x) {
2774     if (!arguments.length) return origin;
2775     origin = x;
2776     return circle;
2777   };
2778
2779   circle.angle = function(x) {
2780     if (!arguments.length) return angle;
2781     interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians);
2782     return circle;
2783   };
2784
2785   circle.precision = function(_) {
2786     if (!arguments.length) return precision;
2787     interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians);
2788     return circle;
2789   };
2790
2791   return circle.angle(90);
2792 };
2793
2794 // Interpolates along a circle centered at [0°, 0°], with a given radius and
2795 // precision.
2796 function d3_geo_circleInterpolate(radius, precision) {
2797   var cr = Math.cos(radius),
2798       sr = Math.sin(radius);
2799   return function(from, to, direction, listener) {
2800     var step = direction * precision;
2801     if (from != null) {
2802       from = d3_geo_circleAngle(cr, from);
2803       to = d3_geo_circleAngle(cr, to);
2804       if (direction > 0 ? from < to: from > to) from += direction * τ;
2805     } else {
2806       from = radius + direction * τ;
2807       to = radius - .5 * step;
2808     }
2809     for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) {
2810       listener.point((point = d3_geo_spherical([
2811         cr,
2812         -sr * Math.cos(t),
2813         -sr * Math.sin(t)
2814       ]))[0], point[1]);
2815     }
2816   };
2817 }
2818
2819 // Signed angle of a cartesian point relative to [cr, 0, 0].
2820 function d3_geo_circleAngle(cr, point) {
2821   var a = d3_geo_cartesian(point);
2822   a[0] -= cr;
2823   d3_geo_cartesianNormalize(a);
2824   var angle = d3_acos(-a[1]);
2825   return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI);
2826 }
2827 // Adds floating point numbers with twice the normal precision.
2828 // Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and
2829 // Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)
2830 // 305–363 (1997).
2831 // Code adapted from GeographicLib by Charles F. F. Karney,
2832 // http://geographiclib.sourceforge.net/
2833 // See lib/geographiclib/LICENSE for details.
2834
2835 function d3_adder() {}
2836
2837 d3_adder.prototype = {
2838   s: 0, // rounded value
2839   t: 0, // exact error
2840   add: function(y) {
2841     d3_adderSum(y, this.t, d3_adderTemp);
2842     d3_adderSum(d3_adderTemp.s, this.s, this);
2843     if (this.s) this.t += d3_adderTemp.t;
2844     else this.s = d3_adderTemp.t;
2845   },
2846   reset: function() {
2847     this.s = this.t = 0;
2848   },
2849   valueOf: function() {
2850     return this.s;
2851   }
2852 };
2853
2854 var d3_adderTemp = new d3_adder;
2855
2856 function d3_adderSum(a, b, o) {
2857   var x = o.s = a + b, // a + b
2858       bv = x - a, av = x - bv; // b_virtual & a_virtual
2859   o.t = (a - av) + (b - bv); // a_roundoff + b_roundoff
2860 }
2861
2862 d3.geo.stream = function(object, listener) {
2863   if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
2864     d3_geo_streamObjectType[object.type](object, listener);
2865   } else {
2866     d3_geo_streamGeometry(object, listener);
2867   }
2868 };
2869
2870 function d3_geo_streamGeometry(geometry, listener) {
2871   if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
2872     d3_geo_streamGeometryType[geometry.type](geometry, listener);
2873   }
2874 }
2875
2876 var d3_geo_streamObjectType = {
2877   Feature: function(feature, listener) {
2878     d3_geo_streamGeometry(feature.geometry, listener);
2879   },
2880   FeatureCollection: function(object, listener) {
2881     var features = object.features, i = -1, n = features.length;
2882     while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
2883   }
2884 };
2885
2886 var d3_geo_streamGeometryType = {
2887   Sphere: function(object, listener) {
2888     listener.sphere();
2889   },
2890   Point: function(object, listener) {
2891     object = object.coordinates;
2892     listener.point(object[0], object[1], object[2]);
2893   },
2894   MultiPoint: function(object, listener) {
2895     var coordinates = object.coordinates, i = -1, n = coordinates.length;
2896     while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]);
2897   },
2898   LineString: function(object, listener) {
2899     d3_geo_streamLine(object.coordinates, listener, 0);
2900   },
2901   MultiLineString: function(object, listener) {
2902     var coordinates = object.coordinates, i = -1, n = coordinates.length;
2903     while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
2904   },
2905   Polygon: function(object, listener) {
2906     d3_geo_streamPolygon(object.coordinates, listener);
2907   },
2908   MultiPolygon: function(object, listener) {
2909     var coordinates = object.coordinates, i = -1, n = coordinates.length;
2910     while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
2911   },
2912   GeometryCollection: function(object, listener) {
2913     var geometries = object.geometries, i = -1, n = geometries.length;
2914     while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
2915   }
2916 };
2917
2918 function d3_geo_streamLine(coordinates, listener, closed) {
2919   var i = -1, n = coordinates.length - closed, coordinate;
2920   listener.lineStart();
2921   while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]);
2922   listener.lineEnd();
2923 }
2924
2925 function d3_geo_streamPolygon(coordinates, listener) {
2926   var i = -1, n = coordinates.length;
2927   listener.polygonStart();
2928   while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
2929   listener.polygonEnd();
2930 }
2931
2932 d3.geo.area = function(object) {
2933   d3_geo_areaSum = 0;
2934   d3.geo.stream(object, d3_geo_area);
2935   return d3_geo_areaSum;
2936 };
2937
2938 var d3_geo_areaSum,
2939     d3_geo_areaRingSum = new d3_adder;
2940
2941 var d3_geo_area = {
2942   sphere: function() { d3_geo_areaSum += 4 * π; },
2943   point: d3_noop,
2944   lineStart: d3_noop,
2945   lineEnd: d3_noop,
2946
2947   // Only count area for polygon rings.
2948   polygonStart: function() {
2949     d3_geo_areaRingSum.reset();
2950     d3_geo_area.lineStart = d3_geo_areaRingStart;
2951   },
2952   polygonEnd: function() {
2953     var area = 2 * d3_geo_areaRingSum;
2954     d3_geo_areaSum += area < 0 ? 4 * π + area : area;
2955     d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
2956   }
2957 };
2958
2959 function d3_geo_areaRingStart() {
2960   var λ00, φ00, λ0, cosφ0, sinφ0; // start point and previous point
2961
2962   // For the first point, …
2963   d3_geo_area.point = function(λ, φ) {
2964     d3_geo_area.point = nextPoint;
2965     λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), sinφ0 = Math.sin(φ);
2966   };
2967
2968   // For subsequent points, …
2969   function nextPoint(λ, φ) {
2970     λ *= d3_radians;
2971     φ = φ * d3_radians / 2 + π / 4; // half the angular distance from south pole
2972
2973     // Spherical excess E for a spherical triangle with vertices: south pole,
2974     // previous point, current point.  Uses a formula derived from Cagnoli’s
2975     // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).
2976     var dλ = λ - λ0,
2977         sdλ = dλ >= 0 ? 1 : -1,
2978         adλ = sdλ * dλ,
2979         cosφ = Math.cos(φ),
2980         sinφ = Math.sin(φ),
2981         k = sinφ0 * sinφ,
2982         u = cosφ0 * cosφ + k * Math.cos(adλ),
2983         v = k * sdλ * Math.sin(adλ);
2984     d3_geo_areaRingSum.add(Math.atan2(v, u));
2985
2986     // Advance the previous points.
2987     λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
2988   }
2989
2990   // For the last point, return to the start.
2991   d3_geo_area.lineEnd = function() {
2992     nextPoint(λ00, φ00);
2993   };
2994 }
2995
2996 function d3_geo_pointInPolygon(point, polygon) {
2997   var meridian = point[0],
2998       parallel = point[1],
2999       meridianNormal = [Math.sin(meridian), -Math.cos(meridian), 0],
3000       polarAngle = 0,
3001       winding = 0;
3002   d3_geo_areaRingSum.reset();
3003
3004   for (var i = 0, n = polygon.length; i < n; ++i) {
3005     var ring = polygon[i],
3006         m = ring.length;
3007     if (!m) continue;
3008     var point0 = ring[0],
3009         λ0 = point0[0],
3010         φ0 = point0[1] / 2 + π / 4,
3011         sinφ0 = Math.sin(φ0),
3012         cosφ0 = Math.cos(φ0),
3013         j = 1;
3014
3015     while (true) {
3016       if (j === m) j = 0;
3017       point = ring[j];
3018       var λ = point[0],
3019           φ = point[1] / 2 + π / 4,
3020           sinφ = Math.sin(φ),
3021           cosφ = Math.cos(φ),
3022           dλ = λ - λ0,
3023           sdλ = dλ >= 0 ? 1 : -1,
3024           adλ = sdλ * dλ,
3025           antimeridian = adλ > π,
3026           k = sinφ0 * sinφ;
3027       d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ)));
3028
3029       polarAngle += antimeridian ? dλ + sdλ * τ : dλ;
3030
3031       // Are the longitudes either side of the point's meridian, and are the
3032       // latitudes smaller than the parallel?
3033       if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) {
3034         var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point));
3035         d3_geo_cartesianNormalize(arc);
3036         var intersection = d3_geo_cartesianCross(meridianNormal, arc);
3037         d3_geo_cartesianNormalize(intersection);
3038         var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]);
3039         if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) {
3040           winding += antimeridian ^ dλ >= 0 ? 1 : -1;
3041         }
3042       }
3043       if (!j++) break;
3044       λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;
3045     }
3046   }
3047
3048   // First, determine whether the South pole is inside or outside:
3049   //
3050   // It is inside if:
3051   // * the polygon winds around it in a clockwise direction.
3052   // * the polygon does not (cumulatively) wind around it, but has a negative
3053   //   (counter-clockwise) area.
3054   //
3055   // Second, count the (signed) number of times a segment crosses a meridian
3056   // from the point to the South pole.  If it is zero, then the point is the
3057   // same side as the South pole.
3058
3059   return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < 0) ^ (winding & 1);
3060 }
3061
3062 // Clip features against a small circle centered at [0°, 0°].
3063 function d3_geo_clipCircle(radius) {
3064   var cr = Math.cos(radius),
3065       smallRadius = cr > 0,
3066       notHemisphere = abs(cr) > ε, // TODO optimise for this common case
3067       interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
3068
3069   return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-π, radius - π]);
3070
3071   function visible(λ, φ) {
3072     return Math.cos(λ) * Math.cos(φ) > cr;
3073   }
3074
3075   // Takes a line and cuts into visible segments. Return values used for
3076   // polygon clipping:
3077   //   0: there were intersections or the line was empty.
3078   //   1: no intersections.
3079   //   2: there were intersections, and the first and last segments should be
3080   //      rejoined.
3081   function clipLine(listener) {
3082     var point0, // previous point
3083         c0, // code for previous point
3084         v0, // visibility of previous point
3085         v00, // visibility of first point
3086         clean; // no intersections
3087     return {
3088       lineStart: function() {
3089         v00 = v0 = false;
3090         clean = 1;
3091       },
3092       point: function(λ, φ) {
3093         var point1 = [λ, φ],
3094             point2,
3095             v = visible(λ, φ),
3096             c = smallRadius
3097               ? v ? 0 : code(λ, φ)
3098               : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
3099         if (!point0 && (v00 = v0 = v)) listener.lineStart();
3100         // Handle degeneracies.
3101         // TODO ignore if not clipping polygons.
3102         if (v !== v0) {
3103           point2 = intersect(point0, point1);
3104           if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
3105             point1[0] += ε;
3106             point1[1] += ε;
3107             v = visible(point1[0], point1[1]);
3108           }
3109         }
3110         if (v !== v0) {
3111           clean = 0;
3112           if (v) {
3113             // outside going in
3114             listener.lineStart();
3115             point2 = intersect(point1, point0);
3116             listener.point(point2[0], point2[1]);
3117           } else {
3118             // inside going out
3119             point2 = intersect(point0, point1);
3120             listener.point(point2[0], point2[1]);
3121             listener.lineEnd();
3122           }
3123           point0 = point2;
3124         } else if (notHemisphere && point0 && smallRadius ^ v) {
3125           var t;
3126           // If the codes for two points are different, or are both zero,
3127           // and there this segment intersects with the small circle.
3128           if (!(c & c0) && (t = intersect(point1, point0, true))) {
3129             clean = 0;
3130             if (smallRadius) {
3131               listener.lineStart();
3132               listener.point(t[0][0], t[0][1]);
3133               listener.point(t[1][0], t[1][1]);
3134               listener.lineEnd();
3135             } else {
3136               listener.point(t[1][0], t[1][1]);
3137               listener.lineEnd();
3138               listener.lineStart();
3139               listener.point(t[0][0], t[0][1]);
3140             }
3141           }
3142         }
3143         if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
3144           listener.point(point1[0], point1[1]);
3145         }
3146         point0 = point1, v0 = v, c0 = c;
3147       },
3148       lineEnd: function() {
3149         if (v0) listener.lineEnd();
3150         point0 = null;
3151       },
3152       // Rejoin first and last segments if there were intersections and the first
3153       // and last points were visible.
3154       clean: function() { return clean | ((v00 && v0) << 1); }
3155     };
3156   }
3157
3158   // Intersects the great circle between a and b with the clip circle.
3159   function intersect(a, b, two) {
3160     var pa = d3_geo_cartesian(a),
3161         pb = d3_geo_cartesian(b);
3162
3163     // We have two planes, n1.p = d1 and n2.p = d2.
3164     // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).
3165     var n1 = [1, 0, 0], // normal
3166         n2 = d3_geo_cartesianCross(pa, pb),
3167         n2n2 = d3_geo_cartesianDot(n2, n2),
3168         n1n2 = n2[0], // d3_geo_cartesianDot(n1, n2),
3169         determinant = n2n2 - n1n2 * n1n2;
3170
3171     // Two polar points.
3172     if (!determinant) return !two && a;
3173
3174     var c1 =  cr * n2n2 / determinant,
3175         c2 = -cr * n1n2 / determinant,
3176         n1xn2 = d3_geo_cartesianCross(n1, n2),
3177         A = d3_geo_cartesianScale(n1, c1),
3178         B = d3_geo_cartesianScale(n2, c2);
3179     d3_geo_cartesianAdd(A, B);
3180
3181     // Solve |p(t)|^2 = 1.
3182     var u = n1xn2,
3183         w = d3_geo_cartesianDot(A, u),
3184         uu = d3_geo_cartesianDot(u, u),
3185         t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
3186
3187     if (t2 < 0) return;
3188
3189     var t = Math.sqrt(t2),
3190         q = d3_geo_cartesianScale(u, (-w - t) / uu);
3191     d3_geo_cartesianAdd(q, A);
3192     q = d3_geo_spherical(q);
3193     if (!two) return q;
3194
3195     // Two intersection points.
3196     var λ0 = a[0],
3197         λ1 = b[0],
3198         φ0 = a[1],
3199         φ1 = b[1],
3200         z;
3201     if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
3202     var δλ = λ1 - λ0,
3203         polar = abs(δλ - π) < ε,
3204         meridian = polar || δλ < ε;
3205
3206     if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
3207
3208     // Check that the first point is between a and b.
3209     if (meridian
3210         ? polar
3211           ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1)
3212           : φ0 <= q[1] && q[1] <= φ1
3213         : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
3214       var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
3215       d3_geo_cartesianAdd(q1, A);
3216       return [q, d3_geo_spherical(q1)];
3217     }
3218   }
3219
3220   // Generates a 4-bit vector representing the location of a point relative to
3221   // the small circle's bounding box.
3222   function code(λ, φ) {
3223     var r = smallRadius ? radius : π - radius,
3224         code = 0;
3225     if (λ < -r) code |= 1; // left
3226     else if (λ > r) code |= 2; // right
3227     if (φ < -r) code |= 4; // below
3228     else if (φ > r) code |= 8; // above
3229     return code;
3230   }
3231 }
3232
3233 // Liang–Barsky line clipping.
3234 function d3_geom_clipLine(x0, y0, x1, y1) {
3235   return function(line) {
3236     var a = line.a,
3237         b = line.b,
3238         ax = a.x,
3239         ay = a.y,
3240         bx = b.x,
3241         by = b.y,
3242         t0 = 0,
3243         t1 = 1,
3244         dx = bx - ax,
3245         dy = by - ay,
3246         r;
3247
3248     r = x0 - ax;
3249     if (!dx && r > 0) return;
3250     r /= dx;
3251     if (dx < 0) {
3252       if (r < t0) return;
3253       if (r < t1) t1 = r;
3254     } else if (dx > 0) {
3255       if (r > t1) return;
3256       if (r > t0) t0 = r;
3257     }
3258
3259     r = x1 - ax;
3260     if (!dx && r < 0) return;
3261     r /= dx;
3262     if (dx < 0) {
3263       if (r > t1) return;
3264       if (r > t0) t0 = r;
3265     } else if (dx > 0) {
3266       if (r < t0) return;
3267       if (r < t1) t1 = r;
3268     }
3269
3270     r = y0 - ay;
3271     if (!dy && r > 0) return;
3272     r /= dy;
3273     if (dy < 0) {
3274       if (r < t0) return;
3275       if (r < t1) t1 = r;
3276     } else if (dy > 0) {
3277       if (r > t1) return;
3278       if (r > t0) t0 = r;
3279     }
3280
3281     r = y1 - ay;
3282     if (!dy && r < 0) return;
3283     r /= dy;
3284     if (dy < 0) {
3285       if (r > t1) return;
3286       if (r > t0) t0 = r;
3287     } else if (dy > 0) {
3288       if (r < t0) return;
3289       if (r < t1) t1 = r;
3290     }
3291
3292     if (t0 > 0) line.a = {x: ax + t0 * dx, y: ay + t0 * dy};
3293     if (t1 < 1) line.b = {x: ax + t1 * dx, y: ay + t1 * dy};
3294     return line;
3295   };
3296 }
3297
3298 var d3_geo_clipExtentMAX = 1e9;
3299
3300 d3.geo.clipExtent = function() {
3301   var x0, y0, x1, y1,
3302       stream,
3303       clip,
3304       clipExtent = {
3305         stream: function(output) {
3306           if (stream) stream.valid = false;
3307           stream = clip(output);
3308           stream.valid = true; // allow caching by d3.geo.path
3309           return stream;
3310         },
3311         extent: function(_) {
3312           if (!arguments.length) return [[x0, y0], [x1, y1]];
3313           clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]);
3314           if (stream) stream.valid = false, stream = null;
3315           return clipExtent;
3316         }
3317       };
3318   return clipExtent.extent([[0, 0], [960, 500]]);
3319 };
3320
3321 function d3_geo_clipExtent(x0, y0, x1, y1) {
3322   return function(listener) {
3323     var listener_ = listener,
3324         bufferListener = d3_geo_clipBufferListener(),
3325         clipLine = d3_geom_clipLine(x0, y0, x1, y1),
3326         segments,
3327         polygon,
3328         ring;
3329
3330     var clip = {
3331       point: point,
3332       lineStart: lineStart,
3333       lineEnd: lineEnd,
3334       polygonStart: function() {
3335         listener = bufferListener;
3336         segments = [];
3337         polygon = [];
3338         clean = true;
3339       },
3340       polygonEnd: function() {
3341         listener = listener_;
3342         segments = d3.merge(segments);
3343         var clipStartInside = insidePolygon([x0, y1]),
3344             inside = clean && clipStartInside,
3345             visible = segments.length;
3346         if (inside || visible) {
3347           listener.polygonStart();
3348           if (inside) {
3349             listener.lineStart();
3350             interpolate(null, null, 1, listener);
3351             listener.lineEnd();
3352           }
3353           if (visible) {
3354             d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener);
3355           }
3356           listener.polygonEnd();
3357         }
3358         segments = polygon = ring = null;
3359       }
3360     };
3361
3362     function insidePolygon(p) {
3363       var wn = 0, // the winding number counter
3364           n = polygon.length,
3365           y = p[1];
3366
3367       for (var i = 0; i < n; ++i) {
3368         for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) {
3369           b = v[j];
3370           if (a[1] <= y) {
3371             if (b[1] >  y && d3_cross2d(a, b, p) > 0) ++wn;
3372           } else {
3373             if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn;
3374           }
3375           a = b;
3376         }
3377       }
3378       return wn !== 0;
3379     }
3380
3381     function interpolate(from, to, direction, listener) {
3382       var a = 0, a1 = 0;
3383       if (from == null ||
3384           (a = corner(from, direction)) !== (a1 = corner(to, direction)) ||
3385           comparePoints(from, to) < 0 ^ direction > 0) {
3386         do {
3387           listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
3388         } while ((a = (a + direction + 4) % 4) !== a1);
3389       } else {
3390         listener.point(to[0], to[1]);
3391       }
3392     }
3393
3394     function pointVisible(x, y) {
3395       return x0 <= x && x <= x1 && y0 <= y && y <= y1;
3396     }
3397
3398     function point(x, y) {
3399       if (pointVisible(x, y)) listener.point(x, y);
3400     }
3401
3402     var x__, y__, v__, // first point
3403         x_, y_, v_, // previous point
3404         first,
3405         clean;
3406
3407     function lineStart() {
3408       clip.point = linePoint;
3409       if (polygon) polygon.push(ring = []);
3410       first = true;
3411       v_ = false;
3412       x_ = y_ = NaN;
3413     }
3414
3415     function lineEnd() {
3416       // TODO rather than special-case polygons, simply handle them separately.
3417       // Ideally, coincident intersection points should be jittered to avoid
3418       // clipping issues.
3419       if (segments) {
3420         linePoint(x__, y__);
3421         if (v__ && v_) bufferListener.rejoin();
3422         segments.push(bufferListener.buffer());
3423       }
3424       clip.point = point;
3425       if (v_) listener.lineEnd();
3426     }
3427
3428     function linePoint(x, y) {
3429       x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x));
3430       y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y));
3431       var v = pointVisible(x, y);
3432       if (polygon) ring.push([x, y]);
3433       if (first) {
3434         x__ = x, y__ = y, v__ = v;
3435         first = false;
3436         if (v) {
3437           listener.lineStart();
3438           listener.point(x, y);
3439         }
3440       } else {
3441         if (v && v_) listener.point(x, y);
3442         else {
3443           var l = {a: {x: x_, y: y_}, b: {x: x, y: y}};
3444           if (clipLine(l)) {
3445             if (!v_) {
3446               listener.lineStart();
3447               listener.point(l.a.x, l.a.y);
3448             }
3449             listener.point(l.b.x, l.b.y);
3450             if (!v) listener.lineEnd();
3451             clean = false;
3452           } else if (v) {
3453             listener.lineStart();
3454             listener.point(x, y);
3455             clean = false;
3456           }
3457         }
3458       }
3459       x_ = x, y_ = y, v_ = v;
3460     }
3461
3462     return clip;
3463   };
3464
3465   function corner(p, direction) {
3466     return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3
3467         : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1
3468         : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0
3469         : direction > 0 ? 3 : 2; // abs(p[1] - y1) < ε
3470   }
3471
3472   function compare(a, b) {
3473     return comparePoints(a.x, b.x);
3474   }
3475
3476   function comparePoints(a, b) {
3477     var ca = corner(a, 1),
3478         cb = corner(b, 1);
3479     return ca !== cb ? ca - cb
3480         : ca === 0 ? b[1] - a[1]
3481         : ca === 1 ? a[0] - b[0]
3482         : ca === 2 ? a[1] - b[1]
3483         : b[0] - a[0];
3484   }
3485 }
3486
3487 function d3_geo_conic(projectAt) {
3488   var φ0 = 0,
3489       φ1 = π / 3,
3490       m = d3_geo_projectionMutator(projectAt),
3491       p = m(φ0, φ1);
3492
3493   p.parallels = function(_) {
3494     if (!arguments.length) return [φ0 / π * 180, φ1 / π * 180];
3495     return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
3496   };
3497
3498   return p;
3499 }
3500
3501 function d3_geo_conicEqualArea(φ0, φ1) {
3502   var sinφ0 = Math.sin(φ0),
3503       n = (sinφ0 + Math.sin(φ1)) / 2,
3504       C = 1 + sinφ0 * (2 * n - sinφ0),
3505       ρ0 = Math.sqrt(C) / n;
3506
3507   function forward(λ, φ) {
3508     var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
3509     return [
3510       ρ * Math.sin(λ *= n),
3511       ρ0 - ρ * Math.cos(λ)
3512     ];
3513   }
3514
3515   forward.invert = function(x, y) {
3516     var ρ0_y = ρ0 - y;
3517     return [
3518       Math.atan2(x, ρ0_y) / n,
3519       d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n))
3520     ];
3521   };
3522
3523   return forward;
3524 }
3525
3526 (d3.geo.conicEqualArea = function() {
3527   return d3_geo_conic(d3_geo_conicEqualArea);
3528 }).raw = d3_geo_conicEqualArea;
3529
3530 // ESRI:102003
3531 d3.geo.albers = function() {
3532   return d3.geo.conicEqualArea()
3533       .rotate([96, 0])
3534       .center([-.6, 38.7])
3535       .parallels([29.5, 45.5])
3536       .scale(1070);
3537 };
3538
3539 // A composite projection for the United States, configured by default for
3540 // 960×500. Also works quite well at 960×600 with scale 1285. The set of
3541 // standard parallels for each region comes from USGS, which is published here:
3542 // http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers
3543 d3.geo.albersUsa = function() {
3544   var lower48 = d3.geo.albers();
3545
3546   // EPSG:3338
3547   var alaska = d3.geo.conicEqualArea()
3548       .rotate([154, 0])
3549       .center([-2, 58.5])
3550       .parallels([55, 65]);
3551
3552   // ESRI:102007
3553   var hawaii = d3.geo.conicEqualArea()
3554       .rotate([157, 0])
3555       .center([-3, 19.9])
3556       .parallels([8, 18]);
3557
3558   var point,
3559       pointStream = {point: function(x, y) { point = [x, y]; }},
3560       lower48Point,
3561       alaskaPoint,
3562       hawaiiPoint;
3563
3564   function albersUsa(coordinates) {
3565     var x = coordinates[0], y = coordinates[1];
3566     point = null;
3567     (lower48Point(x, y), point)
3568         || (alaskaPoint(x, y), point)
3569         || hawaiiPoint(x, y);
3570     return point;
3571   }
3572
3573   albersUsa.invert = function(coordinates) {
3574     var k = lower48.scale(),
3575         t = lower48.translate(),
3576         x = (coordinates[0] - t[0]) / k,
3577         y = (coordinates[1] - t[1]) / k;
3578     return (y >= .120 && y < .234 && x >= -.425 && x < -.214 ? alaska
3579         : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii
3580         : lower48).invert(coordinates);
3581   };
3582
3583   // A naïve multi-projection stream.
3584   // The projections must have mutually exclusive clip regions on the sphere,
3585   // as this will avoid emitting interleaving lines and polygons.
3586   albersUsa.stream = function(stream) {
3587     var lower48Stream = lower48.stream(stream),
3588         alaskaStream = alaska.stream(stream),
3589         hawaiiStream = hawaii.stream(stream);
3590     return {
3591       point: function(x, y) {
3592         lower48Stream.point(x, y);
3593         alaskaStream.point(x, y);
3594         hawaiiStream.point(x, y);
3595       },
3596       sphere: function() {
3597         lower48Stream.sphere();
3598         alaskaStream.sphere();
3599         hawaiiStream.sphere();
3600       },
3601       lineStart: function() {
3602         lower48Stream.lineStart();
3603         alaskaStream.lineStart();
3604         hawaiiStream.lineStart();
3605       },
3606       lineEnd: function() {
3607         lower48Stream.lineEnd();
3608         alaskaStream.lineEnd();
3609         hawaiiStream.lineEnd();
3610       },
3611       polygonStart: function() {
3612         lower48Stream.polygonStart();
3613         alaskaStream.polygonStart();
3614         hawaiiStream.polygonStart();
3615       },
3616       polygonEnd: function() {
3617         lower48Stream.polygonEnd();
3618         alaskaStream.polygonEnd();
3619         hawaiiStream.polygonEnd();
3620       }
3621     };
3622   };
3623
3624   albersUsa.precision = function(_) {
3625     if (!arguments.length) return lower48.precision();
3626     lower48.precision(_);
3627     alaska.precision(_);
3628     hawaii.precision(_);
3629     return albersUsa;
3630   };
3631
3632   albersUsa.scale = function(_) {
3633     if (!arguments.length) return lower48.scale();
3634     lower48.scale(_);
3635     alaska.scale(_ * .35);
3636     hawaii.scale(_);
3637     return albersUsa.translate(lower48.translate());
3638   };
3639
3640   albersUsa.translate = function(_) {
3641     if (!arguments.length) return lower48.translate();
3642     var k = lower48.scale(), x = +_[0], y = +_[1];
3643
3644     lower48Point = lower48
3645         .translate(_)
3646         .clipExtent([[x - .455 * k, y - .238 * k], [x + .455 * k, y + .238 * k]])
3647         .stream(pointStream).point;
3648
3649     alaskaPoint = alaska
3650         .translate([x - .307 * k, y + .201 * k])
3651         .clipExtent([[x - .425 * k + ε, y + .120 * k + ε], [x - .214 * k - ε, y + .234 * k - ε]])
3652         .stream(pointStream).point;
3653
3654     hawaiiPoint = hawaii
3655         .translate([x - .205 * k, y + .212 * k])
3656         .clipExtent([[x - .214 * k + ε, y + .166 * k + ε], [x - .115 * k - ε, y + .234 * k - ε]])
3657         .stream(pointStream).point;
3658
3659     return albersUsa;
3660   };
3661
3662   return albersUsa.scale(1070);
3663 };
3664
3665 d3.geo.bounds = (function() {
3666   var λ0, φ0, λ1, φ1, // bounds
3667       λ_, // previous λ-coordinate
3668       λ__, φ__, // first point
3669       p0, // previous 3D point
3670       dλSum,
3671       ranges,
3672       range;
3673
3674   var bound = {
3675     point: point,
3676     lineStart: lineStart,
3677     lineEnd: lineEnd,
3678
3679     polygonStart: function() {
3680       bound.point = ringPoint;
3681       bound.lineStart = ringStart;
3682       bound.lineEnd = ringEnd;
3683       dλSum = 0;
3684       d3_geo_area.polygonStart();
3685     },
3686     polygonEnd: function() {
3687       d3_geo_area.polygonEnd();
3688       bound.point = point;
3689       bound.lineStart = lineStart;
3690       bound.lineEnd = lineEnd;
3691       if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90);
3692       else if (dλSum > ε) φ1 = 90;
3693       else if (dλSum < -ε) φ0 = -90;
3694       range[0] = λ0, range[1] = λ1;
3695     }
3696   };
3697
3698   function point(λ, φ) {
3699     ranges.push(range = [λ0 = λ, λ1 = λ]);
3700     if (φ < φ0) φ0 = φ;
3701     if (φ > φ1) φ1 = φ;
3702   }
3703
3704   function linePoint(λ, φ) {
3705     var p = d3_geo_cartesian([λ * d3_radians, φ * d3_radians]);
3706     if (p0) {
3707       var normal = d3_geo_cartesianCross(p0, p),
3708           equatorial = [normal[1], -normal[0], 0],
3709           inflection = d3_geo_cartesianCross(equatorial, normal);
3710       d3_geo_cartesianNormalize(inflection);
3711       inflection = d3_geo_spherical(inflection);
3712       var dλ = λ - λ_,
3713           s = dλ > 0 ? 1 : -1,
3714           λi = inflection[0] * d3_degrees * s,
3715           antimeridian = abs(dλ) > 180;
3716       if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
3717         var φi = inflection[1] * d3_degrees;
3718         if (φi > φ1) φ1 = φi;
3719       } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
3720         var φi = -inflection[1] * d3_degrees;
3721         if (φi < φ0) φ0 = φi;
3722       } else {
3723         if (φ < φ0) φ0 = φ;
3724         if (φ > φ1) φ1 = φ;
3725       }
3726       if (antimeridian) {
3727         if (λ < λ_) {
3728           if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
3729         } else {
3730           if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
3731         }
3732       } else {
3733         if (λ1 >= λ0) {
3734           if (λ < λ0) λ0 = λ;
3735           if (λ > λ1) λ1 = λ;
3736         } else {
3737           if (λ > λ_) {
3738             if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
3739           } else {
3740             if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
3741           }
3742         }
3743       }
3744     } else {
3745       point(λ, φ);
3746     }
3747     p0 = p, λ_ = λ;
3748   }
3749
3750   function lineStart() { bound.point = linePoint; }
3751   function lineEnd() {
3752     range[0] = λ0, range[1] = λ1;
3753     bound.point = point;
3754     p0 = null;
3755   }
3756
3757   function ringPoint(λ, φ) {
3758     if (p0) {
3759       var dλ = λ - λ_;
3760       dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
3761     } else λ__ = λ, φ__ = φ;
3762     d3_geo_area.point(λ, φ);
3763     linePoint(λ, φ);
3764   }
3765
3766   function ringStart() {
3767     d3_geo_area.lineStart();
3768   }
3769
3770   function ringEnd() {
3771     ringPoint(λ__, φ__);
3772     d3_geo_area.lineEnd();
3773     if (abs(dλSum) > ε) λ0 = -(λ1 = 180);
3774     range[0] = λ0, range[1] = λ1;
3775     p0 = null;
3776   }
3777
3778   // Finds the left-right distance between two longitudes.
3779   // This is almost the same as (λ1 - λ0 + 360°) % 360°, except that we want
3780   // the distance between ±180° to be 360°.
3781   function angle(λ0, λ1) { return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1; }
3782
3783   function compareRanges(a, b) { return a[0] - b[0]; }
3784
3785   function withinRange(x, range) {
3786     return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
3787   }
3788
3789   return function(feature) {
3790     φ1 = λ1 = -(λ0 = φ0 = Infinity);
3791     ranges = [];
3792
3793     d3.geo.stream(feature, bound);
3794
3795     var n = ranges.length;
3796     if (n) {
3797       // First, sort ranges by their minimum longitudes.
3798       ranges.sort(compareRanges);
3799
3800       // Then, merge any ranges that overlap.
3801       for (var i = 1, a = ranges[0], b, merged = [a]; i < n; ++i) {
3802         b = ranges[i];
3803         if (withinRange(b[0], a) || withinRange(b[1], a)) {
3804           if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
3805           if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
3806         } else {
3807           merged.push(a = b);
3808         }
3809       }
3810
3811       // Finally, find the largest gap between the merged ranges.
3812       // The final bounding box will be the inverse of this gap.
3813       var best = -Infinity, dλ;
3814       for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
3815         b = merged[i];
3816         if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
3817       }
3818     }
3819     ranges = range = null;
3820
3821     return λ0 === Infinity || φ0 === Infinity
3822         ? [[NaN, NaN], [NaN, NaN]]
3823         : [[λ0, φ0], [λ1, φ1]];
3824   };
3825 })();
3826
3827 d3.geo.centroid = function(object) {
3828   d3_geo_centroidW0 = d3_geo_centroidW1 =
3829   d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 =
3830   d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 =
3831   d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
3832   d3.geo.stream(object, d3_geo_centroid);
3833
3834   var x = d3_geo_centroidX2,
3835       y = d3_geo_centroidY2,
3836       z = d3_geo_centroidZ2,
3837       m = x * x + y * y + z * z;
3838
3839   // If the area-weighted centroid is undefined, fall back to length-weighted centroid.
3840   if (m < ε2) {
3841     x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
3842     // If the feature has zero length, fall back to arithmetic mean of point vectors.
3843     if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
3844     m = x * x + y * y + z * z;
3845     // If the feature still has an undefined centroid, then return.
3846     if (m < ε2) return [NaN, NaN];
3847   }
3848
3849   return [Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees];
3850 };
3851
3852 var d3_geo_centroidW0,
3853     d3_geo_centroidW1,
3854     d3_geo_centroidX0,
3855     d3_geo_centroidY0,
3856     d3_geo_centroidZ0,
3857     d3_geo_centroidX1,
3858     d3_geo_centroidY1,
3859     d3_geo_centroidZ1,
3860     d3_geo_centroidX2,
3861     d3_geo_centroidY2,
3862     d3_geo_centroidZ2;
3863
3864 var d3_geo_centroid = {
3865   sphere: d3_noop,
3866   point: d3_geo_centroidPoint,
3867   lineStart: d3_geo_centroidLineStart,
3868   lineEnd: d3_geo_centroidLineEnd,
3869   polygonStart: function() {
3870     d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
3871   },
3872   polygonEnd: function() {
3873     d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
3874   }
3875 };
3876
3877 // Arithmetic mean of Cartesian vectors.
3878 function d3_geo_centroidPoint(λ, φ) {
3879   λ *= d3_radians;
3880   var cosφ = Math.cos(φ *= d3_radians);
3881   d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
3882 }
3883
3884 function d3_geo_centroidPointXYZ(x, y, z) {
3885   ++d3_geo_centroidW0;
3886   d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
3887   d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
3888   d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
3889 }
3890
3891 function d3_geo_centroidLineStart() {
3892   var x0, y0, z0; // previous point
3893
3894   d3_geo_centroid.point = function(λ, φ) {
3895     λ *= d3_radians;
3896     var cosφ = Math.cos(φ *= d3_radians);
3897     x0 = cosφ * Math.cos(λ);
3898     y0 = cosφ * Math.sin(λ);
3899     z0 = Math.sin(φ);
3900     d3_geo_centroid.point = nextPoint;
3901     d3_geo_centroidPointXYZ(x0, y0, z0);
3902   };
3903
3904   function nextPoint(λ, φ) {
3905     λ *= d3_radians;
3906     var cosφ = Math.cos(φ *= d3_radians),
3907         x = cosφ * Math.cos(λ),
3908         y = cosφ * Math.sin(λ),
3909         z = Math.sin(φ),
3910         w = Math.atan2(
3911           Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w),
3912           x0 * x + y0 * y + z0 * z);
3913     d3_geo_centroidW1 += w;
3914     d3_geo_centroidX1 += w * (x0 + (x0 = x));
3915     d3_geo_centroidY1 += w * (y0 + (y0 = y));
3916     d3_geo_centroidZ1 += w * (z0 + (z0 = z));
3917     d3_geo_centroidPointXYZ(x0, y0, z0);
3918   }
3919 }
3920
3921 function d3_geo_centroidLineEnd() {
3922   d3_geo_centroid.point = d3_geo_centroidPoint;
3923 }
3924
3925 // See J. E. Brock, The Inertia Tensor for a Spherical Triangle,
3926 // J. Applied Mechanics 42, 239 (1975).
3927 function d3_geo_centroidRingStart() {
3928   var λ00, φ00, // first point
3929       x0, y0, z0; // previous point
3930
3931   d3_geo_centroid.point = function(λ, φ) {
3932     λ00 = λ, φ00 = φ;
3933     d3_geo_centroid.point = nextPoint;
3934     λ *= d3_radians;
3935     var cosφ = Math.cos(φ *= d3_radians);
3936     x0 = cosφ * Math.cos(λ);
3937     y0 = cosφ * Math.sin(λ);
3938     z0 = Math.sin(φ);
3939     d3_geo_centroidPointXYZ(x0, y0, z0);
3940   };
3941
3942   d3_geo_centroid.lineEnd = function() {
3943     nextPoint(λ00, φ00);
3944     d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
3945     d3_geo_centroid.point = d3_geo_centroidPoint;
3946   };
3947
3948   function nextPoint(λ, φ) {
3949     λ *= d3_radians;
3950     var cosφ = Math.cos(φ *= d3_radians),
3951         x = cosφ * Math.cos(λ),
3952         y = cosφ * Math.sin(λ),
3953         z = Math.sin(φ),
3954         cx = y0 * z - z0 * y,
3955         cy = z0 * x - x0 * z,
3956         cz = x0 * y - y0 * x,
3957         m = Math.sqrt(cx * cx + cy * cy + cz * cz),
3958         u = x0 * x + y0 * y + z0 * z,
3959         v = m && -d3_acos(u) / m, // area weight
3960         w = Math.atan2(m, u); // line weight
3961     d3_geo_centroidX2 += v * cx;
3962     d3_geo_centroidY2 += v * cy;
3963     d3_geo_centroidZ2 += v * cz;
3964     d3_geo_centroidW1 += w;
3965     d3_geo_centroidX1 += w * (x0 + (x0 = x));
3966     d3_geo_centroidY1 += w * (y0 + (y0 = y));
3967     d3_geo_centroidZ1 += w * (z0 + (z0 = z));
3968     d3_geo_centroidPointXYZ(x0, y0, z0);
3969   }
3970 }
3971
3972 // TODO Unify this code with d3.geom.polygon area?
3973
3974 var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
3975   point: d3_noop,
3976   lineStart: d3_noop,
3977   lineEnd: d3_noop,
3978
3979   // Only count area for polygon rings.
3980   polygonStart: function() {
3981     d3_geo_pathAreaPolygon = 0;
3982     d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
3983   },
3984   polygonEnd: function() {
3985     d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
3986     d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
3987   }
3988 };
3989
3990 function d3_geo_pathAreaRingStart() {
3991   var x00, y00, x0, y0;
3992
3993   // For the first point, …
3994   d3_geo_pathArea.point = function(x, y) {
3995     d3_geo_pathArea.point = nextPoint;
3996     x00 = x0 = x, y00 = y0 = y;
3997   };
3998
3999   // For subsequent points, …
4000   function nextPoint(x, y) {
4001     d3_geo_pathAreaPolygon += y0 * x - x0 * y;
4002     x0 = x, y0 = y;
4003   }
4004
4005   // For the last point, return to the start.
4006   d3_geo_pathArea.lineEnd = function() {
4007     nextPoint(x00, y00);
4008   };
4009 }
4010
4011 var d3_geo_pathBoundsX0,
4012     d3_geo_pathBoundsY0,
4013     d3_geo_pathBoundsX1,
4014     d3_geo_pathBoundsY1;
4015
4016 var d3_geo_pathBounds = {
4017   point: d3_geo_pathBoundsPoint,
4018   lineStart: d3_noop,
4019   lineEnd: d3_noop,
4020   polygonStart: d3_noop,
4021   polygonEnd: d3_noop
4022 };
4023
4024 function d3_geo_pathBoundsPoint(x, y) {
4025   if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
4026   if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
4027   if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
4028   if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
4029 }
4030 function d3_geo_pathBuffer() {
4031   var pointCircle = d3_geo_pathBufferCircle(4.5),
4032       buffer = [];
4033
4034   var stream = {
4035     point: point,
4036
4037     // While inside a line, override point to moveTo then lineTo.
4038     lineStart: function() { stream.point = pointLineStart; },
4039     lineEnd: lineEnd,
4040
4041     // While inside a polygon, override lineEnd to closePath.
4042     polygonStart: function() { stream.lineEnd = lineEndPolygon; },
4043     polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
4044
4045     pointRadius: function(_) {
4046       pointCircle = d3_geo_pathBufferCircle(_);
4047       return stream;
4048     },
4049
4050     result: function() {
4051       if (buffer.length) {
4052         var result = buffer.join("");
4053         buffer = [];
4054         return result;
4055       }
4056     }
4057   };
4058
4059   function point(x, y) {
4060     buffer.push("M", x, ",", y, pointCircle);
4061   }
4062
4063   function pointLineStart(x, y) {
4064     buffer.push("M", x, ",", y);
4065     stream.point = pointLine;
4066   }
4067
4068   function pointLine(x, y) {
4069     buffer.push("L", x, ",", y);
4070   }
4071
4072   function lineEnd() {
4073     stream.point = point;
4074   }
4075
4076   function lineEndPolygon() {
4077     buffer.push("Z");
4078   }
4079
4080   return stream;
4081 }
4082
4083 function d3_geo_pathBufferCircle(radius) {
4084   return "m0," + radius
4085       + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius
4086       + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius
4087       + "z";
4088 }
4089
4090 // TODO Unify this code with d3.geom.polygon centroid?
4091 // TODO Enforce positive area for exterior, negative area for interior?
4092
4093 var d3_geo_pathCentroid = {
4094   point: d3_geo_pathCentroidPoint,
4095
4096   // For lines, weight by length.
4097   lineStart: d3_geo_pathCentroidLineStart,
4098   lineEnd: d3_geo_pathCentroidLineEnd,
4099
4100   // For polygons, weight by area.
4101   polygonStart: function() {
4102     d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
4103   },
4104   polygonEnd: function() {
4105     d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
4106     d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
4107     d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
4108   }
4109 };
4110
4111 function d3_geo_pathCentroidPoint(x, y) {
4112   d3_geo_centroidX0 += x;
4113   d3_geo_centroidY0 += y;
4114   ++d3_geo_centroidZ0;
4115 }
4116
4117 function d3_geo_pathCentroidLineStart() {
4118   var x0, y0;
4119
4120   d3_geo_pathCentroid.point = function(x, y) {
4121     d3_geo_pathCentroid.point = nextPoint;
4122     d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4123   };
4124
4125   function nextPoint(x, y) {
4126     var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
4127     d3_geo_centroidX1 += z * (x0 + x) / 2;
4128     d3_geo_centroidY1 += z * (y0 + y) / 2;
4129     d3_geo_centroidZ1 += z;
4130     d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4131   }
4132 }
4133
4134 function d3_geo_pathCentroidLineEnd() {
4135   d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
4136 }
4137
4138 function d3_geo_pathCentroidRingStart() {
4139   var x00, y00, x0, y0;
4140
4141   // For the first point, …
4142   d3_geo_pathCentroid.point = function(x, y) {
4143     d3_geo_pathCentroid.point = nextPoint;
4144     d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
4145   };
4146
4147   // For subsequent points, …
4148   function nextPoint(x, y) {
4149     var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
4150     d3_geo_centroidX1 += z * (x0 + x) / 2;
4151     d3_geo_centroidY1 += z * (y0 + y) / 2;
4152     d3_geo_centroidZ1 += z;
4153
4154     z = y0 * x - x0 * y;
4155     d3_geo_centroidX2 += z * (x0 + x);
4156     d3_geo_centroidY2 += z * (y0 + y);
4157     d3_geo_centroidZ2 += z * 3;
4158     d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4159   }
4160
4161   // For the last point, return to the start.
4162   d3_geo_pathCentroid.lineEnd = function() {
4163     nextPoint(x00, y00);
4164   };
4165 }
4166
4167 function d3_geo_pathContext(context) {
4168   var pointRadius = 4.5;
4169
4170   var stream = {
4171     point: point,
4172
4173     // While inside a line, override point to moveTo then lineTo.
4174     lineStart: function() { stream.point = pointLineStart; },
4175     lineEnd: lineEnd,
4176
4177     // While inside a polygon, override lineEnd to closePath.
4178     polygonStart: function() { stream.lineEnd = lineEndPolygon; },
4179     polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
4180
4181     pointRadius: function(_) {
4182       pointRadius = _;
4183       return stream;
4184     },
4185
4186     result: d3_noop
4187   };
4188
4189   function point(x, y) {
4190     context.moveTo(x + pointRadius, y);
4191     context.arc(x, y, pointRadius, 0, τ);
4192   }
4193
4194   function pointLineStart(x, y) {
4195     context.moveTo(x, y);
4196     stream.point = pointLine;
4197   }
4198
4199   function pointLine(x, y) {
4200     context.lineTo(x, y);
4201   }
4202
4203   function lineEnd() {
4204     stream.point = point;
4205   }
4206
4207   function lineEndPolygon() {
4208     context.closePath();
4209   }
4210
4211   return stream;
4212 }
4213
4214 function d3_geo_resample(project) {
4215   var δ2 = .5, // precision, px²
4216       cosMinDistance = Math.cos(30 * d3_radians), // cos(minimum angular distance)
4217       maxDepth = 16;
4218
4219   function resample(stream) {
4220     return (maxDepth ? resampleRecursive : resampleNone)(stream);
4221   }
4222
4223   function resampleNone(stream) {
4224     return d3_geo_transformPoint(stream, function(x, y) {
4225       x = project(x, y);
4226       stream.point(x[0], x[1]);
4227     });
4228   }
4229
4230   function resampleRecursive(stream) {
4231     var λ00, φ00, x00, y00, a00, b00, c00, // first point
4232         λ0, x0, y0, a0, b0, c0; // previous point
4233
4234     var resample = {
4235       point: point,
4236       lineStart: lineStart,
4237       lineEnd: lineEnd,
4238       polygonStart: function() { stream.polygonStart(); resample.lineStart = ringStart; },
4239       polygonEnd: function() { stream.polygonEnd(); resample.lineStart = lineStart; }
4240     };
4241
4242     function point(x, y) {
4243       x = project(x, y);
4244       stream.point(x[0], x[1]);
4245     }
4246
4247     function lineStart() {
4248       x0 = NaN;
4249       resample.point = linePoint;
4250       stream.lineStart();
4251     }
4252
4253     function linePoint(λ, φ) {
4254       var c = d3_geo_cartesian([λ, φ]), p = project(λ, φ);
4255       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);
4256       stream.point(x0, y0);
4257     }
4258
4259     function lineEnd() {
4260       resample.point = point;
4261       stream.lineEnd();
4262     }
4263
4264     function ringStart() {
4265       lineStart();
4266       resample.point = ringPoint;
4267       resample.lineEnd = ringEnd;
4268     }
4269
4270     function ringPoint(λ, φ) {
4271       linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
4272       resample.point = linePoint;
4273     }
4274
4275     function ringEnd() {
4276       resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream);
4277       resample.lineEnd = lineEnd;
4278       lineEnd();
4279     }
4280
4281     return resample;
4282   }
4283
4284   function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) {
4285     var dx = x1 - x0,
4286         dy = y1 - y0,
4287         d2 = dx * dx + dy * dy;
4288     if (d2 > 4 * δ2 && depth--) {
4289       var a = a0 + a1,
4290           b = b0 + b1,
4291           c = c0 + c1,
4292           m = Math.sqrt(a * a + b * b + c * c),
4293           φ2 = Math.asin(c /= m),
4294           λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a),
4295           p = project(λ2, φ2),
4296           x2 = p[0],
4297           y2 = p[1],
4298           dx2 = x2 - x0,
4299           dy2 = y2 - y0,
4300           dz = dy * dx2 - dx * dy2;
4301       if (dz * dz / d2 > δ2 // perpendicular projected distance
4302           || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 // midpoint close to an end
4303           || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance
4304         resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream);
4305         stream.point(x2, y2);
4306         resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream);
4307       }
4308     }
4309   }
4310
4311   resample.precision = function(_) {
4312     if (!arguments.length) return Math.sqrt(δ2);
4313     maxDepth = (δ2 = _ * _) > 0 && 16;
4314     return resample;
4315   };
4316
4317   return resample;
4318 }
4319
4320 d3.geo.path = function() {
4321   var pointRadius = 4.5,
4322       projection,
4323       context,
4324       projectStream,
4325       contextStream,
4326       cacheStream;
4327
4328   function path(object) {
4329     if (object) {
4330       if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
4331       if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
4332       d3.geo.stream(object, cacheStream);
4333     }
4334     return contextStream.result();
4335   }
4336
4337   path.area = function(object) {
4338     d3_geo_pathAreaSum = 0;
4339     d3.geo.stream(object, projectStream(d3_geo_pathArea));
4340     return d3_geo_pathAreaSum;
4341   };
4342
4343   path.centroid = function(object) {
4344     d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 =
4345     d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 =
4346     d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
4347     d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4348     return d3_geo_centroidZ2 ? [d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2]
4349         : d3_geo_centroidZ1 ? [d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1]
4350         : d3_geo_centroidZ0 ? [d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0]
4351         : [NaN, NaN];
4352   };
4353
4354   path.bounds = function(object) {
4355     d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
4356     d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4357     return [[d3_geo_pathBoundsX0, d3_geo_pathBoundsY0], [d3_geo_pathBoundsX1, d3_geo_pathBoundsY1]];
4358   };
4359
4360   path.projection = function(_) {
4361     if (!arguments.length) return projection;
4362     projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
4363     return reset();
4364   };
4365
4366   path.context = function(_) {
4367     if (!arguments.length) return context;
4368     contextStream = (context = _) == null ? new d3_geo_pathBuffer : new d3_geo_pathContext(_);
4369     if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
4370     return reset();
4371   };
4372
4373   path.pointRadius = function(_) {
4374     if (!arguments.length) return pointRadius;
4375     pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
4376     return path;
4377   };
4378
4379   function reset() {
4380     cacheStream = null;
4381     return path;
4382   }
4383
4384   return path.projection(d3.geo.albersUsa()).context(null);
4385 };
4386
4387 function d3_geo_pathProjectStream(project) {
4388   var resample = d3_geo_resample(function(x, y) { return project([x * d3_degrees, y * d3_degrees]); });
4389   return function(stream) { return d3_geo_projectionRadians(resample(stream)); };
4390 }
4391
4392 d3.geo.transform = function(methods) {
4393   return {
4394     stream: function(stream) {
4395       var transform = new d3_geo_transform(stream);
4396       for (var k in methods) transform[k] = methods[k];
4397       return transform;
4398     }
4399   };
4400 };
4401
4402 function d3_geo_transform(stream) {
4403   this.stream = stream;
4404 }
4405
4406 d3_geo_transform.prototype = {
4407   point: function(x, y) { this.stream.point(x, y); },
4408   sphere: function() { this.stream.sphere(); },
4409   lineStart: function() { this.stream.lineStart(); },
4410   lineEnd: function() { this.stream.lineEnd(); },
4411   polygonStart: function() { this.stream.polygonStart(); },
4412   polygonEnd: function() { this.stream.polygonEnd(); }
4413 };
4414
4415 function d3_geo_transformPoint(stream, point) {
4416   return {
4417     point: point,
4418     sphere: function() { stream.sphere(); },
4419     lineStart: function() { stream.lineStart(); },
4420     lineEnd: function() { stream.lineEnd(); },
4421     polygonStart: function() { stream.polygonStart(); },
4422     polygonEnd: function() { stream.polygonEnd(); },
4423   };
4424 }
4425
4426 d3.geo.projection = d3_geo_projection;
4427 d3.geo.projectionMutator = d3_geo_projectionMutator;
4428
4429 function d3_geo_projection(project) {
4430   return d3_geo_projectionMutator(function() { return project; })();
4431 }
4432
4433 function d3_geo_projectionMutator(projectAt) {
4434   var project,
4435       rotate,
4436       projectRotate,
4437       projectResample = d3_geo_resample(function(x, y) { x = project(x, y); return [x[0] * k + δx, δy - x[1] * k]; }),
4438       k = 150, // scale
4439       x = 480, y = 250, // translate
4440       λ = 0, φ = 0, // center
4441       δλ = 0, δφ = 0, δγ = 0, // rotate
4442       δx, δy, // center
4443       preclip = d3_geo_clipAntimeridian,
4444       postclip = d3_identity,
4445       clipAngle = null,
4446       clipExtent = null,
4447       stream;
4448
4449   function projection(point) {
4450     point = projectRotate(point[0] * d3_radians, point[1] * d3_radians);
4451     return [point[0] * k + δx, δy - point[1] * k];
4452   }
4453
4454   function invert(point) {
4455     point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k);
4456     return point && [point[0] * d3_degrees, point[1] * d3_degrees];
4457   }
4458
4459   projection.stream = function(output) {
4460     if (stream) stream.valid = false;
4461     stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output))));
4462     stream.valid = true; // allow caching by d3.geo.path
4463     return stream;
4464   };
4465
4466   projection.clipAngle = function(_) {
4467     if (!arguments.length) return clipAngle;
4468     preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians);
4469     return invalidate();
4470   };
4471
4472   projection.clipExtent = function(_) {
4473     if (!arguments.length) return clipExtent;
4474     clipExtent = _;
4475     postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity;
4476     return invalidate();
4477   };
4478
4479   projection.scale = function(_) {
4480     if (!arguments.length) return k;
4481     k = +_;
4482     return reset();
4483   };
4484
4485   projection.translate = function(_) {
4486     if (!arguments.length) return [x, y];
4487     x = +_[0];
4488     y = +_[1];
4489     return reset();
4490   };
4491
4492   projection.center = function(_) {
4493     if (!arguments.length) return [λ * d3_degrees, φ * d3_degrees];
4494     λ = _[0] % 360 * d3_radians;
4495     φ = _[1] % 360 * d3_radians;
4496     return reset();
4497   };
4498
4499   projection.rotate = function(_) {
4500     if (!arguments.length) return [δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees];
4501     δλ = _[0] % 360 * d3_radians;
4502     δφ = _[1] % 360 * d3_radians;
4503     δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0;
4504     return reset();
4505   };
4506
4507   d3.rebind(projection, projectResample, "precision");
4508
4509   function reset() {
4510     projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project);
4511     var center = project(λ, φ);
4512     δx = x - center[0] * k;
4513     δy = y + center[1] * k;
4514     return invalidate();
4515   }
4516
4517   function invalidate() {
4518     if (stream) stream.valid = false, stream = null;
4519     return projection;
4520   }
4521
4522   return function() {
4523     project = projectAt.apply(this, arguments);
4524     projection.invert = project.invert && invert;
4525     return reset();
4526   };
4527 }
4528
4529 function d3_geo_projectionRadians(stream) {
4530   return d3_geo_transformPoint(stream, function(x, y) {
4531     stream.point(x * d3_radians, y * d3_radians);
4532   });
4533 }
4534
4535 function d3_geo_mercator(λ, φ) {
4536   return [λ, Math.log(Math.tan(π / 4 + φ / 2))];
4537 }
4538
4539 d3_geo_mercator.invert = function(x, y) {
4540   return [x, 2 * Math.atan(Math.exp(y)) - halfπ];
4541 };
4542
4543 function d3_geo_mercatorProjection(project) {
4544   var m = d3_geo_projection(project),
4545       scale = m.scale,
4546       translate = m.translate,
4547       clipExtent = m.clipExtent,
4548       clipAuto;
4549
4550   m.scale = function() {
4551     var v = scale.apply(m, arguments);
4552     return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
4553   };
4554
4555   m.translate = function() {
4556     var v = translate.apply(m, arguments);
4557     return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
4558   };
4559
4560   m.clipExtent = function(_) {
4561     var v = clipExtent.apply(m, arguments);
4562     if (v === m) {
4563       if (clipAuto = _ == null) {
4564         var k = π * scale(), t = translate();
4565         clipExtent([[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]]);
4566       }
4567     } else if (clipAuto) {
4568       v = null;
4569     }
4570     return v;
4571   };
4572
4573   return m.clipExtent(null);
4574 }
4575
4576 (d3.geo.mercator = function() {
4577   return d3_geo_mercatorProjection(d3_geo_mercator);
4578 }).raw = d3_geo_mercator;
4579 d3.geom = {};
4580
4581 d3.geom.polygon = function(coordinates) {
4582   d3_subclass(coordinates, d3_geom_polygonPrototype);
4583   return coordinates;
4584 };
4585
4586 var d3_geom_polygonPrototype = d3.geom.polygon.prototype = [];
4587
4588 d3_geom_polygonPrototype.area = function() {
4589   var i = -1,
4590       n = this.length,
4591       a,
4592       b = this[n - 1],
4593       area = 0;
4594
4595   while (++i < n) {
4596     a = b;
4597     b = this[i];
4598     area += a[1] * b[0] - a[0] * b[1];
4599   }
4600
4601   return area * .5;
4602 };
4603
4604 d3_geom_polygonPrototype.centroid = function(k) {
4605   var i = -1,
4606       n = this.length,
4607       x = 0,
4608       y = 0,
4609       a,
4610       b = this[n - 1],
4611       c;
4612
4613   if (!arguments.length) k = -1 / (6 * this.area());
4614
4615   while (++i < n) {
4616     a = b;
4617     b = this[i];
4618     c = a[0] * b[1] - b[0] * a[1];
4619     x += (a[0] + b[0]) * c;
4620     y += (a[1] + b[1]) * c;
4621   }
4622
4623   return [x * k, y * k];
4624 };
4625
4626 // The Sutherland-Hodgman clipping algorithm.
4627 // Note: requires the clip polygon to be counterclockwise and convex.
4628 d3_geom_polygonPrototype.clip = function(subject) {
4629   var input,
4630       closed = d3_geom_polygonClosed(subject),
4631       i = -1,
4632       n = this.length - d3_geom_polygonClosed(this),
4633       j,
4634       m,
4635       a = this[n - 1],
4636       b,
4637       c,
4638       d;
4639
4640   while (++i < n) {
4641     input = subject.slice();
4642     subject.length = 0;
4643     b = this[i];
4644     c = input[(m = input.length - closed) - 1];
4645     j = -1;
4646     while (++j < m) {
4647       d = input[j];
4648       if (d3_geom_polygonInside(d, a, b)) {
4649         if (!d3_geom_polygonInside(c, a, b)) {
4650           subject.push(d3_geom_polygonIntersect(c, d, a, b));
4651         }
4652         subject.push(d);
4653       } else if (d3_geom_polygonInside(c, a, b)) {
4654         subject.push(d3_geom_polygonIntersect(c, d, a, b));
4655       }
4656       c = d;
4657     }
4658     if (closed) subject.push(subject[0]);
4659     a = b;
4660   }
4661
4662   return subject;
4663 };
4664
4665 function d3_geom_polygonInside(p, a, b) {
4666   return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]);
4667 }
4668
4669 // Intersect two infinite lines cd and ab.
4670 function d3_geom_polygonIntersect(c, d, a, b) {
4671   var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3,
4672       y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3,
4673       ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
4674   return [x1 + ua * x21, y1 + ua * y21];
4675 }
4676
4677 // Returns true if the polygon is closed.
4678 function d3_geom_polygonClosed(coordinates) {
4679   var a = coordinates[0],
4680       b = coordinates[coordinates.length - 1];
4681   return !(a[0] - b[0] || a[1] - b[1]);
4682 }
4683 function d3_geom_pointX(d) {
4684   return d[0];
4685 }
4686
4687 function d3_geom_pointY(d) {
4688   return d[1];
4689 }
4690
4691 /**
4692  * Computes the 2D convex hull of a set of points using the monotone chain
4693  * algorithm:
4694  * http://en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Convex_hull/Monotone_chain)
4695  *
4696  * The runtime of this algorithm is O(n log n), where n is the number of input
4697  * points. However in practice it outperforms other O(n log n) hulls.
4698  *
4699  * @param vertices [[x1, y1], [x2, y2], ...]
4700  * @returns polygon [[x1, y1], [x2, y2], ...]
4701  */
4702 d3.geom.hull = function(vertices) {
4703   var x = d3_geom_pointX,
4704       y = d3_geom_pointY;
4705
4706   if (arguments.length) return hull(vertices);
4707
4708   function hull(data) {
4709     // Hull of < 3 points is not well-defined
4710     if (data.length < 3) return [];
4711
4712     var fx = d3_functor(x),
4713         fy = d3_functor(y),
4714         i,
4715         n = data.length,
4716         points = [], // of the form [[x0, y0, 0], ..., [xn, yn, n]]
4717         flippedPoints = [];
4718
4719     for (i = 0 ; i < n; i++) {
4720       points.push([+fx.call(this, data[i], i), +fy.call(this, data[i], i), i]);
4721     }
4722
4723     // sort ascending by x-coord first, y-coord second
4724     points.sort(d3_geom_hullOrder);
4725
4726     // we flip bottommost points across y axis so we can use the upper hull routine on both
4727     for (i = 0; i < n; i++) flippedPoints.push([points[i][0], -points[i][1]]);
4728
4729     var upper = d3_geom_hullUpper(points),
4730         lower = d3_geom_hullUpper(flippedPoints);
4731
4732     // construct the polygon, removing possible duplicate endpoints
4733     var skipLeft = lower[0] === upper[0],
4734         skipRight  = lower[lower.length - 1] === upper[upper.length - 1],
4735         polygon = [];
4736
4737     // add upper hull in r->l order
4738     // then add lower hull in l->r order
4739     for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]);
4740     for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]);
4741
4742     return polygon;
4743   }
4744
4745   hull.x = function(_) {
4746     return arguments.length ? (x = _, hull) : x;
4747   };
4748
4749   hull.y = function(_) {
4750     return arguments.length ? (y = _, hull) : y;
4751   };
4752
4753   return hull;
4754 };
4755
4756 // finds the 'upper convex hull' (see wiki link above)
4757 // assumes points arg has >=3 elements, is sorted by x, unique in y
4758 // returns array of indices into points in left to right order
4759 function d3_geom_hullUpper(points) {
4760   var n = points.length,
4761       hull = [0, 1],
4762       hs = 2; // hull size
4763
4764   for (var i = 2; i < n; i++) {
4765     while (hs > 1 && d3_cross2d(points[hull[hs-2]], points[hull[hs-1]], points[i]) <= 0) --hs;
4766     hull[hs++] = i;
4767   }
4768
4769   // we slice to make sure that the points we 'popped' from hull don't stay behind
4770   return hull.slice(0, hs);
4771 }
4772
4773 // comparator for ascending sort by x-coord first, y-coord second
4774 function d3_geom_hullOrder(a, b) {
4775   return a[0] - b[0] || a[1] - b[1];
4776 }
4777 // import "../transition/transition";
4778
4779 d3_selectionPrototype.transition = function(name) {
4780   var id = d3_transitionInheritId || ++d3_transitionId,
4781       ns = d3_transitionNamespace(name),
4782       subgroups = [],
4783       subgroup,
4784       node,
4785       transition = d3_transitionInherit || {time: Date.now(), ease: d3_ease_cubicInOut, delay: 0, duration: 250};
4786
4787   for (var j = -1, m = this.length; ++j < m;) {
4788     subgroups.push(subgroup = []);
4789     for (var group = this[j], i = -1, n = group.length; ++i < n;) {
4790       if (node = group[i]) d3_transitionNode(node, i, ns, id, transition);
4791       subgroup.push(node);
4792     }
4793   }
4794
4795   return d3_transition(subgroups, ns, id);
4796 };
4797 // import "../transition/transition";
4798
4799 // TODO Interrupt transitions for all namespaces?
4800 d3_selectionPrototype.interrupt = function(name) {
4801   return this.each(name == null
4802       ? d3_selection_interrupt
4803       : d3_selection_interruptNS(d3_transitionNamespace(name)));
4804 };
4805
4806 var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace());
4807
4808 function d3_selection_interruptNS(ns) {
4809   return function() {
4810     var lock, active;
4811     if ((lock = this[ns]) && (active = lock[lock.active])) {
4812       if (--lock.count) delete lock[lock.active];
4813       else delete