Bump lots of changes

13 files changed, 682 insertions, 0 deletions

diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/array-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/array-test.js
new file mode 100644
index 0000000..34ac6ef
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/array-test.js
@@ -0,0 +1,24 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateArray");
+
+suite.addBatch({
+  "interpolateArray": {
+    topic: load("interpolate/array").expression("d3.interpolateArray"),
+    "interpolates defined elements": function(interpolate) {
+      assert.deepEqual(interpolate([2, 12], [4, 24])(.5), [3, 18]);
+    },
+    "interpolates nested objects and arrays": function(interpolate) {
+      assert.deepEqual(interpolate([[2, 12]], [[4, 24]])(.5), [[3, 18]]);
+      assert.deepEqual(interpolate([{foo: [2, 12]}], [{foo: [4, 24]}])(.5), [{foo: [3, 18]}]);
+    },
+    "merges non-shared elements": function(interpolate) {
+      assert.deepEqual(interpolate([2, 12], [4, 24, 12])(.5), [3, 18, 12]);
+      assert.deepEqual(interpolate([2, 12, 12], [4, 24])(.5), [3, 18, 12]);
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/ease-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/ease-test.js
new file mode 100644
index 0000000..7e36548
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/ease-test.js
@@ -0,0 +1,135 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.ease");
+
+suite.addBatch({
+  "ease": {
+    topic: load("interpolate/ease").expression("d3.ease"),
+    "supports linear easing": function(ease) {
+      var e = ease("linear");
+      assert.inDelta(e(.5), .5, 1e-6);
+    },
+    "supports polynomial easing": function(ease) {
+      var e = ease("poly", 2);
+      assert.inDelta(e(.5), .25, 1e-6);
+    },
+    "supports quadratic easing": function(ease) {
+      var e = ease("quad");
+      assert.inDelta(e(.5), .25, 1e-6);
+    },
+    "supports cubic easing": function(ease) {
+      var e = ease("cubic");
+      assert.inDelta(e(.5), .125, 1e-6);
+    },
+    "supports sinusoidal easing": function(ease) {
+      var e = ease("sin");
+      assert.inDelta(e(.5), 1 - Math.cos(Math.PI / 4), 1e-6);
+    },
+    "supports exponential easing": function(ease) {
+      var e = ease("exp");
+      assert.inDelta(e(.5), 0.03125, 1e-6);
+    },
+    "supports circular easing": function(ease) {
+      var e = ease("circle");
+      assert.inDelta(e(.5), 0.133975, 1e-6);
+    },
+    "supports elastic easing": function(ease) {
+      var e = ease("elastic");
+      assert.inDelta(e(.5), 0.976061, 1e-6);
+    },
+    "supports back easing": function(ease) {
+      var e = ease("back");
+      assert.inDelta(e(.5), -0.0876975, 1e-6);
+    },
+    "supports bounce easing": function(ease) {
+      var e = ease("bounce");
+      assert.inDelta(e(.5), 0.765625, 1e-6);
+    },
+    "invalid eases and modes default to linear-in": function(ease) {
+      var e = ease("__proto__-__proto__");
+      assert.strictEqual(e(0), 0);
+      assert.strictEqual(e(.5), .5);
+      assert.strictEqual(e(1), 1);
+      var e = ease("hasOwnProperty-constructor");
+      assert.strictEqual(e(0), 0);
+      assert.strictEqual(e(.5), .5);
+      assert.strictEqual(e(1), 1);
+    },
+    "all easing functions return exactly 0 for t = 0": function(ease) {
+      assert.strictEqual(ease("linear")(0), 0);
+      assert.strictEqual(ease("poly", 2)(0), 0);
+      assert.strictEqual(ease("quad")(0), 0);
+      assert.strictEqual(ease("cubic")(0), 0);
+      assert.strictEqual(ease("sin")(0), 0);
+      assert.strictEqual(ease("exp")(0), 0);
+      assert.strictEqual(ease("circle")(0), 0);
+      assert.strictEqual(ease("elastic")(0), 0);
+      assert.strictEqual(ease("back")(0), 0);
+      assert.strictEqual(ease("bounce")(0), 0);
+    },
+    "all easing functions return exactly 1 for t = 1": function(ease) {
+      assert.strictEqual(ease("linear")(1), 1);
+      assert.strictEqual(ease("poly", 2)(1), 1);
+      assert.strictEqual(ease("quad")(1), 1);
+      assert.strictEqual(ease("cubic")(1), 1);
+      assert.strictEqual(ease("sin")(1), 1);
+      assert.strictEqual(ease("exp")(1), 1);
+      assert.strictEqual(ease("circle")(1), 1);
+      assert.strictEqual(ease("elastic")(1), 1);
+      assert.strictEqual(ease("back")(1), 1);
+      assert.strictEqual(ease("bounce")(1), 1);
+    },
+    "the -in suffix returns the identity": function(ease) {
+      assert.inDelta(ease("linear-in")(.25), ease("linear")(.25), 1e-6);
+      assert.inDelta(ease("quad-in")(.75), ease("quad")(.75), 1e-6);
+    },
+    "the -out suffix returns the reverse": function(ease) {
+      assert.inDelta(ease("sin-out")(.25), 1 - ease("sin-in")(.75), 1e-6);
+      assert.inDelta(ease("bounce-out")(.25), 1 - ease("bounce-in")(.75), 1e-6);
+      assert.inDelta(ease("elastic-out")(.25), 1 - ease("elastic-in")(.75), 1e-6);
+    },
+    "the -in-out suffix returns the reflection": function(ease) {
+      assert.inDelta(ease("sin-in-out")(.25), .5 * ease("sin-in")(.5), 1e-6);
+      assert.inDelta(ease("bounce-in-out")(.25), .5 * ease("bounce-in")(.5), 1e-6);
+      assert.inDelta(ease("elastic-in-out")(.25), .5 * ease("elastic-in")(.5), 1e-6);
+    },
+    "the -out-in suffix returns the reverse reflection": function(ease) {
+      assert.inDelta(ease("sin-out-in")(.25), .5 * ease("sin-out")(.5), 1e-6);
+      assert.inDelta(ease("bounce-out-in")(.25), .5 * ease("bounce-out")(.5), 1e-6);
+      assert.inDelta(ease("elastic-out-in")(.25), .5 * ease("elastic-out")(.5), 1e-6);
+    },
+    "clamps input time": function(ease) {
+      var e = ease("linear");
+      assert.inDelta(e(-1), 0, 1e-6);
+      assert.inDelta(e(2), 1, 1e-6);
+    },
+    "poly": {
+      "supports an optional polynomial": function(ease) {
+        var e = ease("poly", 1);
+        assert.inDelta(e(.5), .5, 1e-6);
+        var e = ease("poly", .5);
+        assert.inDelta(e(.5), Math.SQRT1_2, 1e-6);
+      }
+    },
+    "elastic": {
+      "supports an optional amplifier (>1)": function(ease) {
+        var e = ease("elastic", 1.5);
+        assert.inDelta(e(.5), 0.998519, 1e-6);
+      },
+      "supports an optional amplifier (>1) and period (>0)": function(ease) {
+        var e = ease("elastic", 1.5, .5);
+        assert.inDelta(e(.5), 0.96875, 1e-6);
+      }
+    },
+    "back": {
+      "supports an optional speed": function(ease) {
+        var e = ease("back", 2);
+        assert.inDelta(e(.5), -0.125, 1e-6);
+      }
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hcl-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hcl-test.js
new file mode 100644
index 0000000..f21ab3b
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hcl-test.js
@@ -0,0 +1,47 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateHcl");
+
+suite.addBatch({
+  "interpolateHcl": {
+    topic: load("interpolate/hcl"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.2), "#6978c9");
+      assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.6), "#e034a2");
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.strictEqual(d3.interpolateHcl(d3.hsl("steelblue"), "#f00")(.2), "#6978c9");
+      assert.strictEqual(d3.interpolateHcl("steelblue", d3.hsl(0, 1, .5))(.6), "#e034a2");
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.strictEqual(d3.interpolateHcl(d3.rgb("steelblue"), "#f00")(.2), "#6978c9");
+      assert.strictEqual(d3.interpolateHcl("steelblue", d3.rgb(255, 0, 0))(.6), "#e034a2");
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.2), "#6978c9");
+    },
+    "uses source hue when destination hue is undefined": function(d3) {
+      assert.equal(d3.interpolateHcl("#f60", "#000")(.5), "#9b0000");
+      assert.equal(d3.interpolateHcl("#6f0", "#000")(.5), "#008100");
+    },
+    "uses destination hue when source hue is undefined": function(d3) {
+      assert.equal(d3.interpolateHcl("#000", "#f60")(.5), "#9b0000");
+      assert.equal(d3.interpolateHcl("#000", "#6f0")(.5), "#008100");
+    },
+    "uses source chroma when destination chroma is undefined": function(d3) {
+      assert.equal(d3.interpolateHcl("#ccc", "#000")(.5), "#616161");
+      assert.equal(d3.interpolateHcl("#f00", "#000")(.5), "#a60000");
+    },
+    "uses destination chroma when source chroma is undefined": function(d3) {
+      assert.equal(d3.interpolateHcl("#000", "#ccc")(.5), "#616161");
+      assert.equal(d3.interpolateHcl("#000", "#f00")(.5), "#a60000");
+    },
+    "outputs a hexadecimal string": function(d3) {
+      assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.2), "#6978c9");
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hsl-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hsl-test.js
new file mode 100644
index 0000000..26689a3
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hsl-test.js
@@ -0,0 +1,47 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateHsl");
+
+suite.addBatch({
+  "interpolateHsl": {
+    topic: load("interpolate/hsl"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.2), "#383dc3");
+      assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.6), "#dd1ce1");
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.strictEqual(d3.interpolateHsl(d3.hsl("steelblue"), "#f00")(.2), "#383dc3");
+      assert.strictEqual(d3.interpolateHsl("steelblue", d3.hsl(0, 1, .5))(.6), "#dd1ce1");
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.strictEqual(d3.interpolateHsl(d3.rgb("steelblue"), "#f00")(.2), "#383dc3");
+      assert.strictEqual(d3.interpolateHsl("steelblue", d3.rgb(255, 0, 0))(.6), "#dd1ce1");
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.2), "#383dc3");
+    },
+    "uses source hue when destination hue is undefined": function(d3) {
+      assert.equal(d3.interpolateHsl("#f60", "#000")(.5), "#803300");
+      assert.equal(d3.interpolateHsl("#6f0", "#fff")(.5), "#b3ff80");
+    },
+    "uses destination hue when source hue is undefined": function(d3) {
+      assert.equal(d3.interpolateHsl("#000", "#f60")(.5), "#803300");
+      assert.equal(d3.interpolateHsl("#fff", "#6f0")(.5), "#b3ff80");
+    },
+    "uses source saturation when destination saturation is undefined": function(d3) {
+      assert.equal(d3.interpolateHsl("#ccc", "#000")(.5), "#666666");
+      assert.equal(d3.interpolateHsl("#f00", "#000")(.5), "#800000");
+    },
+    "uses destination saturation when source saturation is undefined": function(d3) {
+      assert.equal(d3.interpolateHsl("#000", "#ccc")(.5), "#666666");
+      assert.equal(d3.interpolateHsl("#000", "#f00")(.5), "#800000");
+    },
+    "outputs a hexadecimal string": function(d3) {
+      assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.2), "#383dc3");
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-string-benchmark b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-string-benchmark
new file mode 100755
index 0000000..e8babf9
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-string-benchmark
@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+var d3 = require("../../");
+
+var n = +process.argv[2],
+    p = +process.argv[3],
+    k = +process.argv[4];
+
+var formatTime = d3.format(".3s"),
+    formatNumber = d3.format(",.0f");
+
+// Returns the time required to construct a string interpolator
+// for two strings with n numbers, separated by commas,
+// with probability p that the corresponding numbers in a & b are different.
+// The test is run k times, and the mean result is returned.
+function observeConstruction(n, p, k) {
+  if (arguments.length < 3) k = 1;
+  for (var i = 0, sum = 0; i < k; ++i) {
+    var a = d3.range(n).map(function() { return Math.random() * 1000; }),
+        b = d3.range(n).map(function(i) { return Math.random() < p ? Math.random() * 1000 : a[i]; });
+    var start = process.hrtime();
+    d3.interpolateString(a, b);
+    var elapsed = process.hrtime(start);
+    sum += elapsed[0] + elapsed[1] / 1e9;
+    process.stdout.write(".");
+  }
+  console.log("");
+  return sum / k;
+}
+
+console.log(formatTime(observeConstruction(n, p, k)) + "s\tn=" + formatNumber(n) + "\tp=" + p);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-test.js
new file mode 100644
index 0000000..c05e290
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-test.js
@@ -0,0 +1,151 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolate");
+
+suite.addBatch({
+  "interpolate": {
+    topic: load("interpolate/interpolate"),
+
+    "when b is a number": {
+      "interpolates numbers": function(d3) {
+        assert.strictEqual(d3.interpolate(2, 12)(.25), 4.5);
+      },
+      "coerces a to a number": function(d3) {
+        assert.strictEqual(d3.interpolate("", 1)(.5), .5);
+        assert.strictEqual(d3.interpolate("2", 12)(.25), 4.5);
+        assert.strictEqual(d3.interpolate([2], 12)(.25), 4.5);
+      }
+    },
+
+    "when b is a color string": {
+      "interpolates RGB values and returns a hexadecimal string": function(d3) {
+        assert.strictEqual(d3.interpolate("#ff0000", "#008000")(.4), "#993300");
+      },
+      "interpolates named colors in RGB": function(d3) {
+        assert.strictEqual(d3.interpolate("red", "green")(.4), "#993300");
+      },
+      "interpolates decimal RGB colors in RGB": function(d3) {
+        assert.strictEqual(d3.interpolate("rgb(255,0,0)", "rgb(0,128,0)")(.4), "#993300");
+      },
+      "interpolates decimal HSL colors in RGB": function(d3) {
+        assert.strictEqual(d3.interpolate("hsl(0,100%,50%)", "hsl(120,100%,25%)")(.4), "#993300");
+      },
+      "coerces a to a color": function(d3) {
+        assert.strictEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), "#993300");
+      }
+    },
+
+    "when b is a color object": {
+      "interpolates RGB values and returns a hexadecimal string": function(d3) {
+        assert.strictEqual(d3.interpolate(d3.rgb(255, 0, 0), d3.rgb(0, 128, 0))(.4), "#993300");
+      },
+      "interpolates d3.hsl in RGB": function(d3) {
+        assert.strictEqual(d3.interpolate(d3.hsl("red"), d3.hsl("green"))(.4), "#993300");
+      },
+      "interpolates d3.lab in RGB": function(d3) {
+        assert.strictEqual(d3.interpolate(d3.lab("red"), d3.lab("green"))(.4), "#993300");
+      },
+      "interpolates d3.hcl in RGB": function(d3) {
+        assert.strictEqual(d3.interpolate(d3.hcl("red"), d3.hcl("green"))(.4), "#993300");
+      },
+      "coerces a to a color": function(d3) {
+        assert.strictEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), "#993300");
+      }
+    },
+
+    "when b is a string": {
+      "interpolates matching numbers in both strings": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 ");
+      },
+      "if b is coercible to a number, still returns a string": function(d3) {
+        assert.strictEqual(d3.interpolate("1.", "2.")(.5), "1.5");
+        assert.strictEqual(d3.interpolate("1e+3", "1e+4")(.5), "5500");
+      },
+      "preserves non-numbers in string b": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo ");
+      },
+      "preserves non-matching numbers in string b": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 ");
+      },
+      "preserves equal-value numbers in both strings": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 ");
+      },
+      "coerces a to a string": function(d3) {
+        assert.strictEqual(d3.interpolate({toString: function() { return "1."; }}, "2.")(.5), "1.5");
+      }
+    },
+
+    "when b is an array": {
+      "interpolates each element in b": function(d3) {
+        assert.strictEqual(JSON.stringify(d3.interpolate([2, 4], [12, 24])(.25)), "[4.5,9]");
+      },
+      "interpolates arrays, even when both a and b are coercible to numbers": function(d3) {
+        assert.strictEqual(JSON.stringify(d3.interpolate([2], [12])(.25)), "[4.5]");
+        assert.strictEqual(JSON.stringify(d3.interpolate([[2]], [[12]])(.25)), "[[4.5]]");
+      },
+      "reuses the returned array during interpolation": function(d3) {
+        var i = d3.interpolate([2], [12]);
+        assert.strictEqual(i(.2), i(.4));
+      }
+    },
+
+    "when b is an object": {
+      "interpolates each property in b": function(d3) {
+        assert.deepEqual(d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24})(.25), {foo: 4.5, bar: 9});
+      },
+      "interpolates numbers if b is coercible to a number (!isNaN(+b))": function(d3) {
+        assert.strictEqual(d3.interpolate(new Number(2), new Number(12))(.25), 4.5);
+        assert.strictEqual(d3.interpolate(new Date(2012, 0, 1), new Date(2013, 0, 1))(.5), +new Date(2012, 6, 2, 1));
+        assert.strictEqual(d3.interpolate(1, null)(.4), .6); // +null = 0
+        assert.isNaN(d3.interpolate("blue", null)(.4));
+      },
+      "reuses the returned object during interpolation": function(d3) {
+        var i = d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24});
+        assert.strictEqual(i(.2), i(.4));
+      }
+    },
+
+    "may or may not interpolate between enumerable and non-enumerable properties": function(d3) {
+      var a = Object.create({}, {foo: {value: 1, enumerable: true}}),
+          b = Object.create({}, {foo: {value: 2, enumerable: false}});
+      try {
+        assert.deepEqual(d3.interpolate(a, b)(1), {});
+      } catch (e) {
+        assert.deepEqual(d3.interpolate(a, b)(1), {foo: 2});
+      }
+      try {
+        assert.deepEqual(d3.interpolate(b, a)(1), {});
+      } catch (e) {
+        assert.deepEqual(d3.interpolate(b, a)(1), {foo: 1});
+      }
+    },
+    "interpolates inherited properties of objects": function(d3) {
+      var a = Object.create({foo: 0}),
+          b = Object.create({foo: 2});
+      assert.deepEqual(d3.interpolate(a, b)(.5), {foo: 1});
+    },
+    "doesn't interpret properties in the default object's prototype chain as RGB": function(d3) {
+      assert.equal(d3.interpolate("hasOwnProperty", "hasOwnProperty")(0), "hasOwnProperty");
+    }
+  },
+
+  "interpolators": {
+    topic: load("interpolate/interpolate").document(),
+    "can register a custom interpolator": function(d3) {
+      d3.interpolators.push(function(a, b) { return a == "one" && b == "two" && d3.interpolateNumber(1, 2); });
+      try {
+        assert.equal(d3.interpolate("one", "two")(-.5), .5);
+        assert.equal(d3.interpolate("one", "two")(0), 1);
+        assert.equal(d3.interpolate("one", "two")(.5), 1.5);
+        assert.equal(d3.interpolate("one", "two")(1), 2);
+        assert.equal(d3.interpolate("one", "two")(1.5), 2.5);
+      } finally {
+        d3.interpolators.pop();
+      }
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-transform-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-transform-test.js
new file mode 100644
index 0000000..5320740
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-transform-test.js
@@ -0,0 +1,60 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateTransform");
+
+suite.addBatch({
+  "interpolateTransform": {
+    topic: load("interpolate/transform").document(),
+    "interpolation of a decomposed transform": {
+      topic: function(d3) {
+        // Use a custom d3.transform to parse a decomposed transform, since
+        // JSDOM doesn't support consolidating SVG transform strings.
+        d3.transform = function(s) {
+          var m = s.split(/,/g).map(Number);
+          return {
+            translate: [m[0], m[1]],
+            rotate: m[2],
+            skew: m[3],
+            scale: [m[4], m[5]]
+          };
+        };
+        return d3;
+      },
+      "identity": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 0, 1, 1] + "")(.4), "");
+      },
+      "translate": {
+        "x": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [10, 0, 0, 0, 1, 1] + "")(.4), "translate(4,0)");
+        },
+        "y": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 10, 0, 0, 1, 1] + "")(.4), "translate(0,4)");
+        },
+        "x and y": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [1, 10, 0, 0, 1, 1] + "")(.4), "translate(0.4,4)");
+        }
+      },
+      "rotate": {
+        "simple": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, -10, 0, 1, 1] + "", [0, 0, 30, 0, 1, 1] + "")(.4), "rotate(6)");
+        },
+        "with constant translate": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([5, 6, -10, 0, 1, 1] + "", [5, 6, 30, 0, 1, 1] + "")(.4), "translate(5,6)rotate(6)");
+        }
+      },
+      "skew": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 40, 1, 1] + "")(.4), "skewX(16)");
+      },
+      "scale": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 0, 10, 1] + "")(.5), "scale(5.5,1)");
+      },
+      "translate and rotate": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [100, 0, 90, 0, 1, 1] + "")(.5), "translate(50,0)rotate(45)");
+      }
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/lab-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/lab-test.js
new file mode 100644
index 0000000..bb4622a
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/lab-test.js
@@ -0,0 +1,31 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateLab");
+
+suite.addBatch({
+  "interpolateLab": {
+    topic: load("interpolate/lab"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.2), "#8a7793");
+      assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.6), "#cf5952");
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.strictEqual(d3.interpolateLab(d3.hsl("steelblue"), "#f00")(.2), "#8a7793");
+      assert.strictEqual(d3.interpolateLab("steelblue", d3.hsl(0, 1, .5))(.6), "#cf5952");
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.strictEqual(d3.interpolateLab(d3.rgb("steelblue"), "#f00")(.2), "#8a7793");
+      assert.strictEqual(d3.interpolateLab("steelblue", d3.rgb(255, 0, 0))(.6), "#cf5952");
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.2), "#8a7793");
+    },
+    "returns an instanceof d3.lab": function(d3) {
+      assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.2), "#8a7793");
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/number-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/number-test.js
new file mode 100644
index 0000000..61c3477
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/number-test.js
@@ -0,0 +1,20 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateNumber");
+
+suite.addBatch({
+  "interpolateNumber": {
+    topic: load("interpolate/number").expression("d3.interpolateNumber"),
+    "interpolates numbers": function(interpolate) {
+      assert.strictEqual(interpolate(2, 12)(.25), 4.5);
+      assert.strictEqual(interpolate(2, 12)(.75), 9.5);
+    },
+    "coerces strings to numbers": function(interpolate) {
+      assert.strictEqual(interpolate("2", "12")(.25), 4.5);
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/object-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/object-test.js
new file mode 100644
index 0000000..f9539a6
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/object-test.js
@@ -0,0 +1,35 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateObject");
+
+suite.addBatch({
+  "interpolateObject": {
+    topic: load("interpolate/object").expression("d3.interpolateObject"),
+    "interpolates defined properties": function(interpolate) {
+      assert.deepEqual(interpolate({a: 2, b: 12}, {a: 4, b: 24})(.5), {a: 3, b: 18});
+    },
+    "interpolates inherited properties": function(interpolate) {
+      function a(a) { this.a = a; }
+      a.prototype.b = 12;
+      assert.deepEqual(interpolate(new a(2), new a(4))(.5), {a: 3, b: 12});
+    },
+    "interpolates color properties as rgb": function(interpolate) {
+      assert.deepEqual(interpolate({background: "red"}, {background: "green"})(.5), {background: "#804000"});
+      assert.deepEqual(interpolate({fill: "red"}, {fill: "green"})(.5), {fill: "#804000"});
+      assert.deepEqual(interpolate({stroke: "red"}, {stroke: "green"})(.5), {stroke: "#804000"});
+      assert.deepEqual(interpolate({color: "red"}, {color: "green"})(.5), {color: "#804000"});
+    },
+    "interpolates nested objects and arrays": function(interpolate) {
+      assert.deepEqual(interpolate({foo: [2, 12]}, {foo: [4, 24]})(.5), {foo: [3, 18]});
+      assert.deepEqual(interpolate({foo: {bar: [2, 12]}}, {foo: {bar: [4, 24]}})(.5), {foo: {bar: [3, 18]}});
+    },
+    "merges non-shared properties": function(interpolate) {
+      assert.deepEqual(interpolate({foo: 2}, {foo: 4, bar: 12})(.5), {foo: 3, bar: 12});
+      assert.deepEqual(interpolate({foo: 2, bar: 12}, {foo: 4})(.5), {foo: 3, bar: 12});
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/rgb-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/rgb-test.js
new file mode 100644
index 0000000..89f9959
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/rgb-test.js
@@ -0,0 +1,31 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateRgb");
+
+suite.addBatch({
+  "interpolateRgb": {
+    topic: load("interpolate/rgb"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.2), "#6b6890");
+      assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.6), "#b53448");
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.strictEqual(d3.interpolateRgb(d3.rgb("steelblue"), "#f00")(.2), "#6b6890");
+      assert.strictEqual(d3.interpolateRgb("steelblue", d3.rgb(255, 0, 0))(.6), "#b53448");
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.strictEqual(d3.interpolateRgb(d3.hsl("steelblue"), "#f00")(.2), "#6b6890");
+      assert.strictEqual(d3.interpolateRgb("steelblue", d3.hsl(0, 1, .5))(.6), "#b53448");
+    },
+    "interpolates in RGB color space": function(d3) {
+      assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.2), "#6b6890");
+    },
+    "outputs an RGB string": function(d3) {
+      assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.2), "#6b6890");
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/round-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/round-test.js
new file mode 100644
index 0000000..98fad58
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/round-test.js
@@ -0,0 +1,17 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateRound");
+
+suite.addBatch({
+  "interpolateRound": {
+    topic: load("interpolate/round").expression("d3.interpolateRound"),
+    "interpolates integers": function(interpolate) {
+      assert.strictEqual(interpolate(2, 12)(.456), 7);
+      assert.strictEqual(interpolate(2, 12)(.678), 9);
+    }
+  }
+});
+
+suite.export(module);
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/string-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/string-test.js
new file mode 100644
index 0000000..37aeade
--- /dev/null
+++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/string-test.js
@@ -0,0 +1,53 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateString");
+
+suite.addBatch({
+  "interpolateString": {
+    topic: load("interpolate/string").expression("d3.interpolateString"),
+    "interpolates matching numbers in both strings": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 100 ")(.2), "18/18 44 ");
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 ");
+    },
+    "coerces objects to strings": function(interpolate) {
+      assert.strictEqual(interpolate({toString: function() { return "2px"; }}, {toString: function() { return "12px"; }})(.25), "4.5px");
+    },
+    "preserves non-numbers in string b": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 foo ")(.2), "18/18 foo ");
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo ");
+    },
+    "preserves non-matching numbers in string b": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 foo", "50/10 100 ")(.2), "18/18 100 ");
+      assert.strictEqual(interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 ");
+    },
+    "preserves equal-value numbers in both strings": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.2), "18/18 100, 20 ");
+      assert.strictEqual(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 ");
+    },
+    "interpolates decimal notation correctly": function(interpolate) {
+      assert.strictEqual(interpolate("1.", "2.")(.5), "1.5");
+    },
+    "interpolates exponent notation correctly": function(interpolate) {
+      assert.strictEqual(interpolate("1e+3", "1e+4")(.5), "5500");
+      assert.strictEqual(interpolate("1e-3", "1e-4")(.5), "0.00055");
+      assert.strictEqual(interpolate("1.e-3", "1.e-4")(.5), "0.00055");
+      assert.strictEqual(interpolate("-1.e-3", "-1.e-4")(.5), "-0.00055");
+      assert.strictEqual(interpolate("+1.e-3", "+1.e-4")(.5), "0.00055");
+      assert.strictEqual(interpolate(".1e-2", ".1e-3")(.5), "0.00055");
+    },
+    "with no numbers, returns the target string": function(interpolate) {
+      assert.strictEqual(interpolate("foo", "bar")(.5), "bar");
+      assert.strictEqual(interpolate("foo", "")(.5), "");
+      assert.strictEqual(interpolate("", "bar")(.5), "bar");
+      assert.strictEqual(interpolate("", "")(.5), "");
+    },
+    "with two numerically-equivalent numbers, returns the default format": function(interpolate) {
+      assert.strictEqual(interpolate("top: 1000px;", "top: 1e3px;")(.5), "top: 1000px;");
+      assert.strictEqual(interpolate("top: 1e3px;", "top: 1000px;")(.5), "top: 1000px;");
+    }
+  }
+});
+
+suite.export(module);