d3_rails 0.0.9 → 0.0.10

data/lib/d3_rails/version.rb

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

data/vendor/assets/javascripts/d3.csv.js

@@ -0,0 +1,92 @@
+(function(){d3.csv = function(url, callback) {
+  d3.text(url, "text/csv", function(text) {
+    callback(text && d3.csv.parse(text));
+  });
+};
+d3.csv.parse = function(text) {
+  var header;
+  return d3.csv.parseRows(text, function(row, i) {
+    if (i) {
+      var o = {}, j = -1, m = header.length;
+      while (++j < m) o[header[j]] = row[j];
+      return o;
+    } else {
+      header = row;
+      return null;
+    }
+  });
+};
+
+d3.csv.parseRows = function(text, f) {
+  var EOL = {}, // sentinel value for end-of-line
+      EOF = {}, // sentinel value for end-of-file
+      rows = [], // output rows
+      re = /\r\n|[,\r\n]/g, // field separator regex
+      n = 0, // the current line number
+      t, // the current token
+      eol; // is the current token followed by EOL?
+
+  re.lastIndex = 0; // work-around bug in FF 3.6
+
+  /** @private Returns the next token. */
+  function token() {
+    if (re.lastIndex >= text.length) return EOF; // special case: end of file
+    if (eol) { eol = false; return EOL; } // special case: end of line
+
+    // special case: quotes
+    var j = re.lastIndex;
+    if (text.charCodeAt(j) === 34) {
+      var i = j;
+      while (i++ < text.length) {
+        if (text.charCodeAt(i) === 34) {
+          if (text.charCodeAt(i + 1) !== 34) break;
+          i++;
+        }
+      }
+      re.lastIndex = i + 2;
+      var c = text.charCodeAt(i + 1);
+      if (c === 13) {
+        eol = true;
+        if (text.charCodeAt(i + 2) === 10) re.lastIndex++;
+      } else if (c === 10) {
+        eol = true;
+      }
+      return text.substring(j + 1, i).replace(/""/g, "\"");
+    }
+
+    // common case
+    var m = re.exec(text);
+    if (m) {
+      eol = m[0].charCodeAt(0) !== 44;
+      return text.substring(j, m.index);
+    }
+    re.lastIndex = text.length;
+    return text.substring(j);
+  }
+
+  while ((t = token()) !== EOF) {
+    var a = [];
+    while ((t !== EOL) && (t !== EOF)) {
+      a.push(t);
+      t = token();
+    }
+    if (f && !(a = f(a, n++))) continue;
+    rows.push(a);
+  }
+
+  return rows;
+};
+d3.csv.format = function(rows) {
+  return rows.map(d3_csv_formatRow).join("\n");
+};
+
+function d3_csv_formatRow(row) {
+  return row.map(d3_csv_formatValue).join(",");
+}
+
+function d3_csv_formatValue(text) {
+  return /[",\n]/.test(text)
+      ? "\"" + text.replace(/\"/g, "\"\"") + "\""
+      : text;
+}
+})();

data/vendor/assets/javascripts/d3.js

@@ -1,22 +1,26 @@
-(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();
+(function(){if (!Date.now) Date.now = function() {
+  return +new Date;
 };
+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.6"}; // semver
 var d3_array = d3_arraySlice; // conversion for NodeLists
 
-function d3_arrayCopy(psuedoarray) {
-  var i = -1, n = psuedoarray.length, array = [];
-  while (++i < n) array.push(psuedoarray[i]);
+function d3_arrayCopy(pseudoarray) {
+  var i = -1, n = pseudoarray.length, array = [];
+  while (++i < n) array.push(pseudoarray[i]);
   return array;
 }
 
-function d3_arraySlice(psuedoarray) {
-  return Array.prototype.slice.call(psuedoarray);
+function d3_arraySlice(pseudoarray) {
+  return Array.prototype.slice.call(pseudoarray);
 }
 
 try {
@@ -24,8 +28,23 @@ 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) {
@@ -35,34 +54,156 @@ d3.rebind = function(object, method) {
   };
 };
 d3.ascending = function(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
 };
 d3.descending = function(a, b) {
-  return b < a ? -1 : b > a ? 1 : 0;
+  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;
 };
 d3.min = function(array, f) {
-  var i = 0,
+  var i = -1,
       n = array.length,
-      a = array[0],
+      a,
       b;
-  if (arguments.length == 1) {
-    while (++i < n) if (a > (b = array[i])) 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 {
-    a = f(array[0]);
-    while (++i < n) if (a > (b = f(array[i]))) a = b;
+    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) {
-    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;
+  if (arguments.length === 1) f = d3.ascending;
+  while (++i < n) {
+    if (f.call(array, a, b = array[i]) > 0) {
+      a = b;
+    }
+  }
+  return a;
+};
+d3.last = 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;
+    }
   }
   return a;
 };
@@ -168,6 +309,13 @@ 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);
 };
@@ -195,27 +343,19 @@ 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 == 1) { stop = start; start = 0; }
-  if (step == null) step = 1;
+  if (arguments.length < 3) {
+    step = 1;
+    if (arguments.length < 2) {
+      stop = start;
+      start = 0;
+    }
+  }
   if ((stop - start) / step == Infinity) throw new Error("infinite range");
   var range = [],
        i = -1,
@@ -228,14 +368,19 @@ d3.requote = function(s) {
   return s.replace(d3_requote_re, "\\$&");
 };
 
-var d3_requote_re = /[\\\^\$\*\+\?\[\]\(\)\.\{\}]/g;
+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);
+};
 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);
 };
@@ -338,7 +483,7 @@ function d3_dispatch(type) {
 
   return dispatch;
 };
-// TODO align, type
+// TODO align
 d3.format = function(specifier) {
   var match = d3_format_re.exec(specifier),
       fill = match[1] || " ",
@@ -347,23 +492,50 @@ d3.format = function(specifier) {
       width = +match[6],
       comma = match[7],
       precision = match[8],
-      type = match[9];
-  if (precision) precision = precision.substring(1);
+      type = match[9],
+      scale = 1,
+      suffix = "",
+      integer = false;
+
+  if (precision) precision = +precision.substring(1);
+
   if (zfill) {
     fill = "0"; // TODO align = "=";
     if (comma) width -= Math.floor((width - 1) / 4);
   }
-  if (type == "d") precision = "0";
+
+  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;
+
   return function(value) {
-    var number = +value,
-        negative = (number < 0) && (number = -number) ? "\u2212" : sign;
 
     // Return the empty string for floats formatted as ints.
-    if ((type == "d") && (number % 1)) return "";
+    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;
+    }
 
-    // Convert the input value to the desired precision.
-    if (precision) value = number.toFixed(precision);
-    else value = "" + number;
+    // Convert to the desired precision.
+    value = type(value, precision);
 
     // If the fill character is 0, the sign and group is applied after the fill.
     if (zfill) {
@@ -381,13 +553,28 @@ d3.format = function(specifier) {
       if (length < width) value = new Array(width - length + 1).join(fill) + value;
     }
 
-    return value;
+    return value + suffix;
   };
 };
 
 // [[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("."),
@@ -396,6 +583,26 @@ 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
  *
@@ -458,9 +665,15 @@ 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_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1)));
+  return d3_ease_clamp(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);
@@ -488,7 +701,7 @@ function d3_ease_sin(t) {
 }
 
 function d3_ease_exp(t) {
-  return t ? Math.pow(2, 10 * (t - 1)) - 1e-3 : 0;
+  return Math.pow(2, 10 * (t - 1));
 }
 
 function d3_ease_circle(t) {
@@ -520,14 +733,9 @@ function d3_ease_bounce(t) {
 }
 d3.event = null;
 d3.interpolate = function(a, b) {
-  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);
+  var i = d3.interpolators.length, f;
+  while (--i >= 0 && !(f = d3.interpolators[i](a, b)));
+  return f;
 };
 
 d3.interpolateNumber = function(a, b) {
@@ -607,7 +815,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; };
   }
 
@@ -628,10 +836,10 @@ d3.interpolateRgb = function(a, b) {
       bg = b.g - ag,
       bb = b.b - ab;
   return function(t) {
-    return "rgb(" + Math.round(ar + br * t)
-        + "," + Math.round(ag + bg * t)
-        + "," + Math.round(ab + bb * 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));
   };
 };
 
@@ -696,27 +904,76 @@ function d3_interpolateByName(n) {
       ? d3.interpolateRgb
       : d3.interpolate;
 }
-/**
- * @param {number=} g
- * @param {number=} b
- */
+
+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)); };
+}
 d3.rgb = function(r, g, b) {
-  return arguments.length == 1
-      ? d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb)
+  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))
       : d3_rgb(~~r, ~~g, ~~b);
 };
 
 function d3_rgb(r, g, b) {
-  return {r: r, g: g, b: b, toString: d3_rgb_format};
+  return new d3_Rgb(r, g, b);
 }
 
-/** @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(r, g, b) {
+  this.r = r;
+  this.g = g;
+  this.b = b;
 }
 
+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() {
+  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" + v.toString(16) : v.toString(16);
+  return v < 0x10
+      ? "0" + Math.max(0, v).toString(16)
+      : Math.min(255, v).toString(16);
 }
 
 function d3_rgb_parse(format, rgb, hsl) {
@@ -753,12 +1010,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);
@@ -792,7 +1049,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 = {
@@ -951,25 +1208,41 @@ 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
-      ? d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl)
+  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))
       : d3_hsl(+h, +s, +l);
 };
 
 function d3_hsl(h, s, l) {
-  return {h: h, s: s, l: l, toString: d3_hsl_format};
+  return new d3_Hsl(h, s, l);
 }
 
-/** @this d3_hsl */
-function d3_hsl_format() {
-  return "hsl(" + this.h + "," + this.s * 100 + "%," + this.l * 100 + "%)";
+function d3_Hsl(h, s, l) {
+  this.h = h;
+  this.s = s;
+  this.l = l;
 }
 
+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;
@@ -998,898 +1271,845 @@ 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 d3_array(n.querySelectorAll(s)); };
+    d3_selectAll = function(s, n) { return n.querySelectorAll(s); };
 
-// Use Sizzle, if available.
-if (typeof Sizzle == "function") {
+// Prefer 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_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
-};
+var d3_selectionPrototype = [];
 
-d3.selectAll = function(selector) {
-  return typeof selector == "string"
-      ? d3_root.selectAll(selector)
-      : d3_selection([d3_array(selector)]); // assume node[]
+d3.selection = function() {
+  return d3_selectionRoot;
 };
 
-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;
-        }
+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);
       }
     }
-    return d3_selection(subgroups);
   }
 
-  // TODO select(function)?
-  groups.select = function(selector) {
-    return select(function(node) {
-      return d3_select(selector, node);
-    });
-  };
-
-  // TODO selectAll(function)?
-  groups.selectAll = function(selector) {
-    return selectAll(function(node) {
-      return d3_selectAll(selector, node);
-    });
-  };
+  return d3_selection(subgroups);
+};
 
-  // 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);
+function d3_selection_selector(selector) {
+  return function() {
+    return d3_select(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);
+}
+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;
       }
     }
-    return groups;
-  };
+  }
 
-  // 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);
-        }
+  return d3_selection(subgroups);
+};
 
-        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 d3_selection_selectorAll(selector) {
+  return function() {
+    return d3_selectAll(selector, this);
+  };
+}
+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);
+  }
 
-        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 attrNull() {
+    this.removeAttribute(name);
+  }
 
-      enterNodes.parentNode
-          = updateNodes.parentNode
-          = exitNodes.parentNode
-          = group.parentNode;
+  function attrNullNS() {
+    this.removeAttributeNS(name.space, name.local);
+  }
 
-      enter.push(enterNodes);
-      update.push(updateNodes);
-      exit.push(exitNodes);
-    }
+  function attrConstant() {
+    this.setAttribute(name, value);
+  }
 
-    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);
-      }
-    }
+  function attrConstantNS() {
+    this.setAttributeNS(name.space, name.local, value);
+  }
 
-    var selection = d3_selection(update);
-    selection.enter = function() {
-      return d3_selectionEnter(enter);
-    };
-    selection.exit = function() {
-      return d3_selection(exit);
-    };
-    return selection;
-  };
+  function attrFunction() {
+    var x = value.apply(this, arguments);
+    if (x == null) this.removeAttribute(name);
+    else this.setAttribute(name, x);
+  }
 
-  // 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 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 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;
+  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;
   }
+};
 
-  groups.empty = function() {
-    return !first(function() { return true; });
-  };
+var d3_selection_classedWhitespace = /\s+/g;
 
-  groups.node = function() {
-    return first(function() { return this; });
-  };
+function d3_selection_classed(name, value) {
+  var re = new RegExp("(^|\\s+)" + d3.requote(name) + "(\\s+|$)", "g");
 
-  groups.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();
+    if (c = node.classList) return c.contains(name);
+    var c = node.className;
+    re.lastIndex = 0;
+    return re.test(c.baseVal != null ? c.baseVal : c);
+  }
 
-    // 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 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;
     }
+  }
 
-    /** @this {Element} */
-    function attrNull() {
-      this.removeAttribute(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 attrNullNS() {
-      this.removeAttributeNS(name.space, name.local);
-    }
+  function classedFunction() {
+    (value.apply(this, arguments)
+        ? classedAdd
+        : classedRemove).call(this);
+  }
 
-    /** @this {Element} */
-    function attrConstant() {
-      this.setAttribute(name, value);
-    }
+  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 attrConstantNS() {
-      this.setAttributeNS(name.space, name.local, 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 attrFunction() {
-      var x = value.apply(this, arguments);
-      if (x == null) this.removeAttribute(name);
-      else this.setAttribute(name, x);
-    }
+  function styleNull() {
+    this.style.removeProperty(name);
+  }
 
-    /** @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 styleConstant() {
+    this.style.setProperty(name, value, priority);
+  }
 
-    return groups.each(value == null
-        ? (name.local ? attrNullNS : attrNull) : (typeof value == "function"
-        ? (name.local ? attrFunctionNS : attrFunction)
-        : (name.local ? attrConstantNS : attrConstant)));
-  };
+  function styleFunction() {
+    var x = value.apply(this, arguments);
+    if (x == null) this.style.removeProperty(name);
+    else this.style.setProperty(name, x, priority);
+  }
 
-  groups.classed = function(name, value) {
-    var re = new RegExp("(^|\\s+)" + d3.requote(name) + "(\\s+|$)", "g");
+  return this.each(value == null
+      ? styleNull : (typeof value === "function"
+      ? styleFunction : styleConstant));
+};
+d3_selectionPrototype.property = function(name, value) {
 
-    // If no value is specified, return the first value.
-    if (arguments.length < 2) {
-      return first(function() {
-        re.lastIndex = 0;
-        return re.test(this.className);
-      });
-    }
+  // If no value is specified, return the first value.
+  if (arguments.length < 2) return this.node()[name];
 
-    /** @this {Element} */
-    function classedAdd() {
-      var classes = this.className;
-      re.lastIndex = 0;
-      if (!re.test(classes)) {
-        this.className = d3_collapse(classes + " " + name);
-      }
-    }
+  function propertyNull() {
+    delete this[name];
+  }
 
-    /** @this {Element} */
-    function classedRemove() {
-      var classes = d3_collapse(this.className.replace(re, " "));
-      this.className = classes.length ? classes : null;
-    }
+  function propertyConstant() {
+    this[name] = value;
+  }
 
-    /** @this {Element} */
-    function classedFunction() {
-      (value.apply(this, arguments)
-          ? classedAdd
-          : classedRemove).call(this);
-    }
+  function propertyFunction() {
+    var x = value.apply(this, arguments);
+    if (x == null) delete this[name];
+    else this[name] = x;
+  }
 
-    return groups.each(typeof value == "function"
-        ? classedFunction : value
-        ? classedAdd
-        : classedRemove);
-  };
+  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);
 
-  groups.style = function(name, value, priority) {
-    if (arguments.length < 3) priority = null;
+  function append() {
+    return this.appendChild(document.createElement(name));
+  }
 
-    // If no value is specified, return the first value.
-    if (arguments.length < 2) {
-      return first(function() {
-        return window.getComputedStyle(this, null).getPropertyValue(name);
-      });
-    }
+  function appendNS() {
+    return this.appendChild(document.createElementNS(name.space, name.local));
+  }
 
-    /** @this {Element} */
-    function styleNull() {
-      this.style.removeProperty(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 styleConstant() {
-      this.style.setProperty(name, value, priority);
-    }
+  function insertNS() {
+    return this.insertBefore(
+        document.createElementNS(name.space, name.local),
+        d3_select(before, this));
+  }
 
-    /** @this {Element} */
-    function styleFunction() {
-      var x = value.apply(this, arguments);
-      if (x == null) this.style.removeProperty(name);
-      else this.style.setProperty(name, x, 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);
+      }
 
-    return groups.each(value == null
-        ? styleNull : (typeof value == "function"
-        ? styleFunction : styleConstant));
-  };
-
-  groups.property = function(name, value) {
-    name = d3.ns.qualify(name);
-
-    // If no value is specified, return the first value.
-    if (arguments.length < 2) {
-      return first(function() {
-        return this[name];
-      });
-    }
-
-    /** @this {Element} */
-    function propertyNull() {
-      delete this[name];
-    }
+      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];
+      }
 
-    /** @this {Element} */
-    function propertyConstant() {
-      this[name] = value;
+      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;
+      }
     }
 
-    /** @this {Element} */
-    function propertyFunction() {
-      var x = value.apply(this, arguments);
-      if (x == null) delete this[name];
-      else this[name] = x;
-    }
+    enterNodes.update
+        = updateNodes;
 
-    return groups.each(value == null
-        ? propertyNull : (typeof value == "function"
-        ? propertyFunction : propertyConstant));
-  };
+    enterNodes.parentNode
+        = updateNodes.parentNode
+        = exitNodes.parentNode
+        = group.parentNode;
 
-  groups.text = function(value) {
+    enter.push(enterNodes);
+    update.push(updateNodes);
+    exit.push(exitNodes);
+  }
 
-    // If no value is specified, return the first value.
-    if (arguments.length < 1) {
-      return first(function() {
-        return this.textContent;
-      });
+  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));
+    }
+  } else {
+    while (++i < n) {
+      bind(group = this[i], data);
     }
+  }
+
+  var selection = d3_selection(update);
+  selection.enter = function() { return d3_selection_enter(enter); };
+  selection.exit = function() { return d3_selection(exit); };
+  return selection;
+};
 
-    /** @this {Element} */
-    function textConstant() {
-      this.textContent = value;
+function d3_selection_dataNode(data) {
+  return {__data__: data};
+}
+// 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 textFunction() {
-      this.textContent = value.apply(this, arguments);
+  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;
+      }
     }
+  }
+  return this;
+};
 
-    return groups.each(typeof value == "function"
-        ? textFunction : textConstant);
+function d3_selection_sortComparator(comparator) {
+  if (!arguments.length) comparator = d3.ascending;
+  return function(a, b) {
+    return comparator(a && a.__data__, b && b.__data__);
   };
-
-  groups.html = function(value) {
-
-    // If no value is specified, return the first value.
-    if (arguments.length < 1) {
-      return first(function() {
-        return this.innerHTML;
-      });
+}
+// 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;
+      }
     }
 
-    /** @this {Element} */
-    function htmlConstant() {
-      this.innerHTML = value;
+    // 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);
     }
-
-    /** @this {Element} */
-    function htmlFunction() {
-      this.innerHTML = value.apply(this, arguments);
+  }
+  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;
+    }
+  }
+  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);
     }
+  }
 
-    return groups.each(typeof value == "function"
-        ? htmlFunction : htmlConstant);
-  };
+  return d3_transition(subgroups, d3_transitionInheritId || ++d3_transitionId, Date.now());
+};
+var d3_selectionRoot = d3_selection([[document]]);
 
-  // TODO append(node)?
-  // TODO append(function)?
-  groups.append = function(name) {
-    name = d3.ns.qualify(name);
+d3_selectionRoot[0].parentNode = document.documentElement;
 
-    function append(node) {
-      return node.appendChild(document.createElement(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 appendNS(node) {
-      return node.appendChild(document.createElementNS(name.space, name.local));
+// TODO selectAll(function)
+d3.selectAll = function(selector) {
+  return typeof selector === "string"
+      ? d3_selectionRoot.selectAll(selector)
+      : d3_selection([d3_array(selector)]); // assume node[]
+};
+function d3_selection_enter(selection) {
+  d3_arraySubclass(selection, d3_selection_enterPrototype);
+  return selection;
+}
+
+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.node = d3_selectionPrototype.node;
+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);
+      }
     }
+  }
 
-    return select(name.local ? appendNS : append);
-  };
+  return d3_selection(subgroups);
+};
+function d3_transition(groups, id, time) {
+  d3_arraySubclass(groups, d3_transitionPrototype);
 
-  // TODO insert(node, function)?
-  // TODO insert(function, string)?
-  // TODO insert(function, function)?
-  groups.insert = function(name, before) {
-    name = d3.ns.qualify(name);
+  var tweens = {},
+      event = d3.dispatch("start", "end"),
+      ease = d3_transitionEase;
 
-    function insert(node) {
-      return node.insertBefore(
-          document.createElement(name),
-          d3_select(before, node));
-    }
+  groups.id = id;
 
-    function insertNS(node) {
-      return node.insertBefore(
-          document.createElementNS(name.space, name.local),
-          d3_select(before, node));
-    }
+  groups.time = time;
 
-    return select(name.local ? insertNS : insert);
+  groups.tween = function(name, tween) {
+    if (arguments.length < 2) return tweens[name];
+    if (tween == null) delete tweens[name];
+    else tweens[name] = tween;
+    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.ease = function(value) {
+    if (!arguments.length) return ease;
+    ease = typeof value === "function" ? value : d3.ease.apply(d3, arguments);
+    return groups;
   };
 
-  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;
-        }
-      }
-    }
+  groups.each = function(type, listener) {
+    if (arguments.length < 2) return d3_transition_each.call(groups, type);
+    event[type].add(listener);
     return groups;
   };
 
-  // type can be namespaced, e.g., "click.foo"
-  // listener can be null for removal
-  groups.on = function(type, listener) {
+  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});
 
-    // parse the type specifier
-    var i = type.indexOf("."),
-        typo = i == -1 ? type : type.substring(0, i),
-        name = "__on" + type;
+      ++lock.count;
 
-    // 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);
+      delay <= elapsed ? start(elapsed) : d3.timer(start, delay, time);
 
-      // 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;
+      function start(elapsed) {
+        if (lock.active > id) return stop();
+        lock.active = id;
+
+        for (var tween in tweens) {
+          if (tween = tweens[tween].call(node, d, i)) {
+            tweened.push(tween);
+          }
         }
+
+        event.start.dispatch.call(node, d, i);
+        if (!tick(elapsed)) d3.timer(tick, 0, time);
+        return 1;
       }
-    });
-  };
 
-  // TODO slice?
+      function tick(elapsed) {
+        if (lock.active !== id) return stop();
 
-  groups.transition = function() {
-    return d3_transition(groups);
-  };
+        var t = (elapsed - delay) / duration,
+            e = ease(t),
+            n = tweened.length;
 
-  groups.call = d3_call;
-
-  return groups;
-}
+        while (n > 0) {
+          tweened[--n].call(node, e);
+        }
 
-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);
+        if (t >= 1) {
+          stop();
+          d3_transitionInheritId = id;
+          event.end.dispatch.call(node, d, i);
+          d3_transitionInheritId = 0;
+          return 1;
         }
       }
-    }
-    return d3_selection(subgroups);
-  }
-
-  // TODO append(node)?
-  // TODO append(function)?
-  groups.append = function(name) {
-    name = d3.ns.qualify(name);
-
-    function append(node) {
-      return node.appendChild(document.createElement(name));
-    }
 
-    function appendNS(node) {
-      return node.appendChild(document.createElementNS(name.space, name.local));
-    }
-
-    return select(name.local ? appendNS : append);
-  };
+      function stop() {
+        if (!--lock.count) delete node.__transition__;
+        return 1;
+      }
+    });
+    return 1;
+  }, 0, time);
 
-  // TODO insert(node, function)?
-  // TODO insert(function, string)?
-  // TODO insert(function, function)?
-  groups.insert = function(name, before) {
-    name = d3.ns.qualify(name);
+  return groups;
+}
 
-    function insert(node) {
-      return node.insertBefore(
-          document.createElement(name),
-          d3_select(before, node));
-    }
+var d3_transitionRemove = {};
 
-    function insertNS(node) {
-      return node.insertBefore(
-          document.createElementNS(name.space, name.local),
-          d3_select(before, node));
-    }
+function d3_transitionNull(d, i, a) {
+  return a != "" && d3_transitionRemove;
+}
 
-    return select(name.local ? insertNS : insert);
-  };
+function d3_transitionTween(b) {
 
-  return groups;
-}
+  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 d3_selection_comparator(comparator) {
-  if (!arguments.length) comparator = d3.ascending;
-  return function(a, b) {
-    return comparator(a && a.__data__, b && b.__data__);
-  };
-}
+  function transitionString(d, i, a) {
+    return a != b && d3.interpolate(a, b);
+  }
 
-function d3_selection_enterNode(data) {
-  return {__data__: data};
+  return typeof b === "function" ? transitionFunction
+      : b == null ? d3_transitionNull
+      : (b += "", transitionString);
 }
-d3.transition = d3_root.transition;
 
-var d3_transitionId = 0,
-    d3_transitionInheritId = 0;
+var d3_transitionPrototype = [],
+    d3_transitionId = 0,
+    d3_transitionInheritId = 0,
+    d3_transitionEase = d3.ease("cubic-in-out");
 
-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_transitionPrototype.call = d3_selectionPrototype.call;
 
-  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 = function() {
+  return d3_selectionRoot.transition();
+};
 
-      // 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;
+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});
       } else {
-        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;
-          }
-        }
+        subgroup.push(null);
       }
+    }
+  }
 
-      // 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 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});
         }
       }
-    });
-    return clear;
-  }
-
-  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;
-  };
-
-  transition.ease = function(value) {
-    ease = typeof value == "function" ? value : d3.ease.apply(d3, arguments);
-    return transition;
-  };
-
-  transition.attrTween = function(name, tween) {
+  }
 
-    /** @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 d3_transition(subgroups, this.id, this.time).ease(this.ease());
+};
+d3_transitionPrototype.attr = function(name, value) {
+  return this.attrTween(name, d3_transitionTween(value));
+};
 
-    /** @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.attrTween = function(nameNS, tween) {
+  var name = d3.ns.qualify(nameNS);
 
-    tweens["attr." + name] = name.local ? attrTweenNS : attrTween;
-    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.attr = function(name, value) {
-    return transition.attrTween(name, d3_transitionTween(value));
-  };
+  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)); };
+  }
 
-  transition.styleTween = function(name, tween, priority) {
-    if (arguments.length < 3) priority = null;
+  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 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);
-      };
+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["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); });
+  }
+  return this;
 }
+d3_transitionPrototype.transition = function() {
+  return this.select(d3_this);
+};
 var d3_timer_queue = null,
-    d3_timer_timeout = 0,
-    d3_timer_interval;
+    d3_timer_interval, // is an interval (or frame) active?
+    d3_timer_timeout; // is a timeout active?
 
 // The timer will continue to fire until callback returns true.
-d3.timer = function(callback) {
-  d3_timer(callback, 0);
-};
-
-function d3_timer(callback, delay) {
-  var now = Date.now(),
-      found = false,
-      start = now + delay,
+d3.timer = function(callback, delay, then) {
+  var found = false,
       t0,
       t1 = d3_timer_queue;
 
-  if (!isFinite(delay)) return;
+  if (arguments.length < 3) {
+    if (arguments.length < 2) delay = 0;
+    else if (!isFinite(delay)) return;
+    then = Date.now();
+  }
 
-  // Scan the queue for earliest callback.
+  // See if the callback's already in the queue.
   while (t1) {
-    if (t1.callback == callback) {
-      t1.then = now;
+    if (t1.callback === callback) {
+      t1.then = then;
       t1.delay = delay;
       found = true;
-    } else {
-      var x = t1.then + t1.delay;
-      if (x < start) start = x;
+      break;
     }
     t0 = t1;
     t1 = t1.next;
@@ -1898,47 +2118,71 @@ function d3_timer(callback, delay) {
   // Otherwise, add the callback to the queue.
   if (!found) d3_timer_queue = {
     callback: callback,
-    then: now,
+    then: then,
     delay: delay,
     next: d3_timer_queue
   };
 
+  // Start animatin'!
   if (!d3_timer_interval) {
-    clearTimeout(d3_timer_timeout);
-    d3_timer_timeout = setTimeout(d3_timer_start, Math.max(24, start - now));
+    d3_timer_timeout = clearTimeout(d3_timer_timeout);
+    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);
+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_step() {
+d3.timer.flush = function() {
   var elapsed,
       now = Date.now(),
-      t0 = null,
       t1 = d3_timer_queue;
+
   while (t1) {
     elapsed = now - t1.then;
-    if (elapsed > t1.delay) t1.flush = t1.callback(elapsed);
-    t1 = (t0 = t1).next;
+    if (!t1.delay) t1.flush = t1.callback(elapsed);
+    t1 = 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;
+      t1 = d3_timer_queue,
+      then = Infinity;
   while (t1) {
-    t1 = t1.flush
-        ? (t0 ? t0.next = t1.next : d3_timer_queue = t1.next)
-        : (t0 = t1).next;
+    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;
+    }
   }
-  if (!t0) d3_timer_interval = 0;
+  return then;
 }
 
 var d3_timer_frame = window.requestAnimationFrame
@@ -1947,44 +2191,72 @@ 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() {
-  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;
+  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;
+  }
 
   function scale(x) {
-    x = (x - x0) * kx;
-    return i(clamp ? Math.max(0, Math.min(1, x)) : x);
+    return output(x);
   }
 
   // Note: requires range is coercible to number!
   scale.invert = function(y) {
-    return (y - y0) * ky + x0;
+    return input(y);
   };
 
   scale.domain = function(x) {
-    if (!arguments.length) return [x0, x1];
-    x0 = +x[0];
-    x1 = +x[1];
-    kx = 1 / (x1 - x0);
-    ky = (x1 - x0) / (y1 - y0);
-    return scale;
+    if (!arguments.length) return domain;
+    domain = x.map(Number);
+    return rescale();
   };
 
   scale.range = function(x) {
-    if (!arguments.length) return [y0, y1];
-    y0 = x[0];
-    y1 = x[1];
-    ky = (x1 - x0) / (y1 - y0);
-    i = interpolate(y0, y1);
-    return scale;
+    if (!arguments.length) return range;
+    range = x;
+    return rescale();
   };
 
   scale.rangeRound = function(x) {
@@ -1994,52 +2266,106 @@ d3.scale.linear = function() {
   scale.clamp = function(x) {
     if (!arguments.length) return clamp;
     clamp = x;
-    return scale;
+    return rescale();
   };
 
   scale.interpolate = function(x) {
     if (!arguments.length) return interpolate;
-    i = (interpolate = x)(y0, y1);
-    return scale;
+    interpolate = x;
+    return rescale();
   };
 
-  // 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);
-
-    // 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.
-    return {
-      start: Math.ceil(start / step) * step,
-      stop: Math.floor(stop / step) * step + step * .5, // inclusive
-      step: step
-    };
-  }
-
   scale.ticks = function(m) {
-    var range = tickRange(m);
-    return d3.range(range.start, range.stop, range.step);
+    return d3_scale_linearTicks(domain, m);
   };
 
   scale.tickFormat = function(m) {
-    var n = Math.max(0, -Math.floor(Math.log(tickRange(m).step) / Math.LN10 + .01));
-    return d3.format(",." + n + "f");
+    return d3_scale_linearTickFormat(domain, m);
   };
 
-  return scale;
+  scale.nice = function() {
+    d3_scale_nice(domain, d3_scale_linearNice);
+    return rescale();
+  };
+
+  scale.copy = function() {
+    return d3_scale_linear(domain, range, interpolate, clamp);
+  };
+
+  return rescale();
 };
+
+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;
+}
+
+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; }
+  };
+}
+
+// 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));
+  };
+}
+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() {
-  var linear = d3.scale.linear(),
-      log = d3_scale_log,
-      pow = log.pow;
+  return d3_scale_log(d3.scale.linear(), d3_scale_logp);
+};
+
+function d3_scale_log(linear, log) {
+  var pow = log.pow;
 
   function scale(x) {
     return linear(log(x));
@@ -2051,25 +2377,25 @@ d3.scale.log = function() {
 
   scale.domain = function(x) {
     if (!arguments.length) return linear.domain().map(pow);
-    log = (x[0] || x[1]) < 0 ? d3_scale_logn : d3_scale_log;
+    log = x[0] < 0 ? d3_scale_logn : d3_scale_logp;
     pow = log.pow;
     linear.domain(x.map(log));
     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.nice = function() {
+    linear.domain(d3_scale_nice(linear.domain(), d3_scale_niceDefault));
+    return scale;
+  };
 
   scale.ticks = function() {
-    var d = linear.domain(),
+    var extent = d3_scaleExtent(linear.domain()),
         ticks = [];
-    if (d.every(isFinite)) {
-      var i = Math.floor(d[0]),
-          j = Math.ceil(d[1]),
-          u = pow(d[0]),
-          v = pow(d[1]);
+    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 (log === d3_scale_logn) {
         ticks.push(pow(i));
         for (; i++ < j;) for (var k = 9; k > 0; k--) ticks.push(pow(i) * k);
@@ -2084,14 +2410,27 @@ d3.scale.log = function() {
     return ticks;
   };
 
-  scale.tickFormat = function() {
-    return function(d) { return d.toPrecision(1); };
+  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);
   };
 
-  return scale;
+  return d3_scale_linearRebind(scale, linear);
 };
 
-function d3_scale_log(x) {
+var d3_scale_logFormat = d3.format("e");
+
+function d3_scale_logp(x) {
   return Math.log(x) / Math.LN10;
 }
 
@@ -2099,7 +2438,7 @@ function d3_scale_logn(x) {
   return -Math.log(-x) / Math.LN10;
 }
 
-d3_scale_log.pow = function(x) {
+d3_scale_logp.pow = function(x) {
   return Math.pow(10, x);
 };
 
@@ -2107,11 +2446,12 @@ d3_scale_logn.pow = function(x) {
   return -Math.pow(10, -x);
 };
 d3.scale.pow = function() {
-  var linear = d3.scale.linear(),
-      tick = d3.scale.linear(), // TODO better tick formatting...
-      exponent = 1,
-      powp = Number,
-      powb = powp;
+  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);
 
   function scale(x) {
     return linear(powp(x));
@@ -2123,70 +2463,72 @@ d3.scale.pow = function() {
 
   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.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.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.exponent = function(x) {
     if (!arguments.length) return exponent;
     var domain = scale.domain();
-    exponent = x;
+    powp = d3_scale_powPow(exponent = x);
+    powb = d3_scale_powPow(1 / exponent);
     return scale.domain(domain);
   };
 
-  return scale;
-};
-
-function d3_scale_pow(e) {
-  return function(x) {
-    return Math.pow(x, e);
+  scale.copy = function() {
+    return d3_scale_pow(linear.copy(), exponent);
   };
-}
 
-function d3_scale_pown(e) {
+  return d3_scale_linearRebind(scale, linear);
+};
+
+function d3_scale_powPow(e) {
   return function(x) {
-    return -Math.pow(-x, e);
+    return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
   };
 }
 d3.scale.sqrt = function() {
   return d3.scale.pow().exponent(.5);
 };
 d3.scale.ordinal = function() {
-  var domain = [],
-      index = {},
-      range = [],
-      rangeBand = 0;
+  return d3_scale_ordinal([], {t: "range", x: []});
+};
+
+function d3_scale_ordinal(domain, ranger) {
+  var index,
+      range,
+      rangeBand;
 
   function scale(x) {
-    var i = x in index ? index[x] : (index[x] = domain.push(x) - 1);
-    return range[i % range.length];
+    return range[((index[x] || (index[x] = domain.push(x))) - 1) % range.length];
   }
 
   scale.domain = function(x) {
     if (!arguments.length) return domain;
-    domain = x;
+    domain = [];
     index = {};
-    var i = -1, j = -1, n = domain.length; while (++i < n) {
-      x = domain[i];
-      if (!(x in index)) index[x] = ++j;
-    }
-    return scale;
+    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);
   };
 
   scale.range = function(x) {
     if (!arguments.length) return range;
     range = x;
+    rangeBand = 0;
+    ranger = {t: "range", x: x};
     return scale;
   };
 
@@ -2195,10 +2537,9 @@ d3.scale.ordinal = function() {
     var start = x[0],
         stop = x[1],
         step = (stop - start) / (domain.length - 1 + padding);
-    range = domain.length == 1
-        ? [(start + stop) / 2]
-        : d3.range(start + step * padding / 2, stop + step / 2, step);
+    range = domain.length < 2 ? [(start + stop) / 2] : d3.range(start + step * padding / 2, stop + step / 2, step);
     rangeBand = 0;
+    ranger = {t: "rangePoints", x: x, p: padding};
     return scale;
   };
 
@@ -2209,6 +2550,7 @@ d3.scale.ordinal = function() {
         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;
   };
 
@@ -2216,11 +2558,11 @@ d3.scale.ordinal = function() {
     if (arguments.length < 2) padding = 0;
     var start = x[0],
         stop = x[1],
-        diff = stop - start,
-        step = Math.floor(diff / (domain.length + padding)),
-        err = diff - (domain.length - padding) * step;
+        step = Math.floor((stop - start) / (domain.length + padding)),
+        err = stop - start - (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;
   };
 
@@ -2228,7 +2570,11 @@ d3.scale.ordinal = function() {
     return rangeBand;
   };
 
-  return scale;
+  scale.copy = function() {
+    return d3_scale_ordinal(domain, ranger);
+  };
+
+  return scale.domain(domain);
 };
 /*
  * This product includes color specifications and designs developed by Cynthia
@@ -2285,81 +2631,83 @@ var d3_category20c = [
   "#636363", "#969696", "#bdbdbd", "#d9d9d9"
 ];
 d3.scale.quantile = function() {
-  var domain = [],
-      range = [],
-      thresholds = [];
+  return d3_scale_quantile([], []);
+};
+
+function d3_scale_quantile(domain, range) {
+  var thresholds;
 
   function rescale() {
-    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;
+    var k = 0,
+        n = domain.length,
+        q = range.length;
+    thresholds = [];
+    while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
+    return scale;
   }
 
   function scale(x) {
-    return range[quantile(x)];
+    if (isNaN(x = +x)) return NaN;
+    return range[d3.bisect(thresholds, x)];
   }
 
   scale.domain = function(x) {
     if (!arguments.length) return domain;
     domain = x.filter(function(d) { return !isNaN(d); }).sort(d3.ascending);
-    rescale();
-    return scale;
+    return rescale();
   };
 
   scale.range = function(x) {
     if (!arguments.length) return range;
     range = x;
-    rescale();
-    return scale;
+    return rescale();
   };
 
   scale.quantiles = function() {
     return thresholds;
   };
 
-  return scale;
+  scale.copy = function() {
+    return d3_scale_quantile(domain, range); // copy on write!
+  };
+
+  return rescale();
 };
 d3.scale.quantize = function() {
-  var x0 = 0,
-      x1 = 1,
-      kx = 2,
-      i = 1,
-      range = [0, 1];
+  return d3_scale_quantize(0, 1, [0, 1]);
+};
+
+function d3_scale_quantize(x0, x1, range) {
+  var kx, i;
 
   function scale(x) {
     return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
   }
 
-  scale.domain = function(x) {
-    if (!arguments.length) return [x0, x1];
-    x0 = x[0];
-    x1 = x[1];
+  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();
   };
 
   scale.range = function(x) {
     if (!arguments.length) return range;
     range = x;
-    kx = range.length / (x1 - x0);
-    i = range.length - 1;
-    return scale;
+    return rescale();
   };
 
-  return scale;
+  scale.copy = function() {
+    return d3_scale_quantize(x0, x1, range); // copy on write
+  };
+
+  return rescale();
 };
 d3.svg = {};
 d3.svg.arc = function() {
@@ -2373,7 +2721,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 = (a1 < a0 && (da = a0, a0 = a1, a1 = da), a1 - a0),
         df = da < Math.PI ? "0" : "1",
         c0 = Math.cos(a0),
         s0 = Math.sin(a0),
@@ -2385,8 +2733,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,1 0," + (-r0)
-      + "A" + r0 + "," + r0 + " 0 1,1 0," + r0
+      + "A" + r0 + "," + r0 + " 0 1,0 0," + (-r0)
+      + "A" + r0 + "," + r0 + " 0 1,0 0," + r0
       + "Z"
       : "M0," + r1
       + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1)
@@ -2457,7 +2805,7 @@ function d3_svg_arcStartAngle(d) {
 function d3_svg_arcEndAngle(d) {
   return d.endAngle;
 }
-d3.svg.line = function() {
+function d3_svg_line(projection) {
   var x = d3_svg_lineX,
       y = d3_svg_lineY,
       interpolate = "linear",
@@ -2465,8 +2813,7 @@ d3.svg.line = function() {
       tension = .7;
 
   function line(d) {
-    return d.length < 1 ? null
-        : "M" + interpolator(d3_svg_linePoints(this, d, x, y), tension);
+    return d.length < 1 ? null : "M" + interpolator(projection(d3_svg_linePoints(this, d, x, y)), tension);
   }
 
   line.x = function(v) {
@@ -2494,6 +2841,10 @@ d3.svg.line = function() {
   };
 
   return line;
+}
+
+d3.svg.line = function() {
+  return d3_svg_line(Object);
 };
 
 // Converts the specified array of data into an array of points
@@ -2504,8 +2855,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([
@@ -2538,44 +2889,53 @@ 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-closed": d3_svg_lineCardinalClosed
+  "cardinal-open": d3_svg_lineCardinalOpen,
+  "cardinal-closed": d3_svg_lineCardinalClosed,
+  "monotone": d3_svg_lineMonotone
 };
 
 // Linear interpolation; generates "L" commands.
 function d3_svg_lineLinear(points) {
-  var path = [],
-      i = 0,
+  var i = 0,
       n = points.length,
-      p = points[0];
-  path.push(p[0], ",", p[1]);
+      p = points[0],
+      path = [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 path = [],
-      i = 0,
+  var i = 0,
       n = points.length,
-      p = points[0];
-  path.push(p[0], ",", p[1]);
+      p = points[0],
+      path = [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 path = [],
-      i = 0,
+  var i = 0,
       n = points.length,
-      p = points[0];
-  path.push(p[0], ",", p[1]);
+      p = points[0],
+      path = [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
@@ -2658,18 +3018,17 @@ function d3_svg_lineCardinalTangents(points, tension) {
   return tangents;
 }
 
-// Open B-spline interpolation; generates "C" commands.
+// B-spline interpolation; generates "C" commands.
 function d3_svg_lineBasis(points) {
   if (points.length < 3) return d3_svg_lineLinear(points);
-  var path = [],
-      i = 1,
+  var 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.push(x0, ",", y0);
+      py = [y0, y0, y0, pi[1]],
+      path = [x0, ",", y0];
   d3_svg_lineBasisBezier(path, px, py);
   while (++i < n) {
     pi = points[i];
@@ -2686,6 +3045,31 @@ 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,
@@ -2713,6 +3097,24 @@ 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];
@@ -2724,7 +3126,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(
@@ -2735,59 +3137,210 @@ function d3_svg_lineBasisBezier(path, x, y) {
       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x),
       ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
 }
-d3.svg.area = function() {
-  var x = d3_svg_lineX,
-      y0 = d3_svg_areaY0,
+
+// 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,
       y1 = d3_svg_lineY,
-      interpolate = "linear",
-      interpolator = d3_svg_lineInterpolators[interpolate],
+      interpolate,
+      i0,
+      i1,
       tension = .7;
 
-  // TODO horizontal / vertical / radial orientation
-
   function area(d) {
-    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";
+    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";
   }
 
-  area.x = function(v) {
-    if (!arguments.length) return x;
-    x = v;
+  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;
     return area;
   };
 
-  area.y0 = function(v) {
+  area.y0 = function(y) {
     if (!arguments.length) return y0;
-    y0 = v;
+    y0 = y;
     return area;
   };
 
-  area.y1 = function(v) {
+  area.y1 = function(y) {
     if (!arguments.length) return y1;
-    y1 = v;
+    y1 = y;
     return area;
   };
 
-  area.interpolate = function(v) {
+  area.interpolate = function(x) {
     if (!arguments.length) return interpolate;
-    interpolator = d3_svg_lineInterpolators[interpolate = v];
+    i0 = d3_svg_lineInterpolators[interpolate = x];
+    i1 = i0.reverse || i0;
     return area;
   };
 
-  area.tension = function(v) {
+  area.tension = function(x) {
     if (!arguments.length) return tension;
-    tension = v;
+    tension = x;
     return area;
   };
 
-  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);
 };
 
-function d3_svg_areaY0() {
-  return 0;
+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];
+  };
 }
+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,
@@ -2925,7 +3478,36 @@ 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)
@@ -2938,18 +3520,23 @@ d3.svg.mouse = function(container) {
     svg.remove();
   }
   if (d3_mouse_bug44083) {
-    point.x = d3.event.pageX;
-    point.y = d3.event.pageY;
+    point.x = e.pageX;
+    point.y = e.pageY;
   } else {
-    point.x = d3.event.clientX;
-    point.y = d3.event.clientY;
+    point.x = e.clientX;
+    point.y = e.clientY;
   }
   point = point.matrixTransform(container.getScreenCTM().inverse());
   return [point.x, point.y];
 };
-
-// https://bugs.webkit.org/show_bug.cgi?id=44083
-var d3_mouse_bug44083 = /WebKit/.test(navigator.userAgent) ? -1 : 0;
+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;
+  }) : [];
+};
 d3.svg.symbol = function() {
   var type = d3_svg_symbolType,
       size = d3_svg_symbolSize;
@@ -2976,16 +3563,6 @@ 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;
 }
@@ -2994,6 +3571,7 @@ function d3_svg_symbolType() {
   return "circle";
 }
 
+// TODO cross-diagonal?
 var d3_svg_symbols = {
   "circle": function(size) {
     var r = Math.sqrt(size / Math.PI);
@@ -3053,6 +3631,520 @@ 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();
+}
+})();