@opendata-ai/openchart-vanilla 2.0.0

package/dist/simulation-worker.js

@@ -0,0 +1,1196 @@
+(() => {
+  var __create = Object.create;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  function __accessProp(key) {
+    return this[key];
+  }
+  var __toESMCache_node;
+  var __toESMCache_esm;
+  var __toESM = (mod, isNodeMode, target) => {
+    var canCache = mod != null && typeof mod === "object";
+    if (canCache) {
+      var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+      var cached = cache.get(mod);
+      if (cached)
+        return cached;
+    }
+    target = mod != null ? __create(__getProtoOf(mod)) : {};
+    const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+    if (canCache)
+      cache.set(mod, to);
+    return to;
+  };
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/center.js
+  function center_default(x, y) {
+    var nodes, strength = 1;
+    if (x == null)
+      x = 0;
+    if (y == null)
+      y = 0;
+    function force() {
+      var i, n = nodes.length, node, sx = 0, sy = 0;
+      for (i = 0;i < n; ++i) {
+        node = nodes[i], sx += node.x, sy += node.y;
+      }
+      for (sx = (sx / n - x) * strength, sy = (sy / n - y) * strength, i = 0;i < n; ++i) {
+        node = nodes[i], node.x -= sx, node.y -= sy;
+      }
+    }
+    force.initialize = function(_) {
+      nodes = _;
+    };
+    force.x = function(_) {
+      return arguments.length ? (x = +_, force) : x;
+    };
+    force.y = function(_) {
+      return arguments.length ? (y = +_, force) : y;
+    };
+    force.strength = function(_) {
+      return arguments.length ? (strength = +_, force) : strength;
+    };
+    return force;
+  }
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/add.js
+  function add_default(d) {
+    const x = +this._x.call(null, d), y = +this._y.call(null, d);
+    return add(this.cover(x, y), x, y, d);
+  }
+  function add(tree, x, y, d) {
+    if (isNaN(x) || isNaN(y))
+      return tree;
+    var parent, node = tree._root, leaf = { data: d }, x0 = tree._x0, y0 = tree._y0, x1 = tree._x1, y1 = tree._y1, xm, ym, xp, yp, right, bottom, i, j;
+    if (!node)
+      return tree._root = leaf, tree;
+    while (node.length) {
+      if (right = x >= (xm = (x0 + x1) / 2))
+        x0 = xm;
+      else
+        x1 = xm;
+      if (bottom = y >= (ym = (y0 + y1) / 2))
+        y0 = ym;
+      else
+        y1 = ym;
+      if (parent = node, !(node = node[i = bottom << 1 | right]))
+        return parent[i] = leaf, tree;
+    }
+    xp = +tree._x.call(null, node.data);
+    yp = +tree._y.call(null, node.data);
+    if (x === xp && y === yp)
+      return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;
+    do {
+      parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);
+      if (right = x >= (xm = (x0 + x1) / 2))
+        x0 = xm;
+      else
+        x1 = xm;
+      if (bottom = y >= (ym = (y0 + y1) / 2))
+        y0 = ym;
+      else
+        y1 = ym;
+    } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | xp >= xm));
+    return parent[j] = node, parent[i] = leaf, tree;
+  }
+  function addAll(data) {
+    var d, i, n = data.length, x, y, xz = new Array(n), yz = new Array(n), x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (i = 0;i < n; ++i) {
+      if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d)))
+        continue;
+      xz[i] = x;
+      yz[i] = y;
+      if (x < x0)
+        x0 = x;
+      if (x > x1)
+        x1 = x;
+      if (y < y0)
+        y0 = y;
+      if (y > y1)
+        y1 = y;
+    }
+    if (x0 > x1 || y0 > y1)
+      return this;
+    this.cover(x0, y0).cover(x1, y1);
+    for (i = 0;i < n; ++i) {
+      add(this, xz[i], yz[i], data[i]);
+    }
+    return this;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/cover.js
+  function cover_default(x, y) {
+    if (isNaN(x = +x) || isNaN(y = +y))
+      return this;
+    var x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1;
+    if (isNaN(x0)) {
+      x1 = (x0 = Math.floor(x)) + 1;
+      y1 = (y0 = Math.floor(y)) + 1;
+    } else {
+      var z = x1 - x0 || 1, node = this._root, parent, i;
+      while (x0 > x || x >= x1 || y0 > y || y >= y1) {
+        i = (y < y0) << 1 | x < x0;
+        parent = new Array(4), parent[i] = node, node = parent, z *= 2;
+        switch (i) {
+          case 0:
+            x1 = x0 + z, y1 = y0 + z;
+            break;
+          case 1:
+            x0 = x1 - z, y1 = y0 + z;
+            break;
+          case 2:
+            x1 = x0 + z, y0 = y1 - z;
+            break;
+          case 3:
+            x0 = x1 - z, y0 = y1 - z;
+            break;
+        }
+      }
+      if (this._root && this._root.length)
+        this._root = node;
+    }
+    this._x0 = x0;
+    this._y0 = y0;
+    this._x1 = x1;
+    this._y1 = y1;
+    return this;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/data.js
+  function data_default() {
+    var data = [];
+    this.visit(function(node) {
+      if (!node.length)
+        do
+          data.push(node.data);
+        while (node = node.next);
+    });
+    return data;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/extent.js
+  function extent_default(_) {
+    return arguments.length ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]];
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/quad.js
+  function quad_default(node, x0, y0, x1, y1) {
+    this.node = node;
+    this.x0 = x0;
+    this.y0 = y0;
+    this.x1 = x1;
+    this.y1 = y1;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/find.js
+  function find_default(x, y, radius) {
+    var data, x0 = this._x0, y0 = this._y0, x1, y1, x2, y2, x3 = this._x1, y3 = this._y1, quads = [], node = this._root, q, i;
+    if (node)
+      quads.push(new quad_default(node, x0, y0, x3, y3));
+    if (radius == null)
+      radius = Infinity;
+    else {
+      x0 = x - radius, y0 = y - radius;
+      x3 = x + radius, y3 = y + radius;
+      radius *= radius;
+    }
+    while (q = quads.pop()) {
+      if (!(node = q.node) || (x1 = q.x0) > x3 || (y1 = q.y0) > y3 || (x2 = q.x1) < x0 || (y2 = q.y1) < y0)
+        continue;
+      if (node.length) {
+        var xm = (x1 + x2) / 2, ym = (y1 + y2) / 2;
+        quads.push(new quad_default(node[3], xm, ym, x2, y2), new quad_default(node[2], x1, ym, xm, y2), new quad_default(node[1], xm, y1, x2, ym), new quad_default(node[0], x1, y1, xm, ym));
+        if (i = (y >= ym) << 1 | x >= xm) {
+          q = quads[quads.length - 1];
+          quads[quads.length - 1] = quads[quads.length - 1 - i];
+          quads[quads.length - 1 - i] = q;
+        }
+      } else {
+        var dx = x - +this._x.call(null, node.data), dy = y - +this._y.call(null, node.data), d2 = dx * dx + dy * dy;
+        if (d2 < radius) {
+          var d = Math.sqrt(radius = d2);
+          x0 = x - d, y0 = y - d;
+          x3 = x + d, y3 = y + d;
+          data = node.data;
+        }
+      }
+    }
+    return data;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/remove.js
+  function remove_default(d) {
+    if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d)))
+      return this;
+    var parent, node = this._root, retainer, previous, next, x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1, x, y, xm, ym, right, bottom, i, j;
+    if (!node)
+      return this;
+    if (node.length)
+      while (true) {
+        if (right = x >= (xm = (x0 + x1) / 2))
+          x0 = xm;
+        else
+          x1 = xm;
+        if (bottom = y >= (ym = (y0 + y1) / 2))
+          y0 = ym;
+        else
+          y1 = ym;
+        if (!(parent = node, node = node[i = bottom << 1 | right]))
+          return this;
+        if (!node.length)
+          break;
+        if (parent[i + 1 & 3] || parent[i + 2 & 3] || parent[i + 3 & 3])
+          retainer = parent, j = i;
+      }
+    while (node.data !== d)
+      if (!(previous = node, node = node.next))
+        return this;
+    if (next = node.next)
+      delete node.next;
+    if (previous)
+      return next ? previous.next = next : delete previous.next, this;
+    if (!parent)
+      return this._root = next, this;
+    next ? parent[i] = next : delete parent[i];
+    if ((node = parent[0] || parent[1] || parent[2] || parent[3]) && node === (parent[3] || parent[2] || parent[1] || parent[0]) && !node.length) {
+      if (retainer)
+        retainer[j] = node;
+      else
+        this._root = node;
+    }
+    return this;
+  }
+  function removeAll(data) {
+    for (var i = 0, n = data.length;i < n; ++i)
+      this.remove(data[i]);
+    return this;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/root.js
+  function root_default() {
+    return this._root;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/size.js
+  function size_default() {
+    var size = 0;
+    this.visit(function(node) {
+      if (!node.length)
+        do
+          ++size;
+        while (node = node.next);
+    });
+    return size;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/visit.js
+  function visit_default(callback) {
+    var quads = [], q, node = this._root, child, x0, y0, x1, y1;
+    if (node)
+      quads.push(new quad_default(node, this._x0, this._y0, this._x1, this._y1));
+    while (q = quads.pop()) {
+      if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {
+        var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+        if (child = node[3])
+          quads.push(new quad_default(child, xm, ym, x1, y1));
+        if (child = node[2])
+          quads.push(new quad_default(child, x0, ym, xm, y1));
+        if (child = node[1])
+          quads.push(new quad_default(child, xm, y0, x1, ym));
+        if (child = node[0])
+          quads.push(new quad_default(child, x0, y0, xm, ym));
+      }
+    }
+    return this;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/visitAfter.js
+  function visitAfter_default(callback) {
+    var quads = [], next = [], q;
+    if (this._root)
+      quads.push(new quad_default(this._root, this._x0, this._y0, this._x1, this._y1));
+    while (q = quads.pop()) {
+      var node = q.node;
+      if (node.length) {
+        var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+        if (child = node[0])
+          quads.push(new quad_default(child, x0, y0, xm, ym));
+        if (child = node[1])
+          quads.push(new quad_default(child, xm, y0, x1, ym));
+        if (child = node[2])
+          quads.push(new quad_default(child, x0, ym, xm, y1));
+        if (child = node[3])
+          quads.push(new quad_default(child, xm, ym, x1, y1));
+      }
+      next.push(q);
+    }
+    while (q = next.pop()) {
+      callback(q.node, q.x0, q.y0, q.x1, q.y1);
+    }
+    return this;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/x.js
+  function defaultX(d) {
+    return d[0];
+  }
+  function x_default(_) {
+    return arguments.length ? (this._x = _, this) : this._x;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/y.js
+  function defaultY(d) {
+    return d[1];
+  }
+  function y_default(_) {
+    return arguments.length ? (this._y = _, this) : this._y;
+  }
+
+  // ../../node_modules/.bun/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/quadtree.js
+  function quadtree(nodes, x, y) {
+    var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN);
+    return nodes == null ? tree : tree.addAll(nodes);
+  }
+  function Quadtree(x, y, x0, y0, x1, y1) {
+    this._x = x;
+    this._y = y;
+    this._x0 = x0;
+    this._y0 = y0;
+    this._x1 = x1;
+    this._y1 = y1;
+    this._root = undefined;
+  }
+  function leaf_copy(leaf) {
+    var copy = { data: leaf.data }, next = copy;
+    while (leaf = leaf.next)
+      next = next.next = { data: leaf.data };
+    return copy;
+  }
+  var treeProto = quadtree.prototype = Quadtree.prototype;
+  treeProto.copy = function() {
+    var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), node = this._root, nodes, child;
+    if (!node)
+      return copy;
+    if (!node.length)
+      return copy._root = leaf_copy(node), copy;
+    nodes = [{ source: node, target: copy._root = new Array(4) }];
+    while (node = nodes.pop()) {
+      for (var i = 0;i < 4; ++i) {
+        if (child = node.source[i]) {
+          if (child.length)
+            nodes.push({ source: child, target: node.target[i] = new Array(4) });
+          else
+            node.target[i] = leaf_copy(child);
+        }
+      }
+    }
+    return copy;
+  };
+  treeProto.add = add_default;
+  treeProto.addAll = addAll;
+  treeProto.cover = cover_default;
+  treeProto.data = data_default;
+  treeProto.extent = extent_default;
+  treeProto.find = find_default;
+  treeProto.remove = remove_default;
+  treeProto.removeAll = removeAll;
+  treeProto.root = root_default;
+  treeProto.size = size_default;
+  treeProto.visit = visit_default;
+  treeProto.visitAfter = visitAfter_default;
+  treeProto.x = x_default;
+  treeProto.y = y_default;
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/constant.js
+  function constant_default(x) {
+    return function() {
+      return x;
+    };
+  }
+
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/jiggle.js
+  function jiggle_default(random) {
+    return (random() - 0.5) * 0.000001;
+  }
+
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/collide.js
+  function x(d) {
+    return d.x + d.vx;
+  }
+  function y(d) {
+    return d.y + d.vy;
+  }
+  function collide_default(radius) {
+    var nodes, radii, random, strength = 1, iterations = 1;
+    if (typeof radius !== "function")
+      radius = constant_default(radius == null ? 1 : +radius);
+    function force() {
+      var i, n = nodes.length, tree, node, xi, yi, ri, ri2;
+      for (var k = 0;k < iterations; ++k) {
+        tree = quadtree(nodes, x, y).visitAfter(prepare);
+        for (i = 0;i < n; ++i) {
+          node = nodes[i];
+          ri = radii[node.index], ri2 = ri * ri;
+          xi = node.x + node.vx;
+          yi = node.y + node.vy;
+          tree.visit(apply);
+        }
+      }
+      function apply(quad, x0, y0, x1, y1) {
+        var { data, r: rj } = quad, r = ri + rj;
+        if (data) {
+          if (data.index > node.index) {
+            var x2 = xi - data.x - data.vx, y2 = yi - data.y - data.vy, l = x2 * x2 + y2 * y2;
+            if (l < r * r) {
+              if (x2 === 0)
+                x2 = jiggle_default(random), l += x2 * x2;
+              if (y2 === 0)
+                y2 = jiggle_default(random), l += y2 * y2;
+              l = (r - (l = Math.sqrt(l))) / l * strength;
+              node.vx += (x2 *= l) * (r = (rj *= rj) / (ri2 + rj));
+              node.vy += (y2 *= l) * r;
+              data.vx -= x2 * (r = 1 - r);
+              data.vy -= y2 * r;
+            }
+          }
+          return;
+        }
+        return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;
+      }
+    }
+    function prepare(quad) {
+      if (quad.data)
+        return quad.r = radii[quad.data.index];
+      for (var i = quad.r = 0;i < 4; ++i) {
+        if (quad[i] && quad[i].r > quad.r) {
+          quad.r = quad[i].r;
+        }
+      }
+    }
+    function initialize() {
+      if (!nodes)
+        return;
+      var i, n = nodes.length, node;
+      radii = new Array(n);
+      for (i = 0;i < n; ++i)
+        node = nodes[i], radii[node.index] = +radius(node, i, nodes);
+    }
+    force.initialize = function(_nodes, _random) {
+      nodes = _nodes;
+      random = _random;
+      initialize();
+    };
+    force.iterations = function(_) {
+      return arguments.length ? (iterations = +_, force) : iterations;
+    };
+    force.strength = function(_) {
+      return arguments.length ? (strength = +_, force) : strength;
+    };
+    force.radius = function(_) {
+      return arguments.length ? (radius = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : radius;
+    };
+    return force;
+  }
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/link.js
+  function index(d) {
+    return d.index;
+  }
+  function find(nodeById, nodeId) {
+    var node = nodeById.get(nodeId);
+    if (!node)
+      throw new Error("node not found: " + nodeId);
+    return node;
+  }
+  function link_default(links) {
+    var id = index, strength = defaultStrength, strengths, distance = constant_default(30), distances, nodes, count, bias, random, iterations = 1;
+    if (links == null)
+      links = [];
+    function defaultStrength(link) {
+      return 1 / Math.min(count[link.source.index], count[link.target.index]);
+    }
+    function force(alpha) {
+      for (var k = 0, n = links.length;k < iterations; ++k) {
+        for (var i = 0, link, source, target, x2, y2, l, b;i < n; ++i) {
+          link = links[i], source = link.source, target = link.target;
+          x2 = target.x + target.vx - source.x - source.vx || jiggle_default(random);
+          y2 = target.y + target.vy - source.y - source.vy || jiggle_default(random);
+          l = Math.sqrt(x2 * x2 + y2 * y2);
+          l = (l - distances[i]) / l * alpha * strengths[i];
+          x2 *= l, y2 *= l;
+          target.vx -= x2 * (b = bias[i]);
+          target.vy -= y2 * b;
+          source.vx += x2 * (b = 1 - b);
+          source.vy += y2 * b;
+        }
+      }
+    }
+    function initialize() {
+      if (!nodes)
+        return;
+      var i, n = nodes.length, m = links.length, nodeById = new Map(nodes.map((d, i2) => [id(d, i2, nodes), d])), link;
+      for (i = 0, count = new Array(n);i < m; ++i) {
+        link = links[i], link.index = i;
+        if (typeof link.source !== "object")
+          link.source = find(nodeById, link.source);
+        if (typeof link.target !== "object")
+          link.target = find(nodeById, link.target);
+        count[link.source.index] = (count[link.source.index] || 0) + 1;
+        count[link.target.index] = (count[link.target.index] || 0) + 1;
+      }
+      for (i = 0, bias = new Array(m);i < m; ++i) {
+        link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);
+      }
+      strengths = new Array(m), initializeStrength();
+      distances = new Array(m), initializeDistance();
+    }
+    function initializeStrength() {
+      if (!nodes)
+        return;
+      for (var i = 0, n = links.length;i < n; ++i) {
+        strengths[i] = +strength(links[i], i, links);
+      }
+    }
+    function initializeDistance() {
+      if (!nodes)
+        return;
+      for (var i = 0, n = links.length;i < n; ++i) {
+        distances[i] = +distance(links[i], i, links);
+      }
+    }
+    force.initialize = function(_nodes, _random) {
+      nodes = _nodes;
+      random = _random;
+      initialize();
+    };
+    force.links = function(_) {
+      return arguments.length ? (links = _, initialize(), force) : links;
+    };
+    force.id = function(_) {
+      return arguments.length ? (id = _, force) : id;
+    };
+    force.iterations = function(_) {
+      return arguments.length ? (iterations = +_, force) : iterations;
+    };
+    force.strength = function(_) {
+      return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initializeStrength(), force) : strength;
+    };
+    force.distance = function(_) {
+      return arguments.length ? (distance = typeof _ === "function" ? _ : constant_default(+_), initializeDistance(), force) : distance;
+    };
+    return force;
+  }
+  // ../../node_modules/.bun/d3-dispatch@3.0.1/node_modules/d3-dispatch/src/dispatch.js
+  var noop = { value: () => {} };
+  function dispatch() {
+    for (var i = 0, n = arguments.length, _ = {}, t;i < n; ++i) {
+      if (!(t = arguments[i] + "") || t in _ || /[\s.]/.test(t))
+        throw new Error("illegal type: " + t);
+      _[t] = [];
+    }
+    return new Dispatch(_);
+  }
+  function Dispatch(_) {
+    this._ = _;
+  }
+  function parseTypenames(typenames, types) {
+    return typenames.trim().split(/^|\s+/).map(function(t) {
+      var name = "", i = t.indexOf(".");
+      if (i >= 0)
+        name = t.slice(i + 1), t = t.slice(0, i);
+      if (t && !types.hasOwnProperty(t))
+        throw new Error("unknown type: " + t);
+      return { type: t, name };
+    });
+  }
+  Dispatch.prototype = dispatch.prototype = {
+    constructor: Dispatch,
+    on: function(typename, callback) {
+      var _ = this._, T = parseTypenames(typename + "", _), t, i = -1, n = T.length;
+      if (arguments.length < 2) {
+        while (++i < n)
+          if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name)))
+            return t;
+        return;
+      }
+      if (callback != null && typeof callback !== "function")
+        throw new Error("invalid callback: " + callback);
+      while (++i < n) {
+        if (t = (typename = T[i]).type)
+          _[t] = set(_[t], typename.name, callback);
+        else if (callback == null)
+          for (t in _)
+            _[t] = set(_[t], typename.name, null);
+      }
+      return this;
+    },
+    copy: function() {
+      var copy = {}, _ = this._;
+      for (var t in _)
+        copy[t] = _[t].slice();
+      return new Dispatch(copy);
+    },
+    call: function(type, that) {
+      if ((n = arguments.length - 2) > 0)
+        for (var args = new Array(n), i = 0, n, t;i < n; ++i)
+          args[i] = arguments[i + 2];
+      if (!this._.hasOwnProperty(type))
+        throw new Error("unknown type: " + type);
+      for (t = this._[type], i = 0, n = t.length;i < n; ++i)
+        t[i].value.apply(that, args);
+    },
+    apply: function(type, that, args) {
+      if (!this._.hasOwnProperty(type))
+        throw new Error("unknown type: " + type);
+      for (var t = this._[type], i = 0, n = t.length;i < n; ++i)
+        t[i].value.apply(that, args);
+    }
+  };
+  function get(type, name) {
+    for (var i = 0, n = type.length, c;i < n; ++i) {
+      if ((c = type[i]).name === name) {
+        return c.value;
+      }
+    }
+  }
+  function set(type, name, callback) {
+    for (var i = 0, n = type.length;i < n; ++i) {
+      if (type[i].name === name) {
+        type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
+        break;
+      }
+    }
+    if (callback != null)
+      type.push({ name, value: callback });
+    return type;
+  }
+  var dispatch_default = dispatch;
+  // ../../node_modules/.bun/d3-timer@3.0.1/node_modules/d3-timer/src/timer.js
+  var frame = 0;
+  var timeout = 0;
+  var interval = 0;
+  var pokeDelay = 1000;
+  var taskHead;
+  var taskTail;
+  var clockLast = 0;
+  var clockNow = 0;
+  var clockSkew = 0;
+  var clock = typeof performance === "object" && performance.now ? performance : Date;
+  var setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) {
+    setTimeout(f, 17);
+  };
+  function now() {
+    return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
+  }
+  function clearNow() {
+    clockNow = 0;
+  }
+  function Timer() {
+    this._call = this._time = this._next = null;
+  }
+  Timer.prototype = timer.prototype = {
+    constructor: Timer,
+    restart: function(callback, delay, time) {
+      if (typeof callback !== "function")
+        throw new TypeError("callback is not a function");
+      time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
+      if (!this._next && taskTail !== this) {
+        if (taskTail)
+          taskTail._next = this;
+        else
+          taskHead = this;
+        taskTail = this;
+      }
+      this._call = callback;
+      this._time = time;
+      sleep();
+    },
+    stop: function() {
+      if (this._call) {
+        this._call = null;
+        this._time = Infinity;
+        sleep();
+      }
+    }
+  };
+  function timer(callback, delay, time) {
+    var t = new Timer;
+    t.restart(callback, delay, time);
+    return t;
+  }
+  function timerFlush() {
+    now();
+    ++frame;
+    var t = taskHead, e;
+    while (t) {
+      if ((e = clockNow - t._time) >= 0)
+        t._call.call(undefined, e);
+      t = t._next;
+    }
+    --frame;
+  }
+  function wake() {
+    clockNow = (clockLast = clock.now()) + clockSkew;
+    frame = timeout = 0;
+    try {
+      timerFlush();
+    } finally {
+      frame = 0;
+      nap();
+      clockNow = 0;
+    }
+  }
+  function poke() {
+    var now2 = clock.now(), delay = now2 - clockLast;
+    if (delay > pokeDelay)
+      clockSkew -= delay, clockLast = now2;
+  }
+  function nap() {
+    var t0, t1 = taskHead, t2, time = Infinity;
+    while (t1) {
+      if (t1._call) {
+        if (time > t1._time)
+          time = t1._time;
+        t0 = t1, t1 = t1._next;
+      } else {
+        t2 = t1._next, t1._next = null;
+        t1 = t0 ? t0._next = t2 : taskHead = t2;
+      }
+    }
+    taskTail = t0;
+    sleep(time);
+  }
+  function sleep(time) {
+    if (frame)
+      return;
+    if (timeout)
+      timeout = clearTimeout(timeout);
+    var delay = time - clockNow;
+    if (delay > 24) {
+      if (time < Infinity)
+        timeout = setTimeout(wake, time - clock.now() - clockSkew);
+      if (interval)
+        interval = clearInterval(interval);
+    } else {
+      if (!interval)
+        clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
+      frame = 1, setFrame(wake);
+    }
+  }
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/lcg.js
+  var a = 1664525;
+  var c = 1013904223;
+  var m = 4294967296;
+  function lcg_default() {
+    let s = 1;
+    return () => (s = (a * s + c) % m) / m;
+  }
+
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/simulation.js
+  function x2(d) {
+    return d.x;
+  }
+  function y2(d) {
+    return d.y;
+  }
+  var initialRadius = 10;
+  var initialAngle = Math.PI * (3 - Math.sqrt(5));
+  function simulation_default(nodes) {
+    var simulation, alpha = 1, alphaMin = 0.001, alphaDecay = 1 - Math.pow(alphaMin, 1 / 300), alphaTarget = 0, velocityDecay = 0.6, forces = new Map, stepper = timer(step), event = dispatch_default("tick", "end"), random = lcg_default();
+    if (nodes == null)
+      nodes = [];
+    function step() {
+      tick();
+      event.call("tick", simulation);
+      if (alpha < alphaMin) {
+        stepper.stop();
+        event.call("end", simulation);
+      }
+    }
+    function tick(iterations) {
+      var i, n = nodes.length, node;
+      if (iterations === undefined)
+        iterations = 1;
+      for (var k = 0;k < iterations; ++k) {
+        alpha += (alphaTarget - alpha) * alphaDecay;
+        forces.forEach(function(force) {
+          force(alpha);
+        });
+        for (i = 0;i < n; ++i) {
+          node = nodes[i];
+          if (node.fx == null)
+            node.x += node.vx *= velocityDecay;
+          else
+            node.x = node.fx, node.vx = 0;
+          if (node.fy == null)
+            node.y += node.vy *= velocityDecay;
+          else
+            node.y = node.fy, node.vy = 0;
+        }
+      }
+      return simulation;
+    }
+    function initializeNodes() {
+      for (var i = 0, n = nodes.length, node;i < n; ++i) {
+        node = nodes[i], node.index = i;
+        if (node.fx != null)
+          node.x = node.fx;
+        if (node.fy != null)
+          node.y = node.fy;
+        if (isNaN(node.x) || isNaN(node.y)) {
+          var radius = initialRadius * Math.sqrt(0.5 + i), angle = i * initialAngle;
+          node.x = radius * Math.cos(angle);
+          node.y = radius * Math.sin(angle);
+        }
+        if (isNaN(node.vx) || isNaN(node.vy)) {
+          node.vx = node.vy = 0;
+        }
+      }
+    }
+    function initializeForce(force) {
+      if (force.initialize)
+        force.initialize(nodes, random);
+      return force;
+    }
+    initializeNodes();
+    return simulation = {
+      tick,
+      restart: function() {
+        return stepper.restart(step), simulation;
+      },
+      stop: function() {
+        return stepper.stop(), simulation;
+      },
+      nodes: function(_) {
+        return arguments.length ? (nodes = _, initializeNodes(), forces.forEach(initializeForce), simulation) : nodes;
+      },
+      alpha: function(_) {
+        return arguments.length ? (alpha = +_, simulation) : alpha;
+      },
+      alphaMin: function(_) {
+        return arguments.length ? (alphaMin = +_, simulation) : alphaMin;
+      },
+      alphaDecay: function(_) {
+        return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;
+      },
+      alphaTarget: function(_) {
+        return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;
+      },
+      velocityDecay: function(_) {
+        return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;
+      },
+      randomSource: function(_) {
+        return arguments.length ? (random = _, forces.forEach(initializeForce), simulation) : random;
+      },
+      force: function(name, _) {
+        return arguments.length > 1 ? (_ == null ? forces.delete(name) : forces.set(name, initializeForce(_)), simulation) : forces.get(name);
+      },
+      find: function(x3, y3, radius) {
+        var i = 0, n = nodes.length, dx, dy, d2, node, closest;
+        if (radius == null)
+          radius = Infinity;
+        else
+          radius *= radius;
+        for (i = 0;i < n; ++i) {
+          node = nodes[i];
+          dx = x3 - node.x;
+          dy = y3 - node.y;
+          d2 = dx * dx + dy * dy;
+          if (d2 < radius)
+            closest = node, radius = d2;
+        }
+        return closest;
+      },
+      on: function(name, _) {
+        return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);
+      }
+    };
+  }
+
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/manyBody.js
+  function manyBody_default() {
+    var nodes, node, random, alpha, strength = constant_default(-30), strengths, distanceMin2 = 1, distanceMax2 = Infinity, theta2 = 0.81;
+    function force(_) {
+      var i, n = nodes.length, tree = quadtree(nodes, x2, y2).visitAfter(accumulate);
+      for (alpha = _, i = 0;i < n; ++i)
+        node = nodes[i], tree.visit(apply);
+    }
+    function initialize() {
+      if (!nodes)
+        return;
+      var i, n = nodes.length, node2;
+      strengths = new Array(n);
+      for (i = 0;i < n; ++i)
+        node2 = nodes[i], strengths[node2.index] = +strength(node2, i, nodes);
+    }
+    function accumulate(quad) {
+      var strength2 = 0, q, c2, weight = 0, x3, y3, i;
+      if (quad.length) {
+        for (x3 = y3 = i = 0;i < 4; ++i) {
+          if ((q = quad[i]) && (c2 = Math.abs(q.value))) {
+            strength2 += q.value, weight += c2, x3 += c2 * q.x, y3 += c2 * q.y;
+          }
+        }
+        quad.x = x3 / weight;
+        quad.y = y3 / weight;
+      } else {
+        q = quad;
+        q.x = q.data.x;
+        q.y = q.data.y;
+        do
+          strength2 += strengths[q.data.index];
+        while (q = q.next);
+      }
+      quad.value = strength2;
+    }
+    function apply(quad, x1, _, x22) {
+      if (!quad.value)
+        return true;
+      var x3 = quad.x - node.x, y3 = quad.y - node.y, w = x22 - x1, l = x3 * x3 + y3 * y3;
+      if (w * w / theta2 < l) {
+        if (l < distanceMax2) {
+          if (x3 === 0)
+            x3 = jiggle_default(random), l += x3 * x3;
+          if (y3 === 0)
+            y3 = jiggle_default(random), l += y3 * y3;
+          if (l < distanceMin2)
+            l = Math.sqrt(distanceMin2 * l);
+          node.vx += x3 * quad.value * alpha / l;
+          node.vy += y3 * quad.value * alpha / l;
+        }
+        return true;
+      } else if (quad.length || l >= distanceMax2)
+        return;
+      if (quad.data !== node || quad.next) {
+        if (x3 === 0)
+          x3 = jiggle_default(random), l += x3 * x3;
+        if (y3 === 0)
+          y3 = jiggle_default(random), l += y3 * y3;
+        if (l < distanceMin2)
+          l = Math.sqrt(distanceMin2 * l);
+      }
+      do
+        if (quad.data !== node) {
+          w = strengths[quad.data.index] * alpha / l;
+          node.vx += x3 * w;
+          node.vy += y3 * w;
+        }
+      while (quad = quad.next);
+    }
+    force.initialize = function(_nodes, _random) {
+      nodes = _nodes;
+      random = _random;
+      initialize();
+    };
+    force.strength = function(_) {
+      return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : strength;
+    };
+    force.distanceMin = function(_) {
+      return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);
+    };
+    force.distanceMax = function(_) {
+      return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);
+    };
+    force.theta = function(_) {
+      return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);
+    };
+    return force;
+  }
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/x.js
+  function x_default2(x3) {
+    var strength = constant_default(0.1), nodes, strengths, xz;
+    if (typeof x3 !== "function")
+      x3 = constant_default(x3 == null ? 0 : +x3);
+    function force(alpha) {
+      for (var i = 0, n = nodes.length, node;i < n; ++i) {
+        node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;
+      }
+    }
+    function initialize() {
+      if (!nodes)
+        return;
+      var i, n = nodes.length;
+      strengths = new Array(n);
+      xz = new Array(n);
+      for (i = 0;i < n; ++i) {
+        strengths[i] = isNaN(xz[i] = +x3(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
+      }
+    }
+    force.initialize = function(_) {
+      nodes = _;
+      initialize();
+    };
+    force.strength = function(_) {
+      return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : strength;
+    };
+    force.x = function(_) {
+      return arguments.length ? (x3 = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : x3;
+    };
+    return force;
+  }
+  // ../../node_modules/.bun/d3-force@3.0.0/node_modules/d3-force/src/y.js
+  function y_default2(y3) {
+    var strength = constant_default(0.1), nodes, strengths, yz;
+    if (typeof y3 !== "function")
+      y3 = constant_default(y3 == null ? 0 : +y3);
+    function force(alpha) {
+      for (var i = 0, n = nodes.length, node;i < n; ++i) {
+        node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;
+      }
+    }
+    function initialize() {
+      if (!nodes)
+        return;
+      var i, n = nodes.length;
+      strengths = new Array(n);
+      yz = new Array(n);
+      for (i = 0;i < n; ++i) {
+        strengths[i] = isNaN(yz[i] = +y3(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
+      }
+    }
+    force.initialize = function(_) {
+      nodes = _;
+      initialize();
+    };
+    force.strength = function(_) {
+      return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : strength;
+    };
+    force.y = function(_) {
+      return arguments.length ? (y3 = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : y3;
+    };
+    return force;
+  }
+  // src/graph/simulation-worker.ts
+  function forceCluster(nodes, strength) {
+    return (alpha) => {
+      const cx = new Map;
+      const cy = new Map;
+      const count = new Map;
+      for (const node of nodes) {
+        if (!node.community)
+          continue;
+        const c2 = node.community;
+        cx.set(c2, (cx.get(c2) ?? 0) + (node.x ?? 0));
+        cy.set(c2, (cy.get(c2) ?? 0) + (node.y ?? 0));
+        count.set(c2, (count.get(c2) ?? 0) + 1);
+      }
+      for (const [c2, n] of count) {
+        cx.set(c2, cx.get(c2) / n);
+        cy.set(c2, cy.get(c2) / n);
+      }
+      const k = strength * alpha;
+      for (const node of nodes) {
+        if (!node.community)
+          continue;
+        const targetX = cx.get(node.community);
+        const targetY = cy.get(node.community);
+        node.vx = (node.vx ?? 0) + (targetX - (node.x ?? 0)) * k;
+        node.vy = (node.vy ?? 0) + (targetY - (node.y ?? 0)) * k;
+      }
+    };
+  }
+  var ctx = self;
+  var simulation = null;
+  var nodeMap = new Map;
+  function post(msg) {
+    ctx.postMessage(msg);
+  }
+  function packPositions(nodes) {
+    return nodes.map((n) => ({
+      id: n.id,
+      x: n.x ?? 0,
+      y: n.y ?? 0
+    }));
+  }
+  ctx.addEventListener("message", (event) => {
+    const msg = event.data;
+    try {
+      switch (msg.type) {
+        case "init": {
+          if (simulation)
+            simulation.stop();
+          const internalNodes = msg.nodes.map((n) => ({
+            id: n.id,
+            x: n.x,
+            y: n.y,
+            radius: n.radius,
+            community: n.community
+          }));
+          nodeMap = new Map(internalNodes.map((n) => [n.id, n]));
+          const { config } = msg;
+          simulation = simulation_default(internalNodes).force("link", link_default(msg.edges.map((e) => ({ ...e }))).id((d) => d.id).distance(config.linkDistance)).force("charge", manyBody_default().strength(config.chargeStrength)).force("center", center_default(0, 0)).force("collide", collide_default().radius((d) => d.radius + 1)).force("gravityX", x_default2(0).strength(0.05)).force("gravityY", y_default2(0).strength(0.05)).alphaDecay(config.alphaDecay).velocityDecay(config.velocityDecay);
+          if (config.clustering) {
+            const clusterFn = forceCluster(internalNodes, config.clustering.strength);
+            simulation.force("cluster", clusterFn);
+          }
+          simulation.on("tick", () => {
+            post({
+              type: "positions",
+              nodes: packPositions(internalNodes),
+              alpha: simulation.alpha()
+            });
+          });
+          simulation.on("end", () => {
+            post({ type: "settled" });
+          });
+          break;
+        }
+        case "reheat": {
+          if (!simulation)
+            break;
+          simulation.alpha(msg.alpha ?? 0.3).restart();
+          break;
+        }
+        case "pin": {
+          const node = nodeMap.get(msg.nodeId);
+          if (node) {
+            node.fx = msg.x;
+            node.fy = msg.y;
+          }
+          break;
+        }
+        case "unpin": {
+          const node = nodeMap.get(msg.nodeId);
+          if (node) {
+            node.fx = null;
+            node.fy = null;
+          }
+          break;
+        }
+        case "drag": {
+          const node = nodeMap.get(msg.nodeId);
+          if (node) {
+            node.fx = msg.x;
+            node.fy = msg.y;
+          }
+          if (simulation && simulation.alpha() < 0.1) {
+            simulation.alpha(0.1).restart();
+          }
+          break;
+        }
+        case "stop": {
+          if (simulation)
+            simulation.stop();
+          break;
+        }
+      }
+    } catch (err) {
+      post({
+        type: "error",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+})();