{"version":3,"sources":["webpack:///./node_modules/d3-force/src/jiggle.js","webpack:///./node_modules/d3-dispatch/src/dispatch.js","webpack:///./node_modules/d3-timer/src/timer.js","webpack:///./node_modules/d3-force/src/lcg.js","webpack:///./node_modules/d3-force/src/simulation.js","webpack:///./node_modules/d3-force/src/manyBody.js","webpack:///./node_modules/d3-force/src/x.js","webpack:///./node_modules/d3-force/src/collide.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/d3-force/src/constant.js","webpack:///./node_modules/d3-quadtree/src/add.js","webpack:///./node_modules/d3-quadtree/src/cover.js","webpack:///./node_modules/d3-quadtree/src/data.js","webpack:///./node_modules/d3-quadtree/src/extent.js","webpack:///./node_modules/d3-quadtree/src/quad.js","webpack:///./node_modules/d3-quadtree/src/find.js","webpack:///./node_modules/d3-quadtree/src/remove.js","webpack:///./node_modules/d3-quadtree/src/root.js","webpack:///./node_modules/d3-quadtree/src/size.js","webpack:///./node_modules/d3-quadtree/src/visit.js","webpack:///./node_modules/d3-quadtree/src/visitAfter.js","webpack:///./node_modules/d3-quadtree/src/x.js","webpack:///./node_modules/d3-quadtree/src/y.js","webpack:///./node_modules/d3-quadtree/src/quadtree.js","webpack:///./node_modules/d3-force/src/y.js","webpack:///./node_modules/d3-force/src/link.js"],"names":["random","noop","value","dispatch","t","i","n","arguments","length","_","test","Error","Dispatch","this","parseTypenames","typenames","types","trim","split","map","name","indexOf","slice","hasOwnProperty","type","get","c","set","callback","concat","push","prototype","constructor","on","typename","T","copy","call","that","args","Array","apply","taskHead","taskTail","timeout","interval","pokeDelay","clockLast","clockNow","clockSkew","clock","performance","now","Date","setFrame","window","requestAnimationFrame","bind","f","setTimeout","clearNow","Timer","_call","_time","_next","timer","delay","time","restart","timerFlush","e","undefined","wake","nap","poke","t0","t2","t1","Infinity","sleep","clearTimeout","clearInterval","setInterval","TypeError","stop","a","m","s","x","d","y","initialRadius","initialAngle","Math","PI","sqrt","simulation","alpha","alphaMin","alphaDecay","pow","alphaTarget","velocityDecay","forces","Map","stepper","step","event","lcg","tick","iterations","node","nodes","k","forEach","force","fx","vx","fy","vy","initializeNodes","index","isNaN","radius","angle","cos","sin","initializeForce","initialize","randomSource","delete","find","dx","dy","d2","closest","strengths","strength","distanceMin2","distanceMax2","theta2","tree","visitAfter","accumulate","visit","quad","q","weight","abs","data","next","x1","x2","w","l","_nodes","_random","distanceMin","distanceMax","theta","xz","radii","xi","yi","ri","ri2","prepare","x0","y0","y1","rj","r","extendStatics","b","Object","setPrototypeOf","__proto__","p","__extends","String","__","create","__assign","assign","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","rejected","result","done","then","__generator","body","label","sent","trys","ops","g","Iterator","verb","Symbol","iterator","v","op","pop","__values","o","__read","ar","error","__spread","SuppressedError","_x","_y","cover","parent","xm","ym","xp","yp","right","bottom","j","_root","leaf","_x0","_y0","_x1","_y1","addAll","yz","floor","z","y2","x3","y3","quads","retainer","previous","removeAll","remove","size","child","defaultX","defaultY","quadtree","Quadtree","NaN","leaf_copy","treeProto","source","target","add","extent","root","nodeById","nodeId","distances","count","bias","id","defaultStrength","distance","link","min","links","initializeStrength","initializeDistance"],"mappings":"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","file":"js/chunk-646997b4.c78dc10d.js","sourcesContent":["export default function(random) {\n  return (random() - 0.5) * 1e-6;\n}\n","var noop = {value: () => {}};\n\nfunction dispatch() {\n  for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {\n    if (!(t = arguments[i] + \"\") || (t in _) || /[\\s.]/.test(t)) throw new Error(\"illegal type: \" + t);\n    _[t] = [];\n  }\n  return new Dispatch(_);\n}\n\nfunction Dispatch(_) {\n  this._ = _;\n}\n\nfunction parseTypenames(typenames, types) {\n  return typenames.trim().split(/^|\\s+/).map(function(t) {\n    var name = \"\", i = t.indexOf(\".\");\n    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n    if (t && !types.hasOwnProperty(t)) throw new Error(\"unknown type: \" + t);\n    return {type: t, name: name};\n  });\n}\n\nDispatch.prototype = dispatch.prototype = {\n  constructor: Dispatch,\n  on: function(typename, callback) {\n    var _ = this._,\n        T = parseTypenames(typename + \"\", _),\n        t,\n        i = -1,\n        n = T.length;\n\n    // If no callback was specified, return the callback of the given type and name.\n    if (arguments.length < 2) {\n      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;\n      return;\n    }\n\n    // If a type was specified, set the callback for the given type and name.\n    // Otherwise, if a null callback was specified, remove callbacks of the given name.\n    if (callback != null && typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n    while (++i < n) {\n      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);\n      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);\n    }\n\n    return this;\n  },\n  copy: function() {\n    var copy = {}, _ = this._;\n    for (var t in _) copy[t] = _[t].slice();\n    return new Dispatch(copy);\n  },\n  call: function(type, that) {\n    if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];\n    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n    for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n  },\n  apply: function(type, that, args) {\n    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n    for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n  }\n};\n\nfunction get(type, name) {\n  for (var i = 0, n = type.length, c; i < n; ++i) {\n    if ((c = type[i]).name === name) {\n      return c.value;\n    }\n  }\n}\n\nfunction set(type, name, callback) {\n  for (var i = 0, n = type.length; i < n; ++i) {\n    if (type[i].name === name) {\n      type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));\n      break;\n    }\n  }\n  if (callback != null) type.push({name: name, value: callback});\n  return type;\n}\n\nexport default dispatch;\n","var frame = 0, // is an animation frame pending?\n    timeout = 0, // is a timeout pending?\n    interval = 0, // are any timers active?\n    pokeDelay = 1000, // how frequently we check for clock skew\n    taskHead,\n    taskTail,\n    clockLast = 0,\n    clockNow = 0,\n    clockSkew = 0,\n    clock = typeof performance === \"object\" && performance.now ? performance : Date,\n    setFrame = typeof window === \"object\" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); };\n\nexport function now() {\n  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);\n}\n\nfunction clearNow() {\n  clockNow = 0;\n}\n\nexport function Timer() {\n  this._call =\n  this._time =\n  this._next = null;\n}\n\nTimer.prototype = timer.prototype = {\n  constructor: Timer,\n  restart: function(callback, delay, time) {\n    if (typeof callback !== \"function\") throw new TypeError(\"callback is not a function\");\n    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);\n    if (!this._next && taskTail !== this) {\n      if (taskTail) taskTail._next = this;\n      else taskHead = this;\n      taskTail = this;\n    }\n    this._call = callback;\n    this._time = time;\n    sleep();\n  },\n  stop: function() {\n    if (this._call) {\n      this._call = null;\n      this._time = Infinity;\n      sleep();\n    }\n  }\n};\n\nexport function timer(callback, delay, time) {\n  var t = new Timer;\n  t.restart(callback, delay, time);\n  return t;\n}\n\nexport function timerFlush() {\n  now(); // Get the current time, if not already set.\n  ++frame; // Pretend we’ve set an alarm, if we haven’t already.\n  var t = taskHead, e;\n  while (t) {\n    if ((e = clockNow - t._time) >= 0) t._call.call(undefined, e);\n    t = t._next;\n  }\n  --frame;\n}\n\nfunction wake() {\n  clockNow = (clockLast = clock.now()) + clockSkew;\n  frame = timeout = 0;\n  try {\n    timerFlush();\n  } finally {\n    frame = 0;\n    nap();\n    clockNow = 0;\n  }\n}\n\nfunction poke() {\n  var now = clock.now(), delay = now - clockLast;\n  if (delay > pokeDelay) clockSkew -= delay, clockLast = now;\n}\n\nfunction nap() {\n  var t0, t1 = taskHead, t2, time = Infinity;\n  while (t1) {\n    if (t1._call) {\n      if (time > t1._time) time = t1._time;\n      t0 = t1, t1 = t1._next;\n    } else {\n      t2 = t1._next, t1._next = null;\n      t1 = t0 ? t0._next = t2 : taskHead = t2;\n    }\n  }\n  taskTail = t0;\n  sleep(time);\n}\n\nfunction sleep(time) {\n  if (frame) return; // Soonest alarm already set, or will be.\n  if (timeout) timeout = clearTimeout(timeout);\n  var delay = time - clockNow; // Strictly less than if we recomputed clockNow.\n  if (delay > 24) {\n    if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);\n    if (interval) interval = clearInterval(interval);\n  } else {\n    if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);\n    frame = 1, setFrame(wake);\n  }\n}\n","// https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use\nconst a = 1664525;\nconst c = 1013904223;\nconst m = 4294967296; // 2^32\n\nexport default function() {\n  let s = 1;\n  return () => (s = (a * s + c) % m) / m;\n}\n","import {dispatch} from \"d3-dispatch\";\nimport {timer} from \"d3-timer\";\nimport lcg from \"./lcg.js\";\n\nexport function x(d) {\n  return d.x;\n}\n\nexport function y(d) {\n  return d.y;\n}\n\nvar initialRadius = 10,\n    initialAngle = Math.PI * (3 - Math.sqrt(5));\n\nexport default function(nodes) {\n  var simulation,\n      alpha = 1,\n      alphaMin = 0.001,\n      alphaDecay = 1 - Math.pow(alphaMin, 1 / 300),\n      alphaTarget = 0,\n      velocityDecay = 0.6,\n      forces = new Map(),\n      stepper = timer(step),\n      event = dispatch(\"tick\", \"end\"),\n      random = lcg();\n\n  if (nodes == null) nodes = [];\n\n  function step() {\n    tick();\n    event.call(\"tick\", simulation);\n    if (alpha < alphaMin) {\n      stepper.stop();\n      event.call(\"end\", simulation);\n    }\n  }\n\n  function tick(iterations) {\n    var i, n = nodes.length, node;\n\n    if (iterations === undefined) iterations = 1;\n\n    for (var k = 0; k < iterations; ++k) {\n      alpha += (alphaTarget - alpha) * alphaDecay;\n\n      forces.forEach(function(force) {\n        force(alpha);\n      });\n\n      for (i = 0; i < n; ++i) {\n        node = nodes[i];\n        if (node.fx == null) node.x += node.vx *= velocityDecay;\n        else node.x = node.fx, node.vx = 0;\n        if (node.fy == null) node.y += node.vy *= velocityDecay;\n        else node.y = node.fy, node.vy = 0;\n      }\n    }\n\n    return simulation;\n  }\n\n  function initializeNodes() {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.index = i;\n      if (node.fx != null) node.x = node.fx;\n      if (node.fy != null) node.y = node.fy;\n      if (isNaN(node.x) || isNaN(node.y)) {\n        var radius = initialRadius * Math.sqrt(0.5 + i), angle = i * initialAngle;\n        node.x = radius * Math.cos(angle);\n        node.y = radius * Math.sin(angle);\n      }\n      if (isNaN(node.vx) || isNaN(node.vy)) {\n        node.vx = node.vy = 0;\n      }\n    }\n  }\n\n  function initializeForce(force) {\n    if (force.initialize) force.initialize(nodes, random);\n    return force;\n  }\n\n  initializeNodes();\n\n  return simulation = {\n    tick: tick,\n\n    restart: function() {\n      return stepper.restart(step), simulation;\n    },\n\n    stop: function() {\n      return stepper.stop(), simulation;\n    },\n\n    nodes: function(_) {\n      return arguments.length ? (nodes = _, initializeNodes(), forces.forEach(initializeForce), simulation) : nodes;\n    },\n\n    alpha: function(_) {\n      return arguments.length ? (alpha = +_, simulation) : alpha;\n    },\n\n    alphaMin: function(_) {\n      return arguments.length ? (alphaMin = +_, simulation) : alphaMin;\n    },\n\n    alphaDecay: function(_) {\n      return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;\n    },\n\n    alphaTarget: function(_) {\n      return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;\n    },\n\n    velocityDecay: function(_) {\n      return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;\n    },\n\n    randomSource: function(_) {\n      return arguments.length ? (random = _, forces.forEach(initializeForce), simulation) : random;\n    },\n\n    force: function(name, _) {\n      return arguments.length > 1 ? ((_ == null ? forces.delete(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name);\n    },\n\n    find: function(x, y, radius) {\n      var i = 0,\n          n = nodes.length,\n          dx,\n          dy,\n          d2,\n          node,\n          closest;\n\n      if (radius == null) radius = Infinity;\n      else radius *= radius;\n\n      for (i = 0; i < n; ++i) {\n        node = nodes[i];\n        dx = x - node.x;\n        dy = y - node.y;\n        d2 = dx * dx + dy * dy;\n        if (d2 < radius) closest = node, radius = d2;\n      }\n\n      return closest;\n    },\n\n    on: function(name, _) {\n      return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);\n    }\n  };\n}\n","import {quadtree} from \"d3-quadtree\";\nimport constant from \"./constant.js\";\nimport jiggle from \"./jiggle.js\";\nimport {x, y} from \"./simulation.js\";\n\nexport default function() {\n  var nodes,\n      node,\n      random,\n      alpha,\n      strength = constant(-30),\n      strengths,\n      distanceMin2 = 1,\n      distanceMax2 = Infinity,\n      theta2 = 0.81;\n\n  function force(_) {\n    var i, n = nodes.length, tree = quadtree(nodes, x, y).visitAfter(accumulate);\n    for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length, node;\n    strengths = new Array(n);\n    for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes);\n  }\n\n  function accumulate(quad) {\n    var strength = 0, q, c, weight = 0, x, y, i;\n\n    // For internal nodes, accumulate forces from child quadrants.\n    if (quad.length) {\n      for (x = y = i = 0; i < 4; ++i) {\n        if ((q = quad[i]) && (c = Math.abs(q.value))) {\n          strength += q.value, weight += c, x += c * q.x, y += c * q.y;\n        }\n      }\n      quad.x = x / weight;\n      quad.y = y / weight;\n    }\n\n    // For leaf nodes, accumulate forces from coincident quadrants.\n    else {\n      q = quad;\n      q.x = q.data.x;\n      q.y = q.data.y;\n      do strength += strengths[q.data.index];\n      while (q = q.next);\n    }\n\n    quad.value = strength;\n  }\n\n  function apply(quad, x1, _, x2) {\n    if (!quad.value) return true;\n\n    var x = quad.x - node.x,\n        y = quad.y - node.y,\n        w = x2 - x1,\n        l = x * x + y * y;\n\n    // Apply the Barnes-Hut approximation if possible.\n    // Limit forces for very close nodes; randomize direction if coincident.\n    if (w * w / theta2 < l) {\n      if (l < distanceMax2) {\n        if (x === 0) x = jiggle(random), l += x * x;\n        if (y === 0) y = jiggle(random), l += y * y;\n        if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n        node.vx += x * quad.value * alpha / l;\n        node.vy += y * quad.value * alpha / l;\n      }\n      return true;\n    }\n\n    // Otherwise, process points directly.\n    else if (quad.length || l >= distanceMax2) return;\n\n    // Limit forces for very close nodes; randomize direction if coincident.\n    if (quad.data !== node || quad.next) {\n      if (x === 0) x = jiggle(random), l += x * x;\n      if (y === 0) y = jiggle(random), l += y * y;\n      if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n    }\n\n    do if (quad.data !== node) {\n      w = strengths[quad.data.index] * alpha / l;\n      node.vx += x * w;\n      node.vy += y * w;\n    } while (quad = quad.next);\n  }\n\n  force.initialize = function(_nodes, _random) {\n    nodes = _nodes;\n    random = _random;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant(+_), initialize(), force) : strength;\n  };\n\n  force.distanceMin = function(_) {\n    return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);\n  };\n\n  force.distanceMax = function(_) {\n    return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);\n  };\n\n  force.theta = function(_) {\n    return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);\n  };\n\n  return force;\n}\n","import constant from \"./constant.js\";\n\nexport default function(x) {\n  var strength = constant(0.1),\n      nodes,\n      strengths,\n      xz;\n\n  if (typeof x !== \"function\") x = constant(x == null ? 0 : +x);\n\n  function force(alpha) {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length;\n    strengths = new Array(n);\n    xz = new Array(n);\n    for (i = 0; i < n; ++i) {\n      strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant(+_), initialize(), force) : strength;\n  };\n\n  force.x = function(_) {\n    return arguments.length ? (x = typeof _ === \"function\" ? _ : constant(+_), initialize(), force) : x;\n  };\n\n  return force;\n}\n","import {quadtree} from \"d3-quadtree\";\nimport constant from \"./constant.js\";\nimport jiggle from \"./jiggle.js\";\n\nfunction x(d) {\n  return d.x + d.vx;\n}\n\nfunction y(d) {\n  return d.y + d.vy;\n}\n\nexport default function(radius) {\n  var nodes,\n      radii,\n      random,\n      strength = 1,\n      iterations = 1;\n\n  if (typeof radius !== \"function\") radius = constant(radius == null ? 1 : +radius);\n\n  function force() {\n    var i, n = nodes.length,\n        tree,\n        node,\n        xi,\n        yi,\n        ri,\n        ri2;\n\n    for (var k = 0; k < iterations; ++k) {\n      tree = quadtree(nodes, x, y).visitAfter(prepare);\n      for (i = 0; i < n; ++i) {\n        node = nodes[i];\n        ri = radii[node.index], ri2 = ri * ri;\n        xi = node.x + node.vx;\n        yi = node.y + node.vy;\n        tree.visit(apply);\n      }\n    }\n\n    function apply(quad, x0, y0, x1, y1) {\n      var data = quad.data, rj = quad.r, r = ri + rj;\n      if (data) {\n        if (data.index > node.index) {\n          var x = xi - data.x - data.vx,\n              y = yi - data.y - data.vy,\n              l = x * x + y * y;\n          if (l < r * r) {\n            if (x === 0) x = jiggle(random), l += x * x;\n            if (y === 0) y = jiggle(random), l += y * y;\n            l = (r - (l = Math.sqrt(l))) / l * strength;\n            node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj));\n            node.vy += (y *= l) * r;\n            data.vx -= x * (r = 1 - r);\n            data.vy -= y * r;\n          }\n        }\n        return;\n      }\n      return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;\n    }\n  }\n\n  function prepare(quad) {\n    if (quad.data) return quad.r = radii[quad.data.index];\n    for (var i = quad.r = 0; i < 4; ++i) {\n      if (quad[i] && quad[i].r > quad.r) {\n        quad.r = quad[i].r;\n      }\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length, node;\n    radii = new Array(n);\n    for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);\n  }\n\n  force.initialize = function(_nodes, _random) {\n    nodes = _nodes;\n    random = _random;\n    initialize();\n  };\n\n  force.iterations = function(_) {\n    return arguments.length ? (iterations = +_, force) : iterations;\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = +_, force) : strength;\n  };\n\n  force.radius = function(_) {\n    return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant(+_), initialize(), force) : radius;\n  };\n\n  return force;\n}\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n","export default function(x) {\n  return function() {\n    return x;\n  };\n}\n","export default function(d) {\n  const x = +this._x.call(null, d),\n      y = +this._y.call(null, d);\n  return add(this.cover(x, y), x, y, d);\n}\n\nfunction add(tree, x, y, d) {\n  if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points\n\n  var parent,\n      node = tree._root,\n      leaf = {data: d},\n      x0 = tree._x0,\n      y0 = tree._y0,\n      x1 = tree._x1,\n      y1 = tree._y1,\n      xm,\n      ym,\n      xp,\n      yp,\n      right,\n      bottom,\n      i,\n      j;\n\n  // If the tree is empty, initialize the root as a leaf.\n  if (!node) return tree._root = leaf, tree;\n\n  // Find the existing leaf for the new point, or add it.\n  while (node.length) {\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n    if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;\n  }\n\n  // Is the new point is exactly coincident with the existing point?\n  xp = +tree._x.call(null, node.data);\n  yp = +tree._y.call(null, node.data);\n  if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;\n\n  // Otherwise, split the leaf node until the old and new point are separated.\n  do {\n    parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n  } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm)));\n  return parent[j] = node, parent[i] = leaf, tree;\n}\n\nexport function addAll(data) {\n  var d, i, n = data.length,\n      x,\n      y,\n      xz = new Array(n),\n      yz = new Array(n),\n      x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n\n  // Compute the points and their extent.\n  for (i = 0; i < n; ++i) {\n    if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue;\n    xz[i] = x;\n    yz[i] = y;\n    if (x < x0) x0 = x;\n    if (x > x1) x1 = x;\n    if (y < y0) y0 = y;\n    if (y > y1) y1 = y;\n  }\n\n  // If there were no (valid) points, abort.\n  if (x0 > x1 || y0 > y1) return this;\n\n  // Expand the tree to cover the new points.\n  this.cover(x0, y0).cover(x1, y1);\n\n  // Add the new points.\n  for (i = 0; i < n; ++i) {\n    add(this, xz[i], yz[i], data[i]);\n  }\n\n  return this;\n}\n","export default function(x, y) {\n  if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points\n\n  var x0 = this._x0,\n      y0 = this._y0,\n      x1 = this._x1,\n      y1 = this._y1;\n\n  // If the quadtree has no extent, initialize them.\n  // Integer extent are necessary so that if we later double the extent,\n  // the existing quadrant boundaries don’t change due to floating point error!\n  if (isNaN(x0)) {\n    x1 = (x0 = Math.floor(x)) + 1;\n    y1 = (y0 = Math.floor(y)) + 1;\n  }\n\n  // Otherwise, double repeatedly to cover.\n  else {\n    var z = x1 - x0 || 1,\n        node = this._root,\n        parent,\n        i;\n\n    while (x0 > x || x >= x1 || y0 > y || y >= y1) {\n      i = (y < y0) << 1 | (x < x0);\n      parent = new Array(4), parent[i] = node, node = parent, z *= 2;\n      switch (i) {\n        case 0: x1 = x0 + z, y1 = y0 + z; break;\n        case 1: x0 = x1 - z, y1 = y0 + z; break;\n        case 2: x1 = x0 + z, y0 = y1 - z; break;\n        case 3: x0 = x1 - z, y0 = y1 - z; break;\n      }\n    }\n\n    if (this._root && this._root.length) this._root = node;\n  }\n\n  this._x0 = x0;\n  this._y0 = y0;\n  this._x1 = x1;\n  this._y1 = y1;\n  return this;\n}\n","export default function() {\n  var data = [];\n  this.visit(function(node) {\n    if (!node.length) do data.push(node.data); while (node = node.next)\n  });\n  return data;\n}\n","export default function(_) {\n  return arguments.length\n      ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1])\n      : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]];\n}\n","export default function(node, x0, y0, x1, y1) {\n  this.node = node;\n  this.x0 = x0;\n  this.y0 = y0;\n  this.x1 = x1;\n  this.y1 = y1;\n}\n","import Quad from \"./quad.js\";\n\nexport default function(x, y, radius) {\n  var data,\n      x0 = this._x0,\n      y0 = this._y0,\n      x1,\n      y1,\n      x2,\n      y2,\n      x3 = this._x1,\n      y3 = this._y1,\n      quads = [],\n      node = this._root,\n      q,\n      i;\n\n  if (node) quads.push(new Quad(node, x0, y0, x3, y3));\n  if (radius == null) radius = Infinity;\n  else {\n    x0 = x - radius, y0 = y - radius;\n    x3 = x + radius, y3 = y + radius;\n    radius *= radius;\n  }\n\n  while (q = quads.pop()) {\n\n    // Stop searching if this quadrant can’t contain a closer node.\n    if (!(node = q.node)\n        || (x1 = q.x0) > x3\n        || (y1 = q.y0) > y3\n        || (x2 = q.x1) < x0\n        || (y2 = q.y1) < y0) continue;\n\n    // Bisect the current quadrant.\n    if (node.length) {\n      var xm = (x1 + x2) / 2,\n          ym = (y1 + y2) / 2;\n\n      quads.push(\n        new Quad(node[3], xm, ym, x2, y2),\n        new Quad(node[2], x1, ym, xm, y2),\n        new Quad(node[1], xm, y1, x2, ym),\n        new Quad(node[0], x1, y1, xm, ym)\n      );\n\n      // Visit the closest quadrant first.\n      if (i = (y >= ym) << 1 | (x >= xm)) {\n        q = quads[quads.length - 1];\n        quads[quads.length - 1] = quads[quads.length - 1 - i];\n        quads[quads.length - 1 - i] = q;\n      }\n    }\n\n    // Visit this point. (Visiting coincident points isn’t necessary!)\n    else {\n      var dx = x - +this._x.call(null, node.data),\n          dy = y - +this._y.call(null, node.data),\n          d2 = dx * dx + dy * dy;\n      if (d2 < radius) {\n        var d = Math.sqrt(radius = d2);\n        x0 = x - d, y0 = y - d;\n        x3 = x + d, y3 = y + d;\n        data = node.data;\n      }\n    }\n  }\n\n  return data;\n}\n","export default function(d) {\n  if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points\n\n  var parent,\n      node = this._root,\n      retainer,\n      previous,\n      next,\n      x0 = this._x0,\n      y0 = this._y0,\n      x1 = this._x1,\n      y1 = this._y1,\n      x,\n      y,\n      xm,\n      ym,\n      right,\n      bottom,\n      i,\n      j;\n\n  // If the tree is empty, initialize the root as a leaf.\n  if (!node) return this;\n\n  // Find the leaf node for the point.\n  // While descending, also retain the deepest parent with a non-removed sibling.\n  if (node.length) while (true) {\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n    if (!(parent = node, node = node[i = bottom << 1 | right])) return this;\n    if (!node.length) break;\n    if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i;\n  }\n\n  // Find the point to remove.\n  while (node.data !== d) if (!(previous = node, node = node.next)) return this;\n  if (next = node.next) delete node.next;\n\n  // If there are multiple coincident points, remove just the point.\n  if (previous) return (next ? previous.next = next : delete previous.next), this;\n\n  // If this is the root point, remove it.\n  if (!parent) return this._root = next, this;\n\n  // Remove this leaf.\n  next ? parent[i] = next : delete parent[i];\n\n  // If the parent now contains exactly one leaf, collapse superfluous parents.\n  if ((node = parent[0] || parent[1] || parent[2] || parent[3])\n      && node === (parent[3] || parent[2] || parent[1] || parent[0])\n      && !node.length) {\n    if (retainer) retainer[j] = node;\n    else this._root = node;\n  }\n\n  return this;\n}\n\nexport function removeAll(data) {\n  for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]);\n  return this;\n}\n","export default function() {\n  return this._root;\n}\n","export default function() {\n  var size = 0;\n  this.visit(function(node) {\n    if (!node.length) do ++size; while (node = node.next)\n  });\n  return size;\n}\n","import Quad from \"./quad.js\";\n\nexport default function(callback) {\n  var quads = [], q, node = this._root, child, x0, y0, x1, y1;\n  if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1));\n  while (q = quads.pop()) {\n    if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {\n      var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n      if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n      if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n      if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n      if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n    }\n  }\n  return this;\n}\n","import Quad from \"./quad.js\";\n\nexport default function(callback) {\n  var quads = [], next = [], q;\n  if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1));\n  while (q = quads.pop()) {\n    var node = q.node;\n    if (node.length) {\n      var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n      if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n      if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n      if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n      if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n    }\n    next.push(q);\n  }\n  while (q = next.pop()) {\n    callback(q.node, q.x0, q.y0, q.x1, q.y1);\n  }\n  return this;\n}\n","export function defaultX(d) {\n  return d[0];\n}\n\nexport default function(_) {\n  return arguments.length ? (this._x = _, this) : this._x;\n}\n","export function defaultY(d) {\n  return d[1];\n}\n\nexport default function(_) {\n  return arguments.length ? (this._y = _, this) : this._y;\n}\n","import tree_add, {addAll as tree_addAll} from \"./add.js\";\nimport tree_cover from \"./cover.js\";\nimport tree_data from \"./data.js\";\nimport tree_extent from \"./extent.js\";\nimport tree_find from \"./find.js\";\nimport tree_remove, {removeAll as tree_removeAll} from \"./remove.js\";\nimport tree_root from \"./root.js\";\nimport tree_size from \"./size.js\";\nimport tree_visit from \"./visit.js\";\nimport tree_visitAfter from \"./visitAfter.js\";\nimport tree_x, {defaultX} from \"./x.js\";\nimport tree_y, {defaultY} from \"./y.js\";\n\nexport default function quadtree(nodes, x, y) {\n  var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN);\n  return nodes == null ? tree : tree.addAll(nodes);\n}\n\nfunction Quadtree(x, y, x0, y0, x1, y1) {\n  this._x = x;\n  this._y = y;\n  this._x0 = x0;\n  this._y0 = y0;\n  this._x1 = x1;\n  this._y1 = y1;\n  this._root = undefined;\n}\n\nfunction leaf_copy(leaf) {\n  var copy = {data: leaf.data}, next = copy;\n  while (leaf = leaf.next) next = next.next = {data: leaf.data};\n  return copy;\n}\n\nvar treeProto = quadtree.prototype = Quadtree.prototype;\n\ntreeProto.copy = function() {\n  var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1),\n      node = this._root,\n      nodes,\n      child;\n\n  if (!node) return copy;\n\n  if (!node.length) return copy._root = leaf_copy(node), copy;\n\n  nodes = [{source: node, target: copy._root = new Array(4)}];\n  while (node = nodes.pop()) {\n    for (var i = 0; i < 4; ++i) {\n      if (child = node.source[i]) {\n        if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)});\n        else node.target[i] = leaf_copy(child);\n      }\n    }\n  }\n\n  return copy;\n};\n\ntreeProto.add = tree_add;\ntreeProto.addAll = tree_addAll;\ntreeProto.cover = tree_cover;\ntreeProto.data = tree_data;\ntreeProto.extent = tree_extent;\ntreeProto.find = tree_find;\ntreeProto.remove = tree_remove;\ntreeProto.removeAll = tree_removeAll;\ntreeProto.root = tree_root;\ntreeProto.size = tree_size;\ntreeProto.visit = tree_visit;\ntreeProto.visitAfter = tree_visitAfter;\ntreeProto.x = tree_x;\ntreeProto.y = tree_y;\n","import constant from \"./constant.js\";\n\nexport default function(y) {\n  var strength = constant(0.1),\n      nodes,\n      strengths,\n      yz;\n\n  if (typeof y !== \"function\") y = constant(y == null ? 0 : +y);\n\n  function force(alpha) {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length;\n    strengths = new Array(n);\n    yz = new Array(n);\n    for (i = 0; i < n; ++i) {\n      strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant(+_), initialize(), force) : strength;\n  };\n\n  force.y = function(_) {\n    return arguments.length ? (y = typeof _ === \"function\" ? _ : constant(+_), initialize(), force) : y;\n  };\n\n  return force;\n}\n","import constant from \"./constant.js\";\nimport jiggle from \"./jiggle.js\";\n\nfunction index(d) {\n  return d.index;\n}\n\nfunction find(nodeById, nodeId) {\n  var node = nodeById.get(nodeId);\n  if (!node) throw new Error(\"node not found: \" + nodeId);\n  return node;\n}\n\nexport default function(links) {\n  var id = index,\n      strength = defaultStrength,\n      strengths,\n      distance = constant(30),\n      distances,\n      nodes,\n      count,\n      bias,\n      random,\n      iterations = 1;\n\n  if (links == null) links = [];\n\n  function defaultStrength(link) {\n    return 1 / Math.min(count[link.source.index], count[link.target.index]);\n  }\n\n  function force(alpha) {\n    for (var k = 0, n = links.length; k < iterations; ++k) {\n      for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) {\n        link = links[i], source = link.source, target = link.target;\n        x = target.x + target.vx - source.x - source.vx || jiggle(random);\n        y = target.y + target.vy - source.y - source.vy || jiggle(random);\n        l = Math.sqrt(x * x + y * y);\n        l = (l - distances[i]) / l * alpha * strengths[i];\n        x *= l, y *= l;\n        target.vx -= x * (b = bias[i]);\n        target.vy -= y * b;\n        source.vx += x * (b = 1 - b);\n        source.vy += y * b;\n      }\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n\n    var i,\n        n = nodes.length,\n        m = links.length,\n        nodeById = new Map(nodes.map((d, i) => [id(d, i, nodes), d])),\n        link;\n\n    for (i = 0, count = new Array(n); i < m; ++i) {\n      link = links[i], link.index = i;\n      if (typeof link.source !== \"object\") link.source = find(nodeById, link.source);\n      if (typeof link.target !== \"object\") link.target = find(nodeById, link.target);\n      count[link.source.index] = (count[link.source.index] || 0) + 1;\n      count[link.target.index] = (count[link.target.index] || 0) + 1;\n    }\n\n    for (i = 0, bias = new Array(m); i < m; ++i) {\n      link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);\n    }\n\n    strengths = new Array(m), initializeStrength();\n    distances = new Array(m), initializeDistance();\n  }\n\n  function initializeStrength() {\n    if (!nodes) return;\n\n    for (var i = 0, n = links.length; i < n; ++i) {\n      strengths[i] = +strength(links[i], i, links);\n    }\n  }\n\n  function initializeDistance() {\n    if (!nodes) return;\n\n    for (var i = 0, n = links.length; i < n; ++i) {\n      distances[i] = +distance(links[i], i, links);\n    }\n  }\n\n  force.initialize = function(_nodes, _random) {\n    nodes = _nodes;\n    random = _random;\n    initialize();\n  };\n\n  force.links = function(_) {\n    return arguments.length ? (links = _, initialize(), force) : links;\n  };\n\n  force.id = function(_) {\n    return arguments.length ? (id = _, force) : id;\n  };\n\n  force.iterations = function(_) {\n    return arguments.length ? (iterations = +_, force) : iterations;\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant(+_), initializeStrength(), force) : strength;\n  };\n\n  force.distance = function(_) {\n    return arguments.length ? (distance = typeof _ === \"function\" ? _ : constant(+_), initializeDistance(), force) : distance;\n  };\n\n  return force;\n}\n"],"sourceRoot":""}