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