d3_rails 0.0.8 → 0.0.9

data/lib/d3_rails/version.rb

@@ -1,3 +1,3 @@
 module D3Rails
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/vendor/assets/javascripts/d3.js

@@ -1,26 +1,22 @@
-(function(){if (!Date.now) Date.now = function() {
-  return +new Date;
+(function(){d3 = {version: "1.11.0"}; // semver
+if (!Date.now) Date.now = function() {
+  return +new Date();
+};
+if (!Object.create) Object.create = function(o) {
+  /** @constructor */ function f() {}
+  f.prototype = o;
+  return new f();
 };
-try {
-  document.createElement("div").style.setProperty("opacity", 0, "");
-} catch (error) {
-  var d3_style_prototype = CSSStyleDeclaration.prototype,
-      d3_style_setProperty = d3_style_prototype.setProperty;
-  d3_style_prototype.setProperty = function(name, value, priority) {
-    d3_style_setProperty.call(this, name, value + "", priority);
-  };
-}
-d3 = {version: "2.4.4"}; // semver
 var d3_array = d3_arraySlice; // conversion for NodeLists
 
-function d3_arrayCopy(pseudoarray) {
-  var i = -1, n = pseudoarray.length, array = [];
-  while (++i < n) array.push(pseudoarray[i]);
+function d3_arrayCopy(psuedoarray) {
+  var i = -1, n = psuedoarray.length, array = [];
+  while (++i < n) array.push(psuedoarray[i]);
   return array;
 }
 
-function d3_arraySlice(pseudoarray) {
-  return Array.prototype.slice.call(pseudoarray);
+function d3_arraySlice(psuedoarray) {
+  return Array.prototype.slice.call(psuedoarray);
 }
 
 try {
@@ -28,23 +24,8 @@ try {
 } catch(e) {
   d3_array = d3_arrayCopy;
 }
-
-var d3_arraySubclass = [].__proto__?
-
-// Until ECMAScript supports array subclassing, prototype injection works well.
-function(array, prototype) {
-  array.__proto__ = prototype;
-}:
-
-// And if your browser doesn't support __proto__, we'll use direct extension.
-function(array, prototype) {
-  for (var property in prototype) array[property] = prototype[property];
-};
-function d3_this() {
-  return this;
-}
 d3.functor = function(v) {
-  return typeof v === "function" ? v : function() { return v; };
+  return typeof v == "function" ? v : function() { return v; };
 };
 // A getter-setter method that preserves the appropriate `this` context.
 d3.rebind = function(object, method) {
@@ -54,156 +35,34 @@ d3.rebind = function(object, method) {
   };
 };
 d3.ascending = function(a, b) {
-  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+  return a < b ? -1 : a > b ? 1 : 0;
 };
 d3.descending = function(a, b) {
-  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
-};
-d3.mean = function(array, f) {
-  var n = array.length,
-      a,
-      m = 0,
-      i = -1,
-      j = 0;
-  if (arguments.length === 1) {
-    while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;
-  } else {
-    while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;
-  }
-  return j ? m : undefined;
-};
-d3.median = function(array, f) {
-  if (arguments.length > 1) array = array.map(f);
-  array = array.filter(d3_number);
-  return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;
+  return b < a ? -1 : b > a ? 1 : 0;
 };
 d3.min = function(array, f) {
-  var i = -1,
-      n = array.length,
-      a,
-      b;
-  if (arguments.length === 1) {
-    while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;
-    while (++i < n) if ((b = array[i]) != null && a > b) a = b;
-  } else {
-    while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;
-    while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
-  }
-  return a;
-};
-d3.max = function(array, f) {
-  var i = -1,
-      n = array.length,
-      a,
-      b;
-  if (arguments.length === 1) {
-    while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;
-    while (++i < n) if ((b = array[i]) != null && b > a) a = b;
-  } else {
-    while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;
-    while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
-  }
-  return a;
-};
-function d3_number(x) {
-  return x != null && !isNaN(x);
-}
-d3.sum = function(array, f) {
-  var s = 0,
-      n = array.length,
-      a,
-      i = -1;
-
-  if (arguments.length === 1) {
-    while (++i < n) if (!isNaN(a = +array[i])) s += a;
-  } else {
-    while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;
-  }
-
-  return s;
-};
-// R-7 per <http://en.wikipedia.org/wiki/Quantile>
-d3.quantile = function(values, p) {
-  var H = (values.length - 1) * p + 1,
-      h = Math.floor(H),
-      v = values[h - 1],
-      e = H - h;
-  return e ? v + e * (values[h] - v) : v;
-};
-d3.zip = function() {
-  if (!(n = arguments.length)) return [];
-  for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) {
-    for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) {
-      zip[j] = arguments[j][i];
-    }
-  }
-  return zips;
-};
-
-function d3_zipLength(d) {
-  return d.length;
-}
-// Locate the insertion point for x in a to maintain sorted order. The
-// arguments lo and hi may be used to specify a subset of the array which should
-// be considered; by default the entire array is used. If x is already present
-// in a, the insertion point will be before (to the left of) any existing
-// entries. The return value is suitable for use as the first argument to
-// `array.splice` assuming that a is already sorted.
-//
-// The returned insertion point i partitions the array a into two halves so that
-// all v < x for v in a[lo:i] for the left side and all v >= x for v in a[i:hi]
-// for the right side.
-d3.bisectLeft = function(a, x, lo, hi) {
-  if (arguments.length < 3) lo = 0;
-  if (arguments.length < 4) hi = a.length;
-  while (lo < hi) {
-    var mid = (lo + hi) >> 1;
-    if (a[mid] < x) lo = mid + 1;
-    else hi = mid;
-  }
-  return lo;
-};
-
-// Similar to bisectLeft, but returns an insertion point which comes after (to
-// the right of) any existing entries of x in a.
-//
-// The returned insertion point i partitions the array into two halves so that
-// all v <= x for v in a[lo:i] for the left side and all v > x for v in a[i:hi]
-// for the right side.
-d3.bisect =
-d3.bisectRight = function(a, x, lo, hi) {
-  if (arguments.length < 3) lo = 0;
-  if (arguments.length < 4) hi = a.length;
-  while (lo < hi) {
-    var mid = (lo + hi) >> 1;
-    if (x < a[mid]) hi = mid;
-    else lo = mid + 1;
-  }
-  return lo;
-};
-d3.first = function(array, f) {
   var i = 0,
       n = array.length,
       a = array[0],
       b;
-  if (arguments.length === 1) f = d3.ascending;
-  while (++i < n) {
-    if (f.call(array, a, b = array[i]) > 0) {
-      a = b;
-    }
+  if (arguments.length == 1) {
+    while (++i < n) if (a > (b = array[i])) a = b;
+  } else {
+    a = f(array[0]);
+    while (++i < n) if (a > (b = f(array[i]))) a = b;
   }
   return a;
 };
-d3.last = function(array, f) {
+d3.max = function(array, f) {
   var i = 0,
       n = array.length,
       a = array[0],
       b;
-  if (arguments.length === 1) f = d3.ascending;
-  while (++i < n) {
-    if (f.call(array, a, b = array[i]) <= 0) {
-      a = b;
-    }
+  if (arguments.length == 1) {
+    while (++i < n) if (a < (b = array[i])) a = b;
+  } else {
+    a = f(a);
+    while (++i < n) if (a < (b = f(array[i]))) a = b;
   }
   return a;
 };
@@ -309,13 +168,6 @@ d3.entries = function(map) {
   for (var key in map) entries.push({key: key, value: map[key]});
   return entries;
 };
-d3.permute = function(array, indexes) {
-  var permutes = [],
-      i = -1,
-      n = indexes.length;
-  while (++i < n) permutes[i] = array[indexes[i]];
-  return permutes;
-};
 d3.merge = function(arrays) {
   return Array.prototype.concat.apply([], arrays);
 };
@@ -343,19 +195,27 @@ function d3_splitter(d) {
 function d3_collapse(s) {
   return s.replace(/(^\s+)|(\s+$)/g, "").replace(/\s+/g, " ");
 }
+//
+// Note: assigning to the arguments array simultaneously changes the value of
+// the corresponding argument!
+//
+// TODO The `this` argument probably shouldn't be the first argument to the
+// callback, anyway, since it's redundant. However, that will require a major
+// version bump due to backwards compatibility, so I'm not changing it right
+// away.
+//
+function d3_call(callback) {
+  callback.apply(this, (arguments[0] = this, arguments));
+  return this;
+}
 /**
  * @param {number} start
  * @param {number=} stop
  * @param {number=} step
  */
 d3.range = function(start, stop, step) {
-  if (arguments.length < 3) {
-    step = 1;
-    if (arguments.length < 2) {
-      stop = start;
-      start = 0;
-    }
-  }
+  if (arguments.length == 1) { stop = start; start = 0; }
+  if (step == null) step = 1;
   if ((stop - start) / step == Infinity) throw new Error("infinite range");
   var range = [],
        i = -1,
@@ -368,19 +228,14 @@ d3.requote = function(s) {
   return s.replace(d3_requote_re, "\\$&");
 };
 
-var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
-d3.round = function(x, n) {
-  return n
-      ? Math.round(x * Math.pow(10, n)) * Math.pow(10, -n)
-      : Math.round(x);
-};
+var d3_requote_re = /[\\\^\$\*\+\?\[\]\(\)\.\{\}]/g;
 d3.xhr = function(url, mime, callback) {
-  var req = new XMLHttpRequest;
+  var req = new XMLHttpRequest();
   if (arguments.length < 3) callback = mime;
   else if (mime && req.overrideMimeType) req.overrideMimeType(mime);
   req.open("GET", url, true);
   req.onreadystatechange = function() {
-    if (req.readyState === 4) callback(req.status < 300 ? req : null);
+    if (req.readyState == 4) callback(req.status < 300 ? req : null);
   };
   req.send(null);
 };
@@ -483,7 +338,7 @@ function d3_dispatch(type) {
 
   return dispatch;
 };
-// TODO align
+// TODO align, type
 d3.format = function(specifier) {
   var match = d3_format_re.exec(specifier),
       fill = match[1] || " ",
@@ -492,50 +347,23 @@ d3.format = function(specifier) {
       width = +match[6],
       comma = match[7],
       precision = match[8],
-      type = match[9],
-      scale = 1,
-      suffix = "",
-      integer = false;
-
-  if (precision) precision = +precision.substring(1);
-
+      type = match[9];
+  if (precision) precision = precision.substring(1);
   if (zfill) {
     fill = "0"; // TODO align = "=";
     if (comma) width -= Math.floor((width - 1) / 4);
   }
-
-  switch (type) {
-    case "n": comma = true; type = "g"; break;
-    case "%": scale = 100; suffix = "%"; type = "f"; break;
-    case "p": scale = 100; suffix = "%"; type = "r"; break;
-    case "d": integer = true; precision = 0; break;
-    case "s": scale = -1; type = "r"; break;
-  }
-
-  // If no precision is specified for r, fallback to general notation.
-  if (type == "r" && !precision) type = "g";
-
-  type = d3_format_types[type] || d3_format_typeDefault;
-
+  if (type == "d") precision = "0";
   return function(value) {
+    var number = +value,
+        negative = (number < 0) && (number = -number) ? "\u2212" : sign;
 
     // Return the empty string for floats formatted as ints.
-    if (integer && (value % 1)) return "";
-
-    // Convert negative to positive, and record the sign prefix.
-    var negative = (value < 0) && (value = -value) ? "\u2212" : sign;
-
-    // Apply the scale, computing it from the value's exponent for si format.
-    if (scale < 0) {
-      var prefix = d3.formatPrefix(value, precision);
-      value *= prefix.scale;
-      suffix = prefix.symbol;
-    } else {
-      value *= scale;
-    }
+    if ((type == "d") && (number % 1)) return "";
 
-    // Convert to the desired precision.
-    value = type(value, precision);
+    // Convert the input value to the desired precision.
+    if (precision) value = number.toFixed(precision);
+    else value = "" + number;
 
     // If the fill character is 0, the sign and group is applied after the fill.
     if (zfill) {
@@ -553,28 +381,13 @@ d3.format = function(specifier) {
       if (length < width) value = new Array(width - length + 1).join(fill) + value;
     }
 
-    return value + suffix;
+    return value;
   };
 };
 
 // [[fill]align][sign][#][0][width][,][.precision][type]
 var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/;
 
-var d3_format_types = {
-  g: function(x, p) { return x.toPrecision(p); },
-  e: function(x, p) { return x.toExponential(p); },
-  f: function(x, p) { return x.toFixed(p); },
-  r: function(x, p) { return d3.round(x, p = d3_format_precision(x, p)).toFixed(Math.max(0, Math.min(20, p))); }
-};
-
-function d3_format_precision(x, p) {
-  return p - (x ? 1 + Math.floor(Math.log(x + Math.pow(10, 1 + Math.floor(Math.log(x) / Math.LN10) - p)) / Math.LN10) : 1);
-}
-
-function d3_format_typeDefault(x) {
-  return x + "";
-}
-
 // Apply comma grouping for thousands.
 function d3_format_group(value) {
   var i = value.lastIndexOf("."),
@@ -583,26 +396,6 @@ function d3_format_group(value) {
   while (i > 0) t.push(value.substring(i -= 3, i + 3));
   return t.reverse().join(",") + f;
 }
-var d3_formatPrefixes = ["y","z","a","f","p","n","μ","m","","k","M","G","T","P","E","Z","Y"].map(d3_formatPrefix);
-
-d3.formatPrefix = function(value, precision) {
-  var i = 0;
-  if (value) {
-    if (value < 0) value *= -1;
-    if (precision) value = d3.round(value, d3_format_precision(value, precision));
-    i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
-    i = Math.max(-24, Math.min(24, Math.floor((i <= 0 ? i + 1 : i - 1) / 3) * 3));
-  }
-  return d3_formatPrefixes[8 + i / 3];
-};
-
-function d3_formatPrefix(d, i) {
-  return {
-    scale: Math.pow(10, (8 - i) * 3),
-    symbol: d
-  };
-}
-
 /*
  * TERMS OF USE - EASING EQUATIONS
  *
@@ -665,15 +458,9 @@ d3.ease = function(name) {
   var i = name.indexOf("-"),
       t = i >= 0 ? name.substring(0, i) : name,
       m = i >= 0 ? name.substring(i + 1) : "in";
-  return d3_ease_clamp(d3_ease_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1))));
+  return d3_ease_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1)));
 };
 
-function d3_ease_clamp(f) {
-  return function(t) {
-    return t <= 0 ? 0 : t >= 1 ? 1 : f(t);
-  };
-}
-
 function d3_ease_reverse(f) {
   return function(t) {
     return 1 - f(1 - t);
@@ -701,7 +488,7 @@ function d3_ease_sin(t) {
 }
 
 function d3_ease_exp(t) {
-  return Math.pow(2, 10 * (t - 1));
+  return t ? Math.pow(2, 10 * (t - 1)) - 1e-3 : 0;
 }
 
 function d3_ease_circle(t) {
@@ -733,9 +520,14 @@ function d3_ease_bounce(t) {
 }
 d3.event = null;
 d3.interpolate = function(a, b) {
-  var i = d3.interpolators.length, f;
-  while (--i >= 0 && !(f = d3.interpolators[i](a, b)));
-  return f;
+  if (typeof b == "number") return d3.interpolateNumber(+a, b);
+  if (typeof b == "string") {
+    return (b in d3_rgb_names) || /^(#|rgb\(|hsl\()/.test(b)
+        ? d3.interpolateRgb(String(a), b)
+        : d3.interpolateString(String(a), b);
+  }
+  if (b instanceof Array) return d3.interpolateArray(a, b);
+  return d3.interpolateObject(a, b);
 };
 
 d3.interpolateNumber = function(a, b) {
@@ -815,7 +607,7 @@ d3.interpolateString = function(a, b) {
   }
 
   // Special optimization for only a single match.
-  if (s.length === 1) {
+  if (s.length == 1) {
     return s[0] == null ? q[0].x : function() { return b; };
   }
 
@@ -836,10 +628,10 @@ d3.interpolateRgb = function(a, b) {
       bg = b.g - ag,
       bb = b.b - ab;
   return function(t) {
-    return "#"
-        + d3_rgb_hex(Math.round(ar + br * t))
-        + d3_rgb_hex(Math.round(ag + bg * t))
-        + d3_rgb_hex(Math.round(ab + bb * t));
+    return "rgb(" + Math.round(ar + br * t)
+        + "," + Math.round(ag + bg * t)
+        + "," + Math.round(ab + bb * t)
+        + ")";
   };
 };
 
@@ -904,76 +696,27 @@ function d3_interpolateByName(n) {
       ? d3.interpolateRgb
       : d3.interpolate;
 }
-
-d3.interpolators = [
-  d3.interpolateObject,
-  function(a, b) { return (b instanceof Array) && d3.interpolateArray(a, b); },
-  function(a, b) { return (typeof b === "string") && d3.interpolateString(String(a), b); },
-  function(a, b) { return (typeof b === "string" ? b in d3_rgb_names || /^(#|rgb\(|hsl\()/.test(b) : b instanceof d3_Rgb || b instanceof d3_Hsl) && d3.interpolateRgb(String(a), b); },
-  function(a, b) { return (typeof b === "number") && d3.interpolateNumber(+a, b); }
-];
-function d3_uninterpolateNumber(a, b) {
-  b = b - (a = +a) ? 1 / (b - a) : 0;
-  return function(x) { return (x - a) * b; };
-}
-
-function d3_uninterpolateClamp(a, b) {
-  b = b - (a = +a) ? 1 / (b - a) : 0;
-  return function(x) { return Math.max(0, Math.min(1, (x - a) * b)); };
-}
+/**
+ * @param {number=} g
+ * @param {number=} b
+ */
 d3.rgb = function(r, g, b) {
-  return arguments.length === 1
-      ? (r instanceof d3_Rgb ? d3_rgb(r.r, r.g, r.b)
-      : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb))
+  return arguments.length == 1
+      ? d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb)
       : d3_rgb(~~r, ~~g, ~~b);
 };
 
 function d3_rgb(r, g, b) {
-  return new d3_Rgb(r, g, b);
-}
-
-function d3_Rgb(r, g, b) {
-  this.r = r;
-  this.g = g;
-  this.b = b;
+  return {r: r, g: g, b: b, toString: d3_rgb_format};
 }
 
-d3_Rgb.prototype.brighter = function(k) {
-  k = Math.pow(0.7, arguments.length ? k : 1);
-  var r = this.r,
-      g = this.g,
-      b = this.b,
-      i = 30;
-  if (!r && !g && !b) return d3_rgb(i, i, i);
-  if (r && r < i) r = i;
-  if (g && g < i) g = i;
-  if (b && b < i) b = i;
-  return d3_rgb(
-      Math.min(255, Math.floor(r / k)),
-      Math.min(255, Math.floor(g / k)),
-      Math.min(255, Math.floor(b / k)));
-};
-
-d3_Rgb.prototype.darker = function(k) {
-  k = Math.pow(0.7, arguments.length ? k : 1);
-  return d3_rgb(
-      Math.floor(k * this.r),
-      Math.floor(k * this.g),
-      Math.floor(k * this.b));
-};
-
-d3_Rgb.prototype.hsl = function() {
-  return d3_rgb_hsl(this.r, this.g, this.b);
-};
-
-d3_Rgb.prototype.toString = function() {
+/** @this d3_rgb */
+function d3_rgb_format() {
   return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
-};
+}
 
 function d3_rgb_hex(v) {
-  return v < 0x10
-      ? "0" + Math.max(0, v).toString(16)
-      : Math.min(255, v).toString(16);
+  return v < 0x10 ? "0" + v.toString(16) : v.toString(16);
 }
 
 function d3_rgb_parse(format, rgb, hsl) {
@@ -1010,12 +753,12 @@ function d3_rgb_parse(format, rgb, hsl) {
   if (name = d3_rgb_names[format]) return rgb(name.r, name.g, name.b);
 
   /* Hexadecimal colors: #rgb and #rrggbb. */
-  if (format != null && format.charAt(0) === "#") {
-    if (format.length === 4) {
+  if (format != null && format.charAt(0) == "#") {
+    if (format.length == 4) {
       r = format.charAt(1); r += r;
       g = format.charAt(2); g += g;
       b = format.charAt(3); b += b;
-    } else if (format.length === 7) {
+    } else if (format.length == 7) {
       r = format.substring(1, 3);
       g = format.substring(3, 5);
       b = format.substring(5, 7);
@@ -1049,7 +792,7 @@ function d3_rgb_hsl(r, g, b) {
 
 function d3_rgb_parseNumber(c) { // either integer or percentage
   var f = parseFloat(c);
-  return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
+  return c.charAt(c.length - 1) == "%" ? Math.round(f * 2.55) : f;
 }
 
 var d3_rgb_names = {
@@ -1208,41 +951,25 @@ for (var d3_rgb_name in d3_rgb_names) {
       d3_rgb,
       d3_hsl_rgb);
 }
+/**
+ * @param {number=} s
+ * @param {number=} l
+ */
 d3.hsl = function(h, s, l) {
-  return arguments.length === 1
-      ? (h instanceof d3_Hsl ? d3_hsl(h.h, h.s, h.l)
-      : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl))
+  return arguments.length == 1
+      ? d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl)
       : d3_hsl(+h, +s, +l);
 };
 
 function d3_hsl(h, s, l) {
-  return new d3_Hsl(h, s, l);
+  return {h: h, s: s, l: l, toString: d3_hsl_format};
 }
 
-function d3_Hsl(h, s, l) {
-  this.h = h;
-  this.s = s;
-  this.l = l;
+/** @this d3_hsl */
+function d3_hsl_format() {
+  return "hsl(" + this.h + "," + this.s * 100 + "%," + this.l * 100 + "%)";
 }
 
-d3_Hsl.prototype.brighter = function(k) {
-  k = Math.pow(0.7, arguments.length ? k : 1);
-  return d3_hsl(this.h, this.s, this.l / k);
-};
-
-d3_Hsl.prototype.darker = function(k) {
-  k = Math.pow(0.7, arguments.length ? k : 1);
-  return d3_hsl(this.h, this.s, k * this.l);
-};
-
-d3_Hsl.prototype.rgb = function() {
-  return d3_hsl_rgb(this.h, this.s, this.l);
-};
-
-d3_Hsl.prototype.toString = function() {
-  return this.rgb().toString();
-};
-
 function d3_hsl_rgb(h, s, l) {
   var m1,
       m2;
@@ -1271,844 +998,898 @@ function d3_hsl_rgb(h, s, l) {
 
   return d3_rgb(vv(h + 120), vv(h), vv(h - 120));
 }
-function d3_selection(groups) {
-  d3_arraySubclass(groups, d3_selectionPrototype);
-  return groups;
-}
-
 var d3_select = function(s, n) { return n.querySelector(s); },
-    d3_selectAll = function(s, n) { return n.querySelectorAll(s); };
+    d3_selectAll = function(s, n) { return d3_array(n.querySelectorAll(s)); };
 
-// Prefer Sizzle, if available.
-if (typeof Sizzle === "function") {
+// Use Sizzle, if available.
+if (typeof Sizzle == "function") {
   d3_select = function(s, n) { return Sizzle(s, n)[0]; };
   d3_selectAll = function(s, n) { return Sizzle.uniqueSort(Sizzle(s, n)); };
 }
 
-var d3_selectionPrototype = [];
+var d3_root = d3_selection([[document]]);
+d3_root[0].parentNode = document.documentElement;
+
+// TODO fast singleton implementation!
+d3.select = function(selector) {
+  return typeof selector == "string"
+      ? d3_root.select(selector)
+      : d3_selection([[selector]]); // assume node
+};
 
-d3.selection = function() {
-  return d3_selectionRoot;
+d3.selectAll = function(selector) {
+  return typeof selector == "string"
+      ? d3_root.selectAll(selector)
+      : d3_selection([d3_array(selector)]); // assume node[]
 };
 
-d3.selection.prototype = d3_selectionPrototype;
-d3_selectionPrototype.select = function(selector) {
-  var subgroups = [],
-      subgroup,
-      subnode,
-      group,
-      node;
-
-  if (typeof selector !== "function") selector = d3_selection_selector(selector);
-
-  for (var j = -1, m = this.length; ++j < m;) {
-    subgroups.push(subgroup = []);
-    subgroup.parentNode = (group = this[j]).parentNode;
-    for (var i = -1, n = group.length; ++i < n;) {
-      if (node = group[i]) {
-        subgroup.push(subnode = selector.call(node, node.__data__, i));
-        if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
-      } else {
-        subgroup.push(null);
+function d3_selection(groups) {
+
+  function select(select) {
+    var subgroups = [],
+        subgroup,
+        subnode,
+        group,
+        node;
+    for (var j = 0, m = groups.length; j < m; j++) {
+      group = groups[j];
+      subgroups.push(subgroup = []);
+      subgroup.parentNode = group.parentNode;
+      for (var i = 0, n = group.length; i < n; i++) {
+        if (node = group[i]) {
+          subgroup.push(subnode = select(node));
+          if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
+        } else {
+          subgroup.push(null);
+        }
+      }
+    }
+    return d3_selection(subgroups);
+  }
+
+  function selectAll(selectAll) {
+    var subgroups = [],
+        subgroup,
+        group,
+        node;
+    for (var j = 0, m = groups.length; j < m; j++) {
+      group = groups[j];
+      for (var i = 0, n = group.length; i < n; i++) {
+        if (node = group[i]) {
+          subgroups.push(subgroup = selectAll(node));
+          subgroup.parentNode = node;
+        }
       }
     }
+    return d3_selection(subgroups);
   }
 
-  return d3_selection(subgroups);
-};
+  // TODO select(function)?
+  groups.select = function(selector) {
+    return select(function(node) {
+      return d3_select(selector, node);
+    });
+  };
 
-function d3_selection_selector(selector) {
-  return function() {
-    return d3_select(selector, this);
+  // TODO selectAll(function)?
+  groups.selectAll = function(selector) {
+    return selectAll(function(node) {
+      return d3_selectAll(selector, node);
+    });
   };
-}
-d3_selectionPrototype.selectAll = function(selector) {
-  var subgroups = [],
-      subgroup,
-      node;
-
-  if (typeof selector !== "function") selector = d3_selection_selectorAll(selector);
-
-  for (var j = -1, m = this.length; ++j < m;) {
-    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
-      if (node = group[i]) {
-        subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i)));
-        subgroup.parentNode = node;
+
+  // TODO preserve null elements to maintain index?
+  groups.filter = function(filter) {
+    var subgroups = [],
+        subgroup,
+        group,
+        node;
+    for (var j = 0, m = groups.length; j < m; j++) {
+      group = groups[j];
+      subgroups.push(subgroup = []);
+      subgroup.parentNode = group.parentNode;
+      for (var i = 0, n = group.length; i < n; i++) {
+        if ((node = group[i]) && filter.call(node, node.__data__, i)) {
+          subgroup.push(node);
+        }
       }
     }
-  }
-
-  return d3_selection(subgroups);
-};
+    return d3_selection(subgroups);
+  };
 
-function d3_selection_selectorAll(selector) {
-  return function() {
-    return d3_selectAll(selector, this);
+  groups.map = function(map) {
+    var group,
+        node;
+    for (var j = 0, m = groups.length; j < m; j++) {
+      group = groups[j];
+      for (var i = 0, n = group.length; i < n; i++) {
+        if (node = group[i]) node.__data__ = map.call(node, node.__data__, i);
+      }
+    }
+    return groups;
   };
-}
-d3_selectionPrototype.attr = function(name, value) {
-  name = d3.ns.qualify(name);
-
-  // If no value is specified, return the first value.
-  if (arguments.length < 2) {
-    var node = this.node();
-    return name.local
-        ? node.getAttributeNS(name.space, name.local)
-        : node.getAttribute(name);
-  }
 
-  function attrNull() {
-    this.removeAttribute(name);
-  }
+  // TODO data(null) for clearing data?
+  groups.data = function(data, join) {
+    var enter = [],
+        update = [],
+        exit = [];
+
+    function bind(group, groupData) {
+      var i = 0,
+          n = group.length,
+          m = groupData.length,
+          n0 = Math.min(n, m),
+          n1 = Math.max(n, m),
+          updateNodes = [],
+          enterNodes = [],
+          exitNodes = [],
+          node,
+          nodeData;
+
+      if (join) {
+        var nodeByKey = {},
+            keys = [],
+            key,
+            j = groupData.length;
+
+        for (i = 0; i < n; i++) {
+          key = join.call(node = group[i], node.__data__, i);
+          if (key in nodeByKey) {
+            exitNodes[j++] = group[i]; // duplicate key
+          } else {
+            nodeByKey[key] = node;
+          }
+          keys.push(key);
+        }
 
-  function attrNullNS() {
-    this.removeAttributeNS(name.space, name.local);
-  }
+        for (i = 0; i < m; i++) {
+          node = nodeByKey[key = join.call(groupData, nodeData = groupData[i], i)];
+          if (node) {
+            node.__data__ = nodeData;
+            updateNodes[i] = node;
+            enterNodes[i] = exitNodes[i] = null;
+          } else {
+            enterNodes[i] = d3_selection_enterNode(nodeData);
+            updateNodes[i] = exitNodes[i] = null;
+          }
+          delete nodeByKey[key];
+        }
 
-  function attrConstant() {
-    this.setAttribute(name, value);
-  }
+        for (i = 0; i < n; i++) {
+          if (keys[i] in nodeByKey) {
+            exitNodes[i] = group[i];
+          }
+        }
+      } else {
+        for (; i < n0; i++) {
+          node = group[i];
+          nodeData = groupData[i];
+          if (node) {
+            node.__data__ = nodeData;
+            updateNodes[i] = node;
+            enterNodes[i] = exitNodes[i] = null;
+          } else {
+            enterNodes[i] = d3_selection_enterNode(nodeData);
+            updateNodes[i] = exitNodes[i] = null;
+          }
+        }
+        for (; i < m; i++) {
+          enterNodes[i] = d3_selection_enterNode(groupData[i]);
+          updateNodes[i] = exitNodes[i] = null;
+        }
+        for (; i < n1; i++) {
+          exitNodes[i] = group[i];
+          enterNodes[i] = updateNodes[i] = null;
+        }
+      }
 
-  function attrConstantNS() {
-    this.setAttributeNS(name.space, name.local, value);
-  }
+      enterNodes.parentNode
+          = updateNodes.parentNode
+          = exitNodes.parentNode
+          = group.parentNode;
 
-  function attrFunction() {
-    var x = value.apply(this, arguments);
-    if (x == null) this.removeAttribute(name);
-    else this.setAttribute(name, x);
-  }
+      enter.push(enterNodes);
+      update.push(updateNodes);
+      exit.push(exitNodes);
+    }
 
-  function attrFunctionNS() {
-    var x = value.apply(this, arguments);
-    if (x == null) this.removeAttributeNS(name.space, name.local);
-    else this.setAttributeNS(name.space, name.local, x);
-  }
+    var i = -1,
+        n = groups.length,
+        group;
+    if (typeof data == "function") {
+      while (++i < n) {
+        bind(group = groups[i], data.call(group, group.parentNode.__data__, i));
+      }
+    } else {
+      while (++i < n) {
+        bind(group = groups[i], data);
+      }
+    }
 
-  return this.each(value == null
-      ? (name.local ? attrNullNS : attrNull) : (typeof value === "function"
-      ? (name.local ? attrFunctionNS : attrFunction)
-      : (name.local ? attrConstantNS : attrConstant)));
-};
-d3_selectionPrototype.classed = function(name, value) {
-  var names = name.split(d3_selection_classedWhitespace),
-      n = names.length,
-      i = -1;
-  if (arguments.length > 1) {
-    while (++i < n) d3_selection_classed.call(this, names[i], value);
-    return this;
-  } else {
-    while (++i < n) if (!d3_selection_classed.call(this, names[i])) return false;
-    return true;
+    var selection = d3_selection(update);
+    selection.enter = function() {
+      return d3_selectionEnter(enter);
+    };
+    selection.exit = function() {
+      return d3_selection(exit);
+    };
+    return selection;
+  };
+
+  // TODO mask forEach? or rename for eachData?
+  // TODO offer the same semantics for map, reduce, etc.?
+  groups.each = function(callback) {
+    for (var j = 0, m = groups.length; j < m; j++) {
+      var group = groups[j];
+      for (var i = 0, n = group.length; i < n; i++) {
+        var node = group[i];
+        if (node) callback.call(node, node.__data__, i);
+      }
+    }
+    return groups;
+  };
+
+  function first(callback) {
+    for (var j = 0, m = groups.length; j < m; j++) {
+      var group = groups[j];
+      for (var i = 0, n = group.length; i < n; i++) {
+        var node = group[i];
+        if (node) return callback.call(node, node.__data__, i);
+      }
+    }
+    return null;
   }
-};
 
-var d3_selection_classedWhitespace = /\s+/g;
+  groups.empty = function() {
+    return !first(function() { return true; });
+  };
 
-function d3_selection_classed(name, value) {
-  var re = new RegExp("(^|\\s+)" + d3.requote(name) + "(\\s+|$)", "g");
+  groups.node = function() {
+    return first(function() { return this; });
+  };
 
-  // If no value is specified, return the first value.
-  if (arguments.length < 2) {
-    var node = this.node();
-    if (c = node.classList) return c.contains(name);
-    var c = node.className;
-    re.lastIndex = 0;
-    return re.test(c.baseVal != null ? c.baseVal : c);
-  }
+  groups.attr = function(name, value) {
+    name = d3.ns.qualify(name);
 
-  function classedAdd() {
-    if (c = this.classList) return c.add(name);
-    var c = this.className,
-        cb = c.baseVal != null,
-        cv = cb ? c.baseVal : c;
-    re.lastIndex = 0;
-    if (!re.test(cv)) {
-      cv = d3_collapse(cv + " " + name);
-      if (cb) c.baseVal = cv;
-      else this.className = cv;
+    // If no value is specified, return the first value.
+    if (arguments.length < 2) {
+      return first(name.local
+          ? function() { return this.getAttributeNS(name.space, name.local); }
+          : function() { return this.getAttribute(name); });
     }
-  }
 
-  function classedRemove() {
-    if (c = this.classList) return c.remove(name);
-    var c = this.className,
-        cb = c.baseVal != null,
-        cv = cb ? c.baseVal : c;
-    cv = d3_collapse(cv.replace(re, " "));
-    if (cb) c.baseVal = cv;
-    else this.className = cv;
-  }
+    /** @this {Element} */
+    function attrNull() {
+      this.removeAttribute(name);
+    }
 
-  function classedFunction() {
-    (value.apply(this, arguments)
-        ? classedAdd
-        : classedRemove).call(this);
-  }
+    /** @this {Element} */
+    function attrNullNS() {
+      this.removeAttributeNS(name.space, name.local);
+    }
 
-  return this.each(typeof value === "function"
-      ? classedFunction : value
-      ? classedAdd
-      : classedRemove);
-}
-d3_selectionPrototype.style = function(name, value, priority) {
-  if (arguments.length < 3) priority = "";
+    /** @this {Element} */
+    function attrConstant() {
+      this.setAttribute(name, value);
+    }
 
-  // If no value is specified, return the first value.
-  if (arguments.length < 2) return window
-      .getComputedStyle(this.node(), null)
-      .getPropertyValue(name);
+    /** @this {Element} */
+    function attrConstantNS() {
+      this.setAttributeNS(name.space, name.local, value);
+    }
 
-  function styleNull() {
-    this.style.removeProperty(name);
-  }
+    /** @this {Element} */
+    function attrFunction() {
+      var x = value.apply(this, arguments);
+      if (x == null) this.removeAttribute(name);
+      else this.setAttribute(name, x);
+    }
 
-  function styleConstant() {
-    this.style.setProperty(name, value, priority);
-  }
+    /** @this {Element} */
+    function attrFunctionNS() {
+      var x = value.apply(this, arguments);
+      if (x == null) this.removeAttributeNS(name.space, name.local);
+      else this.setAttributeNS(name.space, name.local, x);
+    }
 
-  function styleFunction() {
-    var x = value.apply(this, arguments);
-    if (x == null) this.style.removeProperty(name);
-    else this.style.setProperty(name, x, priority);
-  }
+    return groups.each(value == null
+        ? (name.local ? attrNullNS : attrNull) : (typeof value == "function"
+        ? (name.local ? attrFunctionNS : attrFunction)
+        : (name.local ? attrConstantNS : attrConstant)));
+  };
 
-  return this.each(value == null
-      ? styleNull : (typeof value === "function"
-      ? styleFunction : styleConstant));
-};
-d3_selectionPrototype.property = function(name, value) {
+  groups.classed = function(name, value) {
+    var re = new RegExp("(^|\\s+)" + d3.requote(name) + "(\\s+|$)", "g");
 
-  // If no value is specified, return the first value.
-  if (arguments.length < 2) return this.node()[name];
+    // If no value is specified, return the first value.
+    if (arguments.length < 2) {
+      return first(function() {
+        re.lastIndex = 0;
+        return re.test(this.className);
+      });
+    }
 
-  function propertyNull() {
-    delete this[name];
-  }
+    /** @this {Element} */
+    function classedAdd() {
+      var classes = this.className;
+      re.lastIndex = 0;
+      if (!re.test(classes)) {
+        this.className = d3_collapse(classes + " " + name);
+      }
+    }
 
-  function propertyConstant() {
-    this[name] = value;
-  }
+    /** @this {Element} */
+    function classedRemove() {
+      var classes = d3_collapse(this.className.replace(re, " "));
+      this.className = classes.length ? classes : null;
+    }
 
-  function propertyFunction() {
-    var x = value.apply(this, arguments);
-    if (x == null) delete this[name];
-    else this[name] = x;
-  }
+    /** @this {Element} */
+    function classedFunction() {
+      (value.apply(this, arguments)
+          ? classedAdd
+          : classedRemove).call(this);
+    }
 
-  return this.each(value == null
-      ? propertyNull : (typeof value === "function"
-      ? propertyFunction : propertyConstant));
-};
-d3_selectionPrototype.text = function(value) {
-  return arguments.length < 1 ? this.node().textContent
-      : (this.each(typeof value === "function"
-      ? function() { this.textContent = value.apply(this, arguments); }
-      : function() { this.textContent = value; }));
-};
-d3_selectionPrototype.html = function(value) {
-  return arguments.length < 1 ? this.node().innerHTML
-      : (this.each(typeof value === "function"
-      ? function() { this.innerHTML = value.apply(this, arguments); }
-      : function() { this.innerHTML = value; }));
-};
-// TODO append(node)?
-// TODO append(function)?
-d3_selectionPrototype.append = function(name) {
-  name = d3.ns.qualify(name);
+    return groups.each(typeof value == "function"
+        ? classedFunction : value
+        ? classedAdd
+        : classedRemove);
+  };
 
-  function append() {
-    return this.appendChild(document.createElement(name));
-  }
+  groups.style = function(name, value, priority) {
+    if (arguments.length < 3) priority = null;
 
-  function appendNS() {
-    return this.appendChild(document.createElementNS(name.space, name.local));
-  }
+    // If no value is specified, return the first value.
+    if (arguments.length < 2) {
+      return first(function() {
+        return window.getComputedStyle(this, null).getPropertyValue(name);
+      });
+    }
 
-  return this.select(name.local ? appendNS : append);
-};
-// TODO insert(node, function)?
-// TODO insert(function, string)?
-// TODO insert(function, function)?
-d3_selectionPrototype.insert = function(name, before) {
-  name = d3.ns.qualify(name);
-
-  function insert() {
-    return this.insertBefore(
-        document.createElement(name),
-        d3_select(before, this));
-  }
+    /** @this {Element} */
+    function styleNull() {
+      this.style.removeProperty(name);
+    }
 
-  function insertNS() {
-    return this.insertBefore(
-        document.createElementNS(name.space, name.local),
-        d3_select(before, this));
-  }
+    /** @this {Element} */
+    function styleConstant() {
+      this.style.setProperty(name, value, priority);
+    }
 
-  return this.select(name.local ? insertNS : insert);
-};
-// TODO remove(selector)?
-// TODO remove(node)?
-// TODO remove(function)?
-d3_selectionPrototype.remove = function() {
-  return this.each(function() {
-    var parent = this.parentNode;
-    if (parent) parent.removeChild(this);
-  });
-};
-// TODO data(null) for clearing data?
-d3_selectionPrototype.data = function(data, join) {
-  var enter = [],
-      update = [],
-      exit = [];
-
-  function bind(group, groupData) {
-    var i,
-        n = group.length,
-        m = groupData.length,
-        n0 = Math.min(n, m),
-        n1 = Math.max(n, m),
-        updateNodes = [],
-        enterNodes = [],
-        exitNodes = [],
-        node,
-        nodeData;
-
-    if (join) {
-      var nodeByKey = {},
-          keys = [],
-          key,
-          j = groupData.length;
-
-      for (i = -1; ++i < n;) {
-        key = join.call(node = group[i], node.__data__, i);
-        if (key in nodeByKey) {
-          exitNodes[j++] = node; // duplicate key
-        } else {
-          nodeByKey[key] = node;
-        }
-        keys.push(key);
-      }
+    /** @this {Element} */
+    function styleFunction() {
+      var x = value.apply(this, arguments);
+      if (x == null) this.style.removeProperty(name);
+      else this.style.setProperty(name, x, priority);
+    }
 
-      for (i = -1; ++i < m;) {
-        node = nodeByKey[key = join.call(groupData, nodeData = groupData[i], i)];
-        if (node) {
-          node.__data__ = nodeData;
-          updateNodes[i] = node;
-          enterNodes[i] = exitNodes[i] = null;
-        } else {
-          enterNodes[i] = d3_selection_dataNode(nodeData);
-          updateNodes[i] = exitNodes[i] = null;
-        }
-        delete nodeByKey[key];
-      }
-
-      for (i = -1; ++i < n;) {
-        if (keys[i] in nodeByKey) {
-          exitNodes[i] = group[i];
-        }
-      }
-    } else {
-      for (i = -1; ++i < n0;) {
-        node = group[i];
-        nodeData = groupData[i];
-        if (node) {
-          node.__data__ = nodeData;
-          updateNodes[i] = node;
-          enterNodes[i] = exitNodes[i] = null;
-        } else {
-          enterNodes[i] = d3_selection_dataNode(nodeData);
-          updateNodes[i] = exitNodes[i] = null;
-        }
-      }
-      for (; i < m; ++i) {
-        enterNodes[i] = d3_selection_dataNode(groupData[i]);
-        updateNodes[i] = exitNodes[i] = null;
-      }
-      for (; i < n1; ++i) {
-        exitNodes[i] = group[i];
-        enterNodes[i] = updateNodes[i] = null;
-      }
-    }
+    return groups.each(value == null
+        ? styleNull : (typeof value == "function"
+        ? styleFunction : styleConstant));
+  };
 
-    enterNodes.update
-        = updateNodes;
+  groups.property = function(name, value) {
+    name = d3.ns.qualify(name);
 
-    enterNodes.parentNode
-        = updateNodes.parentNode
-        = exitNodes.parentNode
-        = group.parentNode;
+    // If no value is specified, return the first value.
+    if (arguments.length < 2) {
+      return first(function() {
+        return this[name];
+      });
+    }
 
-    enter.push(enterNodes);
-    update.push(updateNodes);
-    exit.push(exitNodes);
-  }
+    /** @this {Element} */
+    function propertyNull() {
+      delete this[name];
+    }
 
-  var i = -1,
-      n = this.length,
-      group;
-  if (typeof data === "function") {
-    while (++i < n) {
-      bind(group = this[i], data.call(group, group.parentNode.__data__, i));
+    /** @this {Element} */
+    function propertyConstant() {
+      this[name] = value;
     }
-  } else {
-    while (++i < n) {
-      bind(group = this[i], data);
+
+    /** @this {Element} */
+    function propertyFunction() {
+      var x = value.apply(this, arguments);
+      if (x == null) delete this[name];
+      else this[name] = x;
     }
-  }
 
-  var selection = d3_selection(update);
-  selection.enter = function() { return d3_selection_enter(enter); };
-  selection.exit = function() { return d3_selection(exit); };
-  return selection;
-};
+    return groups.each(value == null
+        ? propertyNull : (typeof value == "function"
+        ? propertyFunction : propertyConstant));
+  };
 
-function d3_selection_dataNode(data) {
-  return {__data__: data};
-}
-function d3_selection_enter(selection) {
-  d3_arraySubclass(selection, d3_selection_enterPrototype);
-  return selection;
-}
+  groups.text = function(value) {
 
-var d3_selection_enterPrototype = [];
-
-d3_selection_enterPrototype.append = d3_selectionPrototype.append;
-d3_selection_enterPrototype.insert = d3_selectionPrototype.insert;
-d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
-d3_selection_enterPrototype.select = function(selector) {
-  var subgroups = [],
-      subgroup,
-      subnode,
-      upgroup,
-      group,
-      node;
-
-  for (var j = -1, m = this.length; ++j < m;) {
-    upgroup = (group = this[j]).update;
-    subgroups.push(subgroup = []);
-    subgroup.parentNode = group.parentNode;
-    for (var i = -1, n = group.length; ++i < n;) {
-      if (node = group[i]) {
-        subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i));
-        subnode.__data__ = node.__data__;
-      } else {
-        subgroup.push(null);
-      }
+    // If no value is specified, return the first value.
+    if (arguments.length < 1) {
+      return first(function() {
+        return this.textContent;
+      });
     }
-  }
 
-  return d3_selection(subgroups);
-};
-// TODO preserve null elements to maintain index?
-d3_selectionPrototype.filter = function(filter) {
-  var subgroups = [],
-      subgroup,
-      group,
-      node;
-
-  for (var j = 0, m = this.length; j < m; j++) {
-    subgroups.push(subgroup = []);
-    subgroup.parentNode = (group = this[j]).parentNode;
-    for (var i = 0, n = group.length; i < n; i++) {
-      if ((node = group[i]) && filter.call(node, node.__data__, i)) {
-        subgroup.push(node);
-      }
+    /** @this {Element} */
+    function textConstant() {
+      this.textContent = value;
     }
-  }
 
-  return d3_selection(subgroups);
-};
-d3_selectionPrototype.map = function(map) {
-  return this.each(function() {
-    this.__data__ = map.apply(this, arguments);
-  });
-};
-d3_selectionPrototype.sort = function(comparator) {
-  comparator = d3_selection_sortComparator.apply(this, arguments);
-  for (var j = 0, m = this.length; j < m; j++) {
-    for (var group = this[j].sort(comparator), i = 1, n = group.length, prev = group[0]; i < n; i++) {
-      var node = group[i];
-      if (node) {
-        if (prev) prev.parentNode.insertBefore(node, prev.nextSibling);
-        prev = node;
-      }
+    /** @this {Element} */
+    function textFunction() {
+      this.textContent = value.apply(this, arguments);
     }
-  }
-  return this;
-};
 
-function d3_selection_sortComparator(comparator) {
-  if (!arguments.length) comparator = d3.ascending;
-  return function(a, b) {
-    return comparator(a && a.__data__, b && b.__data__);
+    return groups.each(typeof value == "function"
+        ? textFunction : textConstant);
   };
-}
-// type can be namespaced, e.g., "click.foo"
-// listener can be null for removal
-d3_selectionPrototype.on = function(type, listener, capture) {
-  if (arguments.length < 3) capture = false;
-
-  // parse the type specifier
-  var name = "__on" + type, i = type.indexOf(".");
-  if (i > 0) type = type.substring(0, i);
-
-  // if called with only one argument, return the current listener
-  if (arguments.length < 2) return (i = this.node()[name]) && i._;
-
-  // remove the old event listener, and add the new event listener
-  return this.each(function(d, i) {
-    var node = this;
-
-    if (node[name]) node.removeEventListener(type, node[name], capture);
-    if (listener) node.addEventListener(type, node[name] = l, capture);
-
-    // wrapped event listener that preserves i
-    function l(e) {
-      var o = d3.event; // Events can be reentrant (e.g., focus).
-      d3.event = e;
-      try {
-        listener.call(node, node.__data__, i);
-      } finally {
-        d3.event = o;
-      }
-    }
 
-    // stash the unwrapped listener for retrieval
-    l._ = listener;
-  });
-};
-d3_selectionPrototype.each = function(callback) {
-  for (var j = -1, m = this.length; ++j < m;) {
-    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
-      var node = group[i];
-      if (node) callback.call(node, node.__data__, i, j);
+  groups.html = function(value) {
+
+    // If no value is specified, return the first value.
+    if (arguments.length < 1) {
+      return first(function() {
+        return this.innerHTML;
+      });
     }
-  }
-  return this;
-};
-//
-// Note: assigning to the arguments array simultaneously changes the value of
-// the corresponding argument!
-//
-// TODO The `this` argument probably shouldn't be the first argument to the
-// callback, anyway, since it's redundant. However, that will require a major
-// version bump due to backwards compatibility, so I'm not changing it right
-// away.
-//
-d3_selectionPrototype.call = function(callback) {
-  callback.apply(this, (arguments[0] = this, arguments));
-  return this;
-};
-d3_selectionPrototype.empty = function() {
-  return !this.node();
-};
-d3_selectionPrototype.node = function(callback) {
-  for (var j = 0, m = this.length; j < m; j++) {
-    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
-      var node = group[i];
-      if (node) return node;
+
+    /** @this {Element} */
+    function htmlConstant() {
+      this.innerHTML = value;
     }
-  }
-  return null;
-};
-d3_selectionPrototype.transition = function() {
-  var subgroups = [],
-      subgroup,
-      node;
-
-  for (var j = -1, m = this.length; ++j < m;) {
-    subgroups.push(subgroup = []);
-    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
-      subgroup.push((node = group[i]) ? {node: node, delay: 0, duration: 250} : null);
+
+    /** @this {Element} */
+    function htmlFunction() {
+      this.innerHTML = value.apply(this, arguments);
     }
-  }
 
-  return d3_transition(subgroups, d3_transitionInheritId || ++d3_transitionId, Date.now());
-};
-var d3_selectionRoot = d3_selection([[document]]);
+    return groups.each(typeof value == "function"
+        ? htmlFunction : htmlConstant);
+  };
 
-d3_selectionRoot[0].parentNode = document.documentElement;
+  // TODO append(node)?
+  // TODO append(function)?
+  groups.append = function(name) {
+    name = d3.ns.qualify(name);
 
-// TODO fast singleton implementation!
-// TODO select(function)
-d3.select = function(selector) {
-  return typeof selector === "string"
-      ? d3_selectionRoot.select(selector)
-      : d3_selection([[selector]]); // assume node
-};
+    function append(node) {
+      return node.appendChild(document.createElement(name));
+    }
 
-// TODO selectAll(function)
-d3.selectAll = function(selector) {
-  return typeof selector === "string"
-      ? d3_selectionRoot.selectAll(selector)
-      : d3_selection([d3_array(selector)]); // assume node[]
-};
-function d3_transition(groups, id, time) {
-  d3_arraySubclass(groups, d3_transitionPrototype);
+    function appendNS(node) {
+      return node.appendChild(document.createElementNS(name.space, name.local));
+    }
 
-  var tweens = {},
-      event = d3.dispatch("start", "end"),
-      ease = d3_transitionEase;
+    return select(name.local ? appendNS : append);
+  };
 
-  groups.id = id;
+  // TODO insert(node, function)?
+  // TODO insert(function, string)?
+  // TODO insert(function, function)?
+  groups.insert = function(name, before) {
+    name = d3.ns.qualify(name);
 
-  groups.time = time;
+    function insert(node) {
+      return node.insertBefore(
+          document.createElement(name),
+          d3_select(before, node));
+    }
 
-  groups.tween = function(name, tween) {
-    if (arguments.length < 2) return tweens[name];
-    if (tween == null) delete tweens[name];
-    else tweens[name] = tween;
-    return groups;
+    function insertNS(node) {
+      return node.insertBefore(
+          document.createElementNS(name.space, name.local),
+          d3_select(before, node));
+    }
+
+    return select(name.local ? insertNS : insert);
   };
 
-  groups.ease = function(value) {
-    if (!arguments.length) return ease;
-    ease = typeof value === "function" ? value : d3.ease.apply(d3, arguments);
-    return groups;
+  // TODO remove(selector)?
+  // TODO remove(node)?
+  // TODO remove(function)?
+  groups.remove = function() {
+    return groups.each(function() {
+      var parent = this.parentNode;
+      if (parent) parent.removeChild(this);
+    });
   };
 
-  groups.each = function(type, listener) {
-    if (arguments.length < 2) return d3_transition_each.call(groups, type);
-    event[type].add(listener);
+  groups.sort = function(comparator) {
+    comparator = d3_selection_comparator.apply(this, arguments);
+    for (var j = 0, m = groups.length; j < m; j++) {
+      var group = groups[j];
+      group.sort(comparator);
+      for (var i = 1, n = group.length, prev = group[0]; i < n; i++) {
+        var node = group[i];
+        if (node) {
+          if (prev) prev.parentNode.insertBefore(node, prev.nextSibling);
+          prev = node;
+        }
+      }
+    }
     return groups;
   };
 
-  d3.timer(function(elapsed) {
-    groups.each(function(d, i, j) {
-      var tweened = [],
-          node = this,
-          delay = groups[j][i].delay,
-          duration = groups[j][i].duration,
-          lock = node.__transition__ || (node.__transition__ = {active: 0, count: 0});
-
-      ++lock.count;
+  // type can be namespaced, e.g., "click.foo"
+  // listener can be null for removal
+  groups.on = function(type, listener) {
 
-      delay <= elapsed ? start(elapsed) : d3.timer(start, delay, time);
+    // parse the type specifier
+    var i = type.indexOf("."),
+        typo = i == -1 ? type : type.substring(0, i),
+        name = "__on" + type;
 
-      function start(elapsed) {
-        if (lock.active > id) return stop();
-        lock.active = id;
+    // remove the old event listener, and add the new event listener
+    return groups.each(function(d, i) {
+      if (this[name]) this.removeEventListener(typo, this[name], false);
+      if (listener) this.addEventListener(typo, this[name] = l, false);
 
-        for (var tween in tweens) {
-          if (tween = tweens[tween].call(node, d, i)) {
-            tweened.push(tween);
-          }
+      // wrapped event listener that preserves d, i
+      function l(e) {
+        var o = d3.event; // Events can be reentrant (e.g., focus).
+        d3.event = e;
+        try {
+          listener.call(this, d, i);
+        } finally {
+          d3.event = o;
         }
-
-        event.start.dispatch.call(node, d, i);
-        if (!tick(elapsed)) d3.timer(tick, 0, time);
-        return 1;
       }
+    });
+  };
 
-      function tick(elapsed) {
-        if (lock.active !== id) return stop();
+  // TODO slice?
 
-        var t = (elapsed - delay) / duration,
-            e = ease(t),
-            n = tweened.length;
+  groups.transition = function() {
+    return d3_transition(groups);
+  };
 
-        while (n > 0) {
-          tweened[--n].call(node, e);
-        }
+  groups.call = d3_call;
 
-        if (t >= 1) {
-          stop();
-          d3_transitionInheritId = id;
-          event.end.dispatch.call(node, d, i);
-          d3_transitionInheritId = 0;
-          return 1;
+  return groups;
+}
+
+function d3_selectionEnter(groups) {
+
+  function select(select) {
+    var subgroups = [],
+        subgroup,
+        subnode,
+        group,
+        node;
+    for (var j = 0, m = groups.length; j < m; j++) {
+      group = groups[j];
+      subgroups.push(subgroup = []);
+      subgroup.parentNode = group.parentNode;
+      for (var i = 0, n = group.length; i < n; i++) {
+        if (node = group[i]) {
+          subgroup.push(subnode = select(group.parentNode));
+          subnode.__data__ = node.__data__;
+        } else {
+          subgroup.push(null);
         }
       }
+    }
+    return d3_selection(subgroups);
+  }
 
-      function stop() {
-        if (!--lock.count) delete node.__transition__;
-        return 1;
-      }
-    });
-    return 1;
-  }, 0, time);
+  // TODO append(node)?
+  // TODO append(function)?
+  groups.append = function(name) {
+    name = d3.ns.qualify(name);
 
-  return groups;
-}
+    function append(node) {
+      return node.appendChild(document.createElement(name));
+    }
 
-var d3_transitionRemove = {};
+    function appendNS(node) {
+      return node.appendChild(document.createElementNS(name.space, name.local));
+    }
 
-function d3_transitionNull(d, i, a) {
-  return a != "" && d3_transitionRemove;
-}
+    return select(name.local ? appendNS : append);
+  };
 
-function d3_transitionTween(b) {
+  // TODO insert(node, function)?
+  // TODO insert(function, string)?
+  // TODO insert(function, function)?
+  groups.insert = function(name, before) {
+    name = d3.ns.qualify(name);
 
-  function transitionFunction(d, i, a) {
-    var v = b.call(this, d, i);
-    return v == null
-        ? a != "" && d3_transitionRemove
-        : a != v && d3.interpolate(a, v);
-  }
+    function insert(node) {
+      return node.insertBefore(
+          document.createElement(name),
+          d3_select(before, node));
+    }
 
-  function transitionString(d, i, a) {
-    return a != b && d3.interpolate(a, b);
-  }
+    function insertNS(node) {
+      return node.insertBefore(
+          document.createElementNS(name.space, name.local),
+          d3_select(before, node));
+    }
+
+    return select(name.local ? insertNS : insert);
+  };
+
+  return groups;
+}
+
+function d3_selection_comparator(comparator) {
+  if (!arguments.length) comparator = d3.ascending;
+  return function(a, b) {
+    return comparator(a && a.__data__, b && b.__data__);
+  };
+}
 
-  return typeof b === "function" ? transitionFunction
-      : b == null ? d3_transitionNull
-      : (b += "", transitionString);
+function d3_selection_enterNode(data) {
+  return {__data__: data};
 }
+d3.transition = d3_root.transition;
 
-var d3_transitionPrototype = [],
-    d3_transitionId = 0,
-    d3_transitionInheritId = 0,
-    d3_transitionEase = d3.ease("cubic-in-out");
+var d3_transitionId = 0,
+    d3_transitionInheritId = 0;
 
-d3_transitionPrototype.call = d3_selectionPrototype.call;
+function d3_transition(groups) {
+  var transition = {},
+      transitionId = d3_transitionInheritId || ++d3_transitionId,
+      tweens = {},
+      interpolators = [],
+      remove = false,
+      event = d3.dispatch("start", "end"),
+      stage = [],
+      delay = [],
+      duration = [],
+      durationMax,
+      ease = d3.ease("cubic-in-out");
+
+  //
+  // Be careful with concurrent transitions!
+  //
+  // Say transition A causes an exit. Before A finishes, a transition B is
+  // created, and believes it only needs to do an update, because the elements
+  // haven't been removed yet (which happens at the very end of the exit
+  // transition).
+  //
+  // Even worse, what if either transition A or B has a staggered delay? Then,
+  // some elements may be removed, while others remain. Transition B does not
+  // know to enter the elements because they were still present at the time
+  // the transition B was created (but not yet started).
+  //
+  // To prevent such confusion, we only trigger end events for transitions if
+  // the transition ending is the only one scheduled for the given element.
+  // Similarly, we only allow one transition to be active for any given
+  // element, so that concurrent transitions do not overwrite each other's
+  // properties.
+  //
+  // TODO Support transition namespaces, so that transitions can proceed
+  // concurrently on the same element if needed. Hopefully, this is rare!
+  //
+
+  groups.each(function() {
+    (this.__transition__ || (this.__transition__ = {})).owner = transitionId;
+  });
 
-d3.transition = function() {
-  return d3_selectionRoot.transition();
-};
+  function step(elapsed) {
+    var clear = true,
+        k = -1;
+    groups.each(function() {
+      if (stage[++k] == 2) return; // ended
+      var t = (elapsed - delay[k]) / duration[k],
+          tx = this.__transition__,
+          te, // ease(t)
+          tk, // tween key
+          ik = interpolators[k];
+
+      // Check if the (un-eased) time is outside the range [0,1].
+      if (t < 1) {
+        clear = false;
+        if (t < 0) return;
+      } else {
+        t = 1;
+      }
 
-d3.transition.prototype = d3_transitionPrototype;
-d3_transitionPrototype.select = function(selector) {
-  var subgroups = [],
-      subgroup,
-      subnode,
-      node;
-
-  if (typeof selector !== "function") selector = d3_selection_selector(selector);
-
-  for (var j = -1, m = this.length; ++j < m;) {
-    subgroups.push(subgroup = []);
-    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
-      if ((node = group[i]) && (subnode = selector.call(node.node, node.node.__data__, i))) {
-        if ("__data__" in node.node) subnode.__data__ = node.node.__data__;
-        subgroup.push({node: subnode, delay: node.delay, duration: node.duration});
+      // Determine the stage of this transition.
+      // 0 - Not yet started.
+      // 1 - In progress.
+      // 2 - Ended.
+      if (stage[k]) {
+        if (!tx || tx.active != transitionId) {
+          stage[k] = 2;
+          return;
+        }
+      } else if (!tx || tx.active > transitionId) {
+        stage[k] = 2;
+        return;
       } else {
-        subgroup.push(null);
+        stage[k] = 1;
+        event.start.dispatch.apply(this, arguments);
+        ik = interpolators[k] = {};
+        tx.active = transitionId;
+        for (tk in tweens) {
+          if (te = tweens[tk].apply(this, arguments)) {
+            ik[tk] = te;
+          }
+        }
       }
-    }
-  }
 
-  return d3_transition(subgroups, this.id, this.time).ease(this.ease());
-};
-d3_transitionPrototype.selectAll = function(selector) {
-  var subgroups = [],
-      subgroup,
-      subnodes,
-      node;
-
-  if (typeof selector !== "function") selector = d3_selection_selectorAll(selector);
-
-  for (var j = -1, m = this.length; ++j < m;) {
-    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
-      if (node = group[i]) {
-        subnodes = selector.call(node.node, node.node.__data__, i);
-        subgroups.push(subgroup = []);
-        for (var k = -1, o = subnodes.length; ++k < o;) {
-          subgroup.push({node: subnodes[k], delay: node.delay, duration: node.duration});
+      // Apply the interpolators!
+      te = ease(t);
+      for (tk in ik) ik[tk].call(this, te);
+
+      // Handle ending transitions.
+      if (t == 1) {
+        stage[k] = 2;
+        if (tx.active == transitionId) {
+          var owner = tx.owner;
+          if (owner == transitionId) {
+            delete this.__transition__;
+            if (remove) this.parentNode.removeChild(this);
+          }
+          d3_transitionInheritId = transitionId;
+          event.end.dispatch.apply(this, arguments);
+          d3_transitionInheritId = 0;
+          tx.owner = owner;
         }
       }
-    }
+    });
+    return clear;
   }
 
-  return d3_transition(subgroups, this.id, this.time).ease(this.ease());
-};
-d3_transitionPrototype.attr = function(name, value) {
-  return this.attrTween(name, d3_transitionTween(value));
-};
+  transition.delay = function(value) {
+    var delayMin = Infinity,
+        k = -1;
+    if (typeof value == "function") {
+      groups.each(function(d, i) {
+        var x = delay[++k] = +value.apply(this, arguments);
+        if (x < delayMin) delayMin = x;
+      });
+    } else {
+      delayMin = +value;
+      groups.each(function(d, i) {
+        delay[++k] = delayMin;
+      });
+    }
+    d3_timer(step, delayMin);
+    return transition;
+  };
+
+  transition.duration = function(value) {
+    var k = -1;
+    if (typeof value == "function") {
+      durationMax = 0;
+      groups.each(function(d, i) {
+        var x = duration[++k] = +value.apply(this, arguments);
+        if (x > durationMax) durationMax = x;
+      });
+    } else {
+      durationMax = +value;
+      groups.each(function(d, i) {
+        duration[++k] = durationMax;
+      });
+    }
+    return transition;
+  };
 
-d3_transitionPrototype.attrTween = function(nameNS, tween) {
-  var name = d3.ns.qualify(nameNS);
+  transition.ease = function(value) {
+    ease = typeof value == "function" ? value : d3.ease.apply(d3, arguments);
+    return transition;
+  };
 
-  function attrTween(d, i) {
-    var f = tween.call(this, d, i, this.getAttribute(name));
-    return f === d3_transitionRemove
-        ? (this.removeAttribute(name), null)
-        : f && function(t) { this.setAttribute(name, f(t)); };
-  }
+  transition.attrTween = function(name, tween) {
 
-  function attrTweenNS(d, i) {
-    var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
-    return f === d3_transitionRemove
-        ? (this.removeAttributeNS(name.space, name.local), null)
-        : f && function(t) { this.setAttributeNS(name.space, name.local, f(t)); };
-  }
+    /** @this {Element} */
+    function attrTween(d, i) {
+      var f = tween.call(this, d, i, this.getAttribute(name));
+      return function(t) {
+        this.setAttribute(name, f(t));
+      };
+    }
 
-  return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween);
-};
-d3_transitionPrototype.style = function(name, value, priority) {
-  if (arguments.length < 3) priority = "";
-  return this.styleTween(name, d3_transitionTween(value), priority);
-};
+    /** @this {Element} */
+    function attrTweenNS(d, i) {
+      var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
+      return function(t) {
+        this.setAttributeNS(name.space, name.local, f(t));
+      };
+    }
 
-d3_transitionPrototype.styleTween = function(name, tween, priority) {
-  if (arguments.length < 3) priority = "";
-  return this.tween("style." + name, function(d, i) {
-    var f = tween.call(this, d, i, window.getComputedStyle(this, null).getPropertyValue(name));
-    return f === d3_transitionRemove
-        ? (this.style.removeProperty(name), null)
-        : f && function(t) { this.style.setProperty(name, f(t), priority); };
-  });
-};
-d3_transitionPrototype.text = function(value) {
-  return this.tween("text", function(d, i) {
-    this.textContent = typeof value === "function"
-        ? value.call(this, d, i)
-        : value;
-  });
-};
-d3_transitionPrototype.remove = function() {
-  return this.each("end", function() {
-    var p;
-    if (!this.__transition__ && (p = this.parentNode)) p.removeChild(this);
-  });
-};
-d3_transitionPrototype.delay = function(value) {
-  var groups = this;
-  return groups.each(typeof value === "function"
-      ? function(d, i, j) { groups[j][i].delay = +value.apply(this, arguments); }
-      : (value = +value, function(d, i, j) { groups[j][i].delay = value; }));
-};
-d3_transitionPrototype.duration = function(value) {
-  var groups = this;
-  return groups.each(typeof value === "function"
-      ? function(d, i, j) { groups[j][i].duration = +value.apply(this, arguments); }
-      : (value = +value, function(d, i, j) { groups[j][i].duration = value; }));
-};
-function d3_transition_each(callback) {
-  for (var j = 0, m = this.length; j < m; j++) {
-    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
-      var node = group[i];
-      if (node) callback.call(node = node.node, node.__data__, i, j);
+    tweens["attr." + name] = name.local ? attrTweenNS : attrTween;
+    return transition;
+  };
+
+  transition.attr = function(name, value) {
+    return transition.attrTween(name, d3_transitionTween(value));
+  };
+
+  transition.styleTween = function(name, tween, priority) {
+    if (arguments.length < 3) priority = null;
+
+    /** @this {Element} */
+    function styleTween(d, i) {
+      var f = tween.call(this, d, i, window.getComputedStyle(this, null).getPropertyValue(name));
+      return function(t) {
+        this.style.setProperty(name, f(t), priority);
+      };
     }
-  }
-  return this;
+
+    tweens["style." + name] = styleTween;
+    return transition;
+  };
+
+  transition.style = function(name, value, priority) {
+    if (arguments.length < 3) priority = null;
+    return transition.styleTween(name, d3_transitionTween(value), priority);
+  };
+
+  transition.text = function(value) {
+    tweens.text = function(d, i) {
+      this.textContent = typeof value == "function"
+          ? value.call(this, d, i)
+          : value;
+    };
+    return transition;
+  };
+
+  transition.select = function(query) {
+    var k, t = d3_transition(groups.select(query)).ease(ease);
+    k = -1; t.delay(function(d, i) { return delay[++k]; });
+    k = -1; t.duration(function(d, i) { return duration[++k]; });
+    return t;
+  };
+
+  transition.selectAll = function(query) {
+    var k, t = d3_transition(groups.selectAll(query)).ease(ease);
+    k = -1; t.delay(function(d, i) { return delay[i ? k : ++k]; })
+    k = -1; t.duration(function(d, i) { return duration[i ? k : ++k]; });
+    return t;
+  };
+
+  transition.remove = function() {
+    remove = true;
+    return transition;
+  };
+
+  transition.each = function(type, listener) {
+    event[type].add(listener);
+    return transition;
+  };
+
+  transition.call = d3_call;
+
+  return transition.delay(0).duration(250);
+}
+
+function d3_transitionTween(b) {
+  return typeof b == "function"
+      ? function(d, i, a) { return d3.interpolate(a, String(b.call(this, d, i))); }
+      : (b = String(b), function(d, i, a) { return d3.interpolate(a, b); });
 }
-d3_transitionPrototype.transition = function() {
-  return this.select(d3_this);
-};
 var d3_timer_queue = null,
-    d3_timer_interval, // is an interval (or frame) active?
-    d3_timer_timeout; // is a timeout active?
+    d3_timer_timeout = 0,
+    d3_timer_interval;
 
 // The timer will continue to fire until callback returns true.
-d3.timer = function(callback, delay, then) {
-  var found = false,
+d3.timer = function(callback) {
+  d3_timer(callback, 0);
+};
+
+function d3_timer(callback, delay) {
+  var now = Date.now(),
+      found = false,
+      start = now + delay,
       t0,
       t1 = d3_timer_queue;
 
-  if (arguments.length < 3) {
-    if (arguments.length < 2) delay = 0;
-    else if (!isFinite(delay)) return;
-    then = Date.now();
-  }
+  if (!isFinite(delay)) return;
 
-  // See if the callback's already in the queue.
+  // Scan the queue for earliest callback.
   while (t1) {
-    if (t1.callback === callback) {
-      t1.then = then;
+    if (t1.callback == callback) {
+      t1.then = now;
       t1.delay = delay;
       found = true;
-      break;
+    } else {
+      var x = t1.then + t1.delay;
+      if (x < start) start = x;
     }
     t0 = t1;
     t1 = t1.next;
@@ -2117,71 +1898,47 @@ d3.timer = function(callback, delay, then) {
   // Otherwise, add the callback to the queue.
   if (!found) d3_timer_queue = {
     callback: callback,
-    then: then,
+    then: now,
     delay: delay,
     next: d3_timer_queue
   };
 
-  // Start animatin'!
   if (!d3_timer_interval) {
-    d3_timer_timeout = clearTimeout(d3_timer_timeout);
-    d3_timer_interval = 1;
-    d3_timer_frame(d3_timer_step);
+    clearTimeout(d3_timer_timeout);
+    d3_timer_timeout = setTimeout(d3_timer_start, Math.max(24, start - now));
   }
 }
 
-function d3_timer_step() {
-  var elapsed,
-      now = Date.now(),
-      t1 = d3_timer_queue;
-
-  while (t1) {
-    elapsed = now - t1.then;
-    if (elapsed >= t1.delay) t1.flush = t1.callback(elapsed);
-    t1 = t1.next;
-  }
-
-  var delay = d3_timer_flush() - now;
-  if (delay > 24) {
-    if (isFinite(delay)) {
-      clearTimeout(d3_timer_timeout);
-      d3_timer_timeout = setTimeout(d3_timer_step, delay);
-    }
-    d3_timer_interval = 0;
-  } else {
-    d3_timer_interval = 1;
-    d3_timer_frame(d3_timer_step);
-  }
+function d3_timer_start() {
+  d3_timer_interval = 1;
+  d3_timer_timeout = 0;
+  d3_timer_frame(d3_timer_step);
 }
 
-d3.timer.flush = function() {
+function d3_timer_step() {
   var elapsed,
       now = Date.now(),
+      t0 = null,
       t1 = d3_timer_queue;
-
   while (t1) {
     elapsed = now - t1.then;
-    if (!t1.delay) t1.flush = t1.callback(elapsed);
-    t1 = t1.next;
+    if (elapsed > t1.delay) t1.flush = t1.callback(elapsed);
+    t1 = (t0 = t1).next;
   }
-
   d3_timer_flush();
-};
+  if (d3_timer_interval) d3_timer_frame(d3_timer_step);
+}
 
 // Flush after callbacks, to avoid concurrent queue modification.
 function d3_timer_flush() {
   var t0 = null,
-      t1 = d3_timer_queue,
-      then = Infinity;
+      t1 = d3_timer_queue;
   while (t1) {
-    if (t1.flush) {
-      t1 = t0 ? t0.next = t1.next : d3_timer_queue = t1.next;
-    } else {
-      then = Math.min(then, t1.then + t1.delay);
-      t1 = (t0 = t1).next;
-    }
+    t1 = t1.flush
+        ? (t0 ? t0.next = t1.next : d3_timer_queue = t1.next)
+        : (t0 = t1).next;
   }
-  return then;
+  if (!t0) d3_timer_interval = 0;
 }
 
 var d3_timer_frame = window.requestAnimationFrame
@@ -2190,72 +1947,44 @@ var d3_timer_frame = window.requestAnimationFrame
     || window.oRequestAnimationFrame
     || window.msRequestAnimationFrame
     || function(callback) { setTimeout(callback, 17); };
-function d3_noop() {}
 d3.scale = {};
-
-function d3_scaleExtent(domain) {
-  var start = domain[0], stop = domain[domain.length - 1];
-  return start < stop ? [start, stop] : [stop, start];
-}
-function d3_scale_nice(domain, nice) {
-  var i0 = 0,
-      i1 = domain.length - 1,
-      x0 = domain[i0],
-      x1 = domain[i1],
-      dx;
-
-  if (x1 < x0) {
-    dx = i0; i0 = i1; i1 = dx;
-    dx = x0; x0 = x1; x1 = dx;
-  }
-
-  if (dx = x1 - x0) {
-    nice = nice(dx);
-    domain[i0] = nice.floor(x0);
-    domain[i1] = nice.ceil(x1);
-  }
-
-  return domain;
-}
-
-function d3_scale_niceDefault() {
-  return Math;
-}
 d3.scale.linear = function() {
-  return d3_scale_linear([0, 1], [0, 1], d3.interpolate, false);
-};
-
-function d3_scale_linear(domain, range, interpolate, clamp) {
-  var output,
-      input;
-
-  function rescale() {
-    var linear = domain.length == 2 ? d3_scale_bilinear : d3_scale_polylinear,
-        uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber;
-    output = linear(domain, range, uninterpolate, interpolate);
-    input = linear(range, domain, uninterpolate, d3.interpolate);
-    return scale;
-  }
+  var x0 = 0,
+      x1 = 1,
+      y0 = 0,
+      y1 = 1,
+      kx = 1, // 1 / (x1 - x0)
+      ky = 1, // (x1 - x0) / (y1 - y0)
+      interpolate = d3.interpolate,
+      i = interpolate(y0, y1),
+      clamp = false;
 
   function scale(x) {
-    return output(x);
+    x = (x - x0) * kx;
+    return i(clamp ? Math.max(0, Math.min(1, x)) : x);
   }
 
   // Note: requires range is coercible to number!
   scale.invert = function(y) {
-    return input(y);
+    return (y - y0) * ky + x0;
   };
 
   scale.domain = function(x) {
-    if (!arguments.length) return domain;
-    domain = x.map(Number);
-    return rescale();
+    if (!arguments.length) return [x0, x1];
+    x0 = +x[0];
+    x1 = +x[1];
+    kx = 1 / (x1 - x0);
+    ky = (x1 - x0) / (y1 - y0);
+    return scale;
   };
 
   scale.range = function(x) {
-    if (!arguments.length) return range;
-    range = x;
-    return rescale();
+    if (!arguments.length) return [y0, y1];
+    y0 = x[0];
+    y1 = x[1];
+    ky = (x1 - x0) / (y1 - y0);
+    i = interpolate(y0, y1);
+    return scale;
   };
 
   scale.rangeRound = function(x) {
@@ -2265,106 +1994,52 @@ function d3_scale_linear(domain, range, interpolate, clamp) {
   scale.clamp = function(x) {
     if (!arguments.length) return clamp;
     clamp = x;
-    return rescale();
+    return scale;
   };
 
   scale.interpolate = function(x) {
     if (!arguments.length) return interpolate;
-    interpolate = x;
-    return rescale();
-  };
-
-  scale.ticks = function(m) {
-    return d3_scale_linearTicks(domain, m);
-  };
-
-  scale.tickFormat = function(m) {
-    return d3_scale_linearTickFormat(domain, m);
-  };
-
-  scale.nice = function() {
-    d3_scale_nice(domain, d3_scale_linearNice);
-    return rescale();
+    i = (interpolate = x)(y0, y1);
+    return scale;
   };
 
-  scale.copy = function() {
-    return d3_scale_linear(domain, range, interpolate, clamp);
-  };
+  // TODO Dates? Ugh.
+  function tickRange(m) {
+    var start = Math.min(x0, x1),
+        stop = Math.max(x0, x1),
+        span = stop - start,
+        step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)),
+        err = m / (span / step);
 
-  return rescale();
-};
+    // Filter ticks to get closer to the desired count.
+    if (err <= .15) step *= 10;
+    else if (err <= .35) step *= 5;
+    else if (err <= .75) step *= 2;
 
-function d3_scale_linearRebind(scale, linear) {
-  scale.range = d3.rebind(scale, linear.range);
-  scale.rangeRound = d3.rebind(scale, linear.rangeRound);
-  scale.interpolate = d3.rebind(scale, linear.interpolate);
-  scale.clamp = d3.rebind(scale, linear.clamp);
-  return scale;
-}
+    // Round start and stop values to step interval.
+    return {
+      start: Math.ceil(start / step) * step,
+      stop: Math.floor(stop / step) * step + step * .5, // inclusive
+      step: step
+    };
+  }
 
-function d3_scale_linearNice(dx) {
-  dx = Math.pow(10, Math.round(Math.log(dx) / Math.LN10) - 1);
-  return {
-    floor: function(x) { return Math.floor(x / dx) * dx; },
-    ceil: function(x) { return Math.ceil(x / dx) * dx; }
+  scale.ticks = function(m) {
+    var range = tickRange(m);
+    return d3.range(range.start, range.stop, range.step);
   };
-}
-
-// TODO Dates? Ugh.
-function d3_scale_linearTickRange(domain, m) {
-  var extent = d3_scaleExtent(domain),
-      span = extent[1] - extent[0],
-      step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)),
-      err = m / span * step;
-
-  // Filter ticks to get closer to the desired count.
-  if (err <= .15) step *= 10;
-  else if (err <= .35) step *= 5;
-  else if (err <= .75) step *= 2;
-
-  // Round start and stop values to step interval.
-  extent[0] = Math.ceil(extent[0] / step) * step;
-  extent[1] = Math.floor(extent[1] / step) * step + step * .5; // inclusive
-  extent[2] = step;
-  return extent;
-}
 
-function d3_scale_linearTicks(domain, m) {
-  return d3.range.apply(d3, d3_scale_linearTickRange(domain, m));
-}
-
-function d3_scale_linearTickFormat(domain, m) {
-  return d3.format(",." + Math.max(0, -Math.floor(Math.log(d3_scale_linearTickRange(domain, m)[2]) / Math.LN10 + .01)) + "f");
-}
-function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
-  var u = uninterpolate(domain[0], domain[1]),
-      i = interpolate(range[0], range[1]);
-  return function(x) {
-    return i(u(x));
+  scale.tickFormat = function(m) {
+    var n = Math.max(0, -Math.floor(Math.log(tickRange(m).step) / Math.LN10 + .01));
+    return d3.format(",." + n + "f");
   };
-}
-function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
-  var u = [],
-      i = [],
-      j = 0,
-      n = domain.length;
-
-  while (++j < n) {
-    u.push(uninterpolate(domain[j - 1], domain[j]));
-    i.push(interpolate(range[j - 1], range[j]));
-  }
 
-  return function(x) {
-    var j = d3.bisect(domain, x, 1, domain.length - 1) - 1;
-    return i[j](u[j](x));
-  };
-}
-d3.scale.log = function() {
-  return d3_scale_log(d3.scale.linear(), d3_scale_logp);
+  return scale;
 };
-
-function d3_scale_log(linear, log) {
-  var pow = log.pow;
+d3.scale.log = function() {
+  var linear = d3.scale.linear(),
+      log = d3_scale_log,
+      pow = log.pow;
 
   function scale(x) {
     return linear(log(x));
@@ -2376,25 +2051,25 @@ function d3_scale_log(linear, log) {
 
   scale.domain = function(x) {
     if (!arguments.length) return linear.domain().map(pow);
-    log = x[0] < 0 ? d3_scale_logn : d3_scale_logp;
+    log = (x[0] || x[1]) < 0 ? d3_scale_logn : d3_scale_log;
     pow = log.pow;
     linear.domain(x.map(log));
     return scale;
   };
 
-  scale.nice = function() {
-    linear.domain(d3_scale_nice(linear.domain(), d3_scale_niceDefault));
-    return scale;
-  };
+  scale.range = d3.rebind(scale, linear.range);
+  scale.rangeRound = d3.rebind(scale, linear.rangeRound);
+  scale.interpolate = d3.rebind(scale, linear.interpolate);
+  scale.clamp = d3.rebind(scale, linear.clamp);
 
   scale.ticks = function() {
-    var extent = d3_scaleExtent(linear.domain()),
+    var d = linear.domain(),
         ticks = [];
-    if (extent.every(isFinite)) {
-      var i = Math.floor(extent[0]),
-          j = Math.ceil(extent[1]),
-          u = Math.round(pow(extent[0])),
-          v = Math.round(pow(extent[1]));
+    if (d.every(isFinite)) {
+      var i = Math.floor(d[0]),
+          j = Math.ceil(d[1]),
+          u = pow(d[0]),
+          v = pow(d[1]);
       if (log === d3_scale_logn) {
         ticks.push(pow(i));
         for (; i++ < j;) for (var k = 9; k > 0; k--) ticks.push(pow(i) * k);
@@ -2409,27 +2084,14 @@ function d3_scale_log(linear, log) {
     return ticks;
   };
 
-  scale.tickFormat = function(n, format) {
-    if (arguments.length < 2) format = d3_scale_logFormat;
-    if (arguments.length < 1) return format;
-    var k = n / scale.ticks().length,
-        f = log === d3_scale_logn ? (e = -1e-15, Math.floor) : (e = 1e-15, Math.ceil),
-        e;
-    return function(d) {
-      return d / pow(f(log(d) + e)) < k ? format(d) : "";
-    };
-  };
-
-  scale.copy = function() {
-    return d3_scale_log(linear.copy(), log);
+  scale.tickFormat = function() {
+    return function(d) { return d.toPrecision(1); };
   };
 
-  return d3_scale_linearRebind(scale, linear);
+  return scale;
 };
 
-var d3_scale_logFormat = d3.format("e");
-
-function d3_scale_logp(x) {
+function d3_scale_log(x) {
   return Math.log(x) / Math.LN10;
 }
 
@@ -2437,7 +2099,7 @@ function d3_scale_logn(x) {
   return -Math.log(-x) / Math.LN10;
 }
 
-d3_scale_logp.pow = function(x) {
+d3_scale_log.pow = function(x) {
   return Math.pow(10, x);
 };
 
@@ -2445,12 +2107,11 @@ d3_scale_logn.pow = function(x) {
   return -Math.pow(10, -x);
 };
 d3.scale.pow = function() {
-  return d3_scale_pow(d3.scale.linear(), 1);
-};
-
-function d3_scale_pow(linear, exponent) {
-  var powp = d3_scale_powPow(exponent),
-      powb = d3_scale_powPow(1 / exponent);
+  var linear = d3.scale.linear(),
+      tick = d3.scale.linear(), // TODO better tick formatting...
+      exponent = 1,
+      powp = Number,
+      powb = powp;
 
   function scale(x) {
     return linear(powp(x));
@@ -2462,72 +2123,70 @@ function d3_scale_pow(linear, exponent) {
 
   scale.domain = function(x) {
     if (!arguments.length) return linear.domain().map(powb);
+    var pow = (x[0] || x[1]) < 0 ? d3_scale_pown : d3_scale_pow;
+    powp = pow(exponent);
+    powb = pow(1 / exponent);
     linear.domain(x.map(powp));
+    tick.domain(x);
     return scale;
   };
 
-  scale.ticks = function(m) {
-    return d3_scale_linearTicks(scale.domain(), m);
-  };
-
-  scale.tickFormat = function(m) {
-    return d3_scale_linearTickFormat(scale.domain(), m);
-  };
-
-  scale.nice = function() {
-    return scale.domain(d3_scale_nice(scale.domain(), d3_scale_linearNice));
-  };
+  scale.range = d3.rebind(scale, linear.range);
+  scale.rangeRound = d3.rebind(scale, linear.rangeRound);
+  scale.interpolate = d3.rebind(scale, linear.interpolate);
+  scale.clamp = d3.rebind(scale, linear.clamp);
+  scale.ticks = tick.ticks;
+  scale.tickFormat = tick.tickFormat;
 
   scale.exponent = function(x) {
     if (!arguments.length) return exponent;
     var domain = scale.domain();
-    powp = d3_scale_powPow(exponent = x);
-    powb = d3_scale_powPow(1 / exponent);
+    exponent = x;
     return scale.domain(domain);
   };
 
-  scale.copy = function() {
-    return d3_scale_pow(linear.copy(), exponent);
-  };
-
-  return d3_scale_linearRebind(scale, linear);
+  return scale;
 };
 
-function d3_scale_powPow(e) {
+function d3_scale_pow(e) {
+  return function(x) {
+    return Math.pow(x, e);
+  };
+}
+
+function d3_scale_pown(e) {
   return function(x) {
-    return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
+    return -Math.pow(-x, e);
   };
 }
 d3.scale.sqrt = function() {
   return d3.scale.pow().exponent(.5);
 };
 d3.scale.ordinal = function() {
-  return d3_scale_ordinal([], {t: "range", x: []});
-};
-
-function d3_scale_ordinal(domain, ranger) {
-  var index,
-      range,
-      rangeBand;
+  var domain = [],
+      index = {},
+      range = [],
+      rangeBand = 0;
 
   function scale(x) {
-    return range[((index[x] || (index[x] = domain.push(x))) - 1) % range.length];
+    var i = x in index ? index[x] : (index[x] = domain.push(x) - 1);
+    return range[i % range.length];
   }
 
   scale.domain = function(x) {
     if (!arguments.length) return domain;
-    domain = [];
+    domain = x;
     index = {};
-    var i = -1, n = x.length, xi;
-    while (++i < n) if (!index[xi = x[i]]) index[xi] = domain.push(xi);
-    return scale[ranger.t](ranger.x, ranger.p);
+    var i = -1, j = -1, n = domain.length; while (++i < n) {
+      x = domain[i];
+      if (!(x in index)) index[x] = ++j;
+    }
+    return scale;
   };
 
   scale.range = function(x) {
     if (!arguments.length) return range;
     range = x;
-    rangeBand = 0;
-    ranger = {t: "range", x: x};
     return scale;
   };
 
@@ -2536,9 +2195,10 @@ function d3_scale_ordinal(domain, ranger) {
     var start = x[0],
         stop = x[1],
         step = (stop - start) / (domain.length - 1 + padding);
-    range = domain.length < 2 ? [(start + stop) / 2] : d3.range(start + step * padding / 2, stop + step / 2, step);
+    range = domain.length == 1
+        ? [(start + stop) / 2]
+        : d3.range(start + step * padding / 2, stop + step / 2, step);
     rangeBand = 0;
-    ranger = {t: "rangePoints", x: x, p: padding};
     return scale;
   };
 
@@ -2549,7 +2209,6 @@ function d3_scale_ordinal(domain, ranger) {
         step = (stop - start) / (domain.length + padding);
     range = d3.range(start + step * padding, stop, step);
     rangeBand = step * (1 - padding);
-    ranger = {t: "rangeBands", x: x, p: padding};
     return scale;
   };
 
@@ -2557,11 +2216,11 @@ function d3_scale_ordinal(domain, ranger) {
     if (arguments.length < 2) padding = 0;
     var start = x[0],
         stop = x[1],
-        step = Math.floor((stop - start) / (domain.length + padding)),
-        err = stop - start - (domain.length - padding) * step;
+        diff = stop - start,
+        step = Math.floor(diff / (domain.length + padding)),
+        err = diff - (domain.length - padding) * step;
     range = d3.range(start + Math.round(err / 2), stop, step);
     rangeBand = Math.round(step * (1 - padding));
-    ranger = {t: "rangeRoundBands", x: x, p: padding};
     return scale;
   };
 
@@ -2569,11 +2228,7 @@ function d3_scale_ordinal(domain, ranger) {
     return rangeBand;
   };
 
-  scale.copy = function() {
-    return d3_scale_ordinal(domain, ranger);
-  };
-
-  return scale.domain(domain);
+  return scale;
 };
 /*
  * This product includes color specifications and designs developed by Cynthia
@@ -2630,83 +2285,81 @@ var d3_category20c = [
   "#636363", "#969696", "#bdbdbd", "#d9d9d9"
 ];
 d3.scale.quantile = function() {
-  return d3_scale_quantile([], []);
-};
-
-function d3_scale_quantile(domain, range) {
-  var thresholds;
+  var domain = [],
+      range = [],
+      thresholds = [];
 
   function rescale() {
-    var k = 0,
-        n = domain.length,
-        q = range.length;
-    thresholds = [];
-    while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
-    return scale;
+    var i = -1,
+        n = thresholds.length = range.length,
+        k = domain.length / n;
+    while (++i < n) thresholds[i] = domain[~~(i * k)];
+  }
+
+  function quantile(value) {
+    if (isNaN(value = +value)) return NaN;
+    var low = 0, high = thresholds.length - 1;
+    while (low <= high) {
+      var mid = (low + high) >> 1, midValue = thresholds[mid];
+      if (midValue < value) low = mid + 1;
+      else if (midValue > value) high = mid - 1;
+      else return mid;
+    }
+    return high < 0 ? 0 : high;
   }
 
   function scale(x) {
-    if (isNaN(x = +x)) return NaN;
-    return range[d3.bisect(thresholds, x)];
+    return range[quantile(x)];
   }
 
   scale.domain = function(x) {
     if (!arguments.length) return domain;
     domain = x.filter(function(d) { return !isNaN(d); }).sort(d3.ascending);
-    return rescale();
+    rescale();
+    return scale;
   };
 
   scale.range = function(x) {
     if (!arguments.length) return range;
     range = x;
-    return rescale();
+    rescale();
+    return scale;
   };
 
   scale.quantiles = function() {
     return thresholds;
   };
 
-  scale.copy = function() {
-    return d3_scale_quantile(domain, range); // copy on write!
-  };
-
-  return rescale();
+  return scale;
 };
 d3.scale.quantize = function() {
-  return d3_scale_quantize(0, 1, [0, 1]);
-};
-
-function d3_scale_quantize(x0, x1, range) {
-  var kx, i;
+  var x0 = 0,
+      x1 = 1,
+      kx = 2,
+      i = 1,
+      range = [0, 1];
 
   function scale(x) {
     return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
   }
 
-  function rescale() {
-    kx = range.length / (x1 - x0);
-    i = range.length - 1;
-    return scale;
-  }
-
   scale.domain = function(x) {
     if (!arguments.length) return [x0, x1];
-    x0 = +x[0];
-    x1 = +x[x.length - 1];
-    return rescale();
+    x0 = x[0];
+    x1 = x[1];
+    kx = range.length / (x1 - x0);
+    return scale;
   };
 
   scale.range = function(x) {
     if (!arguments.length) return range;
     range = x;
-    return rescale();
-  };
-
-  scale.copy = function() {
-    return d3_scale_quantize(x0, x1, range); // copy on write
+    kx = range.length / (x1 - x0);
+    i = range.length - 1;
+    return scale;
   };
 
-  return rescale();
+  return scale;
 };
 d3.svg = {};
 d3.svg.arc = function() {
@@ -2720,7 +2373,7 @@ d3.svg.arc = function() {
         r1 = outerRadius.apply(this, arguments),
         a0 = startAngle.apply(this, arguments) + d3_svg_arcOffset,
         a1 = endAngle.apply(this, arguments) + d3_svg_arcOffset,
-        da = (a1 < a0 && (da = a0, a0 = a1, a1 = da), a1 - a0),
+        da = a1 - a0,
         df = da < Math.PI ? "0" : "1",
         c0 = Math.cos(a0),
         s0 = Math.sin(a0),
@@ -2732,8 +2385,8 @@ d3.svg.arc = function() {
       + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1)
       + "A" + r1 + "," + r1 + " 0 1,1 0," + r1
       + "M0," + r0
-      + "A" + r0 + "," + r0 + " 0 1,0 0," + (-r0)
-      + "A" + r0 + "," + r0 + " 0 1,0 0," + r0
+      + "A" + r0 + "," + r0 + " 0 1,1 0," + (-r0)
+      + "A" + r0 + "," + r0 + " 0 1,1 0," + r0
       + "Z"
       : "M0," + r1
       + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1)
@@ -2804,7 +2457,7 @@ function d3_svg_arcStartAngle(d) {
 function d3_svg_arcEndAngle(d) {
   return d.endAngle;
 }
-function d3_svg_line(projection) {
+d3.svg.line = function() {
   var x = d3_svg_lineX,
       y = d3_svg_lineY,
       interpolate = "linear",
@@ -2812,7 +2465,8 @@ function d3_svg_line(projection) {
       tension = .7;
 
   function line(d) {
-    return d.length < 1 ? null : "M" + interpolator(projection(d3_svg_linePoints(this, d, x, y)), tension);
+    return d.length < 1 ? null
+        : "M" + interpolator(d3_svg_linePoints(this, d, x, y), tension);
   }
 
   line.x = function(v) {
@@ -2839,11 +2493,7 @@ function d3_svg_line(projection) {
     return line;
   };
 
-  return line;
-}
-
-d3.svg.line = function() {
-  return d3_svg_line(Object);
+  return line;
 };
 
 // Converts the specified array of data into an array of points
@@ -2854,8 +2504,8 @@ function d3_svg_linePoints(self, d, x, y) {
   var points = [],
       i = -1,
       n = d.length,
-      fx = typeof x === "function",
-      fy = typeof y === "function",
+      fx = typeof x == "function",
+      fy = typeof y == "function",
       value;
   if (fx && fy) {
     while (++i < n) points.push([
@@ -2888,53 +2538,44 @@ var d3_svg_lineInterpolators = {
   "step-before": d3_svg_lineStepBefore,
   "step-after": d3_svg_lineStepAfter,
   "basis": d3_svg_lineBasis,
-  "basis-open": d3_svg_lineBasisOpen,
   "basis-closed": d3_svg_lineBasisClosed,
-  "bundle": d3_svg_lineBundle,
   "cardinal": d3_svg_lineCardinal,
-  "cardinal-open": d3_svg_lineCardinalOpen,
-  "cardinal-closed": d3_svg_lineCardinalClosed,
-  "monotone": d3_svg_lineMonotone
+  "cardinal-closed": d3_svg_lineCardinalClosed
 };
 
 // Linear interpolation; generates "L" commands.
 function d3_svg_lineLinear(points) {
-  var i = 0,
+  var path = [],
+      i = 0,
       n = points.length,
-      p = points[0],
-      path = [p[0], ",", p[1]];
+      p = points[0];
+  path.push(p[0], ",", p[1]);
   while (++i < n) path.push("L", (p = points[i])[0], ",", p[1]);
   return path.join("");
 }
 
 // Step interpolation; generates "H" and "V" commands.
 function d3_svg_lineStepBefore(points) {
-  var i = 0,
+  var path = [],
+      i = 0,
       n = points.length,
-      p = points[0],
-      path = [p[0], ",", p[1]];
+      p = points[0];
+  path.push(p[0], ",", p[1]);
   while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
   return path.join("");
 }
 
 // Step interpolation; generates "H" and "V" commands.
 function d3_svg_lineStepAfter(points) {
-  var i = 0,
+  var path = [],
+      i = 0,
       n = points.length,
-      p = points[0],
-      path = [p[0], ",", p[1]];
+      p = points[0];
+  path.push(p[0], ",", p[1]);
   while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
   return path.join("");
 }
 
-// Open cardinal spline interpolation; generates "C" commands.
-function d3_svg_lineCardinalOpen(points, tension) {
-  return points.length < 4
-      ? d3_svg_lineLinear(points)
-      : points[1] + d3_svg_lineHermite(points.slice(1, points.length - 1),
-        d3_svg_lineCardinalTangents(points, tension));
-}
-
 // Closed cardinal spline interpolation; generates "C" commands.
 function d3_svg_lineCardinalClosed(points, tension) {
   return points.length < 3
@@ -3017,17 +2658,18 @@ function d3_svg_lineCardinalTangents(points, tension) {
   return tangents;
 }
 
-// B-spline interpolation; generates "C" commands.
+// Open B-spline interpolation; generates "C" commands.
 function d3_svg_lineBasis(points) {
   if (points.length < 3) return d3_svg_lineLinear(points);
-  var i = 1,
+  var path = [],
+      i = 1,
       n = points.length,
       pi = points[0],
       x0 = pi[0],
       y0 = pi[1],
       px = [x0, x0, x0, (pi = points[1])[0]],
-      py = [y0, y0, y0, pi[1]],
-      path = [x0, ",", y0];
+      py = [y0, y0, y0, pi[1]];
+  path.push(x0, ",", y0);
   d3_svg_lineBasisBezier(path, px, py);
   while (++i < n) {
     pi = points[i];
@@ -3044,31 +2686,6 @@ function d3_svg_lineBasis(points) {
   return path.join("");
 }
 
-// Open B-spline interpolation; generates "C" commands.
-function d3_svg_lineBasisOpen(points) {
-  if (points.length < 4) return d3_svg_lineLinear(points);
-  var path = [],
-      i = -1,
-      n = points.length,
-      pi,
-      px = [0],
-      py = [0];
-  while (++i < 3) {
-    pi = points[i];
-    px.push(pi[0]);
-    py.push(pi[1]);
-  }
-  path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px)
-    + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
-  --i; while (++i < n) {
-    pi = points[i];
-    px.shift(); px.push(pi[0]);
-    py.shift(); py.push(pi[1]);
-    d3_svg_lineBasisBezier(path, px, py);
-  }
-  return path.join("");
-}
-
 // Closed B-spline interpolation; generates "C" commands.
 function d3_svg_lineBasisClosed(points) {
   var path,
@@ -3096,24 +2713,6 @@ function d3_svg_lineBasisClosed(points) {
   return path.join("");
 }
 
-function d3_svg_lineBundle(points, tension) {
-  var n = points.length - 1,
-      x0 = points[0][0],
-      y0 = points[0][1],
-      dx = points[n][0] - x0,
-      dy = points[n][1] - y0,
-      i = -1,
-      p,
-      t;
-  while (++i <= n) {
-    p = points[i];
-    t = i / n;
-    p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx);
-    p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy);
-  }
-  return d3_svg_lineBasis(points);
-}
-
 // Returns the dot product of the given four-element vectors.
 function d3_svg_lineDot4(a, b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
@@ -3125,7 +2724,7 @@ var d3_svg_lineBasisBezier1 = [0, 2/3, 1/3, 0],
     d3_svg_lineBasisBezier2 = [0, 1/3, 2/3, 0],
     d3_svg_lineBasisBezier3 = [0, 1/6, 2/3, 1/6];
 
-// Pushes a "C" Bézier curve onto the specified path array, given the
+// Pushes a "C" Bézier curve onto the specified path array, given the
 // two specified four-element arrays which define the control points.
 function d3_svg_lineBasisBezier(path, x, y) {
   path.push(
@@ -3136,210 +2735,59 @@ function d3_svg_lineBasisBezier(path, x, y) {
       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x),
       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
 }
-
-// Computes the slope from points p0 to p1.
-function d3_svg_lineSlope(p0, p1) {
-  return (p1[1] - p0[1]) / (p1[0] - p0[0]);
-}
-
-// Compute three-point differences for the given points.
-// http://en.wikipedia.org/wiki/Cubic_Hermite_spline#Finite_difference
-function d3_svg_lineFiniteDifferences(points) {
-  var i = 0,
-      j = points.length - 1,
-      m = [],
-      p0 = points[0],
-      p1 = points[1],
-      d = m[0] = d3_svg_lineSlope(p0, p1);
-  while (++i < j) {
-    m[i] = d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]));
-  }
-  m[i] = d;
-  return m;
-}
-
-// Interpolates the given points using Fritsch-Carlson Monotone cubic Hermite
-// interpolation. Returns an array of tangent vectors. For details, see
-// http://en.wikipedia.org/wiki/Monotone_cubic_interpolation
-function d3_svg_lineMonotoneTangents(points) {
-  var tangents = [],
-      d,
-      a,
-      b,
-      s,
-      m = d3_svg_lineFiniteDifferences(points),
-      i = -1,
-      j = points.length - 1;
-
-  // The first two steps are done by computing finite-differences:
-  // 1. Compute the slopes of the secant lines between successive points.
-  // 2. Initialize the tangents at every point as the average of the secants.
-
-  // Then, for each segment…
-  while (++i < j) {
-    d = d3_svg_lineSlope(points[i], points[i + 1]);
-
-    // 3. If two successive yk = y{k + 1} are equal (i.e., d is zero), then set
-    // mk = m{k + 1} = 0 as the spline connecting these points must be flat to
-    // preserve monotonicity. Ignore step 4 and 5 for those k.
-
-    if (Math.abs(d) < 1e-6) {
-      m[i] = m[i + 1] = 0;
-    } else {
-      // 4. Let ak = mk / dk and bk = m{k + 1} / dk.
-      a = m[i] / d;
-      b = m[i + 1] / d;
-
-      // 5. Prevent overshoot and ensure monotonicity by restricting the
-      // magnitude of vector <ak, bk> to a circle of radius 3.
-      s = a * a + b * b;
-      if (s > 9) {
-        s = d * 3 / Math.sqrt(s);
-        m[i] = s * a;
-        m[i + 1] = s * b;
-      }
-    }
-  }
-
-  // Compute the normalized tangent vector from the slopes. Note that if x is
-  // not monotonic, it's possible that the slope will be infinite, so we protect
-  // against NaN by setting the coordinate to zero.
-  i = -1; while (++i <= j) {
-    s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0])
-      / (6 * (1 + m[i] * m[i]));
-    tangents.push([s || 0, m[i] * s || 0]);
-  }
-
-  return tangents;
-}
-
-function d3_svg_lineMonotone(points) {
-  return points.length < 3
-      ? d3_svg_lineLinear(points)
-      : points[0] +
-        d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
-}
-d3.svg.line.radial = function() {
-  var line = d3_svg_line(d3_svg_lineRadial);
-  line.radius = line.x, delete line.x;
-  line.angle = line.y, delete line.y;
-  return line;
-};
-
-function d3_svg_lineRadial(points) {
-  var point,
-      i = -1,
-      n = points.length,
-      r,
-      a;
-  while (++i < n) {
-    point = points[i];
-    r = point[0];
-    a = point[1] + d3_svg_arcOffset;
-    point[0] = r * Math.cos(a);
-    point[1] = r * Math.sin(a);
-  }
-  return points;
-}
-function d3_svg_area(projection) {
-  var x0 = d3_svg_lineX,
-      x1 = d3_svg_lineX,
-      y0 = 0,
+d3.svg.area = function() {
+  var x = d3_svg_lineX,
+      y0 = d3_svg_areaY0,
       y1 = d3_svg_lineY,
-      interpolate,
-      i0,
-      i1,
+      interpolate = "linear",
+      interpolator = d3_svg_lineInterpolators[interpolate],
       tension = .7;
 
+  // TODO horizontal / vertical / radial orientation
+
   function area(d) {
-    if (d.length < 1) return null;
-    var points0 = d3_svg_linePoints(this, d, x0, y0),
-        points1 = d3_svg_linePoints(this, d, x0 === x1 ? d3_svg_areaX(points0) : x1, y0 === y1 ? d3_svg_areaY(points0) : y1);
-    return "M" + i0(projection(points1), tension)
-         + "L" + i1(projection(points0.reverse()), tension)
-         + "Z";
+    return d.length < 1 ? null
+        : "M" + interpolator(d3_svg_linePoints(this, d, x, y1), tension)
+        + "L" + interpolator(d3_svg_linePoints(this, d, x, y0).reverse(), tension)
+        + "Z";
   }
 
-  area.x = function(x) {
-    if (!arguments.length) return x1;
-    x0 = x1 = x;
-    return area;
-  };
-
-  area.x0 = function(x) {
-    if (!arguments.length) return x0;
-    x0 = x;
-    return area;
-  };
-
-  area.x1 = function(x) {
-    if (!arguments.length) return x1;
-    x1 = x;
-    return area;
-  };
-
-  area.y = function(y) {
-    if (!arguments.length) return y1;
-    y0 = y1 = y;
+  area.x = function(v) {
+    if (!arguments.length) return x;
+    x = v;
     return area;
   };
 
-  area.y0 = function(y) {
+  area.y0 = function(v) {
     if (!arguments.length) return y0;
-    y0 = y;
+    y0 = v;
     return area;
   };
 
-  area.y1 = function(y) {
+  area.y1 = function(v) {
     if (!arguments.length) return y1;
-    y1 = y;
+    y1 = v;
     return area;
   };
 
-  area.interpolate = function(x) {
+  area.interpolate = function(v) {
     if (!arguments.length) return interpolate;
-    i0 = d3_svg_lineInterpolators[interpolate = x];
-    i1 = i0.reverse || i0;
+    interpolator = d3_svg_lineInterpolators[interpolate = v];
     return area;
   };
 
-  area.tension = function(x) {
+  area.tension = function(v) {
     if (!arguments.length) return tension;
-    tension = x;
+    tension = v;
     return area;
   };
 
-  return area.interpolate("linear");
-}
-
-d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter;
-d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore;
-
-d3.svg.area = function() {
-  return d3_svg_area(Object);
+  return area;
 };
 
-function d3_svg_areaX(points) {
-  return function(d, i) {
-    return points[i][0];
-  };
-}
-
-function d3_svg_areaY(points) {
-  return function(d, i) {
-    return points[i][1];
-  };
+function d3_svg_areaY0() {
+  return 0;
 }
-d3.svg.area.radial = function() {
-  var area = d3_svg_area(d3_svg_lineRadial);
-  area.radius = area.x, delete area.x;
-  area.innerRadius = area.x0, delete area.x0;
-  area.outerRadius = area.x1, delete area.x1;
-  area.angle = area.y, delete area.y;
-  area.startAngle = area.y0, delete area.y0;
-  area.endAngle = area.y1, delete area.y1;
-  return area;
-};
 d3.svg.chord = function() {
   var source = d3_svg_chordSource,
       target = d3_svg_chordTarget,
@@ -3477,36 +2925,7 @@ d3.svg.diagonal = function() {
 function d3_svg_diagonalProjection(d) {
   return [d.x, d.y];
 }
-d3.svg.diagonal.radial = function() {
-  var diagonal = d3.svg.diagonal(),
-      projection = d3_svg_diagonalProjection,
-      projection_ = diagonal.projection;
-
-  diagonal.projection = function(x) {
-    return arguments.length
-        ? projection_(d3_svg_diagonalRadialProjection(projection = x))
-        : projection;
-  };
-
-  return diagonal;
-};
-
-function d3_svg_diagonalRadialProjection(projection) {
-  return function() {
-    var d = projection.apply(this, arguments),
-        r = d[0],
-        a = d[1] + d3_svg_arcOffset;
-    return [r * Math.cos(a), r * Math.sin(a)];
-  };
-}
 d3.svg.mouse = function(container) {
-  return d3_svg_mousePoint(container, d3.event);
-};
-
-// https://bugs.webkit.org/show_bug.cgi?id=44083
-var d3_mouse_bug44083 = /WebKit/.test(navigator.userAgent) ? -1 : 0;
-
-function d3_svg_mousePoint(container, e) {
   var point = (container.ownerSVGElement || container).createSVGPoint();
   if ((d3_mouse_bug44083 < 0) && (window.scrollX || window.scrollY)) {
     var svg = d3.select(document.body)
@@ -3519,23 +2938,18 @@ function d3_svg_mousePoint(container, e) {
     svg.remove();
   }
   if (d3_mouse_bug44083) {
-    point.x = e.pageX;
-    point.y = e.pageY;
+    point.x = d3.event.pageX;
+    point.y = d3.event.pageY;
   } else {
-    point.x = e.clientX;
-    point.y = e.clientY;
+    point.x = d3.event.clientX;
+    point.y = d3.event.clientY;
   }
   point = point.matrixTransform(container.getScreenCTM().inverse());
   return [point.x, point.y];
 };
-d3.svg.touches = function(container) {
-  var touches = d3.event.touches;
-  return touches ? d3_array(touches).map(function(touch) {
-    var point = d3_svg_mousePoint(container, touch);
-    point.identifier = touch.identifier;
-    return point;
-  }) : [];
-};
+
+// https://bugs.webkit.org/show_bug.cgi?id=44083
+var d3_mouse_bug44083 = /WebKit/.test(navigator.userAgent) ? -1 : 0;
 d3.svg.symbol = function() {
   var type = d3_svg_symbolType,
       size = d3_svg_symbolSize;
@@ -3562,6 +2976,16 @@ d3.svg.symbol = function() {
   return symbol;
 };
 
+// TODO cross-diagonal?
+d3.svg.symbolTypes = [
+  "circle",
+  "cross",
+  "diamond",
+  "square",
+  "triangle-down",
+  "triangle-up"
+];
+
 function d3_svg_symbolSize() {
   return 64;
 }
@@ -3570,7 +2994,6 @@ function d3_svg_symbolType() {
   return "circle";
 }
 
-// TODO cross-diagonal?
 var d3_svg_symbols = {
   "circle": function(size) {
     var r = Math.sqrt(size / Math.PI);
@@ -3630,520 +3053,6 @@ var d3_svg_symbols = {
   }
 };
 
-d3.svg.symbolTypes = d3.keys(d3_svg_symbols);
-
 var d3_svg_symbolSqrt3 = Math.sqrt(3),
     d3_svg_symbolTan30 = Math.tan(30 * Math.PI / 180);
-d3.svg.axis = function() {
-  var scale = d3.scale.linear(),
-      orient = "bottom",
-      tickMajorSize = 6,
-      tickMinorSize = 6,
-      tickEndSize = 6,
-      tickPadding = 3,
-      tickArguments_ = [10],
-      tickFormat_,
-      tickSubdivide = 0;
-
-  function axis(selection) {
-    selection.each(function(d, i, j) {
-      var g = d3.select(this);
-
-      // If selection is a transition, create subtransitions.
-      var transition = selection.delay ? function(o) {
-        var id = d3_transitionInheritId;
-        try {
-          d3_transitionInheritId = selection.id;
-          return o.transition()
-              .delay(selection[j][i].delay)
-              .duration(selection[j][i].duration)
-              .ease(selection.ease());
-        } finally {
-          d3_transitionInheritId = id;
-        }
-      } : Object;
-
-      // Ticks.
-      var ticks = scale.ticks.apply(scale, tickArguments_),
-          tickFormat = tickFormat_ == null ? scale.tickFormat.apply(scale, tickArguments_) : tickFormat_;
-
-      // Minor ticks.
-      var subticks = d3_svg_axisSubdivide(scale, ticks, tickSubdivide),
-          subtick = g.selectAll(".minor").data(subticks, String),
-          subtickEnter = subtick.enter().insert("svg:line", "g").attr("class", "tick minor").style("opacity", 1e-6),
-          subtickExit = transition(subtick.exit()).style("opacity", 1e-6).remove(),
-          subtickUpdate = transition(subtick).style("opacity", 1);
-
-      // Major ticks.
-      var tick = g.selectAll("g").data(ticks, String),
-          tickEnter = tick.enter().insert("svg:g", "path").style("opacity", 1e-6),
-          tickExit = transition(tick.exit()).style("opacity", 1e-6).remove(),
-          tickUpdate = transition(tick).style("opacity", 1),
-          tickTransform;
-
-      // Domain.
-      var range = d3_scaleExtent(scale.range()),
-          path = g.selectAll(".domain").data([0]),
-          pathEnter = path.enter().append("svg:path").attr("class", "domain"),
-          pathUpdate = transition(path);
-
-      // Stash the new scale and grab the old scale.
-      var scale0 = this.__chart__ || scale;
-      this.__chart__ = scale.copy();
-
-      tickEnter.append("svg:line").attr("class", "tick");
-      tickEnter.append("svg:text");
-      tickUpdate.select("text").text(tickFormat);
-
-      switch (orient) {
-        case "bottom": {
-          tickTransform = d3_svg_axisX;
-          subtickUpdate.attr("x2", 0).attr("y2", tickMinorSize);
-          tickUpdate.select("line").attr("x2", 0).attr("y2", tickMajorSize);
-          tickUpdate.select("text").attr("x", 0).attr("y", Math.max(tickMajorSize, 0) + tickPadding).attr("dy", ".71em").attr("text-anchor", "middle");
-          pathUpdate.attr("d", "M" + range[0] + "," + tickEndSize + "V0H" + range[1] + "V" + tickEndSize);
-          break;
-        }
-        case "top": {
-          tickTransform = d3_svg_axisX;
-          subtickUpdate.attr("x2", 0).attr("y2", -tickMinorSize);
-          tickUpdate.select("line").attr("x2", 0).attr("y2", -tickMajorSize);
-          tickUpdate.select("text").attr("x", 0).attr("y", -(Math.max(tickMajorSize, 0) + tickPadding)).attr("dy", "0em").attr("text-anchor", "middle");
-          pathUpdate.attr("d", "M" + range[0] + "," + -tickEndSize + "V0H" + range[1] + "V" + -tickEndSize);
-          break;
-        }
-        case "left": {
-          tickTransform = d3_svg_axisY;
-          subtickUpdate.attr("x2", -tickMinorSize).attr("y2", 0);
-          tickUpdate.select("line").attr("x2", -tickMajorSize).attr("y2", 0);
-          tickUpdate.select("text").attr("x", -(Math.max(tickMajorSize, 0) + tickPadding)).attr("y", 0).attr("dy", ".32em").attr("text-anchor", "end");
-          pathUpdate.attr("d", "M" + -tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + -tickEndSize);
-          break;
-        }
-        case "right": {
-          tickTransform = d3_svg_axisY;
-          subtickUpdate.attr("x2", tickMinorSize).attr("y2", 0);
-          tickUpdate.select("line").attr("x2", tickMajorSize).attr("y2", 0);
-          tickUpdate.select("text").attr("x", Math.max(tickMajorSize, 0) + tickPadding).attr("y", 0).attr("dy", ".32em").attr("text-anchor", "start");
-          pathUpdate.attr("d", "M" + tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + tickEndSize);
-          break;
-        }
-      }
-
-      tickEnter.call(tickTransform, scale0);
-      tickUpdate.call(tickTransform, scale);
-      tickExit.call(tickTransform, scale);
-
-      subtickEnter.call(tickTransform, scale0);
-      subtickUpdate.call(tickTransform, scale);
-      subtickExit.call(tickTransform, scale);
-    });
-  }
-
-  axis.scale = function(x) {
-    if (!arguments.length) return scale;
-    scale = x;
-    return axis;
-  };
-
-  axis.orient = function(x) {
-    if (!arguments.length) return orient;
-    orient = x;
-    return axis;
-  };
-
-  axis.ticks = function() {
-    if (!arguments.length) return tickArguments_;
-    tickArguments_ = arguments;
-    return axis;
-  };
-
-  axis.tickFormat = function(x) {
-    if (!arguments.length) return tickFormat_;
-    tickFormat_ = x;
-    return axis;
-  };
-
-  axis.tickSize = function(x, y, z) {
-    if (!arguments.length) return tickMajorSize;
-    var n = arguments.length - 1;
-    tickMajorSize = +x;
-    tickMinorSize = n > 1 ? +y : tickMajorSize;
-    tickEndSize = n > 0 ? +arguments[n] : tickMajorSize;
-    return axis;
-  };
-
-  axis.tickPadding = function(x) {
-    if (!arguments.length) return tickPadding;
-    tickPadding = +x;
-    return axis;
-  };
-
-  axis.tickSubdivide = function(x) {
-    if (!arguments.length) return tickSubdivide;
-    tickSubdivide = +x;
-    return axis;
-  };
-
-  return axis;
-};
-
-function d3_svg_axisX(selection, x) {
-  selection.attr("transform", function(d) { return "translate(" + x(d) + ",0)"; });
-}
-
-function d3_svg_axisY(selection, y) {
-  selection.attr("transform", function(d) { return "translate(0," + y(d) + ")"; });
-}
-
-function d3_svg_axisSubdivide(scale, ticks, m) {
-  subticks = [];
-  if (m && ticks.length > 1) {
-    var extent = d3_scaleExtent(scale.domain()),
-        subticks,
-        i = -1,
-        n = ticks.length,
-        d = (ticks[1] - ticks[0]) / ++m,
-        j,
-        v;
-    while (++i < n) {
-      for (j = m; --j > 0;) {
-        if ((v = +ticks[i] - j * d) >= extent[0]) {
-          subticks.push(v);
-        }
-      }
-    }
-    for (--i, j = 0; ++j < m && (v = +ticks[i] + j * d) < extent[1];) {
-      subticks.push(v);
-    }
-  }
-  return subticks;
-}
-d3.behavior = {};
-d3.behavior.drag = function() {
-  var event = d3.dispatch("drag", "dragstart", "dragend");
-
-  function drag() {
-    this
-        .on("mousedown.drag", mousedown)
-        .on("touchstart.drag", mousedown);
-
-    d3.select(window)
-        .on("mousemove.drag", d3_behavior_dragMove)
-        .on("touchmove.drag", d3_behavior_dragMove)
-        .on("mouseup.drag", d3_behavior_dragUp, true)
-        .on("touchend.drag", d3_behavior_dragUp, true)
-        .on("click.drag", d3_behavior_dragClick, true);
-  }
-
-  // snapshot the local context for subsequent dispatch
-  function start() {
-    d3_behavior_dragEvent = event;
-    d3_behavior_dragEventTarget = d3.event.target;
-    d3_behavior_dragOffset = d3_behavior_dragPoint((d3_behavior_dragTarget = this).parentNode);
-    d3_behavior_dragMoved = 0;
-    d3_behavior_dragArguments = arguments;
-  }
-
-  function mousedown() {
-    start.apply(this, arguments);
-    d3_behavior_dragDispatch("dragstart");
-  }
-
-  drag.on = function(type, listener) {
-    event[type].add(listener);
-    return drag;
-  };
-
-  return drag;
-};
-
-var d3_behavior_dragEvent,
-    d3_behavior_dragEventTarget,
-    d3_behavior_dragTarget,
-    d3_behavior_dragArguments,
-    d3_behavior_dragOffset,
-    d3_behavior_dragMoved,
-    d3_behavior_dragStopClick;
-
-function d3_behavior_dragDispatch(type) {
-  var o = d3.event, p = d3_behavior_dragTarget.parentNode, dx = 0, dy = 0;
-
-  if (p) {
-    p = d3_behavior_dragPoint(p);
-    dx = p[0] - d3_behavior_dragOffset[0];
-    dy = p[1] - d3_behavior_dragOffset[1];
-    d3_behavior_dragOffset = p;
-    d3_behavior_dragMoved |= dx | dy;
-  }
-
-  try {
-    d3.event = {dx: dx, dy: dy};
-    d3_behavior_dragEvent[type].dispatch.apply(d3_behavior_dragTarget, d3_behavior_dragArguments);
-  } finally {
-    d3.event = o;
-  }
-
-  o.preventDefault();
-}
-
-function d3_behavior_dragPoint(container) {
-  return d3.event.touches
-      ? d3.svg.touches(container)[0]
-      : d3.svg.mouse(container);
-}
-
-function d3_behavior_dragMove() {
-  if (!d3_behavior_dragTarget) return;
-  var parent = d3_behavior_dragTarget.parentNode;
-
-  // O NOES! The drag element was removed from the DOM.
-  if (!parent) return d3_behavior_dragUp();
-
-  d3_behavior_dragDispatch("drag");
-  d3_behavior_dragCancel();
-}
-
-function d3_behavior_dragUp() {
-  if (!d3_behavior_dragTarget) return;
-  d3_behavior_dragDispatch("dragend");
-  d3_behavior_dragTarget = null;
-
-  // If the node was moved, prevent the mouseup from propagating.
-  // Also prevent the subsequent click from propagating (e.g., for anchors).
-  if (d3_behavior_dragMoved && d3_behavior_dragEventTarget === d3.event.target) {
-    d3_behavior_dragStopClick = true;
-    d3_behavior_dragCancel();
-  }
-}
-
-function d3_behavior_dragClick() {
-  if (d3_behavior_dragStopClick && d3_behavior_dragEventTarget === d3.event.target) {
-    d3_behavior_dragCancel();
-    d3_behavior_dragStopClick = false;
-    d3_behavior_dragEventTarget = null;
-  }
-}
-
-function d3_behavior_dragCancel() {
-  d3.event.stopPropagation();
-  d3.event.preventDefault();
-}
-// TODO unbind zoom behavior?
-// TODO unbind listener?
-d3.behavior.zoom = function() {
-  var xyz = [0, 0, 0],
-      event = d3.dispatch("zoom");
-
-  function zoom() {
-    this
-        .on("mousedown.zoom", mousedown)
-        .on("mousewheel.zoom", mousewheel)
-        .on("DOMMouseScroll.zoom", mousewheel)
-        .on("dblclick.zoom", dblclick)
-        .on("touchstart.zoom", touchstart);
-
-    d3.select(window)
-        .on("mousemove.zoom", d3_behavior_zoomMousemove)
-        .on("mouseup.zoom", d3_behavior_zoomMouseup)
-        .on("touchmove.zoom", d3_behavior_zoomTouchmove)
-        .on("touchend.zoom", d3_behavior_zoomTouchup)
-        .on("click.zoom", d3_behavior_zoomClick, true);
-  }
-
-  // snapshot the local context for subsequent dispatch
-  function start() {
-    d3_behavior_zoomXyz = xyz;
-    d3_behavior_zoomDispatch = event.zoom.dispatch;
-    d3_behavior_zoomEventTarget = d3.event.target;
-    d3_behavior_zoomTarget = this;
-    d3_behavior_zoomArguments = arguments;
-  }
-
-  function mousedown() {
-    start.apply(this, arguments);
-    d3_behavior_zoomPanning = d3_behavior_zoomLocation(d3.svg.mouse(d3_behavior_zoomTarget));
-    d3_behavior_zoomMoved = false;
-    d3.event.preventDefault();
-    window.focus();
-  }
-
-  // store starting mouse location
-  function mousewheel() {
-    start.apply(this, arguments);
-    if (!d3_behavior_zoomZooming) d3_behavior_zoomZooming = d3_behavior_zoomLocation(d3.svg.mouse(d3_behavior_zoomTarget));
-    d3_behavior_zoomTo(d3_behavior_zoomDelta() + xyz[2], d3.svg.mouse(d3_behavior_zoomTarget), d3_behavior_zoomZooming);
-  }
-
-  function dblclick() {
-    start.apply(this, arguments);
-    var mouse = d3.svg.mouse(d3_behavior_zoomTarget);
-    d3_behavior_zoomTo(d3.event.shiftKey ? Math.ceil(xyz[2] - 1) : Math.floor(xyz[2] + 1), mouse, d3_behavior_zoomLocation(mouse));
-  }
-
-  // doubletap detection
-  function touchstart() {
-    start.apply(this, arguments);
-    var touches = d3_behavior_zoomTouchup(),
-        touch,
-        now = Date.now();
-    if ((touches.length === 1) && (now - d3_behavior_zoomLast < 300)) {
-      d3_behavior_zoomTo(1 + Math.floor(xyz[2]), touch = touches[0], d3_behavior_zoomLocations[touch.identifier]);
-    }
-    d3_behavior_zoomLast = now;
-  }
-
-  zoom.on = function(type, listener) {
-    event[type].add(listener);
-    return zoom;
-  };
-
-  return zoom;
-};
-
-var d3_behavior_zoomDiv,
-    d3_behavior_zoomPanning,
-    d3_behavior_zoomZooming,
-    d3_behavior_zoomLocations = {}, // identifier -> location
-    d3_behavior_zoomLast = 0,
-    d3_behavior_zoomXyz,
-    d3_behavior_zoomDispatch,
-    d3_behavior_zoomEventTarget,
-    d3_behavior_zoomTarget,
-    d3_behavior_zoomArguments,
-    d3_behavior_zoomMoved,
-    d3_behavior_zoomStopClick;
-
-function d3_behavior_zoomLocation(point) {
-  return [
-    point[0] - d3_behavior_zoomXyz[0],
-    point[1] - d3_behavior_zoomXyz[1],
-    d3_behavior_zoomXyz[2]
-  ];
-}
-
-// detect the pixels that would be scrolled by this wheel event
-function d3_behavior_zoomDelta() {
-
-  // mousewheel events are totally broken!
-  // https://bugs.webkit.org/show_bug.cgi?id=40441
-  // not only that, but Chrome and Safari differ in re. to acceleration!
-  if (!d3_behavior_zoomDiv) {
-    d3_behavior_zoomDiv = d3.select("body").append("div")
-        .style("visibility", "hidden")
-        .style("top", 0)
-        .style("height", 0)
-        .style("width", 0)
-        .style("overflow-y", "scroll")
-      .append("div")
-        .style("height", "2000px")
-      .node().parentNode;
-  }
-
-  var e = d3.event, delta;
-  try {
-    d3_behavior_zoomDiv.scrollTop = 1000;
-    d3_behavior_zoomDiv.dispatchEvent(e);
-    delta = 1000 - d3_behavior_zoomDiv.scrollTop;
-  } catch (error) {
-    delta = e.wheelDelta || (-e.detail * 5);
-  }
-
-  return delta * .005;
-}
-
-// Note: Since we don't rotate, it's possible for the touches to become
-// slightly detached from their original positions. Thus, we recompute the
-// touch points on touchend as well as touchstart!
-function d3_behavior_zoomTouchup() {
-  var touches = d3.svg.touches(d3_behavior_zoomTarget),
-      i = -1,
-      n = touches.length,
-      touch;
-  while (++i < n) d3_behavior_zoomLocations[(touch = touches[i]).identifier] = d3_behavior_zoomLocation(touch);
-  return touches;
-}
-
-function d3_behavior_zoomTouchmove() {
-  var touches = d3.svg.touches(d3_behavior_zoomTarget);
-  switch (touches.length) {
-
-    // single-touch pan
-    case 1: {
-      var touch = touches[0];
-      d3_behavior_zoomTo(d3_behavior_zoomXyz[2], touch, d3_behavior_zoomLocations[touch.identifier]);
-      break;
-    }
-
-    // double-touch pan + zoom
-    case 2: {
-      var p0 = touches[0],
-          p1 = touches[1],
-          p2 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2],
-          l0 = d3_behavior_zoomLocations[p0.identifier],
-          l1 = d3_behavior_zoomLocations[p1.identifier],
-          l2 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2, l0[2]];
-      d3_behavior_zoomTo(Math.log(d3.event.scale) / Math.LN2 + l0[2], p2, l2);
-      break;
-    }
-  }
-}
-
-function d3_behavior_zoomMousemove() {
-  d3_behavior_zoomZooming = null;
-  if (d3_behavior_zoomPanning) {
-    d3_behavior_zoomMoved = true;
-    d3_behavior_zoomTo(d3_behavior_zoomXyz[2], d3.svg.mouse(d3_behavior_zoomTarget), d3_behavior_zoomPanning);
-  }
-}
-
-function d3_behavior_zoomMouseup() {
-  if (d3_behavior_zoomPanning) {
-    if (d3_behavior_zoomMoved && d3_behavior_zoomEventTarget === d3.event.target) {
-      d3_behavior_zoomStopClick = true;
-    }
-    d3_behavior_zoomMousemove();
-    d3_behavior_zoomPanning = null;
-  }
-}
-
-function d3_behavior_zoomClick() {
-  if (d3_behavior_zoomStopClick && d3_behavior_zoomEventTarget === d3.event.target) {
-    d3.event.stopPropagation();
-    d3.event.preventDefault();
-    d3_behavior_zoomStopClick = false;
-    d3_behavior_zoomEventTarget = null;
-  }
-}
-
-function d3_behavior_zoomTo(z, x0, x1) {
-  var K = Math.pow(2, (d3_behavior_zoomXyz[2] = z) - x1[2]),
-      x = d3_behavior_zoomXyz[0] = x0[0] - K * x1[0],
-      y = d3_behavior_zoomXyz[1] = x0[1] - K * x1[1],
-      o = d3.event, // Events can be reentrant (e.g., focus).
-      k = Math.pow(2, z);
-
-  d3.event = {
-    scale: k,
-    translate: [x, y],
-    transform: function(sx, sy) {
-      if (sx) transform(sx, x);
-      if (sy) transform(sy, y);
-    }
-  };
-
-  function transform(scale, o) {
-    var domain = scale.__domain || (scale.__domain = scale.domain()),
-        range = scale.range().map(function(v) { return (v - o) / k; });
-    scale.domain(domain).domain(range.map(scale.invert));
-  }
-
-  try {
-    d3_behavior_zoomDispatch.apply(d3_behavior_zoomTarget, d3_behavior_zoomArguments);
-  } finally {
-    d3.event = o;
-  }
-
-  o.preventDefault();
-}
-})();
+})()