stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/color/hcl-test.js

@@ -0,0 +1,112 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.hcl");
+
+suite.addBatch({
+  "hcl": {
+    topic: load("color/hcl").expression("d3.hcl"),
+    "converts string channel values to numbers": function(hcl) {
+      assert.hclEqual(hcl("50", "-4", "32"), 50, -4, 32);
+    },
+    "converts null channel values to zero": function(hcl) {
+      assert.hclEqual(hcl(null, null, null), 0, 0, 0);
+    },
+    "exposes h, c and l properties": function(hcl) {
+      var color = hcl(50, -4, 32);
+      assert.equal(color.h, 50);
+      assert.equal(color.c, -4);
+      assert.equal(color.l, 32);
+    },
+    "changing h, c or l affects the string format": function(hcl) {
+      var color = hcl(50, -4, 32);
+      assert.equal(color + "", "#444d50");
+      color.h++;
+      assert.equal(color + "", "#444d50");
+      color.c++;
+      assert.equal(color + "", "#464c4f");
+      color.l++;
+      assert.equal(color + "", "#494f51");
+    },
+    "parses hexadecimal shorthand format (e.g., \"#abc\")": function(hcl) {
+      assert.hclEqual(hcl("#abc"), -102.28223831811077, 10.774886733325554, 75.10497524893663);
+    },
+    "parses hexadecimal format (e.g., \"#abcdef\")": function(hcl) {
+      assert.hclEqual(hcl("#abcdef"), -100.15785184209284, 20.768234621934273, 81.04386565274363);
+    },
+    "parses HSL format (e.g., \"hsl(210, 64%, 13%)\")": function(hcl) {
+      assert.hclEqual(hcl("hsl(210, 64.7058%, 13.33333%)"), -89.58282792342067, 16.833655998102003, 12.65624852526134);
+    },
+    "parses color names (e.g., \"moccasin\")": function(hcl) {
+      assert.hclEqual(hcl("moccasin"), 84.71288921124494, 26.472460854104156, 91.72317744746022);
+    },
+    "parses and converts RGB format (e.g., \"rgb(102, 102, 0)\")": function(hcl) {
+      assert.hclEqual(hcl("rgb(102, 102, 0)"), 102.85124420310271, 49.44871600399321, 41.73251953866431);
+    },
+    "can convert from RGB": function(hcl) {
+      assert.hclEqual(hcl(_.rgb(12, 34, 56)), -89.58282792342067, 16.833655998102003, 12.65624852526134);
+    },
+    "can convert from HSL": function(hcl) {
+      assert.hclEqual(hcl(hcl(20, .8, .3)), 20, 0.8, 0.3);
+    },
+    "can convert to RGB": function(hcl) {
+      assert.rgbEqual(hcl("steelblue").rgb(), 70, 130, 180);
+    },
+    "can derive a brighter color": function(hcl) {
+      assert.hclEqual(hcl("steelblue").brighter(), -97.21873224090723, 32.44906314974561, 70.46551718768575);
+      assert.hclEqual(hcl("steelblue").brighter(.5), -97.21873224090723, 32.44906314974561, 61.46551718768575);
+    },
+    "can derive a darker color": function(hcl) {
+      assert.hclEqual(hcl("lightsteelblue").darker(), -94.8160116310511, 15.26488988314746, 60.45157936968134);
+      assert.hclEqual(hcl("lightsteelblue").darker(.5), -94.8160116310511, 15.26488988314746, 69.45157936968134);
+    },
+    "string coercion returns RGB format": function(hcl) {
+      assert.strictEqual(hcl("hsl(60, 100%, 20%)") + "", "#666600");
+      assert.strictEqual(hcl(hcl(60, -4, 32)) + "", "#454c51");
+    },
+    "roundtrip to HSL is idempotent": function(hcl) {
+      assert.deepEqual(_.hsl(hcl("steelblue")), _.hsl("steelblue"));
+    },
+    "roundtrip to RGB is idempotent": function(hcl) {
+      assert.deepEqual(_.rgb(hcl("steelblue")), _.rgb("steelblue"));
+    },
+    "roundtrip to Lab is idempotent": function(hcl) {
+      assert.deepEqual(_.lab(hcl("steelblue")), _.lab("steelblue"));
+    },
+    "h is defined for non-black grayscale colors (because of the color profile)": function(hcl) {
+      assert.inDelta(hcl("#ccc").h, 158.1986, 1e-3);
+      assert.inDelta(hcl("gray").h, 158.1986, 1e-3);
+      assert.inDelta(hcl(_.rgb("gray")).h, 158.1986, 1e-3);
+      assert.inDelta(hcl("#fff").h, 158.1986, 1e-3);
+      assert.inDelta(hcl("white").h, 158.1986, 1e-3);
+      assert.inDelta(hcl(_.rgb("white")).h, 158.1986, 1e-3);
+    },
+    "h is preserved when explicitly specified, even for black": function(hcl) {
+      assert.strictEqual(hcl(0, 0, 0).h, 0);
+      assert.strictEqual(hcl(42, 0, 0).h, 42);
+      assert.strictEqual(hcl(118, 0, 0).h, 118);
+    },
+    "h is undefined when not explicitly specified for black": function(hcl) {
+      assert.isNaN(hcl("#000").h);
+      assert.isNaN(hcl("black").h);
+      assert.isNaN(hcl(_.rgb("black")).h);
+    },
+    "c is preserved when explicitly specified, even for black": function(hcl) {
+      assert.strictEqual(hcl(0, 0, 0).c, 0);
+      assert.strictEqual(hcl(0, .42, 0).c, .42);
+      assert.strictEqual(hcl(0, 1, 0).c, 1);
+    },
+    "c is undefined when not explicitly specified for black": function(hcl) {
+      assert.isNaN(hcl("#000").c);
+      assert.isNaN(hcl("black").c);
+      assert.isNaN(hcl(_.rgb("black")).c);
+    },
+    "can convert black (with undefined hue and chroma) to RGB": function(hcl) {
+      assert.strictEqual(hcl(NaN, NaN, 0) + "", "#000000");
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/color/hsl-test.js

@@ -0,0 +1,118 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.hsl");
+
+suite.addBatch({
+  "hsl": {
+    topic: load("color/hsl").expression("d3.hsl"),
+    "does not clamp channel values": function(hsl) {
+      assert.hslEqual(hsl(-100, -1, -2), -100, -1, -2);
+      assert.hslEqual(hsl(400, 2, 3), 400, 2, 3);
+    },
+    "converts string channel values to numbers": function(hsl) {
+      assert.hslEqual(hsl("180", ".5", ".6"), 180, .5, .6);
+    },
+    "converts null channel values to zero": function(hsl) {
+      assert.hslEqual(hsl(null, null, null), 0, 0, 0);
+    },
+    "exposes h, s and l properties": function(hsl) {
+      assert.hslEqual(hsl("hsl(180, 50%, 60%)"), 180, .5, .6);
+    },
+    "changing h, s or l affects the string format": function(hsl) {
+      var color = hsl("hsl(180, 50%, 60%)");
+      color.h++;
+      color.s += .1;
+      color.l += .1;
+      assert.equal(color + "", "#85dfe0");
+    },
+    "parses hexadecimal shorthand format (e.g., \"#abc\")": function(hsl) {
+      assert.hslEqual(hsl("#abc"), 210, .25, .733333);
+    },
+    "parses hexadecimal format (e.g., \"#abcdef\")": function(hsl) {
+      assert.hslEqual(hsl("#abcdef"), 210, .68, .803922);
+    },
+    "parses HSL format (e.g., \"hsl(210, 64%, 13%)\")": function(hsl) {
+      assert.hslEqual(hsl("hsl(210, 64.7058%, 13.33333%)"), 210, .647058, .133333);
+    },
+    "parses color names (e.g., \"moccasin\")": function(hsl) {
+      assert.hslEqual(hsl("moccasin"), 38.108108, 1, .854902);
+      assert.hslEqual(hsl("aliceblue"), 208, 1, .970588);
+      assert.hslEqual(hsl("yellow"), 60, 1, .5);
+    },
+    "parses and converts RGB format (e.g., \"rgb(102, 102, 0)\")": function(hsl) {
+      assert.hslEqual(hsl("rgb(102, 102, 0)"), 60, 1, .2);
+    },
+    "can convert from RGB": function(hsl) {
+      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);
+    },
+    "can convert to RGB": function(hsl) {
+      assert.rgbEqual(hsl("steelblue").rgb(), 70, 130, 180);
+    },
+    "can derive a brighter color": function(hsl) {
+      assert.hslEqual(hsl("steelblue").brighter(), 207.272727, .44, .7002801);
+      assert.hslEqual(hsl("steelblue").brighter(.5), 207.272727, .44, .5858964);
+      assert.hslEqual(hsl("steelblue").brighter(1), 207.272727, .44, .7002801);
+      assert.hslEqual(hsl("steelblue").brighter(2), 207.272727, .44, 1.0004002);
+    },
+    "can derive a darker color": function(hsl) {
+      assert.hslEqual(hsl("lightsteelblue").darker(), 213.913043, .4107143, .5462745);
+      assert.hslEqual(hsl("lightsteelblue").darker(.5), 213.913043, .4107143, .6529229);
+      assert.hslEqual(hsl("lightsteelblue").darker(1), 213.913043, .4107143, .5462745);
+      assert.hslEqual(hsl("lightsteelblue").darker(2), 213.913043, .4107143, .38239216);
+    },
+    "string coercion returns RGB format": function(hsl) {
+      assert.strictEqual(hsl("hsl(60, 100%, 20%)") + "", "#666600");
+      assert.strictEqual(hsl(hsl(60, 1, .2)) + "", "#666600");
+    },
+    "h is preserved when explicitly specified, even for grayscale colors": function(hsl) {
+      assert.hslEqual(hsl(0, 0, 0), 0, 0, 0);
+      assert.hslEqual(hsl(42, 0, .5), 42, 0, .5);
+      assert.hslEqual(hsl(118, 0, 1), 118, 0, 1);
+    },
+    "h is undefined when not explicitly specified for grayscale colors": function(hsl) {
+      assert.hslEqual(hsl("#000"), NaN, NaN, 0);
+      assert.hslEqual(hsl("black"), NaN, NaN, 0);
+      assert.hslEqual(hsl(_.rgb("black")), NaN, NaN, 0);
+      assert.hslEqual(hsl("#ccc"), NaN, 0, .8);
+      assert.hslEqual(hsl("gray"), NaN, 0, .5);
+      assert.hslEqual(hsl(_.rgb("gray")), NaN, 0, .5);
+      assert.hslEqual(hsl("#fff"), NaN, NaN, 1);
+      assert.hslEqual(hsl("white"), NaN, NaN, 1);
+      assert.hslEqual(hsl(_.rgb("white")), NaN, NaN, 1);
+    },
+    "s is preserved when explicitly specified, even for white or black": function(hsl) {
+      assert.hslEqual(hsl(0, 0, 0), 0, 0, 0);
+      assert.hslEqual(hsl(0, .18, 0), 0, .18, 0);
+      assert.hslEqual(hsl(0, .42, 1), 0, .42, 1);
+      assert.hslEqual(hsl(0, 1, 1), 0, 1, 1);
+    },
+    "s is zero for grayscale colors (but not white and black)": function(hsl) {
+      assert.hslEqual(hsl("#ccc"), NaN, 0, .8);
+      assert.hslEqual(hsl("#777"), NaN, 0, .47);
+    },
+    "s is undefined when not explicitly specified for white or black": function(hsl) {
+      assert.hslEqual(hsl("#000"), NaN, NaN, 0);
+      assert.hslEqual(hsl("black"), NaN, NaN, 0);
+      assert.hslEqual(hsl(_.rgb("black")), NaN, NaN, 0);
+      assert.hslEqual(hsl("#fff"), NaN, NaN, 1);
+      assert.hslEqual(hsl("white"), NaN, NaN, 1);
+      assert.hslEqual(hsl(_.rgb("white")), NaN, NaN, 1);
+    },
+    "can convert grayscale colors (with undefined hue) to RGB": function(hsl) {
+      assert.strictEqual(hsl(NaN, 0, .2) + "", "#333333");
+      assert.strictEqual(hsl(NaN, 0, .6) + "", "#999999");
+    },
+    "can convert white and black (with undefined hue and saturation) to RGB": function(hsl) {
+      assert.strictEqual(hsl(NaN, NaN, 0) + "", "#000000");
+      assert.strictEqual(hsl(NaN, NaN, 1) + "", "#ffffff");
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/color/lab-test.js

@@ -0,0 +1,81 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.lab");
+
+suite.addBatch({
+  "lab": {
+    topic: load("color/lab").expression("d3.lab"),
+    "converts string channel values to numbers": function(lab) {
+      assert.labEqual(lab("50", "-4", "-32"), 50, -4, -32);
+    },
+    "converts null channel values to zero": function(lab) {
+      assert.labEqual(lab(null, null, null), 0, 0, 0);
+    },
+    "exposes l, a and b properties": function(lab) {
+      var color = lab(50, -4, -32);
+      assert.equal(color.l, 50);
+      assert.equal(color.a, -4);
+      assert.equal(color.b, -32);
+    },
+    "changing l, a or b affects the string format": function(lab) {
+      var color = lab(50, -4, -32);
+      assert.equal(color + "", "#3f7cad");
+      color.l++;
+      assert.equal(color + "", "#427eb0");
+      color.a++;
+      assert.equal(color + "", "#467eb0");
+      color.b++;
+      assert.equal(color + "", "#487eae");
+    },
+    "parses hexadecimal shorthand format (e.g., \"#abc\")": function(lab) {
+      assert.labEqual(lab("#abc"), 75.10497524893663, -2.292114632248876, -10.528266458853786);
+    },
+    "parses hexadecimal format (e.g., \"#abcdef\")": function(lab) {
+      assert.labEqual(lab("#abcdef"), 81.04386565274363, -3.6627002800885267, -20.442705201854984);
+    },
+    "parses HSL format (e.g., \"hsl(210, 64%, 13%)\")": function(lab) {
+      assert.labEqual(lab("hsl(210, 64.7058%, 13.33333%)"), 12.65624852526134, 0.12256520883417721, -16.833209795877284);
+    },
+    "parses color names (e.g., \"moccasin\")": function(lab) {
+      assert.labEqual(lab("moccasin"), 91.72317744746022, 2.4393469358685027, 26.359832514614844);
+    },
+    "parses and converts RGB format (e.g., \"rgb(102, 102, 0)\")": function(lab) {
+      assert.labEqual(lab("rgb(102, 102, 0)"), 41.73251953866431, -10.998411255098816, 48.21006600604577);
+    },
+    "can convert from RGB": function(lab) {
+      assert.labEqual(lab(_.rgb(12, 34, 56)), 12.65624852526134, 0.12256520883417721, -16.833209795877284);
+    },
+    "can convert from HSL": function(lab) {
+      assert.labEqual(lab(lab(20, .8, .3)), 20, 0.8, 0.3);
+    },
+    "can convert to RGB": function(lab) {
+      assert.rgbEqual(lab("steelblue").rgb(), 70, 130, 180);
+    },
+    "can derive a brighter color": function(lab) {
+      assert.labEqual(lab("steelblue").brighter(), 70.46551718768575, -4.0774710123572255, -32.19186122981343);
+      assert.labEqual(lab("steelblue").brighter(.5), 61.46551718768575, -4.0774710123572255, -32.19186122981343);
+    },
+    "can derive a darker color": function(lab) {
+      assert.labEqual(lab("lightsteelblue").darker(), 60.45157936968134, -1.2815839134120433, -15.210996213841522);
+      assert.labEqual(lab("lightsteelblue").darker(.5), 69.45157936968134, -1.2815839134120433, -15.210996213841522);
+    },
+    "string coercion returns RGB format": function(lab) {
+      assert.strictEqual(lab("hsl(60, 100%, 20%)") + "", "#666600");
+      assert.strictEqual(lab(lab(60, -4, -32)) + "", "#5d95c8");
+    },
+    "roundtrip to HSL is idempotent": function(lab) {
+      assert.deepEqual(_.hsl(lab("steelblue")), _.hsl("steelblue"));
+    },
+    "roundtrip to RGB is idempotent": function(lab) {
+      assert.deepEqual(_.rgb(lab("steelblue")), _.rgb("steelblue"));
+    },
+    "roundtrip to HCL is idempotent": function(lab) {
+      assert.deepEqual(_.hcl(lab("steelblue")), _.hcl("steelblue"));
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/color/rgb-test.js

@@ -0,0 +1,91 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.rgb");
+
+suite.addBatch({
+  "rgb": {
+    topic: load("color/rgb").expression("d3.rgb"),
+    "floors channel values": function(rgb) {
+      assert.rgbEqual(rgb(1.2, 2.6, 42.9), 1, 2, 42);
+    },
+    "defaults to black for invalid inputs": function(rgb) {
+      assert.rgbEqual(rgb("invalid"), 0, 0, 0);
+      assert.rgbEqual(rgb("hasOwnProperty"), 0, 0, 0);
+      assert.rgbEqual(rgb("__proto__"), 0, 0, 0);
+    },
+    "does not clamp channel values": function(rgb) {
+      assert.rgbEqual(rgb(-10, -20, -30), -10, -20, -30);
+      assert.rgbEqual(rgb(300, 400, 500), 300, 400, 500);
+    },
+    "converts string channel values to numbers": function(rgb) {
+      assert.rgbEqual(rgb("12", "34", "56"), 12, 34, 56);
+    },
+    "converts null channel values to zero": function(rgb) {
+      assert.rgbEqual(rgb(null, null, null), 0, 0, 0);
+    },
+    "exposes r, g and b properties": function(rgb) {
+      var color = rgb("#abc");
+      assert.equal(color.r, 170);
+      assert.equal(color.g, 187);
+      assert.equal(color.b, 204);
+    },
+    "changing r, g or b affects the string format": function(rgb) {
+      var color = rgb("#abc");
+      color.r++;
+      color.g++;
+      color.b++;
+      assert.equal(color + "", "#abbccd");
+    },
+    "parses hexadecimal shorthand format (e.g., \"#abc\")": function(rgb) {
+      assert.rgbEqual(rgb("#abc"), 170, 187, 204);
+    },
+    "parses hexadecimal format (e.g., \"#abcdef\")": function(rgb) {
+      assert.rgbEqual(rgb("#abcdef"), 171, 205, 239);
+    },
+    "parses RGB format (e.g., \"rgb(12, 34, 56)\")": function(rgb) {
+      assert.rgbEqual(rgb("rgb(12, 34, 56)"), 12, 34, 56);
+    },
+    "parses color names (e.g., \"moccasin\")": function(rgb) {
+      assert.rgbEqual(rgb("moccasin"), 255, 228, 181);
+      assert.rgbEqual(rgb("aliceblue"), 240, 248, 255);
+      assert.rgbEqual(rgb("yellow"), 255, 255, 0);
+    },
+    "parses and converts HSL format (e.g., \"hsl(60, 100%, 20%)\")": function(rgb) {
+      assert.rgbEqual(rgb("hsl(60, 100%, 20%)"), 102, 102, 0);
+    },
+    "can convert from RGB": function(rgb) {
+      assert.rgbEqual(rgb(rgb(12, 34, 56)), 12, 34, 56);
+    },
+    "can convert from HSL": function(rgb) {
+      assert.rgbEqual(rgb(_.hsl(0, 1, .5)), 255, 0, 0);
+    },
+    "can convert to HSL": function(rgb) {
+      assert.hslEqual(rgb("red").hsl(), 0, 1, .5);
+    },
+    "can derive a brighter color": function(rgb) {
+      assert.rgbEqual(rgb("brown").brighter(), 235, 60, 60);
+      assert.rgbEqual(rgb("brown").brighter(.5), 197, 50, 50);
+      assert.rgbEqual(rgb("brown").brighter(1), 235, 60, 60);
+      assert.rgbEqual(rgb("brown").brighter(2), 255, 85, 85);
+    },
+    "can derive a darker color": function(rgb) {
+      assert.rgbEqual(rgb("coral").darker(), 178, 88, 56);
+      assert.rgbEqual(rgb("coral").darker(.5), 213, 106, 66);
+      assert.rgbEqual(rgb("coral").darker(1), 178, 88, 56);
+      assert.rgbEqual(rgb("coral").darker(2), 124, 62, 39);
+    },
+    "string coercion returns hexadecimal format": function(rgb) {
+      assert.strictEqual(rgb("#abcdef") + "", "#abcdef");
+      assert.strictEqual(rgb("moccasin") + "", "#ffe4b5");
+      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(_.hsl(60, 1, .2)) + "", "#666600");
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/core/functor-test.js

@@ -0,0 +1,25 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.functor");
+
+suite.addBatch({
+  "functor": {
+    topic: load("core/functor").expression("d3.functor"),
+    "when passed a function, returns the function": function(functor) {
+      function foo() {}
+      assert.strictEqual(functor(foo), foo);
+    },
+    "when passed a non-function, returns a wrapper function": function(functor) {
+      var a = {};
+      assert.isNull(functor(null)());
+      assert.isUndefined(functor(undefined)());
+      assert.strictEqual(functor(a)(), a);
+      assert.strictEqual(functor(1)(), 1);
+      assert.deepEqual(functor([1])(), [1]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/core/ns-test.js

@@ -0,0 +1,57 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("ns");
+
+suite.addBatch({
+  "ns": {
+    topic: load("core/ns").expression("d3.ns"),
+    "prefix": {
+      topic: function(ns) {
+        return ns.prefix;
+      },
+      "svg is http://www.w3.org/2000/svg": function(prefix) {
+        assert.equal(prefix.svg, "http://www.w3.org/2000/svg");
+      },
+      "xhtml is http://www.w3.org/1999/xhtml": function(prefix) {
+        assert.equal(prefix.xhtml, "http://www.w3.org/1999/xhtml");
+      },
+      "xlink is http://www.w3.org/1999/xlink": function(prefix) {
+        assert.equal(prefix.xlink, "http://www.w3.org/1999/xlink");
+      },
+      "xml is http://www.w3.org/XML/1998/namespace": function(prefix) {
+        assert.equal(prefix.xml, "http://www.w3.org/XML/1998/namespace");
+      },
+      "xmlns is http://www.w3.org/2000/xmlns/": function(prefix) {
+        assert.equal(prefix.xmlns, "http://www.w3.org/2000/xmlns/");
+      }
+    },
+    "qualify": {
+      topic: function(ns) {
+        return ns.qualify;
+      },
+      "local name returns name": function(qualify) {
+        assert.equal(qualify("local"), "local");
+      },
+      "known qualified name returns space and local": function(qualify) {
+        var name = qualify("svg:path");
+        assert.equal(name.space, "http://www.w3.org/2000/svg");
+        assert.equal(name.local, "path");
+      },
+      "unknown qualified name returns name": function(qualify) {
+        assert.equal(qualify("foo:bar"), "bar");
+      },
+      "known local name returns space and local": function(qualify) {
+        var name = qualify("svg");
+        assert.equal(name.space, "http://www.w3.org/2000/svg");
+        assert.equal(name.local, "svg");
+      },
+      "names that collide with built-ins are ignored": function(qualify) {
+        assert.equal(qualify("hasOwnProperty:test"), "test");
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/core/rebind-test.js

@@ -0,0 +1,50 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.rebind");
+
+suite.addBatch({
+  "rebind": {
+    topic: load("core/rebind").expression("d3.rebind"),
+    "source function always has source as context": function(rebind) {
+      var target = {}, source = {method: function() { that = this; }}, that;
+      rebind(target, source, "method");
+      assert.strictEqual((target.method(), that), source);
+      assert.strictEqual((target.method.call({}), that), source);
+    },
+    "source function receives target function's arguments": function(rebind) {
+      var target = {}, source = {method: function() { those = Array.prototype.slice.call(arguments); }}, those;
+      rebind(target, source, "method");
+      assert.deepEqual((target.method(), those), []);
+      assert.deepEqual((target.method(1), those), [1]);
+      assert.deepEqual((target.method(null), those), [null]);
+      assert.deepEqual((target.method(source, source, 1), those), [source, source, 1]);
+    },
+    "target function returns target if source function returns source": function(rebind) {
+      var target = {}, source = {method: function(value) { return value ? source : 42; }};
+      rebind(target, source, "method");
+      assert.strictEqual(target.method(true), target);
+    },
+    "otherwise, target function returns source function return value": function(rebind) {
+      var target = {}, source = {method: function(value) { return value ? source : 42; }};
+      rebind(target, source, "method");
+      assert.strictEqual(target.method(false), 42);
+    },
+    "can bind multiple methods": function(rebind) {
+      var target = {}, source = {
+        foo: function() { return 1; },
+        bar: function() { return 2; }
+      };
+      rebind(target, source, "foo", "bar");
+      assert.strictEqual(target.foo(), 1);
+      assert.strictEqual(target.bar(), 2);
+    },
+    "returns the target object": function(rebind) {
+      var target = {}, source = {foo: function() {}};
+      assert.strictEqual(rebind(target, source, "foo"), target);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/core/version-test.js

@@ -0,0 +1,16 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.version");
+
+suite.addBatch({
+  "version": {
+    topic: load().expression("d3.version"),
+    "has the form major.minor.patch": function(version) {
+      assert.match(version, /^[0-9]+\.[0-9]+\.[0-9]+/);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/data/sample.csv

@@ -0,0 +1,2 @@
+Hello,World
+42,"""fish"""

data/lib/stripmem/public/components/d3/test/data/sample.html

@@ -0,0 +1,5 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <h1>Hello &amp; world!</h1>
+</html>

data/lib/stripmem/public/components/d3/test/data/sample.json

@@ -0,0 +1 @@
+[{"Hello": 42, "World": "\"fish\""}]

data/lib/stripmem/public/components/d3/test/data/sample.tsv

@@ -0,0 +1,2 @@
+Hello	World
+42	"""fish"""

data/lib/stripmem/public/components/d3/test/data/sample.txt

@@ -0,0 +1 @@
+Hello, world!

data/lib/stripmem/public/components/d3/test/data/sample.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<hello>
+  <world name="Earth"/>
+</hello>