{

  "name": "d3",

  "main": "d3.js",

  "_resolution": {

    "type": "version",

  },

  "_target": "~3.5.6",

}

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this

  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,

  this list of conditions and the following disclaimer in the documentation

  and/or other materials provided with the distribution.

* The name Michael Bostock may not be used to endorse or promote products

  derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# Data-Driven Documents

**D3.js** is a JavaScript library for manipulating documents based on data. **D3** helps you bring data to life using HTML, SVG, and CSS. **D3** emphasizes web standards and combines powerful visualization components with a data-driven approach to DOM manipulation, giving you the full capabilities of modern browsers without tying yourself to a proprietary framework.

Want to learn more? [See the wiki.](https://github.com/mbostock/d3/wiki)

For examples, [see the gallery](https://github.com/mbostock/d3/wiki/Gallery) and [mbostock’s bl.ocks](http://bl.ocks.org/mbostock).

{

  "name": "d3",

  "main": "d3.js",

}

!function() {

  var d3 = {

  };

  var d3_arraySlice = [].slice, d3_array = function(list) {

    return d3_arraySlice.call(list);

  };

  var d3_document = this.document;

  function d3_documentElement(node) {

    return node && (node.ownerDocument || node.document || node).documentElement;

  }

  function d3_window(node) {

    return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView);

  }

  if (d3_document) {

    try {

      d3_array(d3_document.documentElement.childNodes)[0].nodeType;

    } catch (e) {

      d3_array = function(list) {

        var i = list.length, array = new Array(i);

        while (i--) array[i] = list[i];

        return array;

      };

    }

  }

  if (!Date.now) Date.now = function() {

    return +new Date();

  };

  if (d3_document) {

    try {

      d3_document.createElement("DIV").style.setProperty("opacity", 0, "");

    } catch (error) {

      var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;

      d3_element_prototype.setAttribute = function(name, value) {

        d3_element_setAttribute.call(this, name, value + "");

      };

      d3_element_prototype.setAttributeNS = function(space, local, value) {

        d3_element_setAttributeNS.call(this, space, local, value + "");

      };

      d3_style_prototype.setProperty = function(name, value, priority) {

        d3_style_setProperty.call(this, name, value + "", priority);

      };

    }

  }

  d3.ascending = d3_ascending;

  function d3_ascending(a, b) {

    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;

  }

  d3.descending = function(a, b) {

    return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;

  };

  d3.min = function(array, f) {

    var i = -1, n = array.length, a, b;

    if (arguments.length === 1) {

      while (++i < n) if ((b = array[i]) != null && b >= b) {

        a = b;

        break;

      }

      while (++i < n) if ((b = array[i]) != null && a > b) a = b;

    } else {

      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {

        a = b;

        break;

      }

      while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;

    }

    return a;

  };

  d3.max = function(array, f) {

    var i = -1, n = array.length, a, b;

    if (arguments.length === 1) {

      while (++i < n) if ((b = array[i]) != null && b >= b) {

        a = b;

        break;

      }

      while (++i < n) if ((b = array[i]) != null && b > a) a = b;

    } else {

      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {

        a = b;

        break;

      }

      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;

    }

    return a;

  };

  d3.extent = function(array, f) {

    var i = -1, n = array.length, a, b, c;

    if (arguments.length === 1) {

      while (++i < n) if ((b = array[i]) != null && b >= b) {

        a = c = b;

        break;

      }

      while (++i < n) if ((b = array[i]) != null) {

        if (a > b) a = b;

        if (c < b) c = b;

      }

    } else {

      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {

        a = c = b;

      while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;

    } else {

      while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j;

    }

    if (j) return s / j;

  };

  d3.quantile = function(values, p) {

    var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;

    return e ? v + e * (values[h] - v) : v;

  };

  d3.median = function(array, f) {

    var numbers = [], n = array.length, a, i = -1;

    if (arguments.length === 1) {

      while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);

    } else {

      while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);

    }

    if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5);

  };

  d3.variance = function(array, f) {

    var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0;

    if (arguments.length === 1) {

      while (++i < n) {

        if (d3_numeric(a = d3_number(array[i]))) {

          d = a - m;

          m += d / ++j;

          s += d * (a - m);

        }

      }

    } else {

      while (++i < n) {

        if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {

          d = a - m;

          m += d / ++j;

          s += d * (a - m);

        }

      }

    }

    if (j > 1) return s / (j - 1);

  };

  d3.deviation = function() {

    var v = d3.variance.apply(this, arguments);

    return v ? Math.sqrt(v) : v;

  };

  function d3_bisector(compare) {

    return {

      left: function(a, x, lo, hi) {

        if (arguments.length < 3) lo = 0;

        if (arguments.length < 4) hi = a.length;

        while (lo < hi) {

          var mid = lo + hi >>> 1;

          if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid;

        }

        return lo;

      },

      right: function(a, x, lo, hi) {

        if (arguments.length < 3) lo = 0;

        if (arguments.length < 4) hi = a.length;

        while (lo < hi) {

          var mid = lo + hi >>> 1;

          if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1;

        }

        return lo;

      }

    };

  }

  var d3_bisect = d3_bisector(d3_ascending);

  d3.bisectLeft = d3_bisect.left;

  d3.bisect = d3.bisectRight = d3_bisect.right;

  d3.bisector = function(f) {

    return d3_bisector(f.length === 1 ? function(d, x) {

      return d3_ascending(f(d), x);

    } : f);

  };

  d3.shuffle = function(array, i0, i1) {

    if ((m = arguments.length) < 3) {

      i1 = array.length;

      if (m < 2) i0 = 0;

    }

    var m = i1 - i0, t, i;

    while (m) {

      i = Math.random() * m-- | 0;

      t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t;

    }

    return array;

  };

  d3.permute = function(array, indexes) {

    var i = indexes.length, permutes = new Array(i);

    while (i--) permutes[i] = array[indexes[i]];

    return permutes;

  };

  d3.pairs = function(array) {

    var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);

    while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];

    return pairs;

  };

  d3.zip = function() {

  };

  d3.keys = function(map) {

    var keys = [];

    for (var key in map) keys.push(key);

    return keys;

  };

  d3.values = function(map) {

    var values = [];

    for (var key in map) values.push(map[key]);

    return values;

  };

  d3.entries = function(map) {

    var entries = [];

    for (var key in map) entries.push({

      key: key,

      value: map[key]

    });

    return entries;

  };

  d3.merge = function(arrays) {

    var n = arrays.length, m, i = -1, j = 0, merged, array;

    while (++i < n) j += arrays[i].length;

    merged = new Array(j);

    while (--n >= 0) {

      array = arrays[n];

      m = array.length;

      while (--m >= 0) {

        merged[--j] = array[m];

      }

    }

    return merged;

  };

  var abs = Math.abs;

  d3.range = function(start, stop, step) {

    if (arguments.length < 3) {

      step = 1;

      if (arguments.length < 2) {

        stop = start;

        start = 0;

      }

    }

    if ((stop - start) / step === Infinity) throw new Error("infinite range");

    var range = [], k = d3_range_integerScale(abs(step)), i = -1, j;

    start *= k, stop *= k, step *= k;

    if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);

    return range;

  };

  function d3_range_integerScale(x) {

    var k = 1;

    while (x * k % 1) k *= 10;

    return k;

  }

  function d3_class(ctor, properties) {

    for (var key in properties) {

      Object.defineProperty(ctor.prototype, key, {

        value: properties[key],

        enumerable: false

      });

    }

  }

  d3.map = function(object, f) {

    var map = new d3_Map();

    if (object instanceof d3_Map) {

      object.forEach(function(key, value) {

        map.set(key, value);

      });

    } else if (Array.isArray(object)) {

      var i = -1, n = object.length, o;

      if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o);

    } else {

      for (var key in object) map.set(key, object[key]);

    }

    return map;

  };

  function d3_Map() {

    this._ = Object.create(null);

  }

  var d3_map_proto = "__proto__", d3_map_zero = "\x00";

  d3_class(d3_Map, {

    has: d3_map_has,

    get: function(key) {

      return this._[d3_map_escape(key)];

    },

    set: function(key, value) {

      return this._[d3_map_escape(key)] = value;

    },

    remove: d3_map_remove,

    keys: d3_map_keys,

    values: function() {

      var values = [];

      for (var key in this._) values.push(this._[key]);

      return values;

    },

    entries: function() {

      var entries = [];

      for (var key in this._) entries.push({

    var e = d3.event, s;

    while (s = e.sourceEvent) e = s;

    return e;

  }

  function d3_eventDispatch(target) {

    var dispatch = new d3_dispatch(), i = 0, n = arguments.length;

    while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);

    dispatch.of = function(thiz, argumentz) {

      return function(e1) {

        try {

          var e0 = e1.sourceEvent = d3.event;

          e1.target = target;

          d3.event = e1;

          dispatch[e1.type].apply(thiz, argumentz);

        } finally {

          d3.event = e0;

        }

      };

    };

    return dispatch;

  }

  d3.requote = function(s) {

    return s.replace(d3_requote_re, "\\$&");

  };

  var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;

  var d3_subclass = {}.__proto__ ? function(object, prototype) {

    object.__proto__ = prototype;

  } : function(object, prototype) {

    for (var property in prototype) object[property] = prototype[property];

  };

  function d3_selection(groups) {

    d3_subclass(groups, d3_selectionPrototype);

    return groups;

  }

  var d3_select = function(s, n) {

    return n.querySelector(s);

  }, d3_selectAll = function(s, n) {

    return n.querySelectorAll(s);

  }, d3_selectMatches = function(n, s) {

    var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")];

    d3_selectMatches = function(n, s) {

      return d3_selectMatcher.call(n, s);

    };

    return d3_selectMatches(n, s);

  };

  if (typeof Sizzle === "function") {

    d3_select = function(s, n) {

      return Sizzle(s, n)[0] || null;

    };

    d3_selectAll = Sizzle;

    d3_selectMatches = Sizzle.matchesSelector;

  }

  d3.selection = function() {

    return d3.select(d3_document.documentElement);

  };

  var d3_selectionPrototype = d3.selection.prototype = [];

  d3_selectionPrototype.select = function(selector) {

    var subgroups = [], subgroup, subnode, group, node;

    selector = d3_selection_selector(selector);

    for (var j = -1, m = this.length; ++j < m; ) {

      subgroups.push(subgroup = []);

      subgroup.parentNode = (group = this[j]).parentNode;

      for (var i = -1, n = group.length; ++i < n; ) {

        if (node = group[i]) {

          subgroup.push(subnode = selector.call(node, node.__data__, i, j));

          if (subnode && "__data__" in node) subnode.__data__ = node.__data__;

        } else {

          subgroup.push(null);

        }

      }

    }

    return d3_selection(subgroups);

  };

  function d3_selection_selector(selector) {

    return typeof selector === "function" ? selector : function() {

      return d3_select(selector, this);

    };

  }

  d3_selectionPrototype.selectAll = function(selector) {

    var subgroups = [], subgroup, node;

    selector = d3_selection_selectorAll(selector);

    for (var j = -1, m = this.length; ++j < m; ) {

      for (var group = this[j], i = -1, n = group.length; ++i < n; ) {

        if (node = group[i]) {

          subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));

          subgroup.parentNode = node;

        }

      }

    }

    return d3_selection(subgroups);

  };

  function d3_selection_selectorAll(selector) {

    return typeof selector === "function" ? selector : function() {

      return d3_selectAll(selector, this);

    };

  }

  var d3_nsPrefix = {

    svg: "http://www.w3.org/2000/svg",

    xlink: "http://www.w3.org/1999/xlink",

    xml: "http://www.w3.org/XML/1998/namespace",

    xmlns: "http://www.w3.org/2000/xmlns/"

  };

  d3.ns = {

    prefix: d3_nsPrefix,

    qualify: function(name) {

      var i = name.indexOf(":"), prefix = name;

      return d3_nsPrefix.hasOwnProperty(prefix) ? {

        space: d3_nsPrefix[prefix],

        local: name

      } : name;

    }

  };

  d3_selectionPrototype.attr = function(name, value) {

    if (arguments.length < 2) {

      if (typeof name === "string") {

        var node = this.node();

        name = d3.ns.qualify(name);

        return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);

      }

      for (value in name) this.each(d3_selection_attr(value, name[value]));

      return this;

    }

    return this.each(d3_selection_attr(name, value));

  };

  function d3_selection_attr(name, value) {

    name = d3.ns.qualify(name);

    function attrNull() {

      this.removeAttribute(name);

    }

    function attrNullNS() {

      this.removeAttributeNS(name.space, name.local);

    }

    function attrConstant() {

      this.setAttribute(name, value);

    }

    function attrConstantNS() {

      this.setAttributeNS(name.space, name.local, value);

    }

    function attrFunction() {

      var x = value.apply(this, arguments);

      if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);

    }

    function attrFunctionNS() {

      var x = value.apply(this, arguments);

      if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);

    }

    return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;

  }

  function d3_collapse(s) {

    return s.trim().replace(/\s+/g, " ");

  }

  d3_selectionPrototype.classed = function(name, value) {

    if (arguments.length < 2) {

      if (typeof name === "string") {

        var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1;

        if (value = node.classList) {

          while (++i < n) if (!value.contains(name[i])) return false;

        } else {

          value = node.getAttribute("class");

          while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;

        }

        return true;

      }

      for (value in name) this.each(d3_selection_classed(value, name[value]));

      return this;

    }

    return this.each(d3_selection_classed(name, value));

  };

  function d3_selection_classedRe(name) {

    return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");

  }

  function d3_selection_classes(name) {

    return (name + "").trim().split(/^|\s+/);

  }

  function d3_selection_classed(name, value) {

    name = d3_selection_classes(name).map(d3_selection_classedName);

    var n = name.length;

    function classedConstant() {

      var i = -1;

      while (++i < n) name[i](this, value);

    }

    function classedFunction() {

      var i = -1, x = value.apply(this, arguments);

      while (++i < n) name[i](this, x);

    }

    return typeof value === "function" ? classedFunction : classedConstant;

  }

  function d3_selection_classedName(name) {

    var re = d3_selection_classedRe(name);

    return function(node, value) {

      if (c = node.classList) return value ? c.add(name) : c.remove(name);

      var c = node.getAttribute("class") || "";

      if (value) {

        re.lastIndex = 0;

        if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));

      } else {

        node.setAttribute("class", d3_collapse(c.replace(re, " ")));

      }

    };

  }

  d3_selectionPrototype.style = function(name, value, priority) {

    var n = arguments.length;

    if (n < 3) {

      if (typeof name !== "string") {

        if (n < 2) value = "";

        for (priority in name) this.each(d3_selection_style(priority, name[priority], value));

        return this;

      }

      if (n < 2) {

        var node = this.node();

        return d3_window(node).getComputedStyle(node, null).getPropertyValue(name);

      }

      priority = "";

    }

    return this.each(d3_selection_style(name, value, priority));

  };

  function d3_selection_style(name, value, priority) {

    function styleNull() {

      this.style.removeProperty(name);

    }

    function styleConstant() {

      this.style.setProperty(name, value, priority);

    }

    function styleFunction() {

      var x = value.apply(this, arguments);

      if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);

    }

    return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;

  }

  d3_selectionPrototype.property = function(name, value) {

    if (arguments.length < 2) {

      if (typeof name === "string") return this.node()[name];

      for (value in name) this.each(d3_selection_property(value, name[value]));

      return this;

    }

    return this.each(d3_selection_property(name, value));

  };

  function d3_selection_property(name, value) {

    function propertyNull() {

      delete this[name];

    }

    function propertyConstant() {

      this[name] = value;

    }

    function propertyFunction() {

      var x = value.apply(this, arguments);

      if (x == null) delete this[name]; else this[name] = x;

    }

    return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;

  }

  d3_selectionPrototype.text = function(value) {

    return arguments.length ? this.each(typeof value === "function" ? function() {

      var v = value.apply(this, arguments);

      this.textContent = v == null ? "" : v;

    } : value == null ? function() {

      this.textContent = "";

    } : function() {

      this.textContent = value;

    }) : this.node().textContent;

  };

  d3_selectionPrototype.html = function(value) {

    return arguments.length ? this.each(typeof value === "function" ? function() {

      var v = value.apply(this, arguments);

      this.innerHTML = v == null ? "" : v;

    } : value == null ? function() {

      this.innerHTML = "";

    } : function() {

      this.innerHTML = value;

    }) : this.node().innerHTML;

  };

  d3_selectionPrototype.append = function(name) {

    name = d3_selection_creator(name);

    return this.select(function() {

      return this.appendChild(name.apply(this, arguments));

    });

  };

  function d3_selection_creator(name) {

    function create() {

      var document = this.ownerDocument, namespace = this.namespaceURI;

    }

    function createNS() {

      return this.ownerDocument.createElementNS(name.space, name.local);

    }

    return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? createNS : create;

  }

  d3_selectionPrototype.insert = function(name, before) {

    name = d3_selection_creator(name);

    before = d3_selection_selector(before);

    return this.select(function() {

      return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);

    });

  };

  d3_selectionPrototype.remove = function() {

    return this.each(d3_selectionRemove);

  };

  function d3_selectionRemove() {

    var parent = this.parentNode;

    if (parent) parent.removeChild(this);

  }

  d3_selectionPrototype.data = function(value, key) {

    var i = -1, n = this.length, group, node;

    if (!arguments.length) {

      value = new Array(n = (group = this[0]).length);

      while (++i < n) {

        if (node = group[i]) {

          value[i] = node.__data__;

        }

      }

      return value;

    }

    function bind(group, groupData) {

      var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;

      if (key) {

        var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue;

        for (i = -1; ++i < n; ) {

          }

        }

        for (i = -1; ++i < m; ) {

          if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) {

            enterNodes[i] = d3_selection_dataNode(nodeData);

          } else if (node !== true) {

            updateNodes[i] = node;

            node.__data__ = nodeData;

          }

          nodeByKeyValue.set(keyValue, true);

        }

        for (i = -1; ++i < n; ) {

            exitNodes[i] = group[i];

          }

        }

      } else {

        for (i = -1; ++i < n0; ) {

          node = group[i];

          nodeData = groupData[i];

          if (node) {

            node.__data__ = nodeData;

            updateNodes[i] = node;

          } else {

            enterNodes[i] = d3_selection_dataNode(nodeData);

          }

        }

        for (;i < m; ++i) {

          enterNodes[i] = d3_selection_dataNode(groupData[i]);

        }

        for (;i < n; ++i) {

          exitNodes[i] = group[i];

        }

      }

      enterNodes.update = updateNodes;

      enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;

      enter.push(enterNodes);

      update.push(updateNodes);

      exit.push(exitNodes);

    }

    var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);

    if (typeof value === "function") {

      while (++i < n) {

        bind(group = this[i], value.call(group, group.parentNode.__data__, i));

      }

    } else {

      while (++i < n) {

        bind(group = this[i], value);

      }

    }

    update.enter = function() {

      return enter;

    };

    update.exit = function() {

      return exit;

    };

    return update;

  };

  function d3_selection_dataNode(data) {

    return {

      __data__: data

    };

  }

  d3_selectionPrototype.datum = function(value) {

    return arguments.length ? this.property("__data__", value) : this.property("__data__");

  };

  d3_selectionPrototype.filter = function(filter) {

    var subgroups = [], subgroup, group, node;

    if (typeof filter !== "function") filter = d3_selection_filter(filter);

    for (var j = 0, m = this.length; j < m; j++) {

      subgroups.push(subgroup = []);

      subgroup.parentNode = (group = this[j]).parentNode;

      for (var i = 0, n = group.length; i < n; i++) {

        if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {

          subgroup.push(node);