{

  "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

# 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) {

  };

  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;

  };

  };

  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;

    }

  };

      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;

  }

    }

    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];

  d3.selectAll = function(nodes) {

    var group;

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

      group = d3_array(d3_selectAll(nodes, d3_document));

      group.parentNode = d3_document.documentElement;

    } else {

      group.parentNode = null;

    }

    return d3_selection([ group ]);

  };

  d3_selectionPrototype.on = function(type, listener, capture) {

    var n = arguments.length;

    var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend");

    function drag() {

      this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);

    }

    function dragstart(id, position, subject, move, end) {

      return function() {

        if (origin) {

          dragOffset = origin.apply(that, arguments);

          dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ];

        } else {

          dragOffset = [ 0, 0 ];

        }

            dy: dy

          });

        }

        function ended() {

          if (!position(parent, dragId)) return;

          dragSubject.on(move + dragName, null).on(end + dragName, null);

          dispatch({

            type: "dragend"

          });

        }

      };

    }

  }

  function d3_haversin(x) {

    return (x = Math.sin(x / 2)) * x;

  }

  var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;

  d3.interpolateZoom = function(p0, p1) {

        return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ];

  };

  d3.behavior.zoom = function() {

    var view = {

      x: 0,

      y: 0,

      k: 1

    };

    zoom.scale = function(_) {

      if (!arguments.length) return view.k;

      view = {

        x: view.x,

        y: view.y,

      };

      rescale();

      return zoom;

    };

    zoom.scaleExtent = function(_) {

      if (!arguments.length) return scaleExtent;

      scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ];

    function zoomended(dispatch) {

      if (!--zooming) dispatch({

        type: "zoomend"

      }), center0 = null;

    }

    function mousedowned() {

      d3_selection_interrupt.call(that);

      zoomstarted(dispatch);

      function moved() {

        dragged = 1;

        translateTo(d3.mouse(that), location0);

        zoomed(dispatch);

      }

      function ended() {

        subject.on(mousemove, null).on(mouseup, null);

        zoomended(dispatch);

      }

    }

    function touchstarted() {

      var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that);

      started();

    return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);

  };

  function d3_rgb_hex(v) {

    return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);

  }

  function d3_rgb_parse(format, rgb, hsl) {

    var r = 0, g = 0, b = 0, m1, m2, color;

    if (m1) {

      m2 = m1[2].split(",");

      switch (m1[1]) {

       case "hsl":

        {

          return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);

      return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;

    }

    return dsv;

  };

  d3.csv = d3.dsv(",", "text/csv");

  d3.tsv = d3.dsv("	", "text/tab-separated-values");

    setTimeout(callback, 17);

  };

    var n = arguments.length;

    if (n < 2) delay = 0;

    if (n < 3) then = Date.now();

    var time = then + delay, timer = {

      c: callback,

      t: time,

      n: null

    };

    if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer;

    d3_timer_queueTail = timer;

    if (!d3_timer_interval) {

      d3_timer_timeout = clearTimeout(d3_timer_timeout);

      d3_timer_interval = 1;

      d3_timer_frame(d3_timer_step);

    }

  function d3_timer_step() {

    var now = d3_timer_mark(), delay = d3_timer_sweep() - now;

    if (delay > 24) {

      if (isFinite(delay)) {

        clearTimeout(d3_timer_timeout);

        d3_timer_timeout = setTimeout(d3_timer_step, delay);

  }

  d3.timer.flush = function() {

    d3_timer_mark();

    d3_timer_sweep();

  };

  function d3_timer_mark() {

    }

    return now;

  }

  function d3_timer_sweep() {

    var t0, t1 = d3_timer_queueHead, time = Infinity;

    while (t1) {

        if (t1.t < time) time = t1.t;

        t1 = (t0 = t1).n;

      }

    }

    d3_timer_queueTail = t0;

    return time;

  }

  function d3_format_precision(x, p) {

  d3.round = function(x, n) {

    return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);

  };

  var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);

  d3.formatPrefix = function(value, precision) {

    var i = 0;

      if (value < 0) value *= -1;

      if (precision) value = d3.round(value, d3_format_precision(value, precision));

      i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);

      i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3));

    }

    return d3_formatPrefixes[8 + i / 3];

          L: 0,

          Z: null

        }, i = d3_time_parse(d, template, string, 0);

        if (i != string.length) return null;

        if ("p" in d) d.H = d.H % 12 + d.p * 12;

        var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)();

          date.setFullYear(d.y, 0, 1);

          date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7);

        } else date.setFullYear(d.y, d.m, d.d);

        date.setHours(d.H + (d.Z / 100 | 0), d.M + d.Z % 100, d.S, d.L);

        return localZ ? date._ : date;

      };

          }

        }

        if (!j++) break;

        λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;

      }

    }

  }

  function d3_geo_clipCircle(radius) {

    var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);

    return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [ 0, -radius ] : [ -π, radius - π ]);

    function visible(λ, φ) {

      return Math.cos(λ) * Math.cos(φ) > cr;

    c: 0,

    d: 1,

    e: 0,

    f: 0

  };

  d3.interpolateTransform = d3_interpolateTransform;

      q.push({

        x: d3_interpolateNumber(ta[0], tb[0])

      }, {

        x: d3_interpolateNumber(ta[1], tb[1])

      });

    } else if (tb[0] || tb[1]) {

      s.push("translate(" + tb + ")");

      if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360;

      q.push({

        x: d3_interpolateNumber(ra, rb)

      });

    } else if (rb) {

      q.push({

        x: d3_interpolateNumber(wa, wb)

      });

    } else if (wb) {

      q.push({

        x: d3_interpolateNumber(ka[0], kb[0])

      }, {

        x: d3_interpolateNumber(ka[1], kb[1])

      });

    return function(t) {

      while (++i < n) s[(o = q[i]).i] = o.x(t);

      return s.join("");

    };

  }

  function d3_uninterpolateNumber(a, b) {

    b = (b -= a = +a) || 1 / b;

          };

        }

        groups[di] = {

          index: di,

          startAngle: x0,

          endAngle: x,

        };

        x += padding;

      }

      i = -1;

      while (++i < n) {

        j = i - 1;

      if (!groups) relayout();

      return groups;

    };

    return chord;

  };

  d3.layout.force = function() {

    function repulse(node) {

      return function(quad, x1, _, x2) {

        if (quad.point !== node) {

          var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy;

          if (dw * dw / theta2 < dn) {

            if (dn < chargeDistance2) {

        }

        return !quad.charge;

      };

    }

    force.tick = function() {

      if ((alpha *= .99) < .005) {

        event.end({

          type: "end",

          alpha: alpha = 0

        });

        return true;

      }

        x = t.x - s.x;

        y = t.y - s.y;

        if (l = x * x + y * y) {

          l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l;

          x *= l;

          y *= l;

          t.y -= y * k;

          s.x += x * (k = 1 - k);

          s.y += y * k;

        }

      }

      if (k = alpha * gravity) {

      return force;

    };

    force.alpha = function(x) {

      if (!arguments.length) return alpha;

      x = +x;

      if (alpha) {

      } else if (x > 0) {

        event.start({

          type: "start",

          alpha: alpha = x

        });

      }

      return force;

    };

    force.start = function() {

      var i, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o;

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

  };

  d3.layout.pie = function() {

    var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ, padAngle = 0;

    function pie(data) {

      var n = data.length, values = data.map(function(d, i) {

        return +value.call(pie, d, i);

      if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) {

        return values[j] - values[i];

      } : function(i, j) {

        return sort(data[i], data[j]);

      });

      index.forEach(function(i) {

        rect.x += v;

        rect.dx -= v;

      }

    }

    function treemap(d) {

      var nodes = stickies || hierarchy(d), root = nodes[0];

      if (stickies) hierarchy.revalue(root);

      scale([ root ], root.dx * root.dy / root.value);

      (stickies ? stickify : squarify)(root);

      if (sticky) stickies = nodes;

      return nodes;

    }

    return rescale();

  }

  function d3_scale_linearRebind(scale, linear) {

    return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp");

  }

  function d3_scale_linearNice(domain, m) {

  }

  function d3_scale_linearTickRange(domain, m) {

    if (m == null) m = 10;

    var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step;

    if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2;

    extent[0] = Math.ceil(extent[0] / step) * step;

      }

      return ticks;

    };

    scale.tickFormat = function(n, format) {

      if (!arguments.length) return d3_scale_logFormat;

      if (arguments.length < 2) format = d3_scale_logFormat; else if (typeof format !== "function") format = d3.format(format);

      return function(d) {

      };

    };

    scale.copy = function() {

      return d3_scale_log(linear.copy(), base, positive, domain);

    };

    return d3_scale_linearRebind(scale, linear);

          y2 = r0 * Math.sin(h0);

          x3 = y3 = null;

        }

      } else {

        x2 = y2 = 0;

      }

        cr = r0 < r1 ^ cw ? 0 : 1;

        if (x1 != null) {

          if (rc === rc1) {

            path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]);

          } else {

            path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);

          }

        } else {

          path.push("M", x0, ",", y0);

        }

        if (x3 != null) {

          if (rc === rc0) {

            path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);

          } else {

            path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);

          }

        } else {

    return d && d.padAngle;

  }

  function d3_svg_arcSweep(x0, y0, x1, y1) {

    return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1;

  }

  function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {

    if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;

    return [ [ cx0 - ox, cy0 - oy ], [ cx0 * r1 / r, cy0 * r1 / r ] ];

  }

  function d3_svg_line(projection) {

    var x = d3_geom_pointX, y = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = .7;

    function line(data) {

  });

  d3_svg_lineInterpolators.forEach(function(key, value) {

    value.key = key;

    value.closed = /-closed$/.test(key);

  });

  function d3_svg_lineLinear(points) {