stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/arrays/permute-test.js

@@ -0,0 +1,49 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.permute");
+
+suite.addBatch({
+  "permute": {
+    topic: load("arrays/permute").expression("d3.permute"),
+    "permutes according to the specified index": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [2, 1, 0]), [5, 4, 3]);
+      assert.deepEqual(permute([3, 4, 5], [2, 0, 1]), [5, 3, 4]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 2]), [3, 4, 5]);
+    },
+    "does not modify the input array": function(permute) {
+      var input = [3, 4, 5];
+      permute(input, [2, 1, 0]);
+      assert.deepEqual(input, [3, 4, 5]);
+    },
+    "can duplicate input values": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 0]), [3, 4, 3]);
+      assert.deepEqual(permute([3, 4, 5], [2, 2, 2]), [5, 5, 5]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 1]), [3, 4, 4]);
+    },
+    "can return more elements": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0, 0, 1, 2]), [3, 3, 4, 5]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 1, 1]), [3, 4, 4, 4]);
+    },
+    "can return fewer elements": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0]), [3]);
+      assert.deepEqual(permute([3, 4, 5], [1, 2]), [4, 5]);
+      assert.deepEqual(permute([3, 4, 5], []), []);
+    },
+    "can return undefined elements": function(permute) {
+      var v1 = permute([3, 4, 5], [10]);
+      assert.equal(v1.length, 1);
+      assert.isUndefined(v1[0]);
+      var v2 = permute([3, 4, 5], [-1]);
+      assert.equal(v2.length, 1);
+      assert.isUndefined(v2[0]);
+      var v3 = permute([3, 4, 5], [0, -1]);
+      assert.equal(v3.length, 2);
+      assert.equal(v3[0], 3);
+      assert.isUndefined(v3[1]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/quantile-test.js

@@ -0,0 +1,56 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.quantile");
+
+suite.addBatch({
+  "quantile": {
+    topic: load("arrays/quantile").expression("d3.quantile"),
+    "requires sorted numeric input": function(quantile) {
+      assert.equal(quantile([1, 2, 3, 4], 0), 1);
+      assert.equal(quantile([1, 2, 3, 4], 1), 4);
+      assert.equal(quantile([4, 3, 2, 1], 0), 4);
+      assert.equal(quantile([4, 3, 2, 1], 1), 1);
+    },
+    "uses the R-7 algorithm": function(quantile) {
+      var data = [3, 6, 7, 8, 8, 10, 13, 15, 16, 20];
+      assert.equal(quantile(data, 0), 3);
+      assert.equal(quantile(data, .25), 7.25);
+      assert.equal(quantile(data, .5), 9);
+      assert.equal(quantile(data, .75), 14.5);
+      assert.equal(quantile(data, 1), 20);
+      var data = [3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20];
+      assert.equal(quantile(data, 0), 3);
+      assert.equal(quantile(data, .25), 7.5);
+      assert.equal(quantile(data, .5), 9);
+      assert.equal(quantile(data, .75), 14);
+      assert.equal(quantile(data, 1), 20);
+    },
+    "coerces values to numbers": function(quantile) {
+      var strings = ["1", "2", "3", "4"];
+      assert.strictEqual(quantile(strings, 1/3), 2);
+      assert.strictEqual(quantile(strings, 1/2), 2.5);
+      assert.strictEqual(quantile(strings, 2/3), 3);
+      var dates = [new Date(2011, 0, 1), new Date(2012, 0, 1)];
+      assert.strictEqual(quantile(dates, 0), +new Date(2011, 0, 1));
+      assert.strictEqual(quantile(dates, 1/2), +new Date(2011, 6, 2, 13));
+      assert.strictEqual(quantile(dates, 1), +new Date(2012, 0, 1));
+    },
+    "returns an exact value for integer p-values": function(quantile) {
+      var data = [1, 2, 3, 4];
+      assert.equal(quantile(data, 1/3), 2);
+      assert.equal(quantile(data, 2/3), 3);
+    },
+    "returns the first value for p = 0": function(quantile) {
+      var data = [1, 2, 3, 4];
+      assert.equal(quantile(data, 0), 1);
+    },
+    "returns the last value for p = 1": function(quantile) {
+      var data = [1, 2, 3, 4];
+      assert.equal(quantile(data, 1), 4);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/range-test.js

@@ -0,0 +1,99 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.range");
+
+suite.addBatch({
+  "range": {
+    topic: load("arrays/range").expression("d3.range"),
+    "start is an inclusive lower bound": function(range) {
+      assert.equal(range(5)[0], 0);
+      assert.equal(range(1, 5)[0], 1);
+      assert.equal(range(5, 1, -1)[0], 5);
+    },
+    "stop is an exclusive upper bound": function(range) {
+      assert.equal(range(5)[4], 4);
+      assert.equal(range(1, 5)[3], 4);
+      assert.equal(range(5, 1, -1)[3], 2);
+    },
+    "with one argument, returns integers [0 … stop)": function(range) {
+      assert.deepEqual(range(0), []);
+      assert.deepEqual(range(1), [0]);
+      assert.deepEqual(range(5), [0, 1, 2, 3, 4]);
+    },
+    "with two arguments, returns integers [start … stop)": function(range) {
+      assert.deepEqual(range(0, 5), [0, 1, 2, 3, 4]);
+      assert.deepEqual(range(5, 9), [5, 6, 7, 8]);
+    },
+    "with three arguments, returns start + k * step": function(range) {
+      assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]);
+      assert.deepEqual(range(5, 9, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5]);
+      assert.deepEqual(range(5, 8.5, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8]);
+      assert.deepEqual(range(2, 0, -.5), [2, 1.5, 1, .5]);
+    },
+    "handles fractional steps without rounding errors": function(range) {
+      assert.deepEqual(range(0, 0.5, 0.1), [0, 0.1, 0.2, 0.3, 0.4]);
+      assert.deepEqual(range(-2, -1.2, 0.1), [-2, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3]);
+    },
+    "handles extremely small steps without rounding errors": function(range) {
+      assert.deepEqual(range(2.1e-31, 5e-31, 1.1e-31), [2.1e-31, 3.2e-31, 4.3e-31]);
+    },
+    "handles extremely large steps without rounding errors": function(range) {
+      assert.deepEqual(range(1e300, 2e300, 0.3e300), [1e300, 1.3e300, 1.6e300, 1.9e300]);
+    },
+    "returns an ascending range if step is positive": function(range) {
+      assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]);
+    },
+    "returns a descending range if step is negative": function(range) {
+      assert.deepEqual(range(5, 0, -1), [5, 4, 3, 2, 1]);
+    },
+    "returns an empty range if start, stop or step are NaN": function(range) {
+      assert.isEmpty(range(0, NaN));
+      assert.isEmpty(range(1, NaN));
+      assert.isEmpty(range(-1, NaN));
+      assert.isEmpty(range(0, undefined));
+      assert.isEmpty(range(1, undefined));
+      assert.isEmpty(range(-1, undefined));
+      assert.isEmpty(range(NaN, 0));
+      assert.isEmpty(range(NaN, 1));
+      assert.isEmpty(range(NaN, -1));
+      assert.isEmpty(range(undefined, 0));
+      assert.isEmpty(range(undefined, 1));
+      assert.isEmpty(range(undefined, -1));
+      assert.isEmpty(range(NaN, NaN));
+      assert.isEmpty(range(undefined, undefined));
+      assert.isEmpty(range(NaN, NaN, NaN));
+      assert.isEmpty(range(undefined, undefined, undefined));
+      assert.isEmpty(range(0, 10, NaN));
+      assert.isEmpty(range(10, 0, NaN));
+      assert.isEmpty(range(0, 10, undefined));
+      assert.isEmpty(range(10, 0, undefined));
+    },
+    "returns an empty range if start equals stop": function(range) {
+      assert.isEmpty(range(10, 10));
+      assert.isEmpty(range(10, 10, 1));
+      assert.isEmpty(range(10, 10, -1));
+      assert.isEmpty(range(10, 10, -.5));
+      assert.isEmpty(range(10, 10, .5));
+      assert.isEmpty(range(0, 0));
+      assert.isEmpty(range(0, 0, 1));
+      assert.isEmpty(range(0, 0, -1));
+      assert.isEmpty(range(0, 0, -.5));
+      assert.isEmpty(range(0, 0, .5));
+    },
+    "returns an empty range if stop is less than start and step is positive": function(range) {
+      assert.isEmpty(range(20, 10));
+      assert.isEmpty(range(20, 10, 2));
+      assert.isEmpty(range(20, 10, 1));
+      assert.isEmpty(range(20, 10, .5));
+    },
+    "returns an empty range if stop is greater than start and step is negative": function(range) {
+      assert.isEmpty(range(10, 20, -2));
+      assert.isEmpty(range(10, 20, -1));
+      assert.isEmpty(range(10, 20, -.5));
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/set-test.js

@@ -0,0 +1,136 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.set");
+
+suite.addBatch({
+  "set": {
+    topic: load("arrays/set").expression("d3.set"),
+    "constructor": {
+      "set() returns an empty set": function(set) {
+        var s = set();
+        assert.deepEqual(s.values(), []);
+      },
+      "set(null) returns an empty set": function(set) {
+        var s = set(null);
+        assert.deepEqual(s.values(), []);
+      },
+      "set(array) adds array entries": function(set) {
+        var s = set(["foo"]);
+        assert.isTrue(s.has("foo"));
+        var s = set(["foo", "bar"]);
+        assert.isTrue(s.has("foo"));
+        assert.isTrue(s.has("bar"));
+      }
+    },
+    "forEach": {
+      "empty sets have an empty values array": function(set) {
+        var s = set();
+        assert.deepEqual(s.values(), []);
+        s.add("foo");
+        assert.deepEqual(s.values(), ["foo"]);
+        s.remove("foo");
+        assert.deepEqual(s.values(), []);
+      },
+      "values are returned in arbitrary order": function(set) {
+        var s = set(["foo", "bar"]);
+        assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
+        var s = set(["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(_.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(_.ascending), ["bar", "foo"]);
+        s.remove("bar");
+        assert.deepEqual(s.values(), ["foo"]);
+        s.remove("foo");
+        assert.deepEqual(s.values(), []);
+        s.remove("foo");
+        assert.deepEqual(s.values(), []);
+      }
+    },
+    "values": {
+      "returns an array of string values": function(set) {
+        var s = set(["foo", "bar"]);
+        assert.deepEqual(s.values().sort(), ["bar", "foo"]);
+      }
+    },
+    "has": {
+      "empty sets do not have object built-ins": function(set) {
+        var s = set();
+        assert.isFalse(s.has("__proto__"));
+        assert.isFalse(s.has("hasOwnProperty"));
+      },
+      "coerces values to strings": function(set) {
+        var s = set(["42", "null", "undefined"]);
+        assert.isTrue(s.has(42));
+        assert.isTrue(s.has(null));
+        assert.isTrue(s.has(undefined));
+      },
+      "observes changes via add and remove": function(set) {
+        var s = set(["foo"]);
+        assert.isTrue(s.has("foo"));
+        s.add("foo");
+        assert.isTrue(s.has("foo"));
+        s.remove("foo");
+        assert.isFalse(s.has("foo"));
+        s.add("foo");
+        assert.isTrue(s.has("foo"));
+      },
+      "returns undefined for missing values": function(set) {
+        var s = set(["foo"]);
+        assert.isFalse(s.has("bar"));
+      }
+    },
+    "add": {
+      "returns the set value": function(set) {
+        var s = set();
+        assert.equal(s.add("foo"), "foo");
+      },
+      "can add values using built-in names": function(set) {
+        var s = set();
+        s.add("__proto__");
+        assert.isTrue(s.has("__proto__"));
+      },
+      "coerces values to strings": function(set) {
+        var s = set();
+        s.add(42);
+        assert.isTrue(s.has(42));
+        s.add(null);
+        assert.isTrue(s.has(null));
+        s.add(undefined);
+        assert.isTrue(s.has(undefined));
+        assert.deepEqual(s.values().sort(), ["42", "null", "undefined"]);
+      },
+      "can add null, undefined or empty string values": function(set) {
+        var s = set();
+        s.add("");
+        s.add("null");
+        s.add("undefined");
+        assert.isTrue(s.has(""));
+        assert.isTrue(s.has("null"));
+        assert.isTrue(s.has("undefined"));
+      }
+    },
+    "remove": {
+      "returns true if the value was removed": function(set) {
+        var s = set(["foo"]);
+        assert.isTrue(s.remove("foo"));
+      },
+      "returns false if the value is not an element": function(set) {
+        var s = set();
+        assert.isFalse(s.remove("foo"));
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/sum-test.js

@@ -0,0 +1,43 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.sum");
+
+suite.addBatch({
+  "sum": {
+    topic: load("arrays/sum").expression("d3.sum"),
+    "sums numbers": function(sum) {
+      assert.equal(sum([1]), 1);
+      assert.equal(sum([5, 1, 2, 3, 4]), 15);
+      assert.equal(sum([20, 3]), 23);
+      assert.equal(sum([3, 20]), 23);
+    },
+    "sums types that can be coerced to numbers": function(sum) {
+      assert.equal(sum(["20", "3"]), 23);
+      assert.equal(sum(["3", "20"]), 23);
+      assert.equal(sum(["3", 20]), 23);
+      assert.equal(sum([20, "3"]), 23);
+      assert.equal(sum([3, "20"]), 23);
+      assert.equal(sum(["20", 3]), 23);
+    },
+    "ignores non-numeric types": function(sum) {
+      assert.equal(sum(["a", "b", "c"]), 0);
+      assert.equal(sum(["a", 1, "2"]), 3);
+    },
+    "ignores null, undefined and NaN": function(sum) {
+      assert.equal(sum([NaN, 1, 2, 3, 4, 5]), 15);
+      assert.equal(sum([1, 2, 3, 4, 5, NaN]), 15);
+      assert.equal(sum([10, null, 3, undefined, 5, NaN]), 18);
+    },
+    "applies the optional acccessor function": function(sum) {
+      assert.equal(sum([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return sum(d); }), 45);
+      assert.equal(sum([1, 2, 3, 4, 5], function(d, i) { return i; }), 10);
+    },
+    "returns zero for the empty array": function(sum) {
+      assert.equal(sum([]), 0);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/transpose-test.js

@@ -0,0 +1,28 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.transpose");
+
+suite.addBatch({
+  "transpose": {
+    topic: load("arrays/transpose").expression("d3.transpose"),
+    "transposes a square matrix": function(transpose) {
+      assert.deepEqual(transpose([[1, 2], [3, 4]]), [[1, 3], [2, 4]]);
+    },
+    "transposes a non-square matrix": function(transpose) {
+      assert.deepEqual(transpose([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]);
+    },
+    "transposes a single-row matrix": function(transpose) {
+      assert.deepEqual(transpose([[1, 2, 3, 4, 5]]), [[1], [2], [3], [4], [5]]);
+    },
+    "transposes an empty matrix": function(transpose) {
+      assert.deepEqual(transpose([]), []);
+    },
+    "ignores extra elements given an irregular matrix": function(transpose) {
+      assert.deepEqual(transpose([[1, 2], [3, 4], [5, 6, 7]]), [[1, 3, 5], [2, 4, 6]]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/values-test.js

@@ -0,0 +1,31 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.values");
+
+suite.addBatch({
+  "values": {
+    topic: load("arrays/values").expression("d3.values"),
+    "enumerates every value": function(values) {
+      assert.deepEqual(values({a: 1, b: 2}), [1, 2]);
+    },
+    "includes values defined on prototypes": function(values) {
+      function abc() {
+        this.a = 1;
+        this.b = 2;
+      }
+      abc.prototype.c = 3;
+      assert.deepEqual(values(new abc()), [1, 2, 3]);
+    },
+    "includes null or undefined values": function(values) {
+      var v = values({a: undefined, b: null, c: NaN});
+      assert.isUndefined(v[0]);
+      assert.isNull(v[1]);
+      assert.isNaN(v[2]);
+      assert.equal(v.length, 3);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/zip-test.js

@@ -0,0 +1,28 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.zip");
+
+suite.addBatch({
+  "zip": {
+    topic: load("arrays/zip").expression("d3.zip"),
+    "transposes a square matrix": function(zip) {
+      assert.deepEqual(zip([1, 2], [3, 4]), [[1, 3], [2, 4]]);
+    },
+    "transposes a non-square matrix": function(zip) {
+      assert.deepEqual(zip([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]);
+    },
+    "transposes a single-row matrix": function(zip) {
+      assert.deepEqual(zip([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]]);
+    },
+    "transposes an empty matrix": function(zip) {
+      assert.deepEqual(zip(), []);
+    },
+    "ignores extra elements given an irregular matrix": function(zip) {
+      assert.deepEqual(zip([1, 2], [3, 4], [5, 6, 7]), [[1, 3, 5], [2, 4, 6]]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/assert.js

@@ -0,0 +1,153 @@
+var assert = require("assert"),
+    _ = require("../");
+
+assert = module.exports = Object.create(assert);
+
+assert.isArray = function(actual, message) {
+  if (!Array.isArray(actual)) {
+    assert.fail(actual, null, message || "expected {actual} to be an Array", null, assert.isArray);
+  }
+};
+
+assert.inDelta = function(actual, expected, delta, message) {
+  if (!inDelta(actual, expected, delta)) {
+    assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta + "* of {expected}", null, assert.inDelta);
+  }
+};
+
+assert.domNull = function(actual, message) {
+  if (actual != null) {
+    assert.fail(actual+"", null, message || "expected null, got {actual}", "===", assert.domNull);
+  }
+};
+
+assert.domEqual = function(actual, expected, message) {
+  if (actual !== expected) {
+    assert.fail(actual+"", expected+"", message || "expected {expected}, got {actual}", "===", assert.domEqual);
+  }
+};
+
+assert.rgbEqual = function(actual, r, g, b, message) {
+  var ar = Math.round(actual.r),
+      ag = Math.round(actual.g),
+      ab = Math.round(actual.b),
+      er = Math.round(r),
+      eg = Math.round(g),
+      eb = Math.round(b);
+  if (ar !== er || ag !== eg || ab !== eb) {
+    assert.fail(
+      "rgb(" + ar + "," + ag + "," + ab + ")",
+      "rgb(" + er + ", " + eg + ", " + eb + ")",
+      message || "expected {expected}, got {actual}", "===", assert.rgbEqual);
+  }
+};
+
+assert.hslEqual = function(actual, h, s, l, message) {
+  var ah = _.round(actual.h, 2),
+      as = _.round(actual.s, 2),
+      al = _.round(actual.l, 2),
+      eh = _.round(h, 2),
+      es = _.round(s, 2),
+      el = _.round(l, 2);
+  if ((!(isNaN(ah) && isNaN(eh)) && ah !== eh) || (!(isNaN(as) && isNaN(es)) && as !== es) || al !== el) {
+    assert.fail(
+      "hsl(" + ah + "," + as + "," + al + ")",
+      "hsl(" + eh + "," + es + "," + el + ")",
+      message || "expected {expected}, got {actual}", null, assert.hslEqual);
+  }
+};
+
+assert.hclEqual = function(actual, h, c, l, message) {
+  var ah = _.round(actual.h, 2),
+      ac = _.round(actual.c, 2),
+      al = _.round(actual.l, 2),
+      eh = _.round(h, 2),
+      ec = _.round(c, 2),
+      el = _.round(l, 2);
+  if ((!(isNaN(ah) && isNaN(eh)) && ah !== eh) || ac !== ec || al !== el) {
+    assert.fail(
+      "hcl(" + ah + "," + ac + "," + al + ")",
+      "hcl(" + eh + "," + ec + "," + el + ")",
+      message || "expected {expected}, got {actual}", null, assert.hclEqual);
+  }
+};
+
+assert.labEqual = function(actual, l, a, b, message) {
+  var al = _.round(actual.l, 2),
+      aa = _.round(actual.a, 2),
+      ab = _.round(actual.b, 2),
+      el = _.round(l, 2),
+      ea = _.round(a, 2),
+      eb = _.round(b, 2);
+  if (al !== el || aa !== ea || ab !== eb) {
+    assert.fail(
+      "lab(" + al + ", " + aa + ", " + ab + ")",
+      "lab(" + el + ", " + ea + ", " + eb + ")",
+      message || "expected {expected}, got {actual}", null, assert.labEqual);
+  }
+};
+
+assert.pathEqual = function(actual, expected, message) {
+  if (!pathEqual(actual, expected)) {
+    assert.fail(formatPath(actual), formatPath(expected), message || "expected {expected}, got {actual}", null, assert.pathEqual);
+  }
+};
+
+function inDelta(actual, expected, delta) {
+  return (Array.isArray(expected) ? inDeltaArray : inDeltaNumber)(actual, expected, delta);
+}
+
+function inDeltaArray(actual, expected, delta) {
+  var n = expected.length, i = -1;
+  if (actual.length !== n) return false;
+  while (++i < n) if (!inDelta(actual[i], expected[i], delta)) return false;
+  return true;
+}
+
+function inDeltaNumber(actual, expected, delta) {
+  return actual >= expected - delta && actual <= expected + delta;
+}
+
+function pathEqual(a, b) {
+  a = parsePath(a);
+  b = parsePath(b);
+  var n = a.length, i = -1, x, y;
+  if (n !== b.length) return false;
+  while (++i < n) {
+    x = a[i];
+    y = b[i];
+    if (typeof x === "string") {
+      if (x !== y) return false;
+    } else if (typeof y !== "number") {
+      return false;
+    } else if (Math.abs(x - y) > 1e-6) {
+      return false;
+    }
+  }
+  return true;
+}
+
+var reNumber = /[-+]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)(?:[eE][-]?\d+)?/g;
+
+function parsePath(path) {
+  var parts = [];
+  reNumber.lastIndex = 0;
+  for (var i = 0, s0 = 0, s1, m; m = reNumber.exec(path); ++i) {
+    if (m.index) {
+      var part = path.substring(s0, s1 = m.index);
+      if (!/^[, ]$/.test(part)) parts.push(part);
+    }
+    parts.push(parseFloat(m[0]));
+    s0 = reNumber.lastIndex;
+  }
+  if (s0 < path.length) parts.push(path.substring(s0));
+  return parts;
+}
+
+function formatPath(path) {
+  return path.replace(reNumber, formatNumber);
+}
+
+function formatNumber(s) {
+  return Math.abs((s = +s) - Math.floor(s)) < 1e-6 ? Math.floor(s) : s.toFixed(6);
+}