stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/geo/rotation-test.js

@@ -0,0 +1,35 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.rotation");
+
+suite.addBatch({
+  "rotation": {
+    topic: load("geo/rotation").expression("d3.geo.rotation"),
+    "a rotation of [+90°, 0°]": {
+      topic: function(rotation) {
+        return rotation([90, 0]);
+      },
+      "only rotates longitude": function(rotation) {
+        assert.inDelta(rotation([0, 0]), [90, 0], 1e-6);
+      },
+      "wraps around when crossing the antimeridian": function(rotation) {
+        assert.inDelta(rotation([150, 0]), [-120, 0], 1e-6);
+      }
+    },
+    "a rotation of [-45°, -45°]": {
+      topic: function(rotation) {
+        return rotation([-45, 45]);
+      },
+      "rotates longitude and latitude": function(rotation) {
+        assert.inDelta(rotation([0, 0]), [-54.73561, 30], 1e-6);
+      },
+      "inverse rotation of longitude and latitude": function(rotation) {
+        assert.inDelta(rotation.invert([-54.73561, 30]), [0, 0], 1e-6);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/geo/stereographic-test.js

@@ -0,0 +1,38 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert"),
+    projectionTestSuite = require("./projection-test-suite");
+
+var suite = vows.describe("d3.geo.stereographic");
+
+suite.addBatch({
+  "stereographic": {
+    topic: load("geo/stereographic").expression("d3.geo.stereographic"),
+    "default": projectionTestSuite({
+      topic: function(projection) { return projection(); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [ 480.00000000,  250.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349103], [ 473.84094732,  117.14003304]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [ 459.00877672,  123.45642208]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [ 482.65216217,  160.62316700]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [ 449.13660231,  342.87385937]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [ 493.06074697,  121.99919699]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [ 480.00000000,  387.44967610]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [ 480.00000000,  112.55032390]]
+    }),
+    "translated to 0,0 and at scale 1": projectionTestSuite({
+      topic: function(projection) { return projection().translate([0, 0]).scale(1); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [   0.00000000,    0.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349120], [  -0.04106035,   -0.88573312]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [  -0.13994149,   -0.84362385]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [   0.01768108,   -0.59584555]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [  -0.20575598,    0.61915906]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [   0.08707165,   -0.85333869]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [   0.00000000,    0.91633117]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [   0.00000000,   -0.91633117]]
+    })
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/geo/stream-test.js

@@ -0,0 +1,264 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.stream");
+
+suite.addBatch({
+  "stream": {
+    topic: load("geo/stream").expression("d3.geo.stream"),
+    "does not allow null input": function(stream) {
+      try {
+        stream(null);
+        assert.fail("expected error");
+      } catch (expected) {}
+    },
+    "ignores unknown types": function(stream) {
+      stream({type: "Unknown"}, {});
+      stream({type: "Feature", geometry: {type: "Unknown"}}, {});
+      stream({type: "FeatureCollection", features: [{type: "Feature", geometry: {type: "Unknown"}}]}, {});
+      stream({type: "GeometryCollection", geometries: [{type: "Unknown"}]}, {});
+    },
+    "ignores null geometries": function(stream) {
+      stream(null, {});
+      stream({type: "Feature", geometry: null}, {});
+      stream({type: "FeatureCollection", features: [{type: "Feature", geometry: null}]}, {});
+      stream({type: "GeometryCollection", geometries: [null]}, {});
+    },
+    "returns void": function(stream) {
+      assert.isUndefined(stream({type: "Point", coordinates: [1, 2]}, {point: function() { return true; }}));
+    },
+    "allows empty multi-geometries": function(stream) {
+      stream({type: "MultiPoint", coordinates: []}, {});
+      stream({type: "MultiLineString", coordinates: []}, {});
+      stream({type: "MultiPolygon", coordinates: []}, {});
+    },
+    "Sphere ↦ sphere": function(stream) {
+      var calls = 0;
+      stream({type: "Sphere"}, {
+        sphere: function() {
+          ++calls;
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "Point ↦ point": function(stream) {
+      var calls = 0;
+      stream({type: "Point", coordinates: [1, 2]}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "MultiPoint ↦ point*": function(stream) {
+      var calls = 0;
+      stream({type: "MultiPoint", coordinates: [[1, 2], [3, 4]]}, {
+        point: function(x, y) {
+          assert.equal(arguments.length, 2);
+          if (++calls === 1) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          }
+        }
+      });
+      assert.equal(calls, 2);
+    },
+    "LineString ↦ lineStart, point{2,}, lineEnd": function(stream) {
+      var calls = 0;
+      stream({type: "LineString", coordinates: [[1, 2], [3, 4]]}, {
+        lineStart: function() {
+          assert.equal(++calls, 1);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          assert.equal(arguments.length, 2);
+          if (++calls === 2) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 3) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          assert.equal(++calls, 4);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 4);
+    },
+    "MultiLineString ↦ (lineStart, point{2,}, lineEnd)*": function(stream) {
+      var calls = 0;
+      stream({type: "MultiLineString", coordinates: [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]}, {
+        lineStart: function() {
+          ++calls;
+          assert.isTrue(calls === 1 || calls === 5);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          if (calls === 2) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 3) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else if (calls === 6) {
+            assert.equal(x, 5);
+            assert.equal(y, 6);
+          } else if (calls === 7) {
+            assert.equal(x, 7);
+            assert.equal(y, 8);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 4 || calls === 8);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 8);
+    },
+    "Polygon ↦ polygonStart, lineStart, point{2,}, lineEnd, polygonEnd": function(stream) {
+      var calls = 0;
+      stream({type: "Polygon", coordinates: [[[1, 2], [3, 4], [1, 2]], [[5, 6], [7, 8], [5, 6]]]}, {
+        polygonStart: function() {
+          ++calls;
+          assert.isTrue(calls === 1);
+          assert.equal(arguments.length, 0);
+        },
+        lineStart: function() {
+          ++calls;
+          assert.isTrue(calls === 2 || calls === 6);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          if (calls === 3) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 4) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else if (calls === 7) {
+            assert.equal(x, 5);
+            assert.equal(y, 6);
+          } else if (calls === 8) {
+            assert.equal(x, 7);
+            assert.equal(y, 8);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 5 || calls === 9);
+          assert.equal(arguments.length, 0);
+        },
+        polygonEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 10);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 10);
+    },
+    "MultiPolygon ↦ (polygonStart, lineStart, point{2,}, lineEnd, polygonEnd)*": function(stream) {
+      var calls = 0;
+      stream({type: "MultiPolygon", coordinates: [[[[1, 2], [3, 4], [1, 2]]], [[[5, 6], [7, 8], [5, 6]]]]}, {
+        polygonStart: function() {
+          ++calls;
+          assert.isTrue(calls === 1 || calls === 7);
+          assert.equal(arguments.length, 0);
+        },
+        lineStart: function() {
+          ++calls;
+          assert.isTrue(calls === 2 || calls === 8);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          if (calls === 3) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 4) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else if (calls === 9) {
+            assert.equal(x, 5);
+            assert.equal(y, 6);
+          } else if (calls === 10) {
+            assert.equal(x, 7);
+            assert.equal(y, 8);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 5 || calls === 11);
+          assert.equal(arguments.length, 0);
+        },
+        polygonEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 6 || calls === 12);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 12);
+    },
+    "Feature ↦ .*": function(stream) {
+      var calls = 0;
+      stream({type: "Feature", geometry: {type: "Point", coordinates: [1, 2]}}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "FeatureCollection ↦ .*": function(stream) {
+      var calls = 0;
+      stream({type: "FeatureCollection", features: [{type: "Feature", geometry: {type: "Point", coordinates: [1, 2]}}]}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "GeometryCollection ↦ .*": function(stream) {
+      var calls = 0;
+      stream({type: "GeometryCollection", geometries: [{type: "Point", coordinates: [1, 2]}]}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/geo/transverse-mercator-test.js

@@ -0,0 +1,38 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert"),
+    projectionTestSuite = require("./projection-test-suite");
+
+var suite = vows.describe("d3.geo.transverseMercator");
+
+suite.addBatch({
+  "transverseMercator": {
+    topic: load("geo/transverse-mercator").expression("d3.geo.transverseMercator"),
+    "default": projectionTestSuite({
+      topic: function(projection) { return projection(); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [ 480.00000000,  250.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349103], [ 473.09890692,   32.39629813]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [ 455.53607488,   38.07095444]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [ 483.91452378,   88.76181349]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [ 435.43771875,  420.48139861]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [ 495.09974957,   37.42095689]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [ 480.00000000,  472.52947963]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [ 480.00000000,   27.47052037]]
+    }),
+    "translated to 0,0 and at scale 1": projectionTestSuite({
+      topic: function(projection) { return projection().translate([0, 0]).scale(1); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [   0.00000000,    0.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349120], [  -0.04600729,   -1.45069135]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [  -0.16309283,   -1.41286030]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [   0.02609683,   -1.07492124]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [  -0.29708188,    1.13654266]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [   0.10066500,   -1.41719362]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [   0.00000000,    1.48352986]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [   0.00000000,   -1.48352986]]
+    })
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/geom/hull-test.js

@@ -0,0 +1,68 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geom.hull");
+
+suite.addBatch({
+  "hull": {
+    topic: load("geom/hull").expression("d3.geom.hull"),
+    "the default hull layout": {
+      topic: function(hull) {
+        return hull();
+      },
+      "has the default x-accessor, d[0]": function(h) {
+        assert.strictEqual(h.x()([42, 43]), 42);
+      },
+      "has the default y-accessor, d[1]": function(h) {
+        assert.strictEqual(h.y()([42, 43]), 43);
+      },
+      "of no points is empty": function(h) {
+        assert.deepEqual(h([]), []);
+      },
+      "of one point is empty": function(h) {
+        assert.deepEqual(h([[200, 200]]), []);
+      },
+      "of two points is empty": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300]]), []);
+      },
+      "for three points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500]]), [[500, 500], [760, 300], [200, 200]]);
+      },
+      "for four points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500], [400, 400]]), [[500, 500], [760, 300], [200, 200]]);
+      },
+      "returns a counter-clockwise polygon": function(h) {
+        assert.greater(_.geom.polygon(h([[200, 200], [760, 300], [500, 500], [400, 400]])).area(), 0);
+      }
+    },
+    "the hull layout with custom accessors": {
+      topic: function(hull) {
+        return hull().x(function(d) { return d.x; }).y(function(d) { return d.y; });
+      },
+      "of four points": function(h) {
+        assert.deepEqual(h([{x: 200, y: 200}, {x: 760, y: 300}, {x: 500, y: 500}, {x: 400, y: 400}]), [{x: 500, y: 500}, {x: 760, y: 300}, {x: 200, y: 200}]);
+      }
+    },
+    "the default hull layout applied directly": {
+      "for no points is empty": function(h) {
+        return h([]);
+      },
+      "for one point is empty": function(h) {
+        return h([[200, 200]]);
+      },
+      "for two points is empty": function(h) {
+        return h([[200, 200], [760, 300]]);
+      },
+      "for three points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500]]), [[500, 500], [760, 300], [200, 200]]);
+      },
+      "for four points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500], [400, 400]]), [[500, 500], [760, 300], [200, 200]]);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/geom/polygon-test.js

@@ -0,0 +1,151 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geom.polygon");
+
+suite.addBatch({
+  "polygon": {
+    topic: load("geom/polygon").expression("d3.geom.polygon"),
+    "closed counterclockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]);
+      },
+      "preserves input coordinates": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), 1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "can clip an open counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1]], 1e-4);
+      },
+      "can clip a closed counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1], [0.9, 0.5]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1], [0.9, 0.5]], 1e-4);
+      }
+    },
+    "closed clockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]);
+      },
+      "preserves input coordinates": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), -1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "is not currently supported for clipping": function(p) {
+        // because clipping requires a counterclockwise source polygon
+      }
+    },
+    "closed clockwise triangle": {
+      topic: function(polygon) {
+        return polygon([[1, 1], [3, 2], [2, 3], [1, 1]]);
+      },
+      "preserves input coordinates": function(p) {
+        assertPolygonInDelta(p, [[1, 1], [3, 2], [2, 3], [1, 1]]);
+      },
+      "has area 1.5": function(p) {
+        assert.equal(p.area(), -1.5);
+      },
+      "has centroid ⟨2,2⟩": function(p) {
+        assertPointInDelta(p.centroid(), [2, 2]);
+      },
+      "is not currently supported for clipping": function(p) {
+        // because clipping requires a counterclockwise source polygon
+      }
+    },
+    "open counterclockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [0, 1], [1, 1], [1, 0]]);
+      },
+      "remains an open polygon": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [0, 1], [1, 1], [1, 0]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), 1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "can clip an open counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1]], 1e-4);
+      },
+      "can clip an closed counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1], [0.9, 0.5]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1], [0.9, 0.5]], 1e-4);
+      }
+    },
+    "open clockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [1, 0], [1, 1], [0, 1]]);
+      },
+      "remains an open polygon": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [1, 0], [1, 1], [0, 1]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), -1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "is not currently supported for clipping": function(p) {
+        // because clipping requires a counterclockwise source polygon
+      }
+    },
+    "open clockwise triangle": {
+      topic: function(polygon) {
+        return polygon([[1, 1], [3, 2], [2, 3]]);
+      },
+      "remains an open polygon": function(p) {
+        assertPolygonInDelta(p, [[1, 1], [3, 2], [2, 3]]);
+      },
+      "has area 1.5": function(p) {
+        assert.equal(p.area(), -1.5);
+      },
+      "has centroid ⟨2,2⟩": function(p) {
+        assertPointInDelta(p.centroid(), [2, 2]);
+      }
+    },
+    "large square": {
+      topic: function(polygon) {
+        var r = 1e8,
+            d = _.range(0, r, r / 1e4);
+        return polygon(
+            d.map(function(y) { return [0, y]; }).concat(
+            d.map(function(x) { return [x, r]; })).concat(
+            d.map(function(y) { return [r, y]; }).reverse()).concat(
+            d.map(function(x) { return [x, 0]; }).reverse()));
+      },
+      "has area 1e16 - 5e7": function(p) {
+        assert.equal(p.area(), 1e16 - 5e7);
+      }
+    }
+  }
+});
+
+function assertPointInDelta(expected, actual, δ, message) {
+  if (!δ) δ = 0;
+  if (!pointInDelta(expected, actual, δ)) {
+    assert.fail(JSON.stringify(actual), JSON.stringify(expected), message || "expected {expected}, got {actual}", "===", assertPointInDelta);
+  }
+}
+
+function assertPolygonInDelta(expected, actual, δ, message) {
+  if (!δ) δ = 0;
+  if (expected.length !== actual.length || expected.some(function(e, i) { return !pointInDelta(e, actual[i], δ); })) {
+    assert.fail(JSON.stringify(actual), JSON.stringify(expected), message || "expected {expected}, got {actual}", "===", assertPolygonInDelta);
+  }
+}
+
+function pointInDelta(a, b, δ) {
+  return !(Math.abs(a[0] - b[0]) > δ || Math.abs(a[1] - b[1]) > δ);
+}
+
+suite.export(module);