d3js-plugins-rails 0.0.2 → 0.0.3

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/van-der-grinten3-test.js

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.vanDerGrinten3");
+
+suite.addBatch({
+  "vanDerGrinten3": {
+    topic: d3.geo.vanDerGrinten3,
+    "projections and inverse projections": function(vanDerGrinten3) {
+      assert.equalInverse(vanDerGrinten3, [  0,   0], [480,        250]);
+      assert.equalInverse(vanDerGrinten3, [  0, -45], [480,        376.268082]);
+      assert.equalInverse(vanDerGrinten3, [  0,  45], [480,        123.731917]);
+      assert.equalInverse(vanDerGrinten3, [-90,   0], [244.380550, 250]);
+      assert.equalInverse(vanDerGrinten3, [ 90,   0], [715.619449, 250]);
+      assert.equalInverse(vanDerGrinten3, [-80,  15], [271.793387, 210.453529]);
+      assert.equalInverse(vanDerGrinten3, [  1,   1], [482.617913, 247.381925]);
+      assert.equalInverse(vanDerGrinten3, [ 15,  45], [516.468521, 123.731917]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/van-der-grinten4-test.js

@@ -0,0 +1,28 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.vanDerGrinten4");
+
+suite.addBatch({
+  "vanDerGrinten4": {
+    topic: d3.geo.vanDerGrinten4,
+    "doesn't generate NaN": function(vanDerGrinten4) {
+      assert.inDelta(vanDerGrinten4([20, 1e-7]), [532.359877, 250], 1e-6);
+    },
+    "projections and inverse projections": function(vanDerGrinten4) {
+      assert.equalInverse(vanDerGrinten4, [  0,   0], [480,        250]);
+      assert.equalInverse(vanDerGrinten4, [  0, -45], [480,        367.809724]);
+      assert.equalInverse(vanDerGrinten4, [  0,  45], [480,        132.190275]);
+      assert.equalInverse(vanDerGrinten4, [-90,   0], [244.380550, 250]);
+      assert.equalInverse(vanDerGrinten4, [ 90,   0], [715.619449, 250]);
+      assert.equalInverse(vanDerGrinten4, [-80,  15], [274.023642, 209.610498]);
+      assert.equalInverse(vanDerGrinten4, [  1,   1], [482.617670, 247.382005]);
+      assert.equalInverse(vanDerGrinten4, [ 15,  45], [509.605158, 131.892658]);
+      assert.equalInverse(vanDerGrinten4, [-180, 15], [ 12.226093, 204.955105]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/wiechel-test.js

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.wiechel");
+
+suite.addBatch({
+  "wiechel": {
+    topic: d3.geo.wiechel,
+    "projections and inverse projections": function(wiechel) {
+      assert.equalInverse(wiechel, [  0,   0], [480,        250]);
+      assert.equalInverse(wiechel, [  0, -45], [436.066017, 356.066017]);
+      assert.equalInverse(wiechel, [  0,  45], [523.933982, 143.933982]);
+      assert.equalInverse(wiechel, [-90,   0], [330,        100]);
+      assert.equalInverse(wiechel, [ 90,   0], [630,        400]);
+      assert.equalInverse(wiechel, [-80,  15], [370.087700,  90.716040]);
+      assert.equalInverse(wiechel, [  1,   1], [482.649770, 247.414442]);
+      assert.equalInverse(wiechel, [ 15,  45], [553.483232, 155.847766]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/times.js

@@ -0,0 +1,19 @@
+function times(λ, φ) {
+  var t = Math.tan(φ / 2),
+      s = Math.sin(π / 4 * t);
+  return [
+    λ * (.74482 - .34588 * s * s),
+    1.70711 * t
+  ];
+}
+
+times.invert = function(x, y) {
+  var t = y / 1.70711,
+      s = Math.sin(π / 4 * t);
+  return [
+    x / (.74482 - .34588 * s * s),
+    2 * Math.atan(t)
+  ];
+};
+
+(d3.geo.times = function() { return projection(times); }).raw = times;

data/vendor/assets/javascripts/d3/plugins/geo/projection/two-point-azimuthal.js

@@ -0,0 +1,46 @@
+// @import two-point-equidistant
+
+function twoPointAzimuthal(d) {
+  var cosd = Math.cos(d);
+
+  function forward(λ, φ) {
+    var coordinates = d3.geo.gnomonic.raw(λ, φ);
+    coordinates[0] *= cosd;
+    return coordinates;
+  }
+
+  forward.invert = function(x, y) {
+    return d3.geo.gnomonic.raw.invert(x / cosd, y);
+  };
+
+  return forward;
+}
+
+function twoPointAzimuthalProjection() {
+  var points = [[0, 0], [0, 0]],
+      m = projectionMutator(twoPointAzimuthal),
+      p = m(0),
+      rotate = p.rotate;
+
+  delete p.rotate;
+
+  p.points = function(_) {
+    if (!arguments.length) return points;
+    points = _;
+
+    var interpolate = d3.geo.interpolate(_[0], _[1]),
+        origin = interpolate(.5),
+        p = twoPointEquidistant_rotate(-origin[0] * radians, -origin[1] * radians, _[0][0] * radians, _[0][1] * radians),
+        b = interpolate.distance * .5, // |[0, 0] - p|
+        c = (p[0] < 0 ? -1 : +1) * p[1], // |[p[0], 0] - p|
+        γ = asin(Math.sin(c) / Math.sin(b));
+
+    rotate.call(p, [-origin[0], -origin[1], -γ * degrees]);
+
+    return m(b);
+  };
+
+  return p;
+}
+
+(d3.geo.twoPointAzimuthal = twoPointAzimuthalProjection).raw = twoPointAzimuthal;

data/vendor/assets/javascripts/d3/plugins/geo/projection/two-point-equidistant.js

@@ -5,8 +5,11 @@ function twoPointEquidistant(z0) {
   if (!z0) return d3.geo.azimuthalEquidistant.raw;
   var λa = -z0 / 2,
       λb = -λa,
-      z02 = z0 * z0;
-  return function(λ, φ) {
+      z02 = z0 * z0,
+      tanλ0 = Math.tan(λb),
+      S = .5 / Math.sin(λb);
+
+  function forward(λ, φ) {
     var za = acos(Math.cos(φ) * Math.cos(λ - λa)),
         zb = acos(Math.cos(φ) * Math.cos(λ - λb)),
         ys = φ < 0 ? -1 : 1;
@@ -15,7 +18,21 @@ function twoPointEquidistant(z0) {
       (za - zb) / (2 * z0),
       ys * asqrt(4 * z02 * zb - (z02 - za + zb) * (z02 - za + zb)) / (2 * z0)
     ];
+  }
+
+  forward.invert = function(x, y) {
+    var y2 = y * y,
+        cosza = Math.cos(Math.sqrt(y2 + (t = x + λa) * t)),
+        coszb = Math.cos(Math.sqrt(y2 + (t = x + λb) * t)),
+        t,
+        d;
+    return [
+      Math.atan2(d = cosza - coszb, t = (cosza + coszb) * tanλ0),
+      (y < 0 ? -1 : 1) * acos(Math.sqrt(t * t + d * d) * S)
+    ];
   };
+
+  return forward;
 }
 
 function twoPointEquidistantProjection() {
@@ -33,9 +50,10 @@ function twoPointEquidistantProjection() {
     // Compute the origin as the midpoint of the two reference points.
     // Rotate one of the reference points by the origin.
     // Apply the spherical law of sines to compute γ rotation.
-    var origin = d3.geo.interpolate(_[0], _[1])(.5),
+    var interpolate = d3.geo.interpolate(_[0], _[1]),
+        origin = interpolate(.5),
         p = twoPointEquidistant_rotate(-origin[0] * radians, -origin[1] * radians, _[0][0] * radians, _[0][1] * radians),
-        b = acos(Math.cos(p[1]) * Math.cos(p[0])), // |[0, 0] - p|
+        b = interpolate.distance * .5, // |[0, 0] - p|
         c = (p[0] < 0 ? -1 : +1) * p[1], // |[p[0], 0] - p|
         γ = asin(Math.sin(c) / Math.sin(b));
 
@@ -44,7 +62,7 @@ function twoPointEquidistantProjection() {
     return m(b * 2);
   };
 
-  return p
+  return p;
 }
 
 function twoPointEquidistant_rotate(δλ, δφ, λ, φ) {

data/vendor/assets/javascripts/d3/plugins/geo/projection/van-der-grinten2.js

@@ -0,0 +1,28 @@
+function vanDerGrinten2(λ, φ) {
+  if (Math.abs(φ) < ε) return [λ, 0];
+  var sinθ = Math.abs(2 * φ / π),
+      θ = asin(sinθ);
+  if (Math.abs(λ) < ε || Math.abs(Math.abs(φ) - π / 2) < ε) return [0, sgn(φ) * π * Math.tan(θ / 2)];
+  var cosθ = Math.cos(θ),
+      A = Math.abs(π / λ - λ / π) / 2,
+      A2 = A * A,
+      x1 = cosθ * (Math.sqrt(1 + A2) - A * cosθ) / (1 + A2 * sinθ * sinθ);
+  return [
+    sgn(λ) * π * x1,
+    sgn(φ) * π * asqrt(1 - x1 * (2 * A + x1))
+  ];
+}
+
+vanDerGrinten2.invert = function(x, y) {
+  if (!x) return [0, π / 2 * Math.sin(2 * Math.atan(y / π))];
+  var x1 = Math.abs(x / π),
+      A = (1 - x1 * x1 - (y /= π) * y) / (2 * x1),
+      A2 = A * A,
+      B = Math.sqrt(A2 + 1);
+  return [
+    sgn(x) * π * (B - A),
+    sgn(y) * π / 2 * Math.sin(2 * Math.atan2(Math.sqrt((1 - 2 * A * x1) * (A + B) - x1), Math.sqrt(B + A + x1)))
+  ];
+};
+
+(d3.geo.vanDerGrinten2 = function() { return projection(vanDerGrinten2); }).raw = vanDerGrinten2;

data/vendor/assets/javascripts/d3/plugins/geo/projection/van-der-grinten3.js

@@ -0,0 +1,24 @@
+function vanDerGrinten3(λ, φ) {
+  if (Math.abs(φ) < ε) return [λ, 0];
+  var sinθ = 2 * φ / π,
+      θ = asin(sinθ);
+  if (Math.abs(λ) < ε || Math.abs(Math.abs(φ) - π / 2) < ε) return [0, π * Math.tan(θ / 2)];
+  var A = (π / λ - λ / π) / 2,
+      y1 = sinθ / (1 + Math.cos(θ));
+  return [
+    π * (sgn(λ) * asqrt(A * A + 1 - y1 * y1) - A),
+    π * y1
+  ];
+}
+
+vanDerGrinten3.invert = function(x, y) {
+  if (!y) return [x, 0];
+  var y1 = y / π,
+      A = (π * π * (1 - y1 * y1) - x * x) / (2 * π * x);
+  return [
+    x ? π * (sgn(x) * Math.sqrt(A * A + 1) - A) : 0,
+    π / 2 * Math.sin(2 * Math.atan(y1))
+  ];
+};
+
+(d3.geo.vanDerGrinten3 = function() { return projection(vanDerGrinten3); }).raw = vanDerGrinten3;

data/vendor/assets/javascripts/d3/plugins/geo/projection/van-der-grinten4.js

@@ -2,21 +2,53 @@ function vanDerGrinten4(λ, φ) {
   if (!φ) return [λ, 0];
   var φ0 = Math.abs(φ);
   if (!λ || φ0 === π / 2) return [0, φ];
-  var t,
-      B = 2 * φ0 / π,
+  var B = 2 * φ0 / π,
       B2 = B * B,
       C = (8 * B - B2 * (B2 + 2) - 5) / (2 * B2 * (B - 1)),
       C2 = C * C,
       BC = B * C,
       B_C2 = B2 + C2 + 2 * BC,
-      D = sgn(Math.abs(λ) - π / 2) * Math.sqrt((t = (t = 2 * λ / π) + 1 / t) * t - 4),
+      B_3C = B + 3 * C,
+      λ0 = 2 * λ / π,
+      λ1 = λ0 + 1 / λ0,
+      D = sgn(Math.abs(λ) - π / 2) * Math.sqrt(λ1 * λ1 - 4),
       D2 = D * D,
-      F = B_C2 * (B2 + C2 * D2 - 1) + (1 - B2) * (B2 * ((t = B + 3 * C) * t + 4 * C2) + 12 * BC * C2 + 4 * C2 * C2),
+      F = B_C2 * (B2 + C2 * D2 - 1) + (1 - B2) * (B2 * (B_3C * B_3C + 4 * C2) + 12 * BC * C2 + 4 * C2 * C2),
       x1 = (D * (B_C2 + C2 - 1) + 2 * Math.sqrt(F)) / (4 * B_C2 + D2);
   return [
     sgn(λ) * π * x1 / 2,
-    sgn(φ) * π / 2 * Math.sqrt(1 + D * Math.abs(x1) - x1 * x1)
+    sgn(φ) * π / 2 * asqrt(1 + D * Math.abs(x1) - x1 * x1)
   ];
 }
 
+vanDerGrinten4.invert = function(x, y) {
+  if (!x || !y) return [x, y];
+  y /= π;
+  var x1 = sgn(x) * x * 2 / π,
+      D = (x1 * x1 - 1 + 4 * y * y) / Math.abs(x1),
+      D2 = D * D,
+      B = 2 * y,
+      i = 50;
+  do {
+    var B2 = B * B,
+        C = (8 * B - B2 * (B2 + 2) - 5) / (2 * B2 * (B - 1)),
+        C_ = (3 * B - B2 * B - 10) / (2 * B2 * B),
+        C2 = C * C,
+        BC = B * C,
+        B_C = B + C,
+        B_C2 = B_C * B_C,
+        B_3C = B + 3 * C,
+        F = B_C2 * (B2 + C2 * D2 - 1) + (1 - B2) * (B2 * (B_3C * B_3C + 4 * C2) + C2 * (12 * BC + 4 * C2)),
+        F_ = -2 * B_C * (4 * BC * C2 + (1 - 4 * B2 + 3 * B2 * B2) * (1 + C_) + C2 * (-6 + 14 * B2 - D2 + (-8 + 8 * B2 - 2 * D2) * C_) + BC * (-8 + 12 * B2 + (-10 + 10 * B2 - D2) * C_)),
+        sqrtF = Math.sqrt(F),
+        f = D * (B_C2 + C2 - 1) + 2 * sqrtF - x1 * (4 * B_C2 + D2),
+        f_ = D * (2 * C * C_ + 2 * B_C * (1 + C_)) + F_ / sqrtF - 8 * B_C * (D * (-1 + C2 + B_C2) + 2 * sqrtF) * (1 + C_) / (D2 + 4 * B_C2);
+    B -= δ = f / f_;
+  } while (δ > ε && --i > 0);
+  return [
+    sgn(x) * (Math.sqrt(D * D + 4) + D) * π / 4,
+    π / 2 * B
+  ];
+};
+
 (d3.geo.vanDerGrinten4 = function() { return projection(vanDerGrinten4); }).raw = vanDerGrinten4;

data/vendor/assets/javascripts/d3/plugins/geo/projection/wiechel.js

@@ -11,4 +11,16 @@ function wiechel(λ, φ) {
   ];
 }
 
+wiechel.invert = function(x, y) {
+  var w = -.5 * (x * x + y * y),
+      k = Math.sqrt(-w * (2 + w)),
+      b = y * w + x * k,
+      a = x * w - y * k,
+      D = Math.sqrt(a * a + b * b);
+  return [
+    Math.atan2(k * b, D * (1 + w)),
+    D ? -asin(k * a / D) : 0
+  ];
+};
+
 (d3.geo.wiechel = function() { return projection(wiechel); }).raw = wiechel;

data/vendor/assets/javascripts/d3/plugins/graph/README.md

@@ -1,6 +1,11 @@
 # d3.graph
 
-A plugin for manipulating [graph data structures](http://opendatastructures.org/ods-cpp/12_Graphs.html). This plugin is unstable and in development.
+This plugin is not currently in active development.
+
+For a more complete set of graph analysis tools, see the work of [Elijah Meeks and Maya Krishnan](http://dhs.stanford.edu/dh/networks/).
+
+A plugin for manipulating [graph data structures](http://opendatastructures.org/ods-cpp/12_Graphs.html).
+
 
 ## Todo
 
@@ -140,9 +145,3 @@ Get a description of the graph
 graph.description();
 // "d3.graph with 3 nodes and 9 links"
 ```
-
-Basic node filters. These currently filter the original node set, so subsequent filters won't stack. See [Gremlin](https://github.com/tinkerpop/gremlin/wiki/Basic-Graph-Traversals).
-
-```js
-graph.traverse().filter(function(d) { return d.indexOf('urp') > -1 }).value();
-```

data/vendor/assets/javascripts/d3/plugins/graph/graph.js

@@ -27,39 +27,6 @@
       return this;
     };
 
-    graph.traverse = function() {
-      var traversal = {},
-          selected = {},            // selected entities
-          selected_type;
-
-      traversal.filter = function(f) {
-        // only works on nodes
-        if (!arguments.length) return this;
-        selected = nodes.filter(f);
-        return this;
-      };
-
-      traversal.value = function(x) {
-        if (!arguments.length) {
-          // reset selection
-          var result = selected;
-          selected_type = false;
-          selected = {};
-          return result;
-        }
-        selected = x;
-        return this;
-      };
-
-      traversal.selected_type = function(x) {
-        if (!arguments.length) return selected_type;
-        selected_type = x;
-        return this;
-      };
-
-      return traversal;
-    };
-
     return graph;
   };
 

data/vendor/assets/javascripts/d3/plugins/graph/index.html

@@ -27,7 +27,6 @@
   console.log('nodes', g.nodes() );
   console.log('links', g.links() );
   console.log('matrix', g.matrix() );
-  console.log('traversal', g.traverse().filter(function(d) { return d.indexOf('urp') > -1 }).value());
 
   var m = d3.graph.matrix([
     [1,1,0],

data/vendor/assets/javascripts/d3/plugins/keybinding/keybinding.js

@@ -1,120 +1,197 @@
-d3.keybinding = function() {
-    // via https://github.com/keithamus/jwerty/
-    // and https://github.com/madrobby/keymaster
-    var _keys = {
-        // MOD aka toggleable keys
-        mods: {
-            // Shift key, ⇧
-            '⇧': 16,
-            // CTRL key, on Mac: ⌃
-            '⌃': 17,
-            // ALT key, on Mac: ⌥ (Alt)
-            '⌥': 18,
-            // META, on Mac: ⌘ (CMD), on Windows (Win), on Linux (Super)
-            '⌘': 91
-        },
-        // Normal keys
-        keys: {
-            // Backspace key, on Mac: ⌫ (Backspace)
-            '⌫': 8, backspace: 8,
-            // Tab Key, on Mac: ⇥ (Tab), on Windows ⇥⇥
-            '⇥': 9, '⇆': 9, tab: 9,
-            // Return key, ↩
-            '↩': 13, 'return': 13, enter: 13, '⌅': 13,
-            // Pause/Break key
-            'pause': 19, 'pause-break': 19,
-            // Caps Lock key, ⇪
-            '⇪': 20, caps: 20, 'caps-lock': 20,
-            // Escape key, on Mac: ⎋, on Windows: Esc
-            '⎋': 27, escape: 27, esc: 27,
-            // Space key
-            space: 32,
-            // Page-Up key, or pgup, on Mac: ↖
-            '↖': 33, pgup: 33, 'page-up': 33,
-            // Page-Down key, or pgdown, on Mac: ↘
-            '↘': 34, pgdown: 34, 'page-down': 34,
-            // END key, on Mac: ⇟
-            '⇟': 35, end: 35,
-            // HOME key, on Mac: ⇞
-            '⇞': 36, home: 36,
-            // Insert key, or ins
-            ins: 45, insert: 45,
-            // Delete key, on Mac: ⌦ (Delete)
-            '⌦': 46, del: 46, 'delete': 46,
-            // Left Arrow Key, or ←
-            '←': 37, left: 37, 'arrow-left': 37,
-            // Up Arrow Key, or ↑
-            '↑': 38, up: 38, 'arrow-up': 38,
-            // Right Arrow Key, or →
-            '→': 39, right: 39, 'arrow-right': 39,
-            // Up Arrow Key, or ↓
-            '↓': 40, down: 40, 'arrow-down': 40,
-            // odities, printing characters that come out wrong:
-            // Num-Multiply, or *
-            '*': 106, star: 106, asterisk: 106, multiply: 106,
-            // Num-Plus or +
-            '+': 107, 'plus': 107,
-            // Num-Subtract, or -
-            '-': 109, subtract: 109,
-            // Semicolon
-            ';': 186, semicolon:186,
-            // = or equals
-            '=': 187, 'equals': 187,
-            // Comma, or ,
-            ',': 188, comma: 188,
-            //'-': 189, //???
-            // Period, or ., or full-stop
-            '.': 190, period: 190, 'full-stop': 190,
-            // Slash, or /, or forward-slash
-            '/': 191, slash: 191, 'forward-slash': 191,
-            // Tick, or `, or back-quote
-            '`': 192, tick: 192, 'back-quote': 192,
-            // Open bracket, or [
-            '[': 219, 'open-bracket': 219,
-            // Back slash, or \
-            '\\': 220, 'back-slash': 220,
-            // Close backet, or ]
-            ']': 221, 'close-bracket': 221,
-            // Apostraphe, or Quote, or '
-            '\'': 222, quote: 222, apostraphe: 222
+/*
+ * This code is licensed under the MIT license.
+ *
+ * Copyright © 2013, iD authors.
+ *
+ * Portions copyright © 2011, Keith Cirkel
+ * See https://github.com/keithamus/jwerty
+ *
+ */
+d3.keybinding = function(namespace) {
+    var bindings = [];
+
+    function matches(binding, event) {
+        for (var p in binding.event) {
+            if (event[p] != binding.event[p])
+                return false;
         }
-    };
-    // To minimise code bloat, add all of the NUMPAD 0-9 keys in a loop
-    var i = 95, n = 0;
-    while (++i < 106) _keys.keys['num-' + n] = i; ++n;
-    // To minimise code bloat, add all of the top row 0-9 keys in a loop
-    i = 47, n = 0;
-    while (++i < 58) _keys.keys[n] = i; ++n;
-    // To minimise code bloat, add all of the F1-F25 keys in a loop
-    i = 111, n = 1;
-    while (++i < 136) _keys.keys['f' + n] = i; ++n;
-    // To minimise code bloat, add all of the letters of the alphabet in a loop
-    i = 64;
-    while(++i < 91) _keys.keys[String.fromCharCode(i).toLowerCase()] = i;
 
-    var pairs = d3.entries(_keys.keys),
-        event = d3.dispatch.apply(d3, d3.keys(_keys.keys));
+        return (!binding.capture) === (event.eventPhase !== Event.CAPTURING_PHASE);
+    }
 
-    function keys(selection) {
-        selection.on('keydown', function () {
-            var tagName = d3.select(d3.event.target).node().tagName;
-            if (tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA') {
-                return;
+    function capture() {
+        for (var i = 0; i < bindings.length; i++) {
+            var binding = bindings[i];
+            if (matches(binding, d3.event)) {
+                binding.callback();
             }
+        }
+    }
+
+    function bubble() {
+        var tagName = d3.select(d3.event.target).node().tagName;
+        if (tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA') {
+            return;
+        }
+        capture();
+    }
 
-            var modifiers = '';
-            if (d3.event.shiftKey) modifiers += '⇧';
-            if (d3.event.ctrlKey) modifiers += '⌃';
-            if (d3.event.altKey) modifiers += '⌥';
-            if (d3.event.metaKey) modifiers += '⌘';
-
-            pairs.filter(function(d) {
-                return d.value === d3.event.keyCode;
-            }).forEach(function(d) {
-                event[d.key](d3.event, modifiers);
-            });
-        });
+    function keybinding(selection) {
+        selection = selection || d3.select(document);
+        selection.on('keydown.capture' + namespace, capture, true);
+        selection.on('keydown.bubble' + namespace, bubble, false);
+        return keybinding;
     }
 
-    return d3.rebind(keys, event, 'on');
+    keybinding.off = function(selection) {
+        selection = selection || d3.select(document);
+        selection.on('keydown.capture' + namespace, null);
+        selection.on('keydown.bubble' + namespace, null);
+        return keybinding;
+    };
+
+    keybinding.on = function(code, callback, capture) {
+        var binding = {
+            event: {
+                keyCode: 0,
+                shiftKey: false,
+                ctrlKey: false,
+                altKey: false,
+                metaKey: false
+            },
+            capture: capture,
+            callback: callback
+        };
+
+        code = code.toLowerCase().match(/(?:(?:[^+])+|\+\+|^\+$)/g);
+
+        for (var i = 0; i < code.length; i++) {
+            // Normalise matching errors
+            if (code[i] === '++') code[i] = '+';
+
+            if (code[i] in d3.keybinding.modifierCodes) {
+                binding.event[d3.keybinding.modifierProperties[d3.keybinding.modifierCodes[code[i]]]] = true;
+            } else if (code[i] in d3.keybinding.keyCodes) {
+                binding.event.keyCode = d3.keybinding.keyCodes[code[i]];
+            }
+        }
+
+        bindings.push(binding);
+
+        return keybinding;
+    };
+
+    return keybinding;
 };
+
+(function () {
+    d3.keybinding.modifierCodes = {
+        // Shift key, ⇧
+        '⇧': 16, shift: 16,
+        // CTRL key, on Mac: ⌃
+        '⌃': 17, ctrl: 17,
+        // ALT key, on Mac: ⌥ (Alt)
+        '⌥': 18, alt: 18, option: 18,
+        // META, on Mac: ⌘ (CMD), on Windows (Win), on Linux (Super)
+        '⌘': 91, meta: 91, cmd: 91, 'super': 91, win: 91
+    };
+
+    d3.keybinding.modifierProperties = {
+        16: 'shiftKey',
+        17: 'ctrlKey',
+        18: 'altKey',
+        91: 'metaKey'
+    };
+
+    d3.keybinding.keyCodes = {
+        // Backspace key, on Mac: ⌫ (Backspace)
+        '⌫': 8, backspace: 8,
+        // Tab Key, on Mac: ⇥ (Tab), on Windows ⇥⇥
+        '⇥': 9, '⇆': 9, tab: 9,
+        // Return key, ↩
+        '↩': 13, 'return': 13, enter: 13, '⌅': 13,
+        // Pause/Break key
+        'pause': 19, 'pause-break': 19,
+        // Caps Lock key, ⇪
+        '⇪': 20, caps: 20, 'caps-lock': 20,
+        // Escape key, on Mac: ⎋, on Windows: Esc
+        '⎋': 27, escape: 27, esc: 27,
+        // Space key
+        space: 32,
+        // Page-Up key, or pgup, on Mac: ↖
+        '↖': 33, pgup: 33, 'page-up': 33,
+        // Page-Down key, or pgdown, on Mac: ↘
+        '↘': 34, pgdown: 34, 'page-down': 34,
+        // END key, on Mac: ⇟
+        '⇟': 35, end: 35,
+        // HOME key, on Mac: ⇞
+        '⇞': 36, home: 36,
+        // Insert key, or ins
+        ins: 45, insert: 45,
+        // Delete key, on Mac: ⌦ (Delete)
+        '⌦': 46, del: 46, 'delete': 46,
+        // Left Arrow Key, or ←
+        '←': 37, left: 37, 'arrow-left': 37,
+        // Up Arrow Key, or ↑
+        '↑': 38, up: 38, 'arrow-up': 38,
+        // Right Arrow Key, or →
+        '→': 39, right: 39, 'arrow-right': 39,
+        // Up Arrow Key, or ↓
+        '↓': 40, down: 40, 'arrow-down': 40,
+        // odities, printing characters that come out wrong:
+        // Num-Multiply, or *
+        '*': 106, star: 106, asterisk: 106, multiply: 106,
+        // Num-Plus or +
+        '+': 107, 'plus': 107,
+        // Num-Subtract, or -
+        '-': 109, subtract: 109,
+        // Semicolon
+        ';': 186, semicolon:186,
+        // = or equals
+        '=': 187, 'equals': 187,
+        // Comma, or ,
+        ',': 188, comma: 188,
+        //'-': 189, //???
+        // Period, or ., or full-stop
+        '.': 190, period: 190, 'full-stop': 190,
+        // Slash, or /, or forward-slash
+        '/': 191, slash: 191, 'forward-slash': 191,
+        // Tick, or `, or back-quote
+        '`': 192, tick: 192, 'back-quote': 192,
+        // Open bracket, or [
+        '[': 219, 'open-bracket': 219,
+        // Back slash, or \
+        '\\': 220, 'back-slash': 220,
+        // Close backet, or ]
+        ']': 221, 'close-bracket': 221,
+        // Apostrophe, or Quote, or '
+        '\'': 222, quote: 222, apostrophe: 222
+    };
+
+    // NUMPAD 0-9
+    var i = 95, n = 0;
+    while (++i < 106) {
+        d3.keybinding.keyCodes['num-' + n] = i;
+        ++n;
+    }
+
+    // 0-9
+    i = 47; n = 0;
+    while (++i < 58) {
+        d3.keybinding.keyCodes[n] = i;
+        ++n;
+    }
+
+    // F1-F25
+    i = 111; n = 1;
+    while (++i < 136) {
+        d3.keybinding.keyCodes['f' + n] = i;
+        ++n;
+    }
+
+    // a-z
+    i = 64;
+    while (++i < 91) {
+        d3.keybinding.keyCodes[String.fromCharCode(i).toLowerCase()] = i;
+    }
+})();