@deck.gl-community/graph-layers 9.0.0

package/dist/index.cjs

@@ -0,0 +1,3540 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  BaseLayout: () => BaseLayout,
+  CompositeEdgeLayer: () => EdgeLayer,
+  D3ForceLayout: () => D3ForceLayout,
+  EDGE_DECORATOR_TYPE: () => EDGE_DECORATOR_TYPE,
+  EDGE_TYPE: () => EDGE_TYPE,
+  Edge: () => Edge,
+  EdgeLayer: () => EdgeLayer,
+  GPUForceLayout: () => GPUForceLayout,
+  Graph: () => Graph,
+  GraphEngine: () => GraphEngine,
+  GraphLayer: () => GraphLayer,
+  JSONLoader: () => JSONLoader,
+  LAYOUT_STATE: () => LAYOUT_STATE,
+  MARKER_TYPE: () => MARKER_TYPE,
+  NODE_STATE: () => NODE_STATE,
+  NODE_TYPE: () => NODE_TYPE,
+  Node: () => Node,
+  SimpleLayout: () => SimpleLayout,
+  basicEdgeParser: () => basicEdgeParser,
+  basicNodeParser: () => basicNodeParser,
+  createGraph: () => createGraph,
+  log: () => log,
+  mixedGetPosition: () => mixedGetPosition
+});
+module.exports = __toCommonJS(dist_exports);
+
+// dist/core/cache.js
+var Cache = class {
+  _keys = /* @__PURE__ */ new Map();
+  /**
+   * @param key The key of the cache
+   * @returns {*} The value of the cache as set by the `set` method.
+   */
+  get(key) {
+    var _a;
+    return (_a = this._keys.get(key)) == null ? void 0 : _a.value;
+  }
+  /**
+   * @param key The key of the cache
+   * @param createValue A callback to create the value of the cache if it is needed.
+   * @param version The version of the cache. If the version is smaller than the current version, the cache will not be updated.
+   */
+  set(key, createValue, version) {
+    const cached = this._keys.get(key);
+    const keyUpdated = cached === void 0 || version > cached.version;
+    if (!keyUpdated) {
+      return;
+    }
+    this._keys.set(key, { version, value: createValue() });
+  }
+};
+
+// dist/core/graph-engine.js
+var GraphEngine = class extends EventTarget {
+  _graph;
+  _layout;
+  _cache = new Cache();
+  _layoutDirty = false;
+  _transactionInProgress = false;
+  constructor(graph, layout) {
+    super();
+    this._graph = graph;
+    this._layout = layout;
+  }
+  /** Getters */
+  getNodes = () => {
+    this._updateCache("nodes", () => this._graph.getNodes().filter((node) => this.getNodePosition(node)));
+    return this._cache.get("nodes");
+  };
+  getEdges = () => {
+    this._updateCache("edges", () => this._graph.getEdges().filter((edge) => this.getEdgePosition(edge)));
+    return this._cache.get("edges");
+  };
+  getNodePosition = (node) => this._layout.getNodePosition(node);
+  getEdgePosition = (edge) => this._layout.getEdgePosition(edge);
+  getGraphVersion = () => this._graph.version;
+  getLayoutLastUpdate = () => this._layout.version;
+  getLayoutState = () => this._layout.state;
+  /** Operations on the graph */
+  lockNodePosition = (node, x, y) => this._layout.lockNodePosition(node, x, y);
+  unlockNodePosition = (node) => this._layout.unlockNodePosition(node);
+  /**
+   * @fires GraphEngine#onLayoutStart
+   */
+  _onLayoutStart = () => {
+    this.dispatchEvent(new CustomEvent("onLayoutStart"));
+  };
+  /**
+   * @fires GraphEngine#onLayoutChange
+   */
+  _onLayoutChange = () => {
+    this.dispatchEvent(new CustomEvent("onLayoutChange"));
+  };
+  /**
+   * @fires GraphEngine#onLayoutDone
+   */
+  _onLayoutDone = () => {
+    this.dispatchEvent(new CustomEvent("onLayoutDone"));
+  };
+  /**
+   * @fires GraphEngine#onLayoutError
+   */
+  _onLayoutError = () => {
+    this.dispatchEvent(new CustomEvent("onLayoutError"));
+  };
+  _onGraphStructureChanged = (entity) => {
+    this._layoutDirty = true;
+    this._graphChanged();
+  };
+  _onTransactionStart = () => {
+    this._transactionInProgress = true;
+  };
+  _onTransactionEnd = () => {
+    this._transactionInProgress = false;
+    this._graphChanged();
+  };
+  /** Layout calculations */
+  run = () => {
+    this._graph.addEventListener("transactionStart", this._onTransactionStart);
+    this._graph.addEventListener("transactionEnd", this._onTransactionEnd);
+    this._graph.addEventListener("onNodeAdded", this._onGraphStructureChanged);
+    this._graph.addEventListener("onNodeRemoved", this._onGraphStructureChanged);
+    this._graph.addEventListener("onEdgeAdded", this._onGraphStructureChanged);
+    this._graph.addEventListener("onEdgeRemoved", this._onGraphStructureChanged);
+    this._layout.addEventListener("onLayoutStart", this._onLayoutStart);
+    this._layout.addEventListener("onLayoutChange", this._onLayoutChange);
+    this._layout.addEventListener("onLayoutDone", this._onLayoutDone);
+    this._layout.addEventListener("onLayoutError", this._onLayoutError);
+    this._layout.initializeGraph(this._graph);
+    this._layout.start();
+  };
+  clear = () => {
+    this._graph.removeEventListener("transactionStart", this._onTransactionStart);
+    this._graph.removeEventListener("transactionEnd", this._onTransactionEnd);
+    this._graph.removeEventListener("onNodeAdded", this._onGraphStructureChanged);
+    this._graph.removeEventListener("onNodeRemoved", this._onGraphStructureChanged);
+    this._graph.removeEventListener("onEdgeAdded", this._onGraphStructureChanged);
+    this._graph.removeEventListener("onEdgeRemoved", this._onGraphStructureChanged);
+    this._layout.removeEventListener("onLayoutStart", this._onLayoutStart);
+    this._layout.removeEventListener("onLayoutChange", this._onLayoutChange);
+    this._layout.removeEventListener("onLayoutDone", this._onLayoutDone);
+    this._layout.removeEventListener("onLayoutError", this._onLayoutError);
+  };
+  resume = () => this._layout.resume();
+  stop = () => this._layout.stop();
+  _graphChanged = () => {
+    if (this._layoutDirty && !this._transactionInProgress) {
+      this._updateLayout();
+    }
+  };
+  _updateLayout = () => {
+    this._layout.updateGraph(this._graph);
+    this._layout.update();
+    this._layoutDirty = false;
+  };
+  _updateCache(key, updateValue) {
+    this._cache.set(key, updateValue, this._graph.version + this._layout.version);
+  }
+};
+
+// dist/utils/log.js
+var import_probe = require("probe.gl");
+var log = new import_probe.Log({ id: "react-graph-layers" }).enable();
+log.log({ color: import_probe.COLOR.CYAN }, "Initialize react-graph-layers logger.")();
+
+// dist/core/graph.js
+var Graph = class extends EventTarget {
+  /** List object of nodes. */
+  _nodeMap = {};
+  /** List of object edges. */
+  _edgeMap = {};
+  /**
+   * Identifies whether performing dirty check when streaming new data. If
+   * the name of the graph is not specified, will fall back to current time stamp.
+   */
+  _name = Date.now().toString();
+  /** Version the graph. A version is a number that is incremented every time the graph is updated. */
+  version = 0;
+  /** Cached data: create array data from maps. */
+  _cache = new Cache();
+  /**
+   * The constructor of the Graph class.
+   * @param  {Object} graph - copy the graph if this exists.
+   */
+  constructor(graph = null) {
+    super();
+    if (graph) {
+      this._nodeMap = graph._nodeMap;
+      this._edgeMap = graph._edgeMap;
+      this._name = graph && graph._name;
+    }
+  }
+  /**
+   * Set graph name
+   * @param {string} name
+   */
+  setGraphName(name) {
+    this._name = name;
+  }
+  /** Get the name of the graph. Default value is the time stamp when creating this graph.
+   * @return {string} graph name.
+   */
+  getGraphName() {
+    return this._name.toString();
+  }
+  /**
+   * Perform a batch of operations defined by cb before indicating graph is updated
+   * @param {function} cb - a callback fuction containing the operations to perform
+   */
+  transaction(cb) {
+    try {
+      this.dispatchEvent(new CustomEvent("transactionStart"));
+      return cb();
+    } finally {
+      this.dispatchEvent(new CustomEvent("transactionEnd"));
+    }
+  }
+  /**
+   * Add a new node to the graph.
+   * @param {Node} node - expect a Node object to be added to the graph.
+   */
+  addNode(node) {
+    this._nodeMap[node.getId()] = node;
+    this._bumpVersion();
+    this.dispatchEvent(new CustomEvent("onNodeAdded", { node }));
+  }
+  /**
+   * Batch add nodes to the graph.
+   * @param  {Node[]} nodes - a list of nodes to be added.
+   */
+  batchAddNodes(nodes) {
+    this._nodeMap = nodes.reduce((res, node) => {
+      res[node.getId()] = node;
+      this.dispatchEvent(new CustomEvent("onNodeAdded", { node }));
+      return res;
+    }, { ...this._nodeMap });
+    this._bumpVersion();
+  }
+  /**
+   * Get all the nodes of the graph.
+   * @return {Node[]} - get all the nodes in the graph.
+   */
+  getNodes() {
+    this._updateCache("nodes", () => Object.values(this._nodeMap));
+    return this._cache.get("nodes");
+  }
+  /**
+   * Get the node map of the graph. The key of the map is the ID of the nodes.
+   * @return {Object} - a map of nodes keyed by node IDs.
+   */
+  getNodeMap() {
+    return this._nodeMap;
+  }
+  /**
+   * Find a node by id
+   * @param  {String} nodeId The id of the node
+   * @return {Object} Node
+   */
+  findNode(nodeId) {
+    return this._nodeMap[nodeId];
+  }
+  /**
+   * Update the indicated node to the provided value
+   * @param {Node} node
+   */
+  updateNode(node) {
+    this._nodeMap[node.getId()] = node;
+    this._bumpVersion();
+    this.dispatchEvent(new CustomEvent("onNodeUpdated", { node }));
+  }
+  /**
+   * Add a new edge to the graph.
+   * @param {Edge} edge - expect a Edge object to be added to the graph.
+   */
+  addEdge(edge) {
+    const sourceNode = this.findNode(edge.getSourceNodeId());
+    const targetNode = this.findNode(edge.getTargetNodeId());
+    if (!sourceNode || !targetNode) {
+      log.warn(`Unable to add edge ${edge.id},  source or target node is missing.`)();
+      return;
+    }
+    this._edgeMap[edge.getId()] = edge;
+    sourceNode.addConnectedEdges(edge);
+    targetNode.addConnectedEdges(edge);
+    this._bumpVersion();
+    this.dispatchEvent(new CustomEvent("onEdgeAdded", { edge }));
+  }
+  /**
+   * Batch add edges to the graph
+   * @param  {Edge[]} edges - a list of edges to be added.
+   */
+  batchAddEdges(edges) {
+    edges.forEach((edge) => this.addEdge(edge));
+    this._bumpVersion();
+  }
+  /**
+   * Update the indicated edge to the provided value
+   * @param {Edge} edge
+   */
+  updateEdge(edge) {
+    this._edgeMap[edge.getId()] = edge;
+    this._bumpVersion();
+    this.dispatchEvent(new CustomEvent("onEdgeUpdated", { edge }));
+  }
+  /**
+   * Remove a node from the graph by node ID
+   * @param  {String|Number} nodeId - the ID of the target node.
+   */
+  removeNode(nodeId) {
+    const node = this.findNode(nodeId);
+    if (!node) {
+      log.warn(`Unable to remove node ${nodeId} - doesn't exist`)();
+      return;
+    }
+    node.getConnectedEdges().forEach((e) => {
+      delete this._edgeMap[e.getId()];
+    });
+    delete this._nodeMap[nodeId];
+    this._bumpVersion();
+    this.dispatchEvent(new CustomEvent("onNodeRemoved", { node }));
+  }
+  /**
+   * Get all the edges of the graph.
+   * @return {Edge[]} get all the edges in the graph.
+   */
+  getEdges() {
+    this._updateCache("edges", () => Object.values(this._edgeMap));
+    return this._cache.get("edges");
+  }
+  /**
+   * Get the edge map of the graph. The key of the map is the ID of the edges.
+   * @return {Object} - a map of edges keyed by edge IDs.
+   */
+  getEdgeMap() {
+    return this._edgeMap;
+  }
+  /**
+   * Remove an edge from the graph by the edge ID
+   * @param  {String|Number} edgeId - the target edge ID.
+   */
+  removeEdge(edgeId) {
+    const edge = this.findEdge(edgeId);
+    if (!edge) {
+      log.warn(`Unable to remove edge ${edgeId} - doesn't exist`)();
+      return;
+    }
+    const sourceNode = this.findNode(edge.getSourceNodeId());
+    const targetNode = this.findNode(edge.getTargetNodeId());
+    delete this._edgeMap[edgeId];
+    sourceNode.removeConnectedEdges(edge);
+    targetNode.removeConnectedEdges(edge);
+    this._bumpVersion();
+  }
+  /**
+   * Find the edge by edge ID.
+   * @param  {String|Number} id - the target edge ID
+   * @return {Edge} - the target edge.
+   */
+  findEdge(edgeId) {
+    return this._edgeMap[edgeId];
+  }
+  /**
+   * Return all the connected edges of a node by nodeID.
+   * @param  {String|Number} nodeId - the target node ID
+   * @return {Edge[]} - an array of the connected edges.
+   */
+  getConnectedEdges(nodeId) {
+    const node = this.findNode(nodeId);
+    if (!node) {
+      log.warn(`Unable to find node ${nodeId} - doesn't exist`)();
+      return [];
+    }
+    return node.getConnectedEdges();
+  }
+  /**
+   * Return all the sibling nodes of a node by nodeID.
+   * @param  {String|Number} nodeId - the target node ID
+   * @return {Node[]} - an array of the sibling nodes.
+   */
+  getNodeSiblings(nodeId) {
+    const node = this.findNode(nodeId);
+    if (!node) {
+      log.warn(`Unable to find node ${nodeId} - doesn't exist`)();
+      return [];
+    }
+    return node.getSiblingIds().map((siblingNodeId) => this.findNode(siblingNodeId));
+  }
+  /**
+   * Get the degree of a node.
+   * @param  {String|Number} nodeId - the target node ID.
+   * @return {Number} - the degree of the node.
+   */
+  getDegree(nodeId) {
+    const node = this.findNode(nodeId);
+    if (!node) {
+      log.warn(`Unable to find node ${nodeId} - doesn't exist`)();
+      return 0;
+    }
+    return node.getDegree();
+  }
+  /**
+   * Clean up all the nodes in the graph.
+   */
+  resetNodes() {
+    this._nodeMap = {};
+    this._bumpVersion();
+  }
+  /**
+   * Clean up all the edges in the graph.
+   */
+  resetEdges() {
+    this._edgeMap = {};
+    this._bumpVersion();
+  }
+  /**
+   * Clean up everything in the graph.
+   */
+  reset() {
+    this.resetNodes();
+    this.resetEdges();
+    this._bumpVersion();
+  }
+  /**
+   * Trigger an update to the graph.
+   */
+  triggerUpdate() {
+    this._bumpVersion();
+  }
+  /**
+   * Return true if the graph is empty.
+   * @return {Boolean} Return true if the graph is empty.
+   */
+  isEmpty() {
+    return Object.keys(this._nodeMap).length === 0;
+  }
+  /**
+   * Check the equality of two graphs data by checking last update time stamp
+   * @param  {Object} g Another graph to be compared against itself
+   * @return {Bool}   True if the graph is the same as itself.
+   */
+  equals(g) {
+    if (!g || !(g instanceof Graph)) {
+      return false;
+    }
+    return this.version === g.version;
+  }
+  _bumpVersion() {
+    this.version += 1;
+  }
+  _updateCache(key, updateValue) {
+    this._cache.set(key, updateValue, this.version);
+  }
+};
+
+// dist/layers/common-layers/marker-layer/marker-list.js
+var MarkerList = {
+  "bell-filled": "bell-filled",
+  bell: "bell",
+  "bookmark-filled": "bookmark-filled",
+  bookmark: "bookmark",
+  "cd-filled": "cd-filled",
+  cd: "cd",
+  checkmark: "checkmark",
+  "circle-check-filled": "circle-check-filled",
+  "circle-check": "circle-check",
+  "circle-filled": "circle-filled",
+  "circle-i-filled": "circle-i-filled",
+  "circle-i": "circle-i",
+  "circle-minus-filled": "circle-minus-filled",
+  "circle-minus": "circle-minus",
+  "circle-plus-filled": "circle-plus-filled",
+  "circle-plus": "circle-plus",
+  "circle-questionmark-filled": "circle-questionmark-filled",
+  "circle-questionmark": "circle-questionmark",
+  "circle-slash-filled": "circle-slash-filled",
+  "circle-slash": "circle-slash",
+  "circle-x-filled": "circle-x-filled",
+  "circle-x": "circle-x",
+  circle: "circle",
+  "diamond-filled": "diamond-filled",
+  diamond: "diamond",
+  "flag-filled": "flag-filled",
+  flag: "flag",
+  gear: "gear",
+  "heart-filled": "heart-filled",
+  heart: "heart",
+  "location-marker-filled": "location-marker-filled",
+  "location-marker": "location-marker",
+  "octagonal-star-filled": "octagonal-star-filled",
+  "octagonal-star": "octagonal-star",
+  "person-filled": "person-filled",
+  person: "person",
+  "pin-filled": "pin-filled",
+  pin: "pin",
+  "plus-small": "plus-small",
+  plus: "plus",
+  "rectangle-filled": "rectangle-filled",
+  rectangle: "rectangle",
+  "star-filled": "star-filled",
+  star: "star",
+  "tag-filled": "tag-filled",
+  tag: "tag",
+  "thumb-down-filled": "thumb-down-filled",
+  "thumb-down": "thumb-down",
+  "thumb-up": "thumb-up",
+  "thumb_up-filled": "thumb_up-filled",
+  "triangle-down-filled": "triangle-down-filled",
+  "triangle-down": "triangle-down",
+  "triangle-left-filled": "triangle-left-filled",
+  "triangle-left": "triangle-left",
+  "triangle-right-filled": "triangle-right-filled",
+  "triangle-right": "triangle-right",
+  "triangle-up-filled": "triangle-up-filled",
+  "triangle-up": "triangle-up",
+  "x-small": "x-small",
+  x: "x"
+};
+
+// dist/core/constants.js
+var MARKER_TYPE = MarkerList;
+var NODE_STATE = {
+  DEFAULT: "default",
+  HOVER: "hover",
+  DRAGGING: "dragging",
+  SELECTED: "selected"
+};
+var EDGE_STATE = {
+  DEFAULT: "default",
+  HOVER: "hover",
+  DRAGGING: "dragging",
+  SELECTED: "selected"
+};
+var NODE_TYPE = {
+  CIRCLE: "CIRCLE",
+  RECTANGLE: "RECTANGLE",
+  ROUNDED_RECTANGLE: "ROUNDED_RECTANGLE",
+  PATH_ROUNDED_RECTANGLE: "PATH_ROUNDED_RECTANGLE",
+  ICON: "ICON",
+  LABEL: "LABEL",
+  MARKER: "MARKER"
+};
+var EDGE_TYPE = {
+  SPLINE_CURVE: "SPLINE_CURVE",
+  LINE: "LINE",
+  PATH: "PATH"
+};
+var EDGE_DECORATOR_TYPE = {
+  LABEL: "EDGE_LABEL",
+  FLOW: "FLOW"
+};
+var LAYOUT_STATE = {
+  INIT: "INIT",
+  START: "START",
+  CALCULATING: "CALCULATING",
+  DONE: "DONE",
+  ERROR: "ERROR"
+};
+
+// dist/core/node.js
+var Node = class {
+  id;
+  /** Keep a reference to origin data. */
+  _data;
+  /** List edges. */
+  _connectedEdges = {};
+  /** Interaction state of the node. */
+  state = NODE_STATE.DEFAULT;
+  /** Can the node be selected? */
+  _selectable;
+  /** Should the state of this node affect the state of the connected edges? */
+  _highlightConnectedEdges;
+  /** Check the type of the object when picking engine gets it. */
+  isNode = true;
+  /**
+   * The constructor of a node
+   * @param  {String|Number} options.id   - the unique ID of the node
+   * @param  {Record<string, unknown>} options.data - origin data reference
+   */
+  constructor({ id, selectable = false, highlightConnectedEdges = false, data = {} }) {
+    this.id = id;
+    this._data = data;
+    this._selectable = selectable;
+    this._highlightConnectedEdges = highlightConnectedEdges;
+  }
+  /**
+   * Return the ID of the node
+   * @return {String|Number} - the ID of the node.
+   */
+  getId() {
+    return this.id;
+  }
+  /**
+   * Return the degree of the node -- includes in-degree and out-degree
+   * @return {Number} - the degree of the node.
+   */
+  getDegree() {
+    return Object.keys(this._connectedEdges).length;
+  }
+  /**
+   * Return the in-degree of the node.
+   * @return {Number} - the in-degree of the node.
+   */
+  getInDegree() {
+    const nodeId = this.getId();
+    return this.getConnectedEdges().reduce((count, e) => {
+      const isDirected = e.isDirected();
+      if (isDirected && e.getTargetNodeId() === nodeId) {
+        count += 1;
+      }
+      return count;
+    }, 0);
+  }
+  /**
+   * Return the out-degree of the node.
+   * @return {Number} - the out-degree of the node.
+   */
+  getOutDegree() {
+    const nodeId = this.getId();
+    return this.getConnectedEdges().reduce((count, e) => {
+      const isDirected = e.isDirected();
+      if (isDirected && e.getSourceNodeId() === nodeId) {
+        count += 1;
+      }
+      return count;
+    }, 0);
+  }
+  /**
+   * Return all the IDs of the sibling nodes.
+   * @return {String[]} [description]
+   */
+  getSiblingIds() {
+    const nodeId = this.getId();
+    return this.getConnectedEdges().reduce((siblings, e) => {
+      if (e.getTargetNodeId() === nodeId) {
+        siblings.push(e.getSourceNodeId());
+      } else {
+        siblings.push(e.getTargetNodeId());
+      }
+      return siblings;
+    }, []);
+  }
+  /**
+   * Return all the connected edges.
+   * @return {Object[]} - an array of the connected edges.
+   */
+  getConnectedEdges() {
+    return Object.values(this._connectedEdges);
+  }
+  /**
+   * Return of the value of the selected property key.
+   * @param  {String} key - property key.
+   * @return {Any} - the value of the property or undefined (not found).
+   */
+  getPropertyValue(key) {
+    if (this.hasOwnProperty(key)) {
+      return this[key];
+    } else if (this._data.hasOwnProperty(key)) {
+      return this._data[key];
+    }
+    return void 0;
+  }
+  /**
+   * Set the new node data.
+   * @param {Record<string, unknown>} data - the new data of the node
+   */
+  setData(data) {
+    this._data = data;
+  }
+  /**
+   * Update a data property.
+   * @param {String} key - the key of the property
+   * @param {Any} value - the value of the property.
+   */
+  setDataProperty(key, value) {
+    this._data[key] = value;
+  }
+  /**
+   * Set node state
+   * @param {String} state - one of NODE_STATE
+   */
+  setState(state) {
+    this.state = state;
+  }
+  /**
+   * Get node state
+   * @returns {string} state - one of NODE_STATE
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Add connected edges to the node
+   * @param {Edge || Edge[]} edge an edge or an array of edges to be added to this._connectedEdges
+   */
+  addConnectedEdges(edge) {
+    const iterableEdges = Array.isArray(edge) ? edge : [edge];
+    iterableEdges.forEach((e) => {
+      this._connectedEdges[e.id] = e;
+      e.addNode(this);
+    });
+  }
+  /**
+   * Remove edges from this._connectedEdges
+   * @param {Edge | Edge[]} edge an edge or an array of edges to be removed from this._connectedEdges
+   */
+  removeConnectedEdges(edge) {
+    const iterableEdges = Array.isArray(edge) ? edge : [edge];
+    iterableEdges.forEach((e) => {
+      e.removeNode(this);
+      delete this._connectedEdges[e.id];
+    });
+  }
+  /**
+   * Clear this._connectedEdges
+   */
+  clearConnectedEdges() {
+    Object.values(this._connectedEdges).forEach((e) => e.removeNode(this));
+    this._connectedEdges = {};
+  }
+  isSelectable() {
+    return this._selectable;
+  }
+  shouldHighlightConnectedEdges() {
+    return this._highlightConnectedEdges;
+  }
+};
+
+// dist/core/edge.js
+var Edge = class {
+  /** Unique uuid of the edge. */
+  id;
+  /** ID of the source node. */
+  _sourceId;
+  /** ID of the target node. */
+  _targetId;
+  /** Whether the edge is directed or not. */
+  _directed;
+  /** Origin data reference of the edge. */
+  _data;
+  /** Check the type of the object when picking engine gets it. */
+  isEdge = true;
+  /** Nodes at either end of this edge. */
+  _connectedNodes = {};
+  /** Edge state. */
+  state = EDGE_STATE.DEFAULT;
+  /**
+   * The constructor
+   * @param  {String|Number} options.id - the unique ID of the edge
+   * @param  {String|Number} options.sourceId - the ID of the source node
+   * @param  {String|Number} options.targetId - the ID of the target node
+   * @param  {Boolean} options.directed - whether the edge is directed or not
+   * @param  {Record<string, unknown>} options.data - origin data reference
+   */
+  constructor({ id, sourceId, targetId, data, directed = false }) {
+    this.id = id;
+    this._sourceId = sourceId;
+    this._targetId = targetId;
+    this._directed = directed;
+    this._data = data;
+  }
+  /**
+   * Return the ID of the edge
+   * @return {String|Number} - the ID of the edge.
+   */
+  getId() {
+    return this.id;
+  }
+  /**
+   * Return whether the edge is directed or not.
+   * @return {Boolean} true if the edge is directed.
+   */
+  isDirected() {
+    return this._directed;
+  }
+  /**
+   * Get the ID of the source node.
+   * @return {String|Number} the ID of the source node.
+   */
+  getSourceNodeId() {
+    return this._sourceId;
+  }
+  /**
+   * Get the ID of the target node.
+   * @return {String|Number} the ID of the target node.
+   */
+  getTargetNodeId() {
+    return this._targetId;
+  }
+  /**
+   * Return of the value of the selected property key.
+   * @param  {String} key - property key.
+   * @return {Any} - the value of the property.
+   */
+  getPropertyValue(key) {
+    if (this.hasOwnProperty(key)) {
+      return this[key];
+    } else if (this._data.hasOwnProperty(key)) {
+      return this._data[key];
+    }
+    return void 0;
+  }
+  /**
+   * Set the origin data as a reference.
+   * @param {Object} data - the origin data.
+   */
+  setData(data) {
+    this._data = data;
+  }
+  /**
+   * Update a data property.
+   * @param {String} key - the key of the property
+   * @param {Any} value - the value of the property.
+   */
+  setDataProperty(key, value) {
+    this._data[key] = value;
+  }
+  /**
+   * Set edge state
+   * @param {String} state - one of EDGE_STATE
+   */
+  setState(state) {
+    this.state = state;
+  }
+  /**
+   * Get edge state
+   * @returns {string} state - one of EDGE_STATE
+   */
+  getState() {
+    return this.state;
+  }
+  addNode(node) {
+    this._connectedNodes[node.getId()] = node;
+  }
+  removeNode(node) {
+    delete this._connectedNodes[node.getId()];
+  }
+  getConnectedNodes() {
+    return Object.values(this._connectedNodes);
+  }
+};
+
+// dist/core/base-layout.js
+var import_lodash = __toESM(require("lodash.isequal"), 1);
+var BaseLayout = class extends EventTarget {
+  /** Name of the layout. */
+  _name = "BaseLayout";
+  /** Extra configuration options of the layout. */
+  _options;
+  version = 0;
+  state = LAYOUT_STATE.INIT;
+  /**
+   * Constructor of BaseLayout
+   * @param  {Object} options extra configuration options of the layout
+   */
+  constructor(options = {}) {
+    super();
+    this._options = options;
+  }
+  /**
+   * @fires BaseLayout#onLayoutStart
+   * @protected
+   */
+  _onLayoutStart() {
+    this._updateState(LAYOUT_STATE.CALCULATING);
+    this.dispatchEvent(new CustomEvent("onLayoutStart"));
+  }
+  /**
+   * @fires BaseLayout#onLayoutChange
+   * @protected
+   */
+  _onLayoutChange() {
+    this._updateState(LAYOUT_STATE.CALCULATING);
+    this.dispatchEvent(new CustomEvent("onLayoutChange"));
+  }
+  /**
+   * @fires BaseLayout#onLayoutDone
+   * @protected
+   */
+  _onLayoutDone() {
+    this._updateState(LAYOUT_STATE.DONE);
+    this.dispatchEvent(new CustomEvent("onLayoutDone"));
+  }
+  /**
+   * @fires BaseLayout#onLayoutError
+   * @protected
+   */
+  _onLayoutError() {
+    this._updateState(LAYOUT_STATE.ERROR);
+    this.dispatchEvent(new CustomEvent("onLayoutError"));
+  }
+  /**
+   * Check the equality of two layouts
+   * @param  {Object} layout The layout to be compared.
+   * @return {Bool}   True if the layout is the same as itself.
+   */
+  equals(layout) {
+    if (!layout || !(layout instanceof BaseLayout)) {
+      return false;
+    }
+    return this._name === layout._name && (0, import_lodash.default)(this._options, layout._options);
+  }
+  /** virtual functions: will be implemented in the child class */
+  // first time to pass the graph data into this layout
+  initializeGraph(graph) {
+  }
+  // update the existing graph
+  updateGraph(graph) {
+  }
+  // start the layout calculation
+  start() {
+  }
+  // update the layout calculation
+  update() {
+  }
+  // resume the layout calculation
+  resume() {
+  }
+  // stop the layout calculation
+  stop() {
+  }
+  // access the position of the node in the layout
+  getNodePosition(node) {
+    return [0, 0];
+  }
+  // access the layout information of the edge
+  getEdgePosition(edge) {
+    return {
+      type: EDGE_TYPE.LINE,
+      sourcePosition: [0, 0],
+      targetPosition: [0, 0],
+      controlPoints: []
+    };
+  }
+  /**
+   * Pin the node to a designated position, and the node won't move anymore
+   * @param  {Object} node Node to be locked
+   * @param  {Number} x    x coordinate
+   * @param  {Number} y    y coordinate
+   */
+  lockNodePosition(node, x, y) {
+  }
+  /**
+   * Unlock the node, the node will be able to move freely.
+   * @param  {Object} node Node to be unlocked
+   */
+  unlockNodePosition(node) {
+  }
+  _updateState(state) {
+    this.state = state;
+    this.version += 1;
+  }
+};
+
+// dist/layouts/d3-force/d3-force-layout.js
+var import_meta = {};
+var defaultOptions = {
+  alpha: 0.3,
+  resumeAlpha: 0.1,
+  nBodyStrength: -900,
+  nBodyDistanceMin: 100,
+  nBodyDistanceMax: 400,
+  getCollisionRadius: 0
+};
+var D3ForceLayout = class extends BaseLayout {
+  _name = "D3";
+  _positionsByNodeId = /* @__PURE__ */ new Map();
+  _graph;
+  _worker;
+  constructor(options) {
+    super(options);
+    this._options = {
+      ...defaultOptions,
+      ...options
+    };
+  }
+  initializeGraph(graph) {
+    this._graph = graph;
+  }
+  // for streaming new data on the same graph
+  updateGraph(graph) {
+    this._graph = graph;
+    this._positionsByNodeId = new Map(this._graph.getNodes().map((node) => [node.id, this._positionsByNodeId.get(node.id)]));
+  }
+  start() {
+    this._engageWorker();
+    this._onLayoutStart();
+  }
+  update() {
+    this._engageWorker();
+  }
+  _engageWorker() {
+    if (this._worker) {
+      this._worker.terminate();
+    }
+    this._worker = new Worker(new URL("./worker.js", import_meta.url).href);
+    this._worker.postMessage({
+      nodes: this._graph.getNodes().map((node) => ({
+        id: node.id,
+        ...this._positionsByNodeId.get(node.id)
+      })),
+      edges: this._graph.getEdges().map((edge) => ({
+        id: edge.id,
+        source: edge.getSourceNodeId(),
+        target: edge.getTargetNodeId()
+      })),
+      options: this._options
+    });
+    this._worker.onmessage = (event) => {
+      if (event.data.type !== "end") {
+        return;
+      }
+      event.data.nodes.forEach(({ id, ...d3 }) => this._positionsByNodeId.set(id, {
+        ...d3,
+        // precompute so that when we return the node position we do not need to do the conversion
+        coordinates: [d3.x, d3.y]
+      }));
+      this._onLayoutChange();
+      this._onLayoutDone();
+    };
+  }
+  resume() {
+    throw new Error("Resume unavailable");
+  }
+  stop() {
+    this._worker.terminate();
+  }
+  getEdgePosition = (edge) => {
+    const sourceNode = this._graph.findNode(edge.getSourceNodeId());
+    const targetNode = this._graph.findNode(edge.getTargetNodeId());
+    if (!this.getNodePosition(sourceNode) || !this.getNodePosition(targetNode)) {
+      return null;
+    }
+    return {
+      type: EDGE_TYPE.LINE,
+      sourcePosition: this.getNodePosition(sourceNode),
+      targetPosition: this.getNodePosition(targetNode),
+      controlPoints: []
+    };
+  };
+  getNodePosition = (node) => {
+    const d3Node = this._positionsByNodeId.get(node.id);
+    if (d3Node) {
+      return d3Node.coordinates;
+    }
+    return null;
+  };
+  lockNodePosition = (node, x, y) => {
+    const d3Node = this._positionsByNodeId.get(node.id);
+    this._positionsByNodeId.set(node.id, {
+      ...d3Node,
+      x,
+      y,
+      fx: x,
+      fy: y,
+      coordinates: [x, y]
+    });
+    this._onLayoutChange();
+    this._onLayoutDone();
+  };
+  unlockNodePosition = (node) => {
+    const d3Node = this._positionsByNodeId.get(node.id);
+    d3Node.fx = null;
+    d3Node.fy = null;
+  };
+};
+
+// dist/layouts/gpu-force/gpu-force-layout.js
+var import_meta2 = {};
+var defaultOptions2 = {
+  alpha: 0.3,
+  resumeAlpha: 0.1,
+  nBodyStrength: -900,
+  nBodyDistanceMin: 100,
+  nBodyDistanceMax: 400,
+  getCollisionRadius: 0
+};
+var GPUForceLayout = class extends BaseLayout {
+  _name = "GPU";
+  _d3Graph;
+  _nodeMap;
+  _edgeMap;
+  _graph;
+  _worker;
+  _callbacks;
+  constructor(options) {
+    super(options);
+    this._name = "GPU";
+    this._options = {
+      ...defaultOptions2,
+      ...options
+    };
+    this._d3Graph = { nodes: [], edges: [] };
+    this._nodeMap = {};
+    this._edgeMap = {};
+  }
+  initializeGraph(graph) {
+    this._graph = graph;
+    this._nodeMap = {};
+    this._edgeMap = {};
+    const d3Nodes = graph.getNodes().map((node) => {
+      const id = node.id;
+      const locked = node.getPropertyValue("locked") || false;
+      const x = node.getPropertyValue("x") || 0;
+      const y = node.getPropertyValue("y") || 0;
+      const collisionRadius = node.getPropertyValue("collisionRadius") || 0;
+      const d3Node = {
+        id,
+        x,
+        y,
+        fx: locked ? x : null,
+        fy: locked ? y : null,
+        collisionRadius,
+        locked
+      };
+      this._nodeMap[node.id] = d3Node;
+      return d3Node;
+    });
+    const d3Edges = graph.getEdges().map((edge) => {
+      const d3Edge = {
+        id: edge.id,
+        source: this._nodeMap[edge.getSourceNodeId()],
+        target: this._nodeMap[edge.getTargetNodeId()]
+      };
+      this._edgeMap[edge.id] = d3Edge;
+      return d3Edge;
+    });
+    this._d3Graph = {
+      nodes: d3Nodes,
+      edges: d3Edges
+    };
+  }
+  start() {
+    this._engageWorker();
+  }
+  update() {
+    this._engageWorker();
+  }
+  _engageWorker() {
+    if (this._worker) {
+      this._worker.terminate();
+    }
+    this._worker = new Worker(new URL("./worker.js", import_meta2.url).href);
+    const { alpha, nBodyStrength, nBodyDistanceMin, nBodyDistanceMax, getCollisionRadius } = this._options;
+    this._worker.postMessage({
+      nodes: this._d3Graph.nodes,
+      edges: this._d3Graph.edges,
+      options: {
+        alpha,
+        nBodyStrength,
+        nBodyDistanceMin,
+        nBodyDistanceMax,
+        getCollisionRadius
+      }
+    });
+    this._worker.onmessage = (event) => {
+      switch (event.data.type) {
+        case "tick":
+          this.ticked(event.data);
+          break;
+        case "end":
+          this.ended(event.data);
+          break;
+        default:
+          break;
+      }
+    };
+  }
+  ticked(data) {
+  }
+  ended(data) {
+    const { nodes, edges } = data;
+    this.updateD3Graph({ nodes, edges });
+    this._onLayoutChange();
+    this._onLayoutDone();
+  }
+  resume() {
+    throw new Error("Resume unavailable");
+  }
+  stop() {
+    this._worker.terminate();
+  }
+  // for steaming new data on the same graph
+  updateGraph(graph) {
+    if (this._graph.getGraphName() !== graph.getGraphName()) {
+      this._nodeMap = {};
+      this._edgeMap = {};
+    }
+    this._graph = graph;
+    const newNodeMap = {};
+    const newD3Nodes = graph.getNodes().map((node) => {
+      const id = node.id;
+      const locked = node.getPropertyValue("locked") || false;
+      const x = node.getPropertyValue("x") || 0;
+      const y = node.getPropertyValue("y") || 0;
+      const fx = locked ? x : null;
+      const fy = locked ? y : null;
+      const collisionRadius = node.getPropertyValue("collisionRadius") || 0;
+      const oldD3Node = this._nodeMap[node.id];
+      const newD3Node = oldD3Node ? oldD3Node : { id, x, y, fx, fy, collisionRadius };
+      newNodeMap[node.id] = newD3Node;
+      return newD3Node;
+    });
+    this._nodeMap = newNodeMap;
+    this._d3Graph.nodes = newD3Nodes;
+    const newEdgeMap = {};
+    const newD3Edges = graph.getEdges().map((edge) => {
+      const oldD3Edge = this._edgeMap[edge.id];
+      const newD3Edge = oldD3Edge || {
+        id: edge.id,
+        source: newNodeMap[edge.getSourceNodeId()],
+        target: newNodeMap[edge.getTargetNodeId()]
+      };
+      newEdgeMap[edge.id] = newD3Edge;
+      return newD3Edge;
+    });
+    this._edgeMap = newEdgeMap;
+    this._d3Graph.edges = newD3Edges;
+  }
+  updateD3Graph(graph) {
+    const existingNodes = this._graph.getNodes();
+    const newNodeMap = {};
+    const newD3Nodes = graph.nodes.map((node) => {
+      const existingNode = existingNodes.find((n) => n.getId() === node.id);
+      existingNode.setDataProperty("locked", node.locked);
+      existingNode.setDataProperty("x", node.x);
+      existingNode.setDataProperty("y", node.y);
+      existingNode.setDataProperty("collisionRadius", node.collisionRadius);
+      newNodeMap[node.id] = node;
+      return node;
+    });
+    this._nodeMap = newNodeMap;
+    this._d3Graph.nodes = newD3Nodes;
+    const newEdgeMap = {};
+    const newD3Edges = graph.edges.map((edge) => {
+      newEdgeMap[edge.id] = edge;
+      return edge;
+    });
+    this._graph.triggerUpdate();
+    this._edgeMap = newEdgeMap;
+    this._d3Graph.edges = newD3Edges;
+  }
+  getNodePosition = (node) => {
+    const d3Node = this._nodeMap[node.id];
+    if (d3Node) {
+      return [d3Node.x, d3Node.y];
+    }
+    return [0, 0];
+  };
+  getEdgePosition = (edge) => {
+    const d3Edge = this._edgeMap[edge.id];
+    const sourcePosition = d3Edge && d3Edge.source;
+    const targetPosition = d3Edge && d3Edge.target;
+    if (d3Edge && sourcePosition && targetPosition) {
+      return {
+        type: EDGE_TYPE.LINE,
+        sourcePosition: [sourcePosition.x, sourcePosition.y],
+        targetPosition: [targetPosition.x, targetPosition.y],
+        controlPoints: []
+      };
+    }
+    return {
+      type: EDGE_TYPE.LINE,
+      sourcePosition: [0, 0],
+      targetPosition: [0, 0],
+      controlPoints: []
+    };
+  };
+  lockNodePosition = (node, x, y) => {
+    const d3Node = this._nodeMap[node.id];
+    d3Node.x = x;
+    d3Node.y = y;
+    d3Node.fx = x;
+    d3Node.fy = y;
+    this._callbacks.onLayoutChange();
+    this._callbacks.onLayoutDone();
+  };
+  unlockNodePosition = (node) => {
+    const d3Node = this._nodeMap[node.id];
+    d3Node.fx = null;
+    d3Node.fy = null;
+  };
+};
+
+// dist/layouts/simple-layout/simple-layout.js
+var defaultOptions3 = {
+  nodePositionAccessor: (node) => [node.getPropertyValue("x"), node.getPropertyValue("y")]
+};
+var SimpleLayout = class extends BaseLayout {
+  _name = "SimpleLayout";
+  _graph = null;
+  _nodeMap = {};
+  _nodePositionMap = {};
+  constructor(options = {}) {
+    super({ ...defaultOptions3, ...options });
+  }
+  initializeGraph(graph) {
+    this.updateGraph(graph);
+  }
+  _notifyLayoutComplete() {
+    this._onLayoutStart();
+    this._onLayoutChange();
+    this._onLayoutDone();
+  }
+  start() {
+    this._notifyLayoutComplete();
+  }
+  update() {
+    this._notifyLayoutComplete();
+  }
+  resume() {
+    this._notifyLayoutComplete();
+  }
+  updateGraph(graph) {
+    this._graph = graph;
+    this._nodeMap = graph.getNodes().reduce((res, node) => {
+      res[node.getId()] = node;
+      return res;
+    }, {});
+    this._nodePositionMap = graph.getNodes().reduce((res, node) => {
+      res[node.getId()] = this._options.nodePositionAccessor(node);
+      return res;
+    }, {});
+  }
+  setNodePositionAccessor = (accessor) => {
+    this._options.nodePositionAccessor = accessor;
+  };
+  getNodePosition = (node) => this._nodePositionMap[node.getId()];
+  getEdgePosition = (edge) => {
+    const sourcePos = this._nodePositionMap[edge.getSourceNodeId()];
+    const targetPos = this._nodePositionMap[edge.getTargetNodeId()];
+    return {
+      type: EDGE_TYPE.LINE,
+      sourcePosition: sourcePos,
+      targetPosition: targetPos,
+      controlPoints: []
+    };
+  };
+  lockNodePosition = (node, x, y) => {
+    this._nodePositionMap[node.getId()] = [x, y];
+    this._onLayoutChange();
+    this._onLayoutDone();
+  };
+};
+
+// dist/utils/create-graph.js
+function createGraph({ name, nodes, edges, nodeParser, edgeParser }) {
+  const graph = new Graph();
+  const graphName = name || Date.now();
+  graph.setGraphName(graphName);
+  const glNodes = nodes.map((node) => {
+    const { id } = nodeParser(node);
+    return new Node({
+      id,
+      data: node
+    });
+  });
+  graph.batchAddNodes(glNodes);
+  const glEdges = edges.map((edge) => {
+    const { id, sourceId, targetId, directed } = edgeParser(edge);
+    return new Edge({
+      id,
+      sourceId,
+      targetId,
+      directed,
+      data: edge
+    });
+  });
+  graph.batchAddEdges(glEdges);
+  return graph;
+}
+
+// dist/loaders/node-parsers.js
+function basicNodeParser(node) {
+  if (node.id === void 0) {
+    log.error("Invalid node: id is missing.")();
+    return null;
+  }
+  return { id: node.id };
+}
+
+// dist/loaders/edge-parsers.js
+function basicEdgeParser(edge) {
+  const { id, directed, sourceId, targetId } = edge;
+  if (sourceId === void 0 || targetId === void 0) {
+    log.error("Invalid edge: sourceId or targetId is missing.")();
+    return null;
+  }
+  return {
+    id,
+    directed: directed || false,
+    sourceId,
+    targetId
+  };
+}
+
+// dist/loaders/json-loader.js
+var JSONLoader = ({ json, nodeParser = basicNodeParser, edgeParser = basicEdgeParser }) => {
+  const { name = "default", nodes, edges } = json;
+  if (!nodes) {
+    log.error("Invalid graph: nodes is missing.")();
+    return null;
+  }
+  const graph = createGraph({ name, nodes, edges, nodeParser, edgeParser });
+  return graph;
+};
+
+// dist/utils/layer-utils.js
+var mixedGetPosition = (getPosition, getOffset2) => {
+  if (!getOffset2) {
+    return getPosition;
+  }
+  if (typeof getOffset2 === "function") {
+    return (d) => {
+      const [x, y] = getPosition(d);
+      const [offX2, offY2] = getOffset2(d);
+      return [x + offX2, y + offY2];
+    };
+  }
+  const [offX, offY] = getOffset2;
+  return (d) => {
+    const [x, y] = getPosition(d);
+    return [x + offX, y + offY];
+  };
+};
+
+// dist/layers/graph-layer.js
+var import_core16 = require("@deck.gl/core");
+
+// dist/style/style-property.js
+var import_color = __toESM(require("color"), 1);
+function getColor(value) {
+  if (typeof value === "string") {
+    try {
+      const color = import_color.default.rgb(value).array();
+      if (Number.isFinite(color[3])) {
+        color[3] *= 255;
+      }
+      return color;
+    } catch (error) {
+      return [0, 0, 0];
+    }
+  }
+  if (Array.isArray(value) && Number.isFinite(value[0])) {
+    return value;
+  }
+  return [0, 0, 0];
+}
+function getNumber(value) {
+  switch (typeof value) {
+    case "string":
+      value = Number(value);
+      return isNaN(value) ? null : value;
+    case "number":
+      return value;
+    default:
+      return null;
+  }
+}
+function getBool(value) {
+  switch (typeof value) {
+    case "boolean":
+      return value;
+    case "string":
+      return value.toLowerCase() !== "false";
+    case "number":
+      return Boolean(value);
+    default:
+      return null;
+  }
+}
+function getOffset(value) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (!Array.isArray(value) || value.length !== 2) {
+    return null;
+  }
+  return value.map(getNumber);
+}
+var IDENTITY = (x) => x;
+var PROPERTY_FORMATTERS = {
+  opacity: getNumber,
+  zIndex: getNumber,
+  width: getNumber,
+  height: getNumber,
+  radius: getNumber,
+  fill: getColor,
+  stroke: getColor,
+  strokeWidth: getNumber,
+  // for marker
+  marker: String,
+  size: getNumber,
+  // text
+  color: getColor,
+  text: String,
+  fontSize: getNumber,
+  textAnchor: String,
+  alignmentBaseline: String,
+  angle: getNumber,
+  textMaxWidth: getNumber,
+  textWordBreak: String,
+  textSizeMinPixels: getNumber,
+  // edges
+  speed: getNumber,
+  tailLength: getNumber,
+  offset: getOffset,
+  scaleWithZoom: getBool
+};
+var DEFAULT_STYLES = {
+  opacity: 1,
+  zIndex: 0,
+  width: 0,
+  height: 0,
+  radius: 1,
+  fill: [0, 0, 0],
+  stroke: [0, 0, 0],
+  strokeWidth: 0,
+  marker: "circle",
+  size: 12,
+  color: [0, 0, 0],
+  text: "",
+  fontSize: 12,
+  textAnchor: "middle",
+  alignmentBaseline: "center",
+  angle: 0,
+  textMaxWidth: -1,
+  textWordBreak: "break-all",
+  textSizeMinPixels: 9,
+  speed: 0,
+  tailLength: 1,
+  offset: null,
+  scaleWithZoom: true
+};
+function generateAccessor(key, value) {
+  const formatter = PROPERTY_FORMATTERS[key] || IDENTITY;
+  const valueMap = Object.keys(value).reduce((res, key0) => {
+    res[key0] = value[key0];
+    return res;
+  }, {});
+  return (node) => {
+    const statefulValue = valueMap[node.state];
+    if (!node.state || typeof statefulValue === "undefined") {
+      return valueMap.default || DEFAULT_STYLES[key];
+    }
+    if (typeof statefulValue === "function") {
+      return formatter(statefulValue(node));
+    }
+    return formatter(statefulValue);
+  };
+}
+var VALUE_TYPE = {
+  ACCESSOR: "ACCESSOR",
+  PLAIN_VALUE: "PLAIN_VALUE"
+};
+var StyleProperty = class {
+  key;
+  _updateTrigger;
+  _value;
+  _valueType;
+  // for getting default style
+  static getDefault(key) {
+    return DEFAULT_STYLES[key];
+  }
+  // pass the key and value of the property
+  // and format the value properly.
+  constructor({ key, value, updateTrigger }) {
+    this.key = key;
+    this._updateTrigger = false;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      this._value = generateAccessor(key, value);
+      this._valueType = VALUE_TYPE.ACCESSOR;
+      this._updateTrigger = updateTrigger;
+    } else if (typeof value === "function") {
+      const formatter = PROPERTY_FORMATTERS[key] || IDENTITY;
+      this._value = (d) => formatter(value(d));
+      this._valueType = VALUE_TYPE.ACCESSOR;
+      this._updateTrigger = value;
+    } else {
+      const formatter = PROPERTY_FORMATTERS[key] || IDENTITY;
+      this._value = formatter(value);
+      this._valueType = VALUE_TYPE.PLAIN_VALUE;
+      this._updateTrigger = false;
+    }
+    if (this._value === null) {
+      log.warn(`Invalid ${key} value: ${value}`)();
+      throw new Error(`Invalid ${key} value: ${value}`);
+    }
+  }
+  // get the formatted value
+  getValue() {
+    return this._value;
+  }
+  getUpdateTrigger() {
+    return this._updateTrigger;
+  }
+};
+
+// dist/style/style-sheet.js
+var COMMON_DECKGL_PROPS = {
+  getOffset: "offset",
+  opacity: "opacity"
+};
+var DECKGL_ACCESSOR_MAP = {
+  [NODE_TYPE.CIRCLE]: {
+    ...COMMON_DECKGL_PROPS,
+    getFillColor: "fill",
+    getLineColor: "stroke",
+    getLineWidth: "strokeWidth",
+    getRadius: "radius"
+  },
+  [NODE_TYPE.RECTANGLE]: {
+    ...COMMON_DECKGL_PROPS,
+    getWidth: "width",
+    getHeight: "height",
+    getFillColor: "fill",
+    getLineColor: "stroke",
+    getLineWidth: "strokeWidth"
+  },
+  [NODE_TYPE.ROUNDED_RECTANGLE]: {
+    ...COMMON_DECKGL_PROPS,
+    getCornerRadius: "cornerRadius",
+    getRadius: "radius",
+    getWidth: "width",
+    getHeight: "height",
+    getFillColor: "fill",
+    getLineColor: "stroke",
+    getLineWidth: "strokeWidth"
+  },
+  [NODE_TYPE.PATH_ROUNDED_RECTANGLE]: {
+    ...COMMON_DECKGL_PROPS,
+    getWidth: "width",
+    getHeight: "height",
+    getFillColor: "fill",
+    getLineColor: "stroke",
+    getLineWidth: "strokeWidth",
+    getCornerRadius: "cornerRadius"
+  },
+  [NODE_TYPE.LABEL]: {
+    ...COMMON_DECKGL_PROPS,
+    getColor: "color",
+    getText: "text",
+    getSize: "fontSize",
+    getTextAnchor: "textAnchor",
+    getAlignmentBaseline: "alignmentBaseline",
+    getAngle: "angle",
+    scaleWithZoom: "scaleWithZoom",
+    textMaxWidth: "textMaxWidth",
+    textWordBreak: "textWordBreak",
+    textSizeMinPixels: "textSizeMinPixels"
+  },
+  [NODE_TYPE.MARKER]: {
+    ...COMMON_DECKGL_PROPS,
+    getColor: "fill",
+    getSize: "size",
+    getMarker: "marker",
+    scaleWithZoom: "scaleWithZoom"
+  },
+  // --------- Edge related ---------
+  Edge: {
+    getColor: "stroke",
+    getWidth: "strokeWidth"
+  },
+  [EDGE_DECORATOR_TYPE.LABEL]: {
+    getColor: "color",
+    getText: "text",
+    getSize: "fontSize",
+    getTextAnchor: "textAnchor",
+    getAlignmentBaseline: "alignmentBaseline",
+    scaleWithZoom: "scaleWithZoom",
+    textMaxWidth: "textMaxWidth",
+    textWordBreak: "textWordBreak",
+    textSizeMinPixels: "textSizeMinPixels"
+  },
+  [EDGE_DECORATOR_TYPE.FLOW]: {
+    getColor: "color",
+    getWidth: "width",
+    getSpeed: "speed",
+    getTailLength: "tailLength"
+  }
+};
+var DECKGL_UPDATE_TRIGGERS = {
+  [NODE_TYPE.CIRCLE]: ["getFillColor", "getRadius", "getLineColor", "getLineWidth"],
+  [NODE_TYPE.RECTANGLE]: ["getFillColor", "getLineColor", "getLineWidth"],
+  [NODE_TYPE.ROUNDED_RECTANGLE]: [
+    "getFillColor",
+    "getLineColor",
+    "getLineWidth",
+    "getCornerRadius"
+  ],
+  [NODE_TYPE.PATH_ROUNDED_RECTANGLE]: [
+    "getFillColor",
+    "getLineColor",
+    "getLineWidth",
+    "getCornerRadius"
+  ],
+  [NODE_TYPE.LABEL]: [
+    "getColor",
+    "getText",
+    "getSize",
+    "getTextAnchor",
+    "getAlignmentBaseline",
+    "getAngle"
+  ],
+  [NODE_TYPE.MARKER]: ["getColor", "getSize", "getMarker"],
+  Edge: ["getColor", "getWidth"],
+  [EDGE_DECORATOR_TYPE.LABEL]: [
+    "getColor",
+    "getText",
+    "getSize",
+    "getTextAnchor",
+    "getAlignmentBaseline"
+  ],
+  [EDGE_DECORATOR_TYPE.FLOW]: ["getColor", "getWidth", "getSpeed", "getTailLength"]
+};
+var Stylesheet = class {
+  type;
+  properties;
+  constructor(style, updateTriggers) {
+    const { type: layerType, ...restStyle } = style;
+    if (!layerType || !(layerType in DECKGL_ACCESSOR_MAP)) {
+      throw new Error(`illegal type: ${layerType}`);
+    }
+    this.type = layerType;
+    const rules = Object.keys(restStyle).reduce((res, key) => {
+      const isSelector = key.startsWith(":");
+      if (isSelector) {
+        const state = key.substring(1);
+        res[state] = restStyle[key];
+        return res;
+      }
+      res.default[key] = restStyle[key];
+      return res;
+    }, {
+      default: {}
+    });
+    const attributes = Object.values(rules).reduce((res, rule) => {
+      const attrs = Object.keys(rule);
+      const set = /* @__PURE__ */ new Set([...res, ...attrs]);
+      return Array.from(set);
+    }, []);
+    const attrMap = attributes.reduce((res, attr) => {
+      res[attr] = Object.entries(rules).reduce((acc, entry) => {
+        const [state, rule] = entry;
+        if (typeof rule[attr] !== "undefined") {
+          acc[state] = rule[attr];
+        }
+        return acc;
+      }, {});
+      return res;
+    }, {});
+    const simplifiedStyleMap = Object.entries(attrMap).reduce((res, entry) => {
+      const [attr, valueMap] = entry;
+      const onlyDefault = Object.keys(valueMap).length === 1 && valueMap.default !== void 0;
+      if (onlyDefault) {
+        res[attr] = valueMap.default;
+        return res;
+      }
+      res[attr] = valueMap;
+      return res;
+    }, {});
+    this.properties = {};
+    for (const key in simplifiedStyleMap) {
+      this.properties[key] = new StyleProperty({
+        key,
+        value: simplifiedStyleMap[key],
+        updateTrigger: updateTriggers.stateUpdateTrigger
+      });
+    }
+  }
+  _getProperty(deckglAccessor) {
+    const map = DECKGL_ACCESSOR_MAP[this.type];
+    if (!map) {
+      throw new Error(`illegal type: ${this.type}`);
+    }
+    const styleProp = map[deckglAccessor];
+    if (!styleProp) {
+      log.error(`Invalid DeckGL accessor: ${deckglAccessor}`)();
+      throw new Error(`Invalid DeckGL accessor: ${deckglAccessor}`);
+    }
+    return this.properties[styleProp];
+  }
+  getDeckGLAccessor(deckglAccessor) {
+    const property = this._getProperty(deckglAccessor);
+    if (property) {
+      return property.getValue();
+    }
+    const styleProp = DECKGL_ACCESSOR_MAP[this.type][deckglAccessor];
+    return StyleProperty.getDefault(styleProp);
+  }
+  getDeckGLAccessorUpdateTrigger(deckglAccessor) {
+    const property = this._getProperty(deckglAccessor);
+    if (property) {
+      return property.getUpdateTrigger();
+    }
+    return false;
+  }
+  getDeckGLAccessors() {
+    const accessorMap = DECKGL_ACCESSOR_MAP[this.type];
+    return Object.keys(accessorMap).reduce((res, accessor) => {
+      res[accessor] = this.getDeckGLAccessor(accessor);
+      return res;
+    }, {});
+  }
+  getDeckGLUpdateTriggers() {
+    return DECKGL_UPDATE_TRIGGERS[this.type].reduce((res, accessor) => {
+      res[accessor] = this.getDeckGLAccessorUpdateTrigger(accessor);
+      return res;
+    }, {});
+  }
+};
+
+// dist/core/interaction-manager.js
+var NODE_TO_EDGE_STATE_MAP = {
+  [NODE_STATE.DEFAULT]: EDGE_STATE.DEFAULT,
+  [NODE_STATE.HOVER]: EDGE_STATE.HOVER,
+  [NODE_STATE.DRAGGING]: EDGE_STATE.DRAGGING,
+  [NODE_STATE.SELECTED]: EDGE_STATE.SELECTED
+};
+function shouldEdgeBeSelected(edge) {
+  return edge.getConnectedNodes().some((node) => node.getState() === NODE_STATE.SELECTED && node.shouldHighlightConnectedEdges());
+}
+function setNodeState(node, state) {
+  node.setState(state);
+  if (node.shouldHighlightConnectedEdges()) {
+    node.getConnectedEdges().forEach((edge) => {
+      let newEdgeState = NODE_TO_EDGE_STATE_MAP[state];
+      if (shouldEdgeBeSelected(edge)) {
+        newEdgeState = EDGE_STATE.SELECTED;
+      }
+      edge.setState(newEdgeState);
+    });
+  }
+}
+var InteractionManager = class {
+  notifyCallback;
+  _lastInteraction = 0;
+  _lastHoveredNode = null;
+  _lastSelectedNode = null;
+  nodeEvents = void 0;
+  edgeEvents = void 0;
+  engine = void 0;
+  enableDragging = void 0;
+  resumeLayoutAfterDragging = void 0;
+  constructor(props, notifyCallback) {
+    this.updateProps(props);
+    this.notifyCallback = notifyCallback;
+    this._lastInteraction = 0;
+    this._lastHoveredNode = null;
+    this._lastSelectedNode = null;
+  }
+  updateProps({ nodeEvents = {}, edgeEvents = {}, engine, enableDragging, resumeLayoutAfterDragging }) {
+    this.nodeEvents = nodeEvents;
+    this.edgeEvents = edgeEvents;
+    this.engine = engine;
+    this.enableDragging = enableDragging;
+    this.resumeLayoutAfterDragging = resumeLayoutAfterDragging;
+  }
+  getLastInteraction() {
+    return this._lastInteraction;
+  }
+  onClick(info, event) {
+    const { object } = info;
+    if (!object) {
+      return;
+    }
+    if (object.isNode) {
+      if (object.isSelectable()) {
+        if (this._lastSelectedNode) {
+          setNodeState(this._lastSelectedNode, NODE_STATE.DEFAULT);
+        }
+        setNodeState(object, NODE_STATE.SELECTED);
+        this._lastSelectedNode = object;
+        this._lastInteraction = Date.now();
+        this.notifyCallback();
+      }
+      if (this.nodeEvents.onClick) {
+        this.nodeEvents.onClick(info, event);
+      }
+    }
+    if (object.isEdge && this.edgeEvents.onClick) {
+      this.edgeEvents.onClick(info, event);
+    }
+  }
+  _mouseLeaveNode() {
+    var _a;
+    const lastHoveredNode = this._lastHoveredNode;
+    if (!(lastHoveredNode.isSelectable() && lastHoveredNode.getState() === NODE_STATE.SELECTED)) {
+      const newState = this._lastSelectedNode !== null && this._lastSelectedNode.id === ((_a = this._lastHoveredNode) == null ? void 0 : _a.id) ? NODE_STATE.SELECTED : NODE_STATE.DEFAULT;
+      setNodeState(lastHoveredNode, newState);
+    }
+    if (this.nodeEvents.onMouseLeave) {
+      this.nodeEvents.onMouseLeave(lastHoveredNode);
+    }
+  }
+  _mouseEnterNode(info) {
+    setNodeState(info.object, NODE_STATE.HOVER);
+    if (this.nodeEvents.onMouseEnter) {
+      this.nodeEvents.onMouseEnter(info);
+    }
+    if (this.nodeEvents.onHover) {
+      this.nodeEvents.onHover(info);
+    }
+  }
+  onHover(info, event) {
+    if (!info.object) {
+      if (this._lastHoveredNode) {
+        this._mouseLeaveNode();
+        this._lastInteraction = Date.now();
+        this._lastHoveredNode = null;
+        this.notifyCallback();
+      }
+      return;
+    }
+    if (info.object.isNode) {
+      const isSameNode = this._lastHoveredNode && this._lastHoveredNode.id === info.object.id;
+      if (isSameNode) {
+        return;
+      }
+      if (this._lastHoveredNode) {
+        this._mouseLeaveNode();
+      }
+      this._mouseEnterNode(info);
+      this._lastInteraction = Date.now();
+      this._lastHoveredNode = info.object;
+      this.notifyCallback();
+    }
+    if (info.object.isEdge && this.edgeEvents.onHover) {
+      this.edgeEvents.onHover(info);
+    }
+  }
+  onDragStart(info, event) {
+    if (this.nodeEvents.onDragStart) {
+      this.nodeEvents.onDragStart(info);
+    }
+  }
+  onDrag(info, event) {
+    if (!info.object.isNode || !this.enableDragging) {
+      return;
+    }
+    event.stopImmediatePropagation();
+    const coordinates = info.layer.context.viewport.unproject([info.x, info.y]);
+    const bounds = info.layer.context.viewport.getBounds();
+    const x = Math.min(Math.max(coordinates[0], bounds[0]), bounds[2]);
+    const y = Math.min(Math.max(coordinates[1], bounds[1]), bounds[3]);
+    this.engine.lockNodePosition(info.object, x, y);
+    setNodeState(info.object, NODE_STATE.DRAGGING);
+    this._lastInteraction = Date.now();
+    this.notifyCallback();
+    if (this.nodeEvents.onDrag) {
+      this.nodeEvents.onDrag(info);
+    }
+  }
+  onDragEnd(info, event) {
+    if (!info.object.isNode || !this.enableDragging) {
+      return;
+    }
+    if (this.resumeLayoutAfterDragging) {
+      this.engine.resume();
+    }
+    setNodeState(info.object, NODE_STATE.DEFAULT);
+    this.engine.unlockNodePosition(info.object);
+  }
+};
+
+// dist/layers/node-layers/circle-layer.js
+var import_core = require("@deck.gl/core");
+var import_layers = require("@deck.gl/layers");
+var CircleLayer = class extends import_core.CompositeLayer {
+  renderLayers() {
+    const { data, getPosition, stylesheet, positionUpdateTrigger = 0 } = this.props;
+    return [
+      new import_layers.ScatterplotLayer(this.getSubLayerProps({
+        id: "__scatterplot-layer",
+        data,
+        getPosition,
+        ...stylesheet.getDeckGLAccessors(),
+        updateTriggers: {
+          getPosition: positionUpdateTrigger,
+          ...stylesheet.getDeckGLUpdateTriggers()
+        }
+      }))
+    ];
+  }
+};
+__publicField(CircleLayer, "layerName", "CircleLayer");
+
+// dist/layers/node-layers/image-layer.js
+var import_core2 = require("@deck.gl/core");
+var import_layers2 = require("@deck.gl/layers");
+var ImageLayer = class extends import_core2.CompositeLayer {
+  renderLayers() {
+    const { data, getPosition, stylesheet, positionUpdateTrigger = 0 } = this.props;
+    return [
+      new import_layers2.IconLayer(this.getSubLayerProps({
+        id: "__icon-layer",
+        data,
+        getPosition,
+        ...stylesheet.getDeckGLAccessors(),
+        updateTriggers: {
+          getPosition: positionUpdateTrigger,
+          ...stylesheet.getDeckGLUpdateTriggers()
+        }
+      }))
+    ];
+  }
+};
+__publicField(ImageLayer, "layerName", "ImageLayer");
+
+// dist/layers/node-layers/label-layer.js
+var import_core4 = require("@deck.gl/core");
+
+// dist/layers/common-layers/zoomable-text-layer/zoomable-text-layer.js
+var import_core3 = require("@deck.gl/core");
+var import_layers3 = require("@deck.gl/layers");
+var ZoomableTextLayer = class extends import_core3.CompositeLayer {
+  initializeState() {
+    this.state = { characterSet: [] };
+  }
+  shouldUpdateState({ props, changeFlags }) {
+    const { scaleWithZoom } = this.props;
+    if (!scaleWithZoom) {
+      return changeFlags.dataChanged || changeFlags.propsChanged;
+    }
+    return changeFlags.dataChanged || changeFlags.propsChanged || changeFlags.viewportChanged;
+  }
+  updateState({ props, oldProps, changeFlags }) {
+    super.updateState({ props, oldProps, changeFlags });
+    if (changeFlags.propsOrDataChanged) {
+      const { getText } = props;
+      let textLabels = [];
+      if (typeof getText === "function") {
+        textLabels = props.data.map(getText);
+      } else {
+        textLabels = [getText];
+      }
+      const characterSet = new Set(textLabels.join(""));
+      const uniqueCharacters = Array.from(characterSet);
+      this.setState({ characterSet: uniqueCharacters });
+    }
+  }
+  renderLayers() {
+    const { data, getPosition, getColor: getColor2, getText, getSize, getTextAnchor, getAlignmentBaseline, getAngle, scaleWithZoom, updateTriggers, fontFamily, textWordUnits, textWordBreak, textMaxWidth, textSizeMinPixels } = this.props;
+    const sizeUpdateTrigger = scaleWithZoom ? [getSize, this.context.viewport.zoom] : false;
+    const newGetText = typeof getText === "function" ? getText : () => getText;
+    return [
+      new import_layers3.TextLayer(this.getSubLayerProps({
+        id: "__text-layer",
+        data,
+        sizeScale: scaleWithZoom ? Math.pow(2, this.context.viewport.zoom - 1) : 1,
+        characterSet: this.state.characterSet,
+        getPosition,
+        getColor: getColor2,
+        getSize,
+        getTextAnchor,
+        getAlignmentBaseline,
+        getAngle,
+        getText: newGetText,
+        maxWidth: textMaxWidth ?? 12,
+        wordBreak: textWordBreak ?? "break-all",
+        fontFamily: fontFamily ?? "Red Hat Text",
+        wordUnits: textWordUnits ?? "pixels",
+        sizeMinPixels: textSizeMinPixels ?? 9,
+        updateTriggers: {
+          getSize: sizeUpdateTrigger,
+          getAngle: [sizeUpdateTrigger, updateTriggers.getPosition],
+          ...updateTriggers
+        }
+      }))
+    ];
+  }
+};
+__publicField(ZoomableTextLayer, "layerName", "ZoomableTextLayer");
+
+// dist/layers/node-layers/label-layer.js
+var LabelLayer = class extends import_core4.CompositeLayer {
+  renderLayers() {
+    const { data, getPosition, stylesheet, positionUpdateTrigger = 0 } = this.props;
+    return [
+      new ZoomableTextLayer(this.getSubLayerProps({
+        id: "__text-layer",
+        data,
+        getPosition,
+        ...stylesheet.getDeckGLAccessors(),
+        updateTriggers: {
+          ...stylesheet.getDeckGLUpdateTriggers(),
+          getPosition: positionUpdateTrigger
+        }
+      }))
+    ];
+  }
+};
+__publicField(LabelLayer, "layerName", "LabelLayer");
+
+// dist/layers/node-layers/rectangle-layer.js
+var import_core5 = require("@deck.gl/core");
+var import_layers4 = require("@deck.gl/layers");
+var generateRectangle = (node, { getWidth, getHeight, getPosition }) => {
+  const pos = getPosition(node);
+  const width = typeof getWidth === "function" ? getWidth(node._data.label.length * 12) : getWidth;
+  const height = typeof getWidth === "function" ? getHeight(node) : getHeight;
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  return [
+    [pos[0] - halfWidth, pos[1] - halfHeight],
+    [pos[0] - halfWidth, pos[1] + halfHeight],
+    [pos[0] + halfWidth, pos[1] + halfHeight],
+    [pos[0] + halfWidth, pos[1] - halfHeight]
+  ];
+};
+var RectangleLayer = class extends import_core5.CompositeLayer {
+  renderLayers() {
+    const { data, getPosition, stylesheet, positionUpdateTrigger = 0 } = this.props;
+    const getFillColor = stylesheet.getDeckGLAccessor("getFillColor");
+    const getLineWidth = stylesheet.getDeckGLAccessor("getLineWidth");
+    return [
+      new import_layers4.PolygonLayer(this.getSubLayerProps({
+        id: "__polygon-layer",
+        data,
+        getPolygon: (node) => generateRectangle(node, {
+          getPosition,
+          getWidth: stylesheet.getDeckGLAccessor("getWidth"),
+          getHeight: stylesheet.getDeckGLAccessor("getHeight")
+        }),
+        filled: Boolean(getFillColor),
+        jointRounded: true,
+        stroked: Boolean(getLineWidth),
+        ...stylesheet.getDeckGLAccessors(),
+        updateTriggers: {
+          getPolygon: [
+            positionUpdateTrigger,
+            stylesheet.getDeckGLAccessorUpdateTrigger("getWidth"),
+            stylesheet.getDeckGLAccessorUpdateTrigger("getHeight")
+          ],
+          ...stylesheet.getDeckGLUpdateTriggers()
+        }
+      }))
+    ];
+  }
+};
+__publicField(RectangleLayer, "layerName", "RectangleLayer");
+
+// dist/layers/node-layers/rounded-rectangle-layer-fragment.js
+var fs = (
+  /* glsl */
+  `#define SHADER_NAME rounded-rectangle-layer-fragment-shader
+
+precision highp float;
+
+uniform float cornerRadius;
+
+varying vec4 vFillColor;
+varying vec2 unitPosition;
+
+void main(void) {
+
+  float distToCenter = length(unitPosition);
+
+  /* Calculate the cutoff radius for the rounded corners */
+  float threshold = sqrt(2.0) * (1.0 - cornerRadius) + 1.0 * cornerRadius;
+  if (distToCenter <= threshold) {
+    gl_FragColor = vFillColor;
+  } else {
+    discard;
+  }
+
+  gl_FragColor = picking_filterHighlightColor(gl_FragColor);
+
+  gl_FragColor = picking_filterPickingColor(gl_FragColor);
+}
+`
+);
+
+// dist/layers/node-layers/rounded-rectangle-layer.js
+var RoundedRectangleLayer = class extends RectangleLayer {
+  draw({ uniforms }) {
+    super.draw({
+      uniforms: {
+        ...uniforms,
+        cornerRadius: this.props.cornerRadius
+      }
+    });
+  }
+  getShaders() {
+    return Object.assign({}, super.getShaders(void 0), {
+      fs
+    });
+  }
+};
+__publicField(RoundedRectangleLayer, "layerName", "RoundedRectangleLayer");
+RoundedRectangleLayer.defaultProps = {
+  // cornerRadius: the amount of rounding at the rectangle corners
+  // 0 - rectangle. 1 - circle.
+  cornerRadius: 0.1
+};
+
+// dist/layers/node-layers/path-rounded-rectange-layer.js
+var import_core6 = require("@deck.gl/core");
+var import_layers5 = require("@deck.gl/layers");
+
+// dist/utils/polygon-calculations.js
+function generateRoundedCorners(pos, width, height, radius, factor = 20) {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const bottomLeft = { X: pos[0] - halfWidth, Y: pos[1] - halfHeight };
+  const topLeft = { X: pos[0] - halfWidth, Y: pos[1] + halfHeight };
+  const bottomRight = { X: pos[0] + halfWidth, Y: pos[1] - halfHeight };
+  const topRight = { X: pos[0] + halfWidth, Y: pos[1] + halfHeight };
+  const roundedPointsForBottomLeft = getRoundedCorner(bottomLeft, topLeft, bottomRight, radius, factor);
+  const roundedPointsForTopLeft = getRoundedCorner(topLeft, topRight, bottomLeft, radius, factor).reverse();
+  const roundedPointsForTopRight = getRoundedCorner(topRight, bottomRight, topLeft, radius, factor).reverse();
+  const roundedPointsForBottomRight = getRoundedCorner(bottomRight, bottomLeft, topRight, radius, factor).reverse();
+  const result = [
+    ...roundedPointsForBottomLeft,
+    ...roundedPointsForTopLeft,
+    ...roundedPointsForTopRight,
+    ...roundedPointsForBottomRight
+  ];
+  return result;
+}
+function getRoundedCorner(angularPoint, p1, p2, radius, factor) {
+  const dx1 = angularPoint.X - p1.X;
+  const dy1 = angularPoint.Y - p1.Y;
+  const dx2 = angularPoint.X - p2.X;
+  const dy2 = angularPoint.Y - p2.Y;
+  const angle = (Math.atan2(dy1, dx1) - Math.atan2(dy2, dx2)) / 2;
+  const tan = Math.abs(Math.tan(angle));
+  let segment = radius / tan;
+  const length1 = getLength(dx1, dy1);
+  const length2 = getLength(dx2, dy2);
+  const length = Math.min(length1, length2);
+  if (segment > length) {
+    segment = length;
+    radius = length * tan;
+  }
+  const p1Cross = getProportionPoint(angularPoint, segment, length1, dx1, dy1);
+  const p2Cross = getProportionPoint(angularPoint, segment, length2, dx2, dy2);
+  const dx = angularPoint.X * 2 - p1Cross.X - p2Cross.X;
+  const dy = angularPoint.Y * 2 - p1Cross.Y - p2Cross.Y;
+  const L = getLength(dx, dy);
+  const d = getLength(segment, radius);
+  const circlePoint = getProportionPoint(angularPoint, d, L, dx, dy);
+  let startAngle = Math.atan2(p1Cross.Y - circlePoint.Y, p1Cross.X - circlePoint.X);
+  const endAngle = Math.atan2(p2Cross.Y - circlePoint.Y, p2Cross.X - circlePoint.X);
+  let sweepAngle = endAngle - startAngle;
+  if (sweepAngle < 0) {
+    startAngle = endAngle;
+    sweepAngle = -sweepAngle;
+  }
+  if (sweepAngle > Math.PI)
+    sweepAngle = Math.PI - sweepAngle;
+  const degreeFactor = factor / Math.PI;
+  return getPointsForArc(sweepAngle, degreeFactor, startAngle, circlePoint, radius);
+}
+function getLength(dx, dy) {
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function getProportionPoint(point, segment, length, dx, dy) {
+  const factor = segment / length;
+  return {
+    X: point.X - dx * factor,
+    Y: point.Y - dy * factor
+  };
+}
+function getPointsForArc(sweepAngle, degreeFactor, startAngle, circlePoint, radius) {
+  const pointsCount = Math.abs(sweepAngle * degreeFactor);
+  const sign = Math.sign(sweepAngle);
+  const points = [];
+  for (let i = 0; i < pointsCount; ++i) {
+    const pointX = circlePoint.X + Math.cos(startAngle + sign * i / degreeFactor) * radius;
+    const pointY = circlePoint.Y + Math.sin(startAngle + sign * i / degreeFactor) * radius;
+    const point = [pointX, pointY];
+    points.push(point);
+  }
+  return points;
+}
+
+// dist/layers/node-layers/path-rounded-rectange-layer.js
+var generateRoundedRectangle = (node, { getWidth, getHeight, getPosition, getCornerRadius }) => {
+  const pos = getPosition(node);
+  const width = typeof getWidth === "function" ? getWidth(node) : getWidth;
+  const height = typeof getWidth === "function" ? getHeight(node) : getHeight;
+  const cornerRadius = typeof getCornerRadius === "function" ? getCornerRadius(node) : getCornerRadius;
+  const factor = 20;
+  return generateRoundedCorners(pos, width, height, cornerRadius, factor);
+};
+var PathBasedRoundedRectangleLayer = class extends import_core6.CompositeLayer {
+  renderLayers() {
+    const { data, getPosition, stylesheet, positionUpdateTrigger = 0 } = this.props;
+    const getFillColor = stylesheet.getDeckGLAccessor("getFillColor");
+    const getLineWidth = stylesheet.getDeckGLAccessor("getLineWidth");
+    return [
+      new import_layers5.PolygonLayer(this.getSubLayerProps({
+        id: "__polygon-layer",
+        data,
+        getPolygon: (node) => generateRoundedRectangle(node, {
+          getPosition,
+          getWidth: stylesheet.getDeckGLAccessor("getWidth"),
+          getHeight: stylesheet.getDeckGLAccessor("getHeight"),
+          getCornerRadius: stylesheet.getDeckGLAccessor("getCornerRadius")
+        }),
+        filled: Boolean(getFillColor),
+        stroked: Boolean(getLineWidth),
+        ...stylesheet.getDeckGLAccessors(),
+        updateTriggers: {
+          getPolygon: [
+            positionUpdateTrigger,
+            stylesheet.getDeckGLAccessorUpdateTrigger("getWidth"),
+            stylesheet.getDeckGLAccessorUpdateTrigger("getHeight"),
+            stylesheet.getDeckGLAccessorUpdateTrigger("getCornerRadius")
+          ],
+          ...stylesheet.getDeckGLUpdateTriggers()
+        }
+      }))
+    ];
+  }
+};
+__publicField(PathBasedRoundedRectangleLayer, "layerName", "PathBasedRoundedRectangleLayer");
+
+// dist/layers/node-layers/zoomable-marker-layer.js
+var import_core8 = require("@deck.gl/core");
+
+// dist/layers/common-layers/marker-layer/marker-layer.js
+var import_core7 = require("@deck.gl/core");
+var import_layers6 = require("@deck.gl/layers");
+
+// dist/layers/common-layers/marker-layer/marker-mapping.js
+var MarkerMapping = {
+  "bell-filled": {
+    x: 0,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  bell: {
+    x: 32,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "bookmark-filled": {
+    x: 0,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  bookmark: {
+    x: 32,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "cd-filled": {
+    x: 64,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  cd: {
+    x: 64,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  checkmark: {
+    x: 0,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-check-filled": {
+    x: 32,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-check": {
+    x: 64,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-filled": {
+    x: 96,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-i-filled": {
+    x: 96,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-i": {
+    x: 96,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-minus-filled": {
+    x: 0,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-minus": {
+    x: 32,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-plus-filled": {
+    x: 64,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-plus": {
+    x: 96,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-questionmark-filled": {
+    x: 128,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-questionmark": {
+    x: 128,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-slash-filled": {
+    x: 128,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-slash": {
+    x: 128,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-x-filled": {
+    x: 0,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "circle-x": {
+    x: 32,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  circle: {
+    x: 64,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "diamond-filled": {
+    x: 96,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  diamond: {
+    x: 128,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "flag-filled": {
+    x: 160,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  flag: {
+    x: 160,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  gear: {
+    x: 160,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "heart-filled": {
+    x: 160,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  heart: {
+    x: 160,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "location-marker-filled": {
+    x: 0,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "location-marker": {
+    x: 32,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "octagonal-star-filled": {
+    x: 64,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "octagonal-star": {
+    x: 96,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "person-filled": {
+    x: 128,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  person: {
+    x: 160,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "pin-filled": {
+    x: 192,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  pin: {
+    x: 192,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "plus-small": {
+    x: 192,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  plus: {
+    x: 192,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "rectangle-filled": {
+    x: 192,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  rectangle: {
+    x: 192,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "star-filled": {
+    x: 0,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  star: {
+    x: 32,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "tag-filled": {
+    x: 64,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  tag: {
+    x: 96,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "thumb-down-filled": {
+    x: 128,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "thumb-down": {
+    x: 160,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "thumb-up": {
+    x: 192,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "thumb_up-filled": {
+    x: 224,
+    y: 0,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-down-filled": {
+    x: 224,
+    y: 32,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-down": {
+    x: 224,
+    y: 64,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-left-filled": {
+    x: 224,
+    y: 96,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-left": {
+    x: 224,
+    y: 128,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-right-filled": {
+    x: 224,
+    y: 160,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-right": {
+    x: 224,
+    y: 192,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-up-filled": {
+    x: 0,
+    y: 224,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "triangle-up": {
+    x: 32,
+    y: 224,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  "x-small": {
+    x: 64,
+    y: 224,
+    width: 32,
+    height: 32,
+    mask: true
+  },
+  x: {
+    x: 96,
+    y: 224,
+    width: 32,
+    height: 32,
+    mask: true
+  }
+};
+
+// dist/layers/common-layers/marker-layer/atlas-data-url.js
+var AtlasDataURL = {
+  dataURL: "data:image/png;base64,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"
+};
+
+// dist/layers/common-layers/marker-layer/marker-layer.js
+var MarkerLayer = class extends import_core7.CompositeLayer {
+  renderLayers() {
+    const { getMarker, ...otherProps } = this.props;
+    return [
+      new import_layers6.IconLayer(this.getSubLayerProps({
+        id: "marker-layer",
+        iconAtlas: AtlasDataURL.dataURL,
+        iconMapping: MarkerMapping,
+        getIcon: getMarker,
+        ...otherProps
+      }))
+    ];
+  }
+};
+__publicField(MarkerLayer, "layerName", "MarkerLayer");
+__publicField(MarkerLayer, "defaultProps", {
+  id: "MarkerLayer",
+  data: [],
+  getMarker: (d) => d.marker,
+  getColor: (d) => [0, 0, 0],
+  getSize: (d) => 10
+});
+
+// dist/layers/node-layers/zoomable-marker-layer.js
+var ZoomableMarkerLayer = class extends import_core8.CompositeLayer {
+  shouldUpdateState({ props, changeFlags }) {
+    const { stylesheet } = this.props;
+    const scaleWithZoom = stylesheet.getDeckGLAccessor("scaleWithZoom");
+    if (!scaleWithZoom) {
+      return changeFlags.somethingChanged;
+    }
+    return changeFlags.somethingChanged || changeFlags.viewportChanged;
+  }
+  renderLayers() {
+    const { data, getPosition, stylesheet, positionUpdateTrigger = 0 } = this.props;
+    const getSize = stylesheet.getDeckGLAccessor("getSize");
+    const scaleWithZoom = stylesheet.getDeckGLAccessor("scaleWithZoom");
+    const sizeUpdateTrigger = scaleWithZoom ? [getSize, this.context.viewport.zoom] : false;
+    const oiginalGetMarker = stylesheet.getDeckGLAccessor("getMarker");
+    const getMarker = typeof oiginalGetMarker === "function" ? oiginalGetMarker : () => oiginalGetMarker;
+    return [
+      new MarkerLayer(this.getSubLayerProps({
+        id: "zoomable-marker-layer",
+        data,
+        getPosition,
+        sizeScale: scaleWithZoom ? Math.max(0, this.context.viewport.zoom) : 1,
+        ...stylesheet.getDeckGLAccessors(),
+        getMarker,
+        updateTriggers: {
+          ...stylesheet.getDeckGLUpdateTriggers(),
+          getPosition: positionUpdateTrigger,
+          getSize: sizeUpdateTrigger
+        }
+      }))
+    ];
+  }
+};
+__publicField(ZoomableMarkerLayer, "layerName", "ZoomableMarkerLayer");
+
+// dist/layers/edge-layer.js
+var import_core13 = require("@deck.gl/core");
+
+// dist/layers/edge-layers/straight-line-edge-layer.js
+var import_core9 = require("@deck.gl/core");
+var import_layers7 = require("@deck.gl/layers");
+var StraightLineEdgeLayer = class extends import_core9.CompositeLayer {
+  renderLayers() {
+    const { data, getLayoutInfo, positionUpdateTrigger = 0, colorUpdateTrigger = 0, widthUpdateTrigger = 0, ...otherProps } = this.props;
+    return [
+      new import_layers7.LineLayer(this.getSubLayerProps({
+        id: "__line-layer",
+        data,
+        getSourcePosition: (e) => getLayoutInfo(e).sourcePosition,
+        getTargetPosition: (e) => getLayoutInfo(e).targetPosition,
+        updateTriggers: {
+          getColor: colorUpdateTrigger,
+          getSourcePosition: positionUpdateTrigger,
+          getTargetPosition: positionUpdateTrigger,
+          getWidth: widthUpdateTrigger
+        },
+        ...otherProps
+      }))
+    ];
+  }
+};
+__publicField(StraightLineEdgeLayer, "layerName", "StraightLineEdgeLayer");
+
+// dist/layers/edge-layers/path-edge-layer.js
+var import_core10 = require("@deck.gl/core");
+var import_layers8 = require("@deck.gl/layers");
+var PathEdgeLayer = class extends import_core10.CompositeLayer {
+  renderLayers() {
+    const { data, getLayoutInfo, positionUpdateTrigger = 0, colorUpdateTrigger = 0, widthUpdateTrigger = 0, ...otherProps } = this.props;
+    return [
+      new import_layers8.PathLayer(this.getSubLayerProps({
+        id: "__line-layer",
+        data,
+        getPath: (e) => {
+          const { sourcePosition, targetPosition, controlPoints } = getLayoutInfo(e);
+          return [sourcePosition, ...controlPoints, targetPosition];
+        },
+        updateTriggers: {
+          getColor: colorUpdateTrigger,
+          getPath: positionUpdateTrigger,
+          getWidth: widthUpdateTrigger
+        },
+        ...otherProps
+      }))
+    ];
+  }
+};
+__publicField(PathEdgeLayer, "layerName", "PathEdgeLayer");
+
+// dist/layers/edge-layers/curved-edge-layer.js
+var import_core12 = require("@deck.gl/core");
+var import_layers10 = require("@deck.gl/layers");
+
+// dist/layers/common-layers/spline-layer/spline-layer.js
+var import_core11 = require("@deck.gl/core");
+var import_layers9 = require("@deck.gl/layers");
+var import_cardinal_spline_js = require("cardinal-spline-js");
+var defaultProps = {
+  id: "spline-layer",
+  getData: (d) => d.points,
+  getAngle: (x) => 0,
+  fontSize: 24,
+  coordinateSystem: import_core11.COORDINATE_SYSTEM.CARTESIAN,
+  fp64: false
+};
+var SplineLayer = class extends import_core11.CompositeLayer {
+  initializeState() {
+    this.state = { typedEdgeData: [] };
+  }
+  shouldUpdateState({ changeFlags }) {
+    return changeFlags.dataChanged || changeFlags.propsChanged;
+  }
+  updateState({ props, oldProps, changeFlags }) {
+    super.updateState({ props, oldProps, changeFlags });
+    if (changeFlags.dataChanged || changeFlags.propsChanged) {
+      this.updateSplineData();
+    }
+  }
+  updateSplineData() {
+    const { data } = this.props;
+    const paths = data.reduce((res, d) => {
+      const sourcePosition = this.props.getSourcePosition(d);
+      const targetPosition = this.props.getTargetPosition(d);
+      const controlPoints = this.props.getControlPoints(d);
+      const serializedControlPoints = controlPoints.toString().split(",");
+      const points = (0, import_cardinal_spline_js.getCurvePoints)([...sourcePosition, ...serializedControlPoints, ...targetPosition], 0.5, 10);
+      const path = [];
+      for (let idx = 0; idx < points.length; idx += 2) {
+        path.push([points[idx], points[idx + 1]]);
+      }
+      res.push(path);
+      return res;
+    }, []);
+    this.setState({ paths });
+  }
+  renderLayers() {
+    const { coordinateSystem, getColor: getColor2, getWidth, id, updateTriggers } = this.props;
+    const { paths } = this.state;
+    return new import_layers9.PathLayer({
+      id: `${id}-splines`,
+      data: paths,
+      getPath: (d) => d,
+      getColor: getColor2,
+      getWidth,
+      coordinateSystem,
+      updateTriggers
+    });
+  }
+};
+__publicField(SplineLayer, "layerName", "SplineLayer");
+SplineLayer.layerName = "SplineLayer";
+SplineLayer.defaultProps = defaultProps;
+
+// dist/layers/edge-layers/curved-edge-layer.js
+var DEBUG = false;
+var CurvedEdgeLayer = class extends import_core12.CompositeLayer {
+  // @ts-expect-error TODO
+  renderLayers() {
+    const { data, getLayoutInfo, positionUpdateTrigger = 0, colorUpdateTrigger = 0, widthUpdateTrigger = 0, ...otherProps } = this.props;
+    return [
+      DEBUG && new import_layers10.ScatterplotLayer(this.getSubLayerProps({
+        id: "__control-points",
+        data,
+        getPosition: (e) => getLayoutInfo(e).controlPoints[0],
+        getColor: (d) => [190, 190, 190, 150],
+        getRadius: (d) => 5,
+        updateTriggers: {
+          getPosition: positionUpdateTrigger
+        },
+        ...otherProps
+      })),
+      DEBUG && new import_layers10.LineLayer(this.getSubLayerProps({
+        id: "__first_segment",
+        data,
+        getSourcePosition: (e) => getLayoutInfo(e).sourcePosition,
+        getTargetPosition: (e) => getLayoutInfo(e).controlPoints[0],
+        getColor: (e) => [210, 210, 210, 150],
+        updateTriggers: {
+          getSourcePosition: positionUpdateTrigger,
+          getTargetPosition: positionUpdateTrigger
+        },
+        ...otherProps
+      })),
+      DEBUG && new import_layers10.LineLayer(this.getSubLayerProps({
+        id: "__last_segment",
+        data,
+        getSourcePosition: (e) => getLayoutInfo(e).controlPoints[0],
+        getTargetPosition: (e) => getLayoutInfo(e).targetPosition,
+        getColor: (e) => [210, 210, 210, 150],
+        updateTriggers: {
+          getSourcePosition: positionUpdateTrigger,
+          getTargetPosition: positionUpdateTrigger
+        },
+        ...otherProps
+      })),
+      new SplineLayer(this.getSubLayerProps({
+        id: "__spline_layer",
+        data,
+        getSourcePosition: (e) => getLayoutInfo(e).sourcePosition,
+        getTargetPosition: (e) => getLayoutInfo(e).targetPosition,
+        getControlPoints: (e) => getLayoutInfo(e).controlPoints,
+        updateTriggers: {
+          getSourcePosition: positionUpdateTrigger,
+          getTargetPosition: positionUpdateTrigger,
+          getControlPoints: positionUpdateTrigger,
+          getColor: colorUpdateTrigger,
+          getWidth: widthUpdateTrigger
+        },
+        ...otherProps
+      }))
+    ];
+  }
+};
+__publicField(CurvedEdgeLayer, "layerName", "CurvedEdgeLayer");
+
+// dist/layers/edge-layer.js
+var EDGE_LAYER_MAP = {
+  [EDGE_TYPE.LINE]: StraightLineEdgeLayer,
+  [EDGE_TYPE.PATH]: PathEdgeLayer,
+  [EDGE_TYPE.SPLINE_CURVE]: CurvedEdgeLayer
+};
+var EdgeLayer = class extends import_core13.CompositeLayer {
+  updateState({ props, oldProps, changeFlags }) {
+    super.updateState({ props, oldProps, changeFlags });
+    if (changeFlags.dataChanged) {
+      this.updateStateData();
+    }
+  }
+  updateStateData() {
+    const { data, getLayoutInfo } = this.props;
+    const typedEdgeData = data.reduce((res, d) => {
+      const { type } = getLayoutInfo(d);
+      res[type].push(d);
+      return res;
+    }, {
+      [EDGE_TYPE.LINE]: [],
+      [EDGE_TYPE.PATH]: [],
+      [EDGE_TYPE.SPLINE_CURVE]: []
+    });
+    this.setState({ typedEdgeData });
+  }
+  renderLayers() {
+    const { getLayoutInfo, pickable, positionUpdateTrigger, stylesheet, id } = this.props;
+    const { typedEdgeData } = this.state;
+    return Object.entries(typedEdgeData).map((e, idx) => {
+      const [type, edgeData] = e;
+      const Layer = EDGE_LAYER_MAP[type];
+      if (!Layer) {
+        return null;
+      }
+      return new Layer({
+        id: `${id}-${idx}`,
+        data: edgeData,
+        getLayoutInfo,
+        getColor: stylesheet.getDeckGLAccessor("getColor"),
+        getWidth: stylesheet.getDeckGLAccessor("getWidth"),
+        colorUpdateTrigger: stylesheet.getDeckGLAccessorUpdateTrigger("getColor"),
+        widthUpdateTrigger: stylesheet.getDeckGLAccessorUpdateTrigger("getWidth"),
+        positionUpdateTrigger,
+        pickable,
+        coordinateSystem: import_core13.COORDINATE_SYSTEM.CARTESIAN,
+        parameters: {
+          depthCompare: "always"
+        }
+      });
+    });
+  }
+};
+__publicField(EdgeLayer, "layerName", "EdgeLayer");
+__publicField(EdgeLayer, "defaultProps", {
+  data: [],
+  pickable: true,
+  getLayoutInfo: (d) => ({
+    type: d.type,
+    sourcePosition: d.sourcePosition,
+    targetPosition: d.targetPosition,
+    controlPoints: []
+  }),
+  positionUpdateTrigger: 0
+});
+
+// dist/layers/edge-layers/edge-label-layer.js
+var import_core14 = require("@deck.gl/core");
+var EdgeLabelLayer = class extends import_core14.CompositeLayer {
+  renderLayers() {
+    const { data, getLayoutInfo, positionUpdateTrigger = 0, stylesheet } = this.props;
+    return [
+      new ZoomableTextLayer(this.getSubLayerProps({
+        id: "edge-label-layer",
+        data,
+        getPosition: (e) => {
+          const { sourcePosition, targetPosition, controlPoints = [] } = getLayoutInfo(e);
+          const allPoints = [sourcePosition, targetPosition, ...controlPoints];
+          const sumX = allPoints.reduce((res, p) => res + p[0], 0);
+          const sumY = allPoints.reduce((res, p) => res + p[1], 0);
+          return [sumX / allPoints.length, sumY / allPoints.length];
+        },
+        getAngle: (e) => {
+          const { sourcePosition, targetPosition } = getLayoutInfo(e);
+          const [newSourcePosition, newTargetPosition] = sourcePosition[0] < targetPosition[0] ? [sourcePosition, targetPosition] : [targetPosition, sourcePosition];
+          const deltaX = newTargetPosition[0] - newSourcePosition[0];
+          const deltaY = newTargetPosition[1] - newSourcePosition[1];
+          return Math.atan2(deltaY, deltaX) * -180 / Math.PI;
+        },
+        ...stylesheet.getDeckGLAccessors(),
+        updateTriggers: {
+          ...stylesheet.getDeckGLUpdateTriggers(),
+          getPosition: positionUpdateTrigger
+        }
+      }))
+    ];
+  }
+};
+__publicField(EdgeLabelLayer, "layerName", "EdgeLabelLayer");
+
+// dist/layers/edge-layers/flow-layer.js
+var import_core15 = require("@deck.gl/core");
+
+// dist/layers/common-layers/flow-path-layer/flow-path-layer.js
+var import_layers11 = require("@deck.gl/layers");
+var import_global = require("global");
+
+// dist/layers/common-layers/flow-path-layer/flow-path-layer-vertex.glsl.js
+var vs = (
+  /* glsl */
+  `#define SHADER_NAME flow-path-layer-vertex-shader
+
+attribute vec3 positions;
+attribute vec3 instanceSourcePositions;
+attribute vec3 instanceTargetPositions;
+attribute vec4 instanceSourceTargetPositions64xyLow;
+attribute vec4 instanceColors;
+attribute vec3 instancePickingColors;
+attribute float instanceWidths;
+attribute float instanceSpeeds;
+attribute float instanceOffsets;
+attribute float instanceTailLengths;
+
+uniform float opacity;
+uniform float widthScale;
+uniform float widthMinPixels;
+uniform float widthMaxPixels;
+
+varying vec4 vColor;
+varying float segmentIndex;
+varying float speed;
+varying float pathLength;
+varying float tailLength;
+varying float offset;
+
+// offset vector by strokeWidth pixels
+// offset_direction is -1 (left) or 1 (right)
+vec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction, float width) {
+  // normalized direction of the line
+  vec2 dir_screenspace = normalize(line_clipspace * project_uViewportSize);
+  // rotate by 90 degrees
+  dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);
+
+  vec2 offset_screenspace = dir_screenspace * offset_direction * width / 2.0;
+  vec2 offset_clipspace = project_pixel_size_to_clipspace(offset_screenspace);
+
+  return offset_clipspace;
+}
+
+void main(void) {
+  // Position
+  vec4 source = project_position_to_clipspace(instanceSourcePositions, instanceSourceTargetPositions64xyLow.xy, vec3(0.));
+  vec4 target = project_position_to_clipspace(instanceTargetPositions, instanceSourceTargetPositions64xyLow.zw, vec3(0.));
+
+  // Multiply out width and clamp to limits
+  float widthPixels = clamp(
+    project_size_to_pixel(instanceWidths * widthScale),
+    widthMinPixels, widthMaxPixels
+  );
+
+  // linear interpolation of source & target to pick right coord
+  segmentIndex = positions.x;
+  speed = instanceSpeeds;
+  tailLength = project_size_to_pixel(instanceTailLengths * widthScale);
+  offset = instanceOffsets;
+  pathLength = distance(instanceSourcePositions, instanceTargetPositions);
+  vec4 p = mix(source, target, segmentIndex);
+
+  // extrude
+  vec2 offset = getExtrusionOffset(target.xy - source.xy, positions.y, widthPixels);
+  gl_Position = p + vec4(offset, 0.0, 0.0);
+
+  // Color
+  vColor = vec4(instanceColors.rgb, instanceColors.a * opacity) / 255.;
+
+  // Set color to be rendered to picking fbo (also used to check for selection highlight).
+  picking_setPickingColor(instancePickingColors);
+}
+`
+);
+
+// dist/layers/common-layers/flow-path-layer/flow-path-layer-fragment.glsl.js
+var fs2 = (
+  /* glsl */
+  `#define SHADER_NAME flow-path-layer-fragment-shader
+
+precision highp float;
+
+varying vec4 vColor;
+varying float segmentIndex;
+varying float speed;
+varying float offset;
+varying float pathLength;
+varying float tailLength;
+
+void main(void) {
+  gl_FragColor = vColor;
+
+  // use highlight color if this fragment belongs to the selected object.
+  gl_FragColor = picking_filterHighlightColor(gl_FragColor);
+
+  // use picking color if rendering to picking FBO.
+  gl_FragColor = picking_filterPickingColor(gl_FragColor);
+
+  if (speed == 0.0) {
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+  } else {
+    // the portion of the visible segment (0 to 1) , ex: 0.3
+    // edge cases: pathLength = 0 or tailLength > pathLength
+    float segFragment = 0.0;
+    if (pathLength != 0.0) {
+      segFragment = tailLength / pathLength;
+    }
+    if (tailLength > pathLength) {
+      segFragment = 1.0;
+    }
+    float startSegmentIndex = mod(offset, 60.0) / 60.0;
+    // the end offset, cap to 1.0 (end of the line)
+    float endSegmentIndex = min(startSegmentIndex + segFragment, 1.0);
+    if (segmentIndex < startSegmentIndex || segmentIndex > endSegmentIndex) {
+      gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+    } else {
+      // fading tail
+      float portion = (segmentIndex - startSegmentIndex) / segFragment;
+      gl_FragColor[3] = portion;
+    }
+  }
+}
+`
+);
+
+// dist/layers/common-layers/flow-path-layer/flow-path-layer.js
+var defaultProps2 = {
+  ...import_layers11.LineLayer.defaultProps,
+  getWidth: { type: "accessor", value: 1 },
+  getSpeed: { type: "accessor", value: 0 }
+};
+var FlowPathLayer = class extends import_layers11.LineLayer {
+  getShaders() {
+    const projectModule = this.use64bitPositions() ? "project64" : "project32";
+    return { vs, fs: fs2, modules: [projectModule, "picking"] };
+  }
+  initializeState() {
+    super.initializeState();
+    this.getAttributeManager().addInstanced({
+      instanceSpeeds: {
+        size: 1,
+        transition: true,
+        accessor: "getSpeed",
+        defaultValue: 0
+      },
+      instanceTailLengths: {
+        size: 1,
+        transition: true,
+        accessor: "getTailLength",
+        defaultValue: 1
+      }
+    });
+    this.setupTransformFeedback();
+    this.setState({
+      ...this.state,
+      animation: import_global.window.requestAnimationFrame(this.animate.bind(this))
+    });
+  }
+  animate() {
+    const { transform } = this.state;
+    if (transform) {
+      transform.run();
+      transform.swap();
+    }
+    this.setState({
+      animation: import_global.window.requestAnimationFrame(this.animate.bind(this))
+    });
+  }
+  updateState({ props, oldProps, changeFlags }) {
+    super.updateState({ props, oldProps, changeFlags });
+    const { speedsBuffer } = this.state;
+    const speedChanged = changeFlags.dataChanged || props.fp64 !== oldProps.fp64 || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getSpeed);
+    if (speedChanged) {
+      const speeds = new Float32Array(props.data.length);
+      for (let i = 0; i < props.data.length; i++) {
+        speeds[i] = typeof props.getSpeed === "function" ? props.getSpeed(props.data[i]) : props.getSpeed;
+      }
+      speedsBuffer.subData({ data: speeds });
+    }
+    if (props.fp64 !== oldProps.fp64) {
+      if (this.state.model) {
+        this.state.model.delete();
+      }
+      this.setState({ model: this._getModel() });
+      this.getAttributeManager().invalidateAll();
+    }
+  }
+  finalizeState() {
+    super.finalizeState(this.context);
+    import_global.window.cancelAnimationFrame(this.state.animation);
+  }
+  setupTransformFeedback() {
+    throw new Error("Not implemented");
+  }
+  draw({ uniforms }) {
+    throw new Error("Not implemented");
+  }
+};
+FlowPathLayer.layerName = "FlowPathLayer";
+FlowPathLayer.defaultProps = defaultProps2;
+
+// dist/layers/edge-layers/flow-layer.js
+var FlowLayer = class extends import_core15.CompositeLayer {
+  renderLayers() {
+    const { data, getLayoutInfo, positionUpdateTrigger = 0, stylesheet } = this.props;
+    return [
+      new FlowPathLayer(this.getSubLayerProps({
+        id: "__flow-layer",
+        data,
+        ...stylesheet.getDeckGLAccessors(),
+        getSourcePosition: (e) => getLayoutInfo(e).sourcePosition,
+        getTargetPosition: (e) => getLayoutInfo(e).targetPosition,
+        parameters: {
+          depthTest: false
+        },
+        updateTriggers: {
+          ...stylesheet.getDeckGLUpdateTriggers(),
+          getSourcePosition: positionUpdateTrigger,
+          getTargetPosition: positionUpdateTrigger
+        }
+      }))
+    ];
+  }
+};
+__publicField(FlowLayer, "layerName", "FlowLayer");
+
+// dist/layers/graph-layer.js
+var NODE_LAYER_MAP = {
+  [NODE_TYPE.RECTANGLE]: RectangleLayer,
+  [NODE_TYPE.ROUNDED_RECTANGLE]: RoundedRectangleLayer,
+  [NODE_TYPE.PATH_ROUNDED_RECTANGLE]: PathBasedRoundedRectangleLayer,
+  [NODE_TYPE.ICON]: ImageLayer,
+  [NODE_TYPE.CIRCLE]: CircleLayer,
+  [NODE_TYPE.LABEL]: LabelLayer,
+  [NODE_TYPE.MARKER]: ZoomableMarkerLayer
+};
+var EDGE_DECORATOR_LAYER_MAP = {
+  [EDGE_DECORATOR_TYPE.LABEL]: EdgeLabelLayer,
+  [EDGE_DECORATOR_TYPE.FLOW]: FlowLayer
+};
+var SHARED_LAYER_PROPS = {
+  coordinateSystem: import_core16.COORDINATE_SYSTEM.CARTESIAN,
+  parameters: {
+    depthTest: false
+  }
+};
+var defaultProps3 = {
+  // an array of styles for layers
+  nodeStyle: [],
+  nodeEvents: {
+    onMouseLeave: () => {
+    },
+    onHover: () => {
+    },
+    onMouseEnter: () => {
+    },
+    onClick: () => {
+    },
+    onDrag: () => {
+    }
+  },
+  edgeStyle: {
+    color: "black",
+    strokeWidth: 1,
+    // an array of styles for layers
+    decorators: []
+  },
+  edgeEvents: {
+    onClick: () => {
+    },
+    onHover: () => {
+    }
+  },
+  enableDragging: false
+};
+var GraphLayer = class extends import_core16.CompositeLayer {
+  forceUpdate = () => {
+    if (this.context && this.context.layerManager) {
+      this.setNeedsUpdate();
+      this.setChangeFlags({ dataChanged: true });
+    }
+  };
+  constructor(props) {
+    super(props);
+    props.engine.addEventListener("onLayoutChange", this.forceUpdate);
+  }
+  initializeState() {
+    const interactionManager = new InteractionManager(this.props, () => this.forceUpdate());
+    this.state = { interactionManager };
+  }
+  shouldUpdateState({ changeFlags }) {
+    return changeFlags.dataChanged || changeFlags.propsChanged;
+  }
+  updateState({ props }) {
+    this.state.interactionManager.updateProps(props);
+  }
+  finalize() {
+    this.props.engine.removeEventListener("onLayoutChange", this.forceUpdate);
+  }
+  createNodeLayers() {
+    const { engine, nodeStyle } = this.props;
+    if (!nodeStyle || !Array.isArray(nodeStyle) || nodeStyle.length === 0) {
+      return [];
+    }
+    return nodeStyle.filter(Boolean).map((style, idx) => {
+      const { pickable = true, visible = true, data = (nodes) => nodes, ...restStyle } = style;
+      const LayerType = NODE_LAYER_MAP[style.type];
+      if (!LayerType) {
+        log.error(`Invalid node type: ${style.type}`)();
+        throw new Error(`Invalid node type: ${style.type}`);
+      }
+      const stylesheet = new Stylesheet(restStyle, {
+        stateUpdateTrigger: this.state.interactionManager.getLastInteraction()
+      });
+      const getOffset2 = stylesheet.getDeckGLAccessor("getOffset");
+      return new LayerType({
+        ...SHARED_LAYER_PROPS,
+        id: `node-rule-${idx}`,
+        data: data(engine.getNodes()),
+        getPosition: mixedGetPosition(engine.getNodePosition, getOffset2),
+        pickable,
+        positionUpdateTrigger: [
+          engine.getLayoutLastUpdate(),
+          engine.getLayoutState(),
+          stylesheet.getDeckGLAccessorUpdateTrigger("getOffset")
+        ].join(),
+        stylesheet,
+        visible
+      });
+    });
+  }
+  createEdgeLayers() {
+    const { edgeStyle, engine } = this.props;
+    if (!edgeStyle) {
+      return [];
+    }
+    return (Array.isArray(edgeStyle) ? edgeStyle : [edgeStyle]).filter(Boolean).flatMap((style, idx) => {
+      const { decorators, data = (edges) => edges, visible = true, ...restEdgeStyle } = style;
+      const stylesheet = new Stylesheet({
+        type: "Edge",
+        ...restEdgeStyle
+      }, {
+        stateUpdateTrigger: this.state.interactionManager.getLastInteraction()
+      });
+      const edgeLayer = new EdgeLayer({
+        ...SHARED_LAYER_PROPS,
+        id: `edge-layer-${idx}`,
+        data: data(engine.getEdges()),
+        getLayoutInfo: engine.getEdgePosition,
+        pickable: true,
+        positionUpdateTrigger: [engine.getLayoutLastUpdate(), engine.getLayoutState()].join(),
+        stylesheet,
+        visible
+      });
+      if (!decorators || !Array.isArray(decorators) || decorators.length === 0) {
+        return edgeLayer;
+      }
+      const decoratorLayers = decorators.filter(Boolean).flatMap((decoratorStyle, idx2) => {
+        const DecoratorLayer = EDGE_DECORATOR_LAYER_MAP[decoratorStyle.type];
+        if (!DecoratorLayer) {
+          log.error(`Invalid edge decorator type: ${decoratorStyle.type}`)();
+          throw new Error(`Invalid edge decorator type: ${decoratorStyle.type}`);
+        }
+        const decoratorStylesheet = new Stylesheet(decoratorStyle, {
+          stateUpdateTrigger: this.state.interactionManager.getLastInteraction()
+        });
+        return new DecoratorLayer({
+          ...SHARED_LAYER_PROPS,
+          id: `edge-decorator-${idx2}`,
+          data: data(engine.getEdges()),
+          getLayoutInfo: engine.getEdgePosition,
+          pickable: true,
+          positionUpdateTrigger: [engine.getLayoutLastUpdate(), engine.getLayoutState()].join(),
+          stylesheet: decoratorStylesheet
+        });
+      });
+      return [edgeLayer, decoratorLayers];
+    });
+  }
+  onClick(info, event) {
+    return this.state.interactionManager.onClick(info, event) || false;
+  }
+  onHover(info, event) {
+    return this.state.interactionManager.onHover(info, event) || false;
+  }
+  onDragStart(info, event) {
+    this.state.interactionManager.onDragStart(info, event);
+  }
+  onDrag(info, event) {
+    this.state.interactionManager.onDrag(info, event);
+  }
+  onDragEnd(info, event) {
+    this.state.interactionManager.onDragEnd(info, event);
+  }
+  renderLayers() {
+    return [this.createEdgeLayers(), this.createNodeLayers()];
+  }
+};
+__publicField(GraphLayer, "defaultProps", {
+  pickable: true
+});
+GraphLayer.layerName = "GraphLayer";
+GraphLayer.defaultProps = defaultProps3;
+//# sourceMappingURL=index.cjs.map