diff --git a/test/arrays/max-test.js b/test/arrays/max-test.js
index 407d36c1..2bdd1f20 100644
--- a/test/arrays/max-test.js
+++ b/test/arrays/max-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -39,7 +39,7 @@ suite.addBatch({
       assert.isUndefined(max([NaN, NaN]));
     },
     "applies the optional accessor function": function(max) {
-      assert.equal(max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.min(d); }), 2);
+      assert.equal(max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.min(d); }), 2);
       assert.equal(max([1, 2, 3, 4, 5], function(d, i) { return i; }), 4);
     }
   }
diff --git a/test/arrays/min-test.js b/test/arrays/min-test.js
index dfe61a47..da5e346a 100644
--- a/test/arrays/min-test.js
+++ b/test/arrays/min-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -38,7 +38,7 @@ suite.addBatch({
       assert.isUndefined(min([NaN, NaN]));
     },
     "applies the optional accessor function": function(min) {
-      assert.equal(min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.max(d); }), 5);
+      assert.equal(min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.max(d); }), 5);
       assert.equal(min([1, 2, 3, 4, 5], function(d, i) { return i; }), 0);
     }
   }
diff --git a/test/arrays/nest-test.js b/test/arrays/nest-test.js
index c4ab2fa8..13d9001d 100644
--- a/test/arrays/nest-test.js
+++ b/test/arrays/nest-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -13,7 +13,7 @@ suite.addBatch({
           .key(function(d) { return d.foo; })
           .entries([{foo: 1}, {foo: 1}, {foo: 2}])
           .map(function(d) { return d.key; })
-          .sort(d3.ascending);
+          .sort(_.ascending);
       assert.deepEqual(keys, ["1", "2"]);
     },
     "each entry is a key-values object, with values in input order": function(nest) {
@@ -27,7 +27,7 @@ suite.addBatch({
     },
     "keys can be sorted using an optional comparator": function(nest) {
       var keys = nest()
-          .key(function(d) { return d.foo; }).sortKeys(d3.descending)
+          .key(function(d) { return d.foo; }).sortKeys(_.descending)
           .entries([{foo: 1}, {foo: 1}, {foo: 2}])
           .map(function(d) { return d.key; });
       assert.deepEqual(keys, ["2", "1"]);
@@ -45,7 +45,7 @@ suite.addBatch({
     "values can be aggregated using an optional rollup": function(nest) {
       var entries = nest()
           .key(function(d) { return d.foo; })
-          .rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
+          .rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
           .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
       assert.deepEqual(entries, [
         {key: "1", values: 3},
@@ -54,8 +54,8 @@ suite.addBatch({
     },
     "multiple key functions can be specified": function(nest) {
       var entries = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
           .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
       assert.deepEqual(entries, [
         {key: "0", values: [
@@ -70,8 +70,8 @@ suite.addBatch({
     },
     "the rollup function only applies to leaf values": function(nest) {
       var entries = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
           .rollup(function(values) { return values.length; })
           .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
       assert.deepEqual(entries, [
@@ -87,8 +87,8 @@ suite.addBatch({
     },
     "the value comparator only applies to leaf values": function(nest) {
       var entries = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
           .sortValues(function(a, b) { return a[2] - b[2]; })
           .entries([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
       assert.deepEqual(entries, [
@@ -104,8 +104,8 @@ suite.addBatch({
     },
     "the key comparator only applies to the last-specified key": function(nest) {
       var entries = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.descending)
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.descending)
           .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
       assert.deepEqual(entries, [
         {key: "0", values: [
@@ -118,8 +118,8 @@ suite.addBatch({
         ]}
       ]);
       var entries = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.descending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[0]; }).sortKeys(_.descending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
           .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
       assert.deepEqual(entries, [
         {key: "1", values: [
@@ -164,7 +164,7 @@ suite.addBatch({
     "values can be aggregated using an optional rollup": function(nest) {
       var map = nest()
           .key(function(d) { return d.foo; })
-          .rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
+          .rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
           .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
       assert.deepEqual(map, {
         "1": 3,
@@ -173,8 +173,8 @@ suite.addBatch({
     },
     "multiple key functions can be specified": function(nest) {
       var map = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
           .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
       assert.deepEqual(map, {
         "0": {
@@ -189,8 +189,8 @@ suite.addBatch({
     },
     "the rollup function only applies to leaf values": function(nest) {
       var map = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
           .rollup(function(values) { return values.length; })
           .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
       assert.deepEqual(map, {
@@ -206,8 +206,8 @@ suite.addBatch({
     },
     "the value comparator only applies to leaf values": function(nest) {
       var map = nest()
-          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
-          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
           .sortValues(function(a, b) { return a[2] - b[2]; })
           .map([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
       assert.deepEqual(map, {
@@ -234,7 +234,7 @@ suite.addBatch({
     "a custom map implementation can be specified": function(nest) {
       var map = nest()
           .key(String)
-          .map(["hasOwnProperty", "__proto__"], d3.map);
+          .map(["hasOwnProperty", "__proto__"], _.map);
       assert.deepEqual(map.entries(), [
         {key: "hasOwnProperty", value: ["hasOwnProperty"]},
         {key: "__proto__", value: ["__proto__"]}
@@ -244,7 +244,7 @@ suite.addBatch({
       var map = nest()
           .key(function(d) { return d.foo; })
           .key(function(d) { return d.bar; })
-          .map([{foo: 42, bar: "red"}], d3.map);
+          .map([{foo: 42, bar: "red"}], _.map);
       assert.deepEqual(map.keys(), ["42"]);
       assert.deepEqual(map.get("42").keys(), ["red"]);
       assert.deepEqual(map.get("42").values(), [[{foo: 42, bar: "red"}]]);
diff --git a/test/arrays/set-test.js b/test/arrays/set-test.js
index b934095d..726d428f 100644
--- a/test/arrays/set-test.js
+++ b/test/arrays/set-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("assert");
 
@@ -36,19 +36,19 @@ suite.addBatch({
       },
       "values are returned in arbitrary order": function(set) {
         var s = set(["foo", "bar"]);
-        assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
+        assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
         var s = set(["bar", "foo"]);
-        assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
+        assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
       },
       "observes changes via add and remove": function(set) {
         var s = set(["foo", "bar"]);
-        assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
+        assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
         s.remove("foo");
         assert.deepEqual(s.values(), ["bar"]);
         s.add("bar");
         assert.deepEqual(s.values(), ["bar"]);
         s.add("foo");
-        assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
+        assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
         s.remove("bar");
         assert.deepEqual(s.values(), ["foo"]);
         s.remove("foo");
diff --git a/test/color/hcl-test.js b/test/color/hcl-test.js
index 512f2445..40035fb1 100644
--- a/test/color/hcl-test.js
+++ b/test/color/hcl-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -46,7 +46,7 @@ suite.addBatch({
       assertHclEqual(hcl("rgb(102, 102, 0)"), 102.85124420310271, 49.44871600399321, 41.73251953866431);
     },
     "can convert from RGB": function(hcl) {
-      assertHclEqual(hcl(d3.rgb(12, 34, 56)), -89.58282792342067, 16.833655998102003, 12.65624852526134);
+      assertHclEqual(hcl(_.rgb(12, 34, 56)), -89.58282792342067, 16.833655998102003, 12.65624852526134);
     },
     "can convert from HSL": function(hcl) {
       assertHclEqual(hcl(hcl(20, .8, .3)), 20, 0.8, 0.3);
@@ -67,13 +67,13 @@ suite.addBatch({
       assert.strictEqual(hcl(hcl(60, -4, 32)) + "", "#454c51");
     },
     "roundtrip to HSL is idempotent": function(hcl) {
-      assert.hslEqual(d3.hsl(hcl("steelblue")), d3.hsl("steelblue"));
+      assert.hslEqual(_.hsl(hcl("steelblue")), _.hsl("steelblue"));
     },
     "roundtrip to RGB is idempotent": function(hcl) {
-      assert.hslEqual(d3.rgb(hcl("steelblue")), d3.rgb("steelblue"));
+      assert.hslEqual(_.rgb(hcl("steelblue")), _.rgb("steelblue"));
     },
     "roundtrip to Lab is idempotent": function(hcl) {
-      assert.hslEqual(d3.lab(hcl("steelblue")), d3.lab("steelblue"));
+      assert.hslEqual(_.lab(hcl("steelblue")), _.lab("steelblue"));
     }
   }
 });
diff --git a/test/color/hsl-test.js b/test/color/hsl-test.js
index 595c6e73..46fbb9f3 100644
--- a/test/color/hsl-test.js
+++ b/test/color/hsl-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -49,7 +49,7 @@ suite.addBatch({
       assert.hslEqual(hsl("rgb(102, 102, 0)"), 60, 1, .2);
     },
     "can convert from RGB": function(hsl) {
-      assert.hslEqual(hsl(d3.rgb(12, 34, 56)), 210, .647058, .133333);
+      assert.hslEqual(hsl(_.rgb(12, 34, 56)), 210, .647058, .133333);
     },
     "can convert from HSL": function(hsl) {
       assert.hslEqual(hsl(hsl(20, .8, .3)), 20, .8, .3);
diff --git a/test/color/lab-test.js b/test/color/lab-test.js
index c6698dd4..87e8e303 100644
--- a/test/color/lab-test.js
+++ b/test/color/lab-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -46,7 +46,7 @@ suite.addBatch({
       assertLabEqual(lab("rgb(102, 102, 0)"), 41.73251953866431, -10.998411255098816, 48.21006600604577);
     },
     "can convert from RGB": function(lab) {
-      assertLabEqual(lab(d3.rgb(12, 34, 56)), 12.65624852526134, 0.12256520883417721, -16.833209795877284);
+      assertLabEqual(lab(_.rgb(12, 34, 56)), 12.65624852526134, 0.12256520883417721, -16.833209795877284);
     },
     "can convert from HSL": function(lab) {
       assertLabEqual(lab(lab(20, .8, .3)), 20, 0.8, 0.3);
@@ -67,13 +67,13 @@ suite.addBatch({
       assert.strictEqual(lab(lab(60, -4, -32)) + "", "#5d95c8");
     },
     "roundtrip to HSL is idempotent": function(lab) {
-      assert.hslEqual(d3.hsl(lab("steelblue")), d3.hsl("steelblue"));
+      assert.hslEqual(_.hsl(lab("steelblue")), _.hsl("steelblue"));
     },
     "roundtrip to RGB is idempotent": function(lab) {
-      assert.hslEqual(d3.rgb(lab("steelblue")), d3.rgb("steelblue"));
+      assert.hslEqual(_.rgb(lab("steelblue")), _.rgb("steelblue"));
     },
     "roundtrip to HCL is idempotent": function(lab) {
-      assert.hslEqual(d3.hcl(lab("steelblue")), d3.hcl("steelblue"));
+      assert.hslEqual(_.hcl(lab("steelblue")), _.hcl("steelblue"));
     }
   }
 });
diff --git a/test/color/rgb-test.js b/test/color/rgb-test.js
index 5366076c..6daf648b 100644
--- a/test/color/rgb-test.js
+++ b/test/color/rgb-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -60,7 +60,7 @@ suite.addBatch({
       assert.rgbEqual(rgb(rgb(12, 34, 56)), 12, 34, 56);
     },
     "can convert from HSL": function(rgb) {
-      assert.rgbEqual(rgb(d3.hsl(0, 1, .5)), 255, 0, 0);
+      assert.rgbEqual(rgb(_.hsl(0, 1, .5)), 255, 0, 0);
     },
     "can convert to HSL": function(rgb) {
       assert.hslEqual(rgb("red").hsl(), 0, 1, .5);
@@ -83,7 +83,7 @@ suite.addBatch({
       assert.strictEqual(rgb("hsl(60, 100%, 20%)") + "", "#666600");
       assert.strictEqual(rgb("rgb(12, 34, 56)") + "", "#0c2238");
       assert.strictEqual(rgb(rgb(12, 34, 56)) + "", "#0c2238");
-      assert.strictEqual(rgb(d3.hsl(60, 1, .2)) + "", "#666600");
+      assert.strictEqual(rgb(_.hsl(60, 1, .2)) + "", "#666600");
     }
   }
 });
diff --git a/test/geo/area-benchmark.js b/test/geo/area-benchmark.js
index 816e3365..4d44b091 100644
--- a/test/geo/area-benchmark.js
+++ b/test/geo/area-benchmark.js
@@ -1,5 +1,6 @@
-var d3 = require("../../"),
-    formatNumber = d3.format(",.02r"),
+var d3 = require("../../");
+
+var formatNumber = d3.format(",.02r"),
     o = d3.geo.circle().angle(30).precision(.1)(),
     n = 1e3,
     then = Date.now();
diff --git a/test/geo/area-test.js b/test/geo/area-test.js
index 9245f887..62c81708 100644
--- a/test/geo/area-test.js
+++ b/test/geo/area-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -53,51 +53,51 @@ suite.addBatch({
       },
       "graticule outline": {
         "sphere": function(area) {
-          assert.inDelta(area(d3.geo.graticule().extent([[-180, -90], [180, 90]]).outline()), 4 * π, 1e-5);
+          assert.inDelta(area(_.geo.graticule().extent([[-180, -90], [180, 90]]).outline()), 4 * π, 1e-5);
         },
         "hemisphere": function(area) {
-          assert.inDelta(area(d3.geo.graticule().extent([[-180, 0], [180, 90]]).outline()), 2 * π, 1e-5);
+          assert.inDelta(area(_.geo.graticule().extent([[-180, 0], [180, 90]]).outline()), 2 * π, 1e-5);
         },
         "semilune": function(area) {
-          assert.inDelta(area(d3.geo.graticule().extent([[0, 0], [90, 90]]).outline()), π / 2, 1e-5);
+          assert.inDelta(area(_.geo.graticule().extent([[0, 0], [90, 90]]).outline()), π / 2, 1e-5);
         }
       },
       "circles": {
         "hemisphere": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(90)()), 2 * π, 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(90)()), 2 * π, 1e-5);
         },
         "60°": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(60).precision(.1)()), π, 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(60).precision(.1)()), π, 1e-5);
         },
         "60° North": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(60).precision(.1).origin([0, 90])()), π, 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(60).precision(.1).origin([0, 90])()), π, 1e-5);
         },
         "45°": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(45).precision(.1)()), π * (2 - Math.SQRT2), 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(45).precision(.1)()), π * (2 - Math.SQRT2), 1e-5);
         },
         "45° North": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(45).precision(.1).origin([0, 90])()), π * (2 - Math.SQRT2), 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(45).precision(.1).origin([0, 90])()), π * (2 - Math.SQRT2), 1e-5);
         },
         "45° South": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(45).precision(.1).origin([0, -90])()), π * (2 - Math.SQRT2), 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(45).precision(.1).origin([0, -90])()), π * (2 - Math.SQRT2), 1e-5);
         },
         "135°": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(135).precision(.1)()), π * (2 + Math.SQRT2), 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(135).precision(.1)()), π * (2 + Math.SQRT2), 1e-5);
         },
         "135° North": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(135).precision(.1).origin([0, 90])()), π * (2 + Math.SQRT2), 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(135).precision(.1).origin([0, 90])()), π * (2 + Math.SQRT2), 1e-5);
         },
         "135° South": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(135).precision(.1).origin([0, -90])()), π * (2 + Math.SQRT2), 1e-5);
+          assert.inDelta(area(_.geo.circle().angle(135).precision(.1).origin([0, -90])()), π * (2 + Math.SQRT2), 1e-5);
         },
         "tiny": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(1e-6).precision(.1)()), 0, 1e-6);
+          assert.inDelta(area(_.geo.circle().angle(1e-6).precision(.1)()), 0, 1e-6);
         },
         "huge": function(area) {
-          assert.inDelta(area(d3.geo.circle().angle(180 - 1e-6).precision(.1)()), 4 * π, 1e-6);
+          assert.inDelta(area(_.geo.circle().angle(180 - 1e-6).precision(.1)()), 4 * π, 1e-6);
         },
         "60° with 45° hole": function(area) {
-          var circle = d3.geo.circle().precision(.1);
+          var circle = _.geo.circle().precision(.1);
           assert.inDelta(area({
             type: "Polygon",
             coordinates: [
@@ -107,7 +107,7 @@ suite.addBatch({
           }), π * (Math.SQRT2 - 1), 1e-5);
         },
         "45° holes at [0°, 0°] and [0°, 90°]": function(area) {
-          var circle = d3.geo.circle().precision(.1).angle(45);
+          var circle = _.geo.circle().precision(.1).angle(45);
           assert.inDelta(area({
             type: "Polygon",
             coordinates: [
@@ -117,7 +117,7 @@ suite.addBatch({
           }), π * 2 * Math.SQRT2, 1e-5);
         },
         "45° holes at [0°, 90°] and [0°, 0°]": function(area) {
-          var circle = d3.geo.circle().precision(.1).angle(45);
+          var circle = _.geo.circle().precision(.1).angle(45);
           assert.inDelta(area({
             type: "Polygon",
             coordinates: [
@@ -129,13 +129,13 @@ suite.addBatch({
       },
       "stripes": {
         "45°, -45°": function(area) {
-          assert.inDelta(area(stripes(d3, 45, -45)), π * 2 * Math.SQRT2, 1e-5);
+          assert.inDelta(area(stripes(45, -45)), π * 2 * Math.SQRT2, 1e-5);
         },
         "-45°, 45°": function(area) {
-          assert.inDelta(area(stripes(d3, -45, 45)), π * 2 * (2 - Math.SQRT2), 1e-5);
+          assert.inDelta(area(stripes(-45, 45)), π * 2 * (2 - Math.SQRT2), 1e-5);
         },
         "45°, 30°": function(area) {
-          assert.inDelta(area(stripes(d3, 45, 30)), π * (Math.SQRT2 - 1), 1e-5);
+          assert.inDelta(area(stripes(45, 30)), π * (Math.SQRT2 - 1), 1e-5);
         }
       }
     },
@@ -164,9 +164,9 @@ suite.addBatch({
 
 suite.export(module);
 
-function stripes(d3, a, b) {
+function stripes(a, b) {
   return {type: "Polygon", coordinates: [a, b].map(function(d, i) {
-    var stripe = d3.range(-180, 180, .1).map(function(x) { return [x, d]; });
+    var stripe = _.range(-180, 180, .1).map(function(x) { return [x, d]; });
     stripe.push(stripe[0]);
     return i ? stripe.reverse() : stripe;
   })};
diff --git a/test/geo/centroid-test.js b/test/geo/centroid-test.js
index b97f2672..63fbab91 100644
--- a/test/geo/centroid-test.js
+++ b/test/geo/centroid-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -43,8 +43,8 @@ suite.addBatch({
     },
     "Polygon": function(centroid) {
       assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -90], [0, 0], [0, 90], [1, 0], [0, -90]]]}), [.5, 0], 1e-6);
-      //assert.inDelta(centroid(d3.geo.circle().angle(5).origin([0, 45])()), [0, 45], 1e-6);
-      assert.equal(centroid({type: "Polygon", coordinates: [d3.range(-180, 180 + 1 / 2, 1).map(function(x) { return [x, -60]; })]})[1], -90);
+      assert.inDelta(centroid(_.geo.circle().angle(5).origin([0, 45])()), [0, 45], 1e-6);
+      assert.equal(centroid({type: "Polygon", coordinates: [_.range(-180, 180 + 1 / 2, 1).map(function(x) { return [x, -60]; })]})[1], -90);
       assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -10], [0, 10], [10, 10], [10, -10], [0, -10]]]}), [5, 0], 1e-6);
     },
     "MultiPolygon": function(centroid) {
diff --git a/test/geo/circle-test.js b/test/geo/circle-test.js
index 52f96671..f441f095 100644
--- a/test/geo/circle-test.js
+++ b/test/geo/circle-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -16,7 +16,7 @@ suite.addBatch({
     "origin([0, 90])": function(circle) {
       var o = circle().origin([0, 90])();
       assert.equal(o.type, "Polygon");
-      assert.inDelta(o.coordinates, [d3.range(360, -1, -6).map(function(x) { return [x >= 180 ? x - 360 : x, 0]; })], 1e-6);
+      assert.inDelta(o.coordinates, [_.range(360, -1, -6).map(function(x) { return [x >= 180 ? x - 360 : x, 0]; })], 1e-6);
     },
     "origin([45, 45])": function(circle) {
       var o = circle().origin([45, 45]).angle(0)();
diff --git a/test/geo/graticule-test.js b/test/geo/graticule-test.js
index 977eaa40..50e690d8 100644
--- a/test/geo/graticule-test.js
+++ b/test/geo/graticule-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -121,7 +121,7 @@ suite.addBatch({
             .filter(function(line) { return line.coordinates[0][0] === line.coordinates[1][0]; })
             .filter(function(line) { return Math.abs(line.coordinates[0][0] % 90) > ε; });
         lines.forEach(function(line) {
-          assert.deepEqual(d3.extent(line.coordinates, function(p) { return p[1]; }), [-80 - ε, +80 + ε]);
+          assert.deepEqual(_.extent(line.coordinates, function(p) { return p[1]; }), [-80 - ε, +80 + ε]);
         });
       },
       "default major longitude lines extend from 90°S to 90°N": function(graticule) {
@@ -129,14 +129,14 @@ suite.addBatch({
             .filter(function(line) { return line.coordinates[0][0] === line.coordinates[1][0]; })
             .filter(function(line) { return Math.abs(line.coordinates[0][0] % 90) < ε; });
         lines.forEach(function(line) {
-          assert.deepEqual(d3.extent(line.coordinates, function(p) { return p[1]; }), [-90 + ε, +90 - ε]);
+          assert.deepEqual(_.extent(line.coordinates, function(p) { return p[1]; }), [-90 + ε, +90 - ε]);
         });
       },
       "default latitude lines extend from 180°W to 180°E": function(graticule) {
         var lines = graticule().lines()
             .filter(function(line) { return line.coordinates[0][1] === line.coordinates[1][1]; });
         lines.forEach(function(line) {
-          assert.deepEqual(d3.extent(line.coordinates, function(p) { return p[0]; }), [-180, +180]);
+          assert.deepEqual(_.extent(line.coordinates, function(p) { return p[0]; }), [-180, +180]);
         });
       },
       "returns an array of LineStrings": function(graticule) {
diff --git a/test/geo/path-test.js b/test/geo/path-test.js
index c37f7352..a9843bbb 100644
--- a/test/geo/path-test.js
+++ b/test/geo/path-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -13,7 +13,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .precision(0));
       },
@@ -261,7 +261,7 @@ suite.addBatch({
     "with the default context (null) and an identity projection": {
       topic: function(path) {
         return path()
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .precision(0));
       },
@@ -307,7 +307,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([-180, -248])
               .scale(900 / Math.PI)
               .precision(0));
@@ -320,7 +320,7 @@ suite.addBatch({
 
     "projection": {
       "returns the current projection when called with no arguments": function(path) {
-        var p = path(), projection = d3.geo.equirectangular();
+        var p = path(), projection = _.geo.equirectangular();
         p.projection(projection);
         assert.strictEqual(p.projection(), projection);
       }
@@ -351,7 +351,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(90));
@@ -385,22 +385,22 @@ suite.addBatch({
         assert.equal(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }).length, 1);
       },
       "renders a small circle of 60°": function(p) {
-        p(d3.geo.circle().angle(60)());
+        p(_.geo.circle().angle(60)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 276, y: 493}]);
       },
       "renders a small circle of 120°": function(p) {
-        p(d3.geo.circle().angle(120)());
+        p(_.geo.circle().angle(120)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 87, y: 700}]);
       }
     },
 
     "with an equirectangular projection clipped to 90° and rotated by [-17°, -451°]": {
       "renders a polygon": function(path) {
-        var pole = d3.range(-180, 180, 10).map(function(x) { return [x, 70]; });
+        var pole = _.range(-180, 180, 10).map(function(x) { return [x, 70]; });
         pole.push(pole[0]);
         path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([-17, -451])
               .scale(900 / Math.PI)
               .precision(0)
@@ -416,7 +416,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([71.03, 42.37])
               .scale(900 / Math.PI)
               .precision(0)
@@ -424,7 +424,7 @@ suite.addBatch({
       },
       /*
       "grid component": function(path) {
-        var yStepsBig = d3.range(-90, 90, 10);
+        var yStepsBig = _.range(-90, 90, 10);
         path({type: "LineString", coordinates: yStepsBig.map(function(y) { return [110, y]; })});
         assert.inDelta(testContext.buffer(), [[
           [109.538009, -90],
@@ -462,7 +462,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([-24, -175.5])
               .scale(900 / Math.PI)
               .precision(0)
@@ -478,18 +478,18 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([90, 0])
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(90));
       },
       "renders a small circle of 60°": function(p) {
-        p(d3.geo.circle().angle(60)());
+        p(_.geo.circle().angle(60)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 930, y: 550}]);
       },
       "renders a small circle of 120°": function(p) {
-        p(d3.geo.circle().angle(120)());
+        p(_.geo.circle().angle(120)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 30, y: 550}]);
       }
     },
@@ -498,18 +498,18 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([180, 0])
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(90));
       },
       "does not render a small circle of 60°": function(p) {
-        p(d3.geo.circle().angle(60)());
+        p(_.geo.circle().angle(60)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), []);
       },
       "renders a small circle of 120° in two parts": function(p) {
-        p(d3.geo.circle().angle(120)());
+        p(_.geo.circle().angle(120)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [
           {type: "moveTo", x: 276, y: 493},
           {type: "moveTo", x:  87, y: 700}
@@ -521,18 +521,18 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([270, 0])
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(90));
       },
       "renders a small circle of 60°": function(p) {
-        p(d3.geo.circle().angle(60)());
+        p(_.geo.circle().angle(60)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 30, y: -50}]);
       },
       "renders a small circle of 120°": function(p) {
-        p(d3.geo.circle().angle(120)());
+        p(_.geo.circle().angle(120)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 930, y: -50}]);
       }
     },
@@ -541,14 +541,14 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([210, 1])
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(90));
       },
       "renders a small circle of 120°": function(p) {
-        p(d3.geo.circle().angle(120)());
+        p(_.geo.circle().angle(120)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 930, y: 250}]);
       }
     },
@@ -557,14 +557,14 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .rotate([-150, 60])
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(90));
       },
       "renders a small circle of 120°": function(p) {
-        p(d3.geo.circle().angle(120)());
+        p(_.geo.circle().angle(120)());
         assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 30, y: -87}]);
       },
       "renders a sphere": function(p) {
@@ -577,7 +577,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(170));
@@ -596,7 +596,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .rotate([0, -90])
               .precision(0)
@@ -615,7 +615,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(30));
@@ -633,7 +633,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .precision(0)
               .clipAngle(150));
@@ -653,7 +653,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .rotate([98, 0])
               .precision(0));
@@ -688,13 +688,13 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .rotate([330, 232])
               .precision(0));
       },
       "renders degenerate points for a small circle of 30°": function(p) {
-        p(d3.geo.circle().angle(30)());
+        p(_.geo.circle().angle(30)());
         assert.equal(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }).length, 2);
       }
     },
@@ -703,14 +703,14 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.equirectangular()
+            .projection(_.geo.equirectangular()
               .scale(900 / Math.PI)
               .rotate([34.5, 90])
               .precision(0));
       },
       "observes proper clip point ordering for lines": function(p) {
-        var line = d3.range(-90,  180,  10).map(function(x) { return [x, 20]; })
-           .concat(d3.range(170, -100, -10).map(function(x) { return [x,  0]; }))
+        var line = _.range(-90,  180,  10).map(function(x) { return [x, 20]; })
+           .concat(_.range(170, -100, -10).map(function(x) { return [x,  0]; }))
            .concat([[-90, 20]]);
         p({type: "Polygon", coordinates: [line]});
         assert.equal(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }).length, 3);
@@ -721,7 +721,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.stereographic()
+            .projection(_.geo.stereographic()
               .precision(1));
       },
       "correctly resamples points on antimeridian": function(p) {
@@ -744,7 +744,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.albers()
+            .projection(_.geo.albers()
               .scale(140)
               .rotate([0, 0])
               .precision(1));
@@ -761,7 +761,7 @@ suite.addBatch({
       topic: function(path) {
         return path()
             .context(testContext)
-            .projection(d3.geo.albers()
+            .projection(_.geo.albers()
               .scale(140)
               .rotate([11.5, 285])
               .precision(1));
@@ -786,7 +786,7 @@ var testContext = {
 
 function stripes(a, b) {
   return {type: "Polygon", coordinates: [a, b].map(function(d, i) {
-    var stripe = d3.range(-180, 180, 1).map(function(x) { return [x, d]; });
+    var stripe = _.range(-180, 180, 1).map(function(x) { return [x, d]; });
     stripe.push(stripe[0]);
     return i ? stripe.reverse() : stripe;
   })};
diff --git a/test/geo/projection-test-suite.js b/test/geo/projection-test-suite.js
index 50e22dd5..d780fd32 100644
--- a/test/geo/projection-test-suite.js
+++ b/test/geo/projection-test-suite.js
@@ -1,6 +1,6 @@
 var assert = require("../assert"),
-    d3 = require("../../"),
-    format = d3.format("13.8f");
+    _ = require("../../"),
+    format = _.format("13.8f");
 
 module.exports = function(suite, mapping) {
 
diff --git a/test/geom/polygon-test.js b/test/geom/polygon-test.js
index 9a0f9a4d..39f70d81 100644
--- a/test/geom/polygon-test.js
+++ b/test/geom/polygon-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -81,7 +81,7 @@ suite.addBatch({
     "large square": {
       topic: function(polygon) {
         var r = 1e8,
-            d = d3.range(0, r, r / 1e4);
+            d = _.range(0, r, r / 1e4);
         return polygon(
             d.map(function(y) { return [0, y]; }).concat(
             d.map(function(x) { return [x, r]; })).concat(
diff --git a/test/scale/category-test.js b/test/scale/category-test.js
index df8c41b2..76e8238e 100644
--- a/test/scale/category-test.js
+++ b/test/scale/category-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -27,7 +27,7 @@ function category(category, n) {
       var y = x.copy();
       assert.deepEqual(y.domain(), x.domain());
       assert.deepEqual(y.range(), x.range());
-      x.domain(d3.range(n));
+      x.domain(_.range(n));
       for (var i = 0; i < n; ++i) assert.equal(x(i + n), x(i));
       assert.equal(y(1), colors[0]);
       assert.equal(y(2), colors[1]);
@@ -56,7 +56,7 @@ function category(category, n) {
       var x = scale[category]();
       x.range().forEach(function(v) {
         assert.match(v, /#[0-9a-f]{6}/);
-        v = d3.rgb(v);
+        v = _.rgb(v);
         assert.isFalse(isNaN(v.r));
         assert.isFalse(isNaN(v.g));
         assert.isFalse(isNaN(v.b));
@@ -65,7 +65,7 @@ function category(category, n) {
     "no range values are very dark or very light": function(scale) {
       var x = scale[category]();
       x.range().forEach(function(v) {
-        var c = d3.hsl(v);
+        var c = _.hsl(v);
         assert.isTrue(c.l >= .34, "expected " + v + " to be lighter (l = " + c.l + ")");
         assert.isTrue(c.l <= .89, "expected " + v + " to be darker (l = " + c.l + ")");
       });
diff --git a/test/scale/quantize-test.js b/test/scale/quantize-test.js
index 2e1b233a..99fbb72c 100644
--- a/test/scale/quantize-test.js
+++ b/test/scale/quantize-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -43,13 +43,13 @@ suite.addBatch({
     },
     "range cardinality determines the degree of quantization": function(quantize) {
       var x = quantize();
-      assert.inDelta(x.range(d3.range(0, 1.001, .001))(1/3), .333, 1e-6);
-      assert.inDelta(x.range(d3.range(0, 1.01, .01))(1/3), .33, 1e-6);
-      assert.inDelta(x.range(d3.range(0, 1.1, .1))(1/3), .3, 1e-6);
-      assert.inDelta(x.range(d3.range(0, 1.2, .2))(1/3), .4, 1e-6);
-      assert.inDelta(x.range(d3.range(0, 1.25, .25))(1/3), .25, 1e-6);
-      assert.inDelta(x.range(d3.range(0, 1.5, .5))(1/3), .5, 1e-6);
-      assert.inDelta(x.range(d3.range(1))(1/3), 0, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.001, .001))(1/3), .333, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.01, .01))(1/3), .33, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.1, .1))(1/3), .3, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.2, .2))(1/3), .4, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.25, .25))(1/3), .25, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.5, .5))(1/3), .5, 1e-6);
+      assert.inDelta(x.range(_.range(1))(1/3), 0, 1e-6);
     },
     "range values are arbitrary": function(quantize) {
       var a = {}, b = {}, c = {}, x = quantize().range([a, b, c]);
diff --git a/test/selection/attr-test.js b/test/selection/attr-test.js
index 92063e3e..c69110e9 100644
--- a/test/selection/attr-test.js
+++ b/test/selection/attr-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    interpolateRgb = require("../../").interpolateRgb,
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -117,7 +117,7 @@ suite.addBatch({
         assert.equal(div[0][1].getAttribute("bgcolor"), "coral");
       },
       "sets an attribute as a function of data": function(div) {
-        div.attr("bgcolor", interpolateRgb("brown", "steelblue"));
+        div.attr("bgcolor", _.interpolateRgb("brown", "steelblue"));
         assert.equal(div[0][0].getAttribute("bgcolor"), "#a52a2a");
         assert.equal(div[0][1].getAttribute("bgcolor"), "#4682b4");
       },
diff --git a/test/selection/filter-test.js b/test/selection/filter-test.js
index f3e861a9..e1fdbcd4 100644
--- a/test/selection/filter-test.js
+++ b/test/selection/filter-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    merge = require("../../").merge,
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -23,7 +23,7 @@ suite.addBatch({
         assert.isTrue(some[1][0] === span[1][0]);
       },
       "removes non-matching elements": function(span) {
-        var some = merge(span.filter(function(d, i) { return d & 1; }));
+        var some = _.merge(span.filter(function(d, i) { return d & 1; }));
         assert.equal(some.indexOf(span[0][0]), -1);
         assert.equal(some.indexOf(span[1][0]), -1);
       },
diff --git a/test/selection/property-test.js b/test/selection/property-test.js
index ad5dc992..075f3bd2 100644
--- a/test/selection/property-test.js
+++ b/test/selection/property-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    interpolateRgb = require("../../").interpolateRgb,
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -81,7 +81,7 @@ suite.addBatch({
         assert.equal(div[0][1].opacity, "0.4");
       },
       "sets a property as a function": function(div) {
-        div.property("bgcolor", interpolateRgb("brown", "steelblue"));
+        div.property("bgcolor", _.interpolateRgb("brown", "steelblue"));
         assert.equal(div[0][0].bgcolor, "#a52a2a");
         assert.equal(div[0][1].bgcolor, "#4682b4");
       },
diff --git a/test/selection/style-test.js b/test/selection/style-test.js
index ed851230..bdadc78b 100644
--- a/test/selection/style-test.js
+++ b/test/selection/style-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    interpolateRgb = require("../../").interpolateRgb,
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -89,7 +89,7 @@ suite.addBatch({
         assert.equal(div[0][1].style.getPropertyValue("opacity"), "0.5");
       },
       "sets a property as a function": function(div) {
-        div.style("background-color", interpolateRgb("orange", "yellow"));
+        div.style("background-color", _.interpolateRgb("orange", "yellow"));
         assert.equal(div[0][0].style.getPropertyValue("background-color"), "#ffa500");
         assert.equal(div[0][1].style.getPropertyValue("background-color"), "#ffff00");
       },
diff --git a/test/svg/area-radial-test.js b/test/svg/area-radial-test.js
index 9e43118b..d837217b 100644
--- a/test/svg/area-radial-test.js
+++ b/test/svg/area-radial-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -180,7 +180,7 @@ suite.addBatch({
 function testInterpolation(interpolate) {
   var data = [[10, 0], [20, 1], [20, 2], [10, 3]];
 
-  var cartesian = d3.svg.area()
+  var cartesian = _.svg.area()
       .x0(function(d) { return d[0] * Math.cos(d[1] - Math.PI / 2); })
       .x1(function(d) { return 2 * d[0] * Math.cos(d[1] - Math.PI / 2); })
       .y0(function(d) { return d[0] * Math.sin(d[1] - Math.PI / 2); })
diff --git a/test/svg/area-test.js b/test/svg/area-test.js
index a84f2ef2..289815c3 100644
--- a/test/svg/area-test.js
+++ b/test/svg/area-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -183,8 +183,8 @@ function testInterpolation(i0, i1) {
   return function(area) {
     var a = area().interpolate(i0),
         d = [[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]],
-        l0 = d3.svg.line().interpolate(i1).x(a.x0()).y(a.y0()),
-        l1 = d3.svg.line().interpolate(i0).x(a.x1()).y(a.y1());
+        l0 = _.svg.line().interpolate(i1).x(a.x0()).y(a.y0()),
+        l1 = _.svg.line().interpolate(i0).x(a.x1()).y(a.y1());
     assert.pathEqual(a(d), l1(d) + "L" + l0(d.reverse()).substring(1) + "Z");
   };
 }
diff --git a/test/svg/axis-test.js b/test/svg/axis-test.js
index 133ac06b..4a3fc987 100644
--- a/test/svg/axis-test.js
+++ b/test/svg/axis-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    ordinal = require("../../").scale.ordinal,
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -17,23 +17,23 @@ suite.addBatch({
         assert.equal(x(0.5), 0.5);
       },
       "can be defined as a scale object": function(d3) {
-        var x = d3.scale.linear(), a = d3.svg.axis().scale(x);
+        var x = _.scale.linear(), a = d3.svg.axis().scale(x);
         assert.equal(a.scale(), x);
       },
       "can be a polylinear scale": function(d3) {
-        var a = d3.svg.axis().scale(d3.scale.linear().domain([0, 1, 10]).range([2, 20, 200])),
+        var a = d3.svg.axis().scale(_.scale.linear().domain([0, 1, 10]).range([2, 20, 200])),
             g = d3.select("body").html("").append("svg:g").call(a),
             path = g.selectAll("path");
         assert.equal(path.attr("d"), "M2,6V0H200V6");
       },
       "can be an ordinal scale": function(d3) {
-        var a = d3.svg.axis().scale(ordinal().domain(["A", "B", "C"]).rangeBands([10, 90])),
+        var a = d3.svg.axis().scale(_.scale.ordinal().domain(["A", "B", "C"]).rangeBands([10, 90])),
             g = d3.select("body").html("").append("svg:g").call(a),
             path = g.selectAll("path");
         assert.equal(path.attr("d"), "M10,6V0H90V6");
       },
       "can be an ordinal scale with explicit range": function(d3) {
-        var a = d3.svg.axis().scale(ordinal().domain(["A", "B", "C"]).range([10, 50, 90])),
+        var a = d3.svg.axis().scale(_.scale.ordinal().domain(["A", "B", "C"]).range([10, 50, 90])),
             g = d3.select("body").html("").append("svg:g").call(a),
             path = g.selectAll("path");
         assert.equal(path.attr("d"), "M10,6V0H90V6");
@@ -205,7 +205,7 @@ suite.addBatch({
         assert.equal(t.length, 2);
       },
       "passes any arguments to the scale's ticks function": function(d3) {
-        var x = d3.scale.linear(), b = {}, a = d3.svg.axis().ticks(b, "%").scale(x), aa = [],
+        var x = _.scale.linear(), b = {}, a = d3.svg.axis().ticks(b, "%").scale(x), aa = [],
             g = d3.select("body").html("").append("svg:g");
         x.ticks = function() { aa.push(arguments); return [42]; };
         g.call(a);
@@ -216,7 +216,7 @@ suite.addBatch({
       },
       "passes any arguments to the scale's tickFormat function": function(d3) {
         var b = {},
-            x = d3.scale.linear(),
+            x = _.scale.linear(),
             a = d3.svg.axis().scale(x).ticks(b, "%"),
             g = d3.select("body").html("").append("svg:g"),
             aa = [];
@@ -265,7 +265,7 @@ suite.addBatch({
         assert.equal(t.length, 2);
       },
       "does not change the arguments passed to the scale's tickFormat function": function(d3) {
-        var x = d3.scale.linear(),
+        var x = _.scale.linear(),
             a = d3.svg.axis().scale(x).ticks(10).tickValues([1, 2, 3]),
             g = d3.select("body").html("").append("svg:g"),
             aa = [];
@@ -316,7 +316,7 @@ suite.addBatch({
         assert.isTrue(a.tickFormat() == null);
       },
       "when null, uses the scale's tick format": function(d3) {
-        var x = d3.scale.linear(), a = d3.svg.axis().scale(x),
+        var x = _.scale.linear(), a = d3.svg.axis().scale(x),
             g = d3.select("body").html("").append("svg:g");
 
         x.tickFormat = function() {
@@ -361,7 +361,7 @@ suite.addBatch({
       "generates new tick marks with labels": function(d3) {
         var a = d3.svg.axis(),
             g = d3.select("body").html("").append("svg:g").call(a),
-            x = d3.scale.linear(),
+            x = _.scale.linear(),
             tick = g.selectAll("g"),
             ticks = x.ticks(10),
             tickFormat = x.tickFormat(10);
diff --git a/test/svg/brush-test.js b/test/svg/brush-test.js
index 38748270..282ffc42 100644
--- a/test/svg/brush-test.js
+++ b/test/svg/brush-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    linear = require("../../").scale.linear,
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -26,33 +26,33 @@ suite.addBatch({
         assert.isNull(brush().extent());
       },
       "returns a one-dimensional array if only x is defined": function(brush) {
-        var b = brush().x(linear());
+        var b = brush().x(_.scale.linear());
         assert.deepEqual(b.extent(), [0, 0]);
       },
       "takes a one-dimensional array if only x is defined": function(brush) {
-        var b = brush().x(linear()).extent([0.1, 0.4]);
+        var b = brush().x(_.scale.linear()).extent([0.1, 0.4]);
         assert.deepEqual(b.extent(), [0.1, 0.4]);
       },
       "returns a one-dimensional array if only y is defined": function(brush) {
-        var b = brush().y(linear());
+        var b = brush().y(_.scale.linear());
         assert.deepEqual(b.extent(), [0, 0]);
       },
       "takes a one-dimensional array if only y is defined": function(brush) {
-        var b = brush().y(linear()).extent([0.1, 0.4]);
+        var b = brush().y(_.scale.linear()).extent([0.1, 0.4]);
         assert.deepEqual(b.extent(), [0.1, 0.4]);
       },
       "returns a two-dimensional array if x and y are defined": function(brush) {
-        var b = brush().x(linear()).y(linear());
+        var b = brush().x(_.scale.linear()).y(_.scale.linear());
         assert.deepEqual(b.extent(), [[0, 0], [0, 0]]);
       },
       "takes a two-dimensional array if x and y are defined": function(brush) {
-        var b = brush().x(linear()).y(linear()).extent([[0.1, 0.2], [0.3, 0.4]]);
+        var b = brush().x(_.scale.linear()).y(_.scale.linear()).extent([[0.1, 0.2], [0.3, 0.4]]);
         assert.deepEqual(b.extent(), [[0.1, 0.2], [0.3, 0.4]]);
       },
       "preserves the set extent exactly": function(brush) {
         var lo = new Number(0.1),
             hi = new Number(0.3),
-            b = brush().x(linear()).extent([lo, hi]),
+            b = brush().x(_.scale.linear()).extent([lo, hi]),
             extent = b.extent();
         assert.strictEqual(extent[0], lo);
         assert.strictEqual(extent[1], hi);
diff --git a/test/svg/line-radial-test.js b/test/svg/line-radial-test.js
index 709ef5eb..6d7e358f 100644
--- a/test/svg/line-radial-test.js
+++ b/test/svg/line-radial-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert");
 
@@ -108,7 +108,7 @@ suite.addBatch({
 function testInterpolation(interpolate) {
   var data = [[10, 0], [20, 1], [20, 2], [10, 3]];
 
-  var cartesian = d3.svg.line()
+  var cartesian = _.svg.line()
       .x(function(d) { return d[0] * Math.cos(d[1] - Math.PI / 2); })
       .y(function(d) { return d[0] * Math.sin(d[1] - Math.PI / 2); });
 
diff --git a/test/time/scale-test.js b/test/time/scale-test.js
index 8b60a0b2..1b87e831 100644
--- a/test/time/scale-test.js
+++ b/test/time/scale-test.js
@@ -1,5 +1,5 @@
 var vows = require("vows"),
-    d3 = require("../../"),
+    _ = require("../../"),
     load = require("../load"),
     assert = require("../assert"),
     time = require("./time"),
@@ -15,17 +15,17 @@ suite.addBatch({
     "nice": {
       "rounds using the specified time interval": function(scale) {
         var x = scale().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 23, 48)]);
-        assert.deepEqual(x.nice(d3.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
-        assert.deepEqual(x.nice(d3.time.week).domain(), [local(2008, 11, 28), local(2009, 0, 4)]);
-        assert.deepEqual(x.nice(d3.time.month).domain(), [local(2008, 11, 1), local(2009, 1, 1)]);
-        assert.deepEqual(x.nice(d3.time.year).domain(), [local(2008, 0, 1), local(2010, 0, 1)]);
+        assert.deepEqual(x.nice(_.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
+        assert.deepEqual(x.nice(_.time.week).domain(), [local(2008, 11, 28), local(2009, 0, 4)]);
+        assert.deepEqual(x.nice(_.time.month).domain(), [local(2008, 11, 1), local(2009, 1, 1)]);
+        assert.deepEqual(x.nice(_.time.year).domain(), [local(2008, 0, 1), local(2010, 0, 1)]);
       },
       "works on degenerate domains": function(scale) {
         var x = scale().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 0, 12)]);
-        assert.deepEqual(x.nice(d3.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
+        assert.deepEqual(x.nice(_.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
       },
       "nicing a polylinear domain only affects the extent": function(linear) {
-        var x = linear().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 23, 48), local(2009, 0, 2, 23, 48)]).nice(d3.time.day);
+        var x = linear().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 23, 48), local(2009, 0, 2, 23, 48)]).nice(_.time.day);
         assert.deepEqual(x.domain(), [local(2009, 0, 1), local(2009, 0, 1, 23, 48), local(2009, 0, 3)]);
       }
     },
@@ -59,7 +59,7 @@ suite.addBatch({
         var x = scale().domain([local(2009, 0, 1), local(2010, 0, 1)]).range(["red", "blue"]),
             i = x.interpolate(),
             y = x.copy();
-        x.interpolate(d3.interpolateHsl);
+        x.interpolate(_.interpolateHsl);
         assert.equal(x(local(2009, 6, 1)), "#ff00fd");
         assert.equal(y(local(2009, 6, 1)), "#81007e");
         assert.equal(y.interpolate(), i);
@@ -80,7 +80,7 @@ suite.addBatch({
     "ticks": {
       "observes explicit tick interval": function(scale) {
         var x = scale().domain([local(2011, 0, 1, 12, 1, 0), local(2011, 0, 1, 12, 4, 4)]);
-        assert.deepEqual(x.ticks(d3.time.minutes), [
+        assert.deepEqual(x.ticks(_.time.minutes), [
           local(2011, 0, 1, 12, 1),
           local(2011, 0, 1, 12, 2),
           local(2011, 0, 1, 12, 3),
@@ -89,7 +89,7 @@ suite.addBatch({
       },
       "observes explicit tick interval and step": function(scale) {
         var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 33, 4)]);
-        assert.deepEqual(x.ticks(d3.time.minutes, 10), [
+        assert.deepEqual(x.ticks(_.time.minutes, 10), [
           local(2011, 0, 1, 12, 0),
           local(2011, 0, 1, 12, 10),
           local(2011, 0, 1, 12, 20),
@@ -332,7 +332,7 @@ suite.addBatch({
     "ticks": {
       "observes explicit tick interval": function(scale) {
         var x = scale().domain([utc(2011, 0, 1, 12, 1, 0), utc(2011, 0, 1, 12, 4, 4)]);
-        assert.deepEqual(x.ticks(d3.time.minutes), [
+        assert.deepEqual(x.ticks(_.time.minutes), [
           utc(2011, 0, 1, 12, 1),
           utc(2011, 0, 1, 12, 2),
           utc(2011, 0, 1, 12, 3),
@@ -341,7 +341,7 @@ suite.addBatch({
       },
       "observes explicit tick interval and step": function(scale) {
         var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 33, 4)]);
-        assert.deepEqual(x.ticks(d3.time.minutes, 10), [
+        assert.deepEqual(x.ticks(_.time.minutes, 10), [
           utc(2011, 0, 1, 12, 0),
           utc(2011, 0, 1, 12, 10),
           utc(2011, 0, 1, 12, 20),
diff --git a/test/transition/transition-test-attrTween.js b/test/transition/transition-test-attrTween.js
index 878fadff..e5c795ec 100644
--- a/test/transition/transition-test-attrTween.js
+++ b/test/transition/transition-test-attrTween.js
@@ -1,9 +1,9 @@
 var assert = require("../assert"),
-    interpolateHsl = require("../../").interpolateHsl;
+    _ = require("../../");
 
 module.exports = {
   topic: function(d3) {
-    var cb = this.callback,
+    var callback = this.callback,
         dd = [],
         ii = [],
         tt = [],
@@ -21,7 +21,7 @@ module.exports = {
       dd.push(d);
       ii.push(i);
       vv.push(v);
-      if (tt.push(this) >= 2) cb(null, {
+      if (tt.push(this) >= 2) callback(null, {
         selection: s,
         transition: t,
         data: dd,
@@ -29,7 +29,7 @@ module.exports = {
         value: vv,
         context: tt
       });
-      return i && interpolateHsl(v, "blue");
+      return i && _.interpolateHsl(v, "blue");
     }
   },
 
@@ -52,8 +52,8 @@ module.exports = {
 
   "end": {
     topic: function(result) {
-      var cb = this.callback;
-      result.transition.each("end", function(d, i) { if (i >= 1) cb(null, result); });
+      var callback = this.callback;
+      result.transition.each("end", function(d, i) { if (i >= 1) callback(null, result); });
     },
     "uses the returned interpolator": function(result) {
       assert.equal(result.selection[0][1].getAttribute("color"), "#0000ff");
diff --git a/test/transition/transition-test-filter.js b/test/transition/transition-test-filter.js
index 7bb20537..02830b7c 100644
--- a/test/transition/transition-test-filter.js
+++ b/test/transition/transition-test-filter.js
@@ -1,5 +1,5 @@
 var assert = require("../assert"),
-    merge = require("../../").merge;
+    _ = require("../../");
 
 var datum = {};
 
@@ -24,7 +24,7 @@ module.exports = {
     assert.isTrue(some[1][0] === span[1][0]);
   },
   "removes non-matching elements": function(span) {
-    var some = merge(span.filter(function(d, i) { return d & 1; }));
+    var some = _.merge(span.filter(function(d, i) { return d & 1; }));
     assert.equal(some.indexOf(span[0][0]), -1);
     assert.equal(some.indexOf(span[1][0]), -1);
   },
diff --git a/test/transition/transition-test-styleTween.js b/test/transition/transition-test-styleTween.js
index a4d4d8f9..e0bfee86 100644
--- a/test/transition/transition-test-styleTween.js
+++ b/test/transition/transition-test-styleTween.js
@@ -1,5 +1,5 @@
 var assert = require("../assert"),
-    interpolateHsl = require("../../").interpolateHsl;
+    _ = require("../../");
 
 module.exports = {
   topic: function(d3) {
@@ -32,7 +32,7 @@ module.exports = {
         context: tt,
         fails: fails
       });
-      return i && interpolateHsl(v, "blue");
+      return i && _.interpolateHsl(v, "blue");
     }
   },