@antv/layout 1.1.0 → 1.2.1

package/dist/11.index.min.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["webpack://Layout/webpack/universalModuleDefinition","webpack://Layout/webpack/runtime/chunk loaded","webpack://Layout/webpack/runtime/startup chunk dependencies","webpack://Layout/./src/util/string.ts","webpack://Layout/./src/util/array.ts","webpack://Layout/./src/util/math.ts","webpack://Layout/./src/util/object.ts","webpack://Layout/./src/util/function.ts","webpack://Layout/./src/util/common.ts","webpack://Layout/./src/circular.ts","webpack://Layout/./src/concentric.ts","webpack://Layout/./src/d3Force/forceInBox.ts","webpack://Layout/./src/d3Force/index.ts","webpack://Layout/./src/dagre/data/list.ts","webpack://Layout/./src/dagre/greedy-fas.ts","webpack://Layout/./src/dagre/acyclic.ts","webpack://Layout/./src/dagre/util.ts","webpack://Layout/./src/dagre/normalize.ts","webpack://Layout/./src/dagre/rank/util.ts","webpack://Layout/./src/dagre/rank/feasible-tree.ts","webpack://Layout/./src/dagre/rank/network-simplex.ts","webpack://Layout/./src/dagre/rank/index.ts","webpack://Layout/./src/dagre/nesting-graph.ts","webpack://Layout/./src/dagre/add-border-segments.ts","webpack://Layout/./src/dagre/coordinate-system.ts","webpack://Layout/./src/dagre/order/init-order.ts","webpack://Layout/./src/dagre/order/cross-count.ts","webpack://Layout/./src/dagre/order/resolve-conflicts.ts","webpack://Layout/./src/dagre/order/sort.ts","webpack://Layout/./src/dagre/order/sort-subgraph.ts","webpack://Layout/./src/dagre/order/barycenter.ts","webpack://Layout/./src/dagre/order/index.ts","webpack://Layout/./src/dagre/order/build-layer-graph.ts","webpack://Layout/./src/dagre/order/add-subgraph-constraints.ts","webpack://Layout/./src/dagre/position/bk.ts","webpack://Layout/./src/dagre/position/index.ts","webpack://Layout/./src/dagre/layout.ts","webpack://Layout/./src/dagre/parent-dummy-chains.ts","webpack://Layout/./src/dagre/order/init-data-order.ts","webpack://Layout/./src/dagre.ts","webpack://Layout/./src/force/forceNBody.ts","webpack://Layout/./src/force/index.ts","webpack://Layout/./src/forceAtlas2/body.ts","webpack://Layout/./src/forceAtlas2/quad.ts","webpack://Layout/./src/forceAtlas2/quadTree.ts","webpack://Layout/./src/forceAtlas2/index.ts","webpack://Layout/./src/fruchterman.ts","webpack://Layout/./src/grid.ts","webpack://Layout/./src/mds.ts","webpack://Layout/./src/radial/radial-nonoverlap-force.ts","webpack://Layout/./src/radial/index.ts","webpack://Layout/./src/radial/mds.ts","webpack://Layout/./src/random.ts","webpack://Layout/./src/registry.ts","webpack://Layout/./src/worker.js","webpack://Layout/./src/types.ts","webpack://Layout/webpack/bootstrap","webpack://Layout/webpack/runtime/define property getters","webpack://Layout/webpack/runtime/ensure chunk","webpack://Layout/webpack/runtime/get javascript chunk filename","webpack://Layout/webpack/runtime/hasOwnProperty shorthand","webpack://Layout/webpack/runtime/publicPath","webpack://Layout/webpack/runtime/importScripts chunk loading","webpack://Layout/webpack/startup"],"names":["root","factory","exports","module","define","amd","this","deferred","next","camelizeRE","str","replace","_","c","toUpperCase","Object","create","Array","isArray","floydWarshall","adjMatrix","dist","size","length","i","j","Infinity","k","getAdjMatrix","data","directed","nodes","edges","matrix","nodeMap","Error","forEach","node","id","push","e","source","target","sIndex","tIndex","undefined","getEuclideanDistance","p1","p2","Math","sqrt","x","y","clone","Date","getTime","v","map","n","keys","cloneFormatData","initRange","cloned","random","formatNumberFn","defaultValue","value","formatSizeFn","resultIsNumber","max","isNaN","width","height","d","formatNodeSize","nodeSize","nodeSpacing","nodeSpacingFunc","bboxSize","dataSize","handleSingleNodeGraph","graph","assign","center","getAllNodes","getAllEdges","mergeNodeData","DEFAULTS_LAYOUT_OPTIONS","radius","startRadius","endRadius","startAngle","endAngle","PI","clockwise","divisions","ordering","angleRatio","options","execute","genericCircularLayout","mergedOptions","paramNodeSpacing","paramNodeSize","calculateCenter","calculatedWidth","calculatedHeight","calculatedCenter","angleStep","nSize","min","astep","layoutNodes","topologyOrdering","orderedNodes","sort","nodeA","nodeB","getDegree","degreeOrdering","divN","ceil","r","angle","floor","cos","sin","orderedCNodes","pickFlags","areNeighbors","children","getSuccessors","getNeighbors","foundChild","child","ii","window","innerWidth","innerHeight","preventOverlap","sweep","equidistant","maxLevelDiff","sortBy","genericConcentricLayout","propsCenter","propsWidth","propsHeight","propsSortBy","propsMaxLevelDiff","propsSweep","maxNodeSpacing","maxNodeSize","cnode","nodeIdxMap","n1","n2","maxValueNode","currentLevel","levels","diff","abs","minDist","firstLvlHasMulti","maxR","rStep","level","dTheta","dcos","dsin","rMin","rDelta","rr","theta","forceInBox","constant","templateForce","groupBy","cluster","forceNodeSize","forceCharge","forceLinkDistance","forceLinkStrength","offset","nodesMap","links","centerX","centerY","foci","none","templateNodes","template","enableGrouping","strength","force","alpha","tick","getFocisFromTemplate","vx","vy","initialize","gnodes","glinks","dNodes","clustersCounts","clustersLinks","net","key","count","sumforceNodeSize","tmpCount","computeClustersNodeCounts","dClusterLinks","clusterLinks","l","link","sourceID","targetID","entries","split","computeClustersLinkCounts","index","val","sourceTerminal","targetTerminal","iterations","distance","initializeWithForce","arguments","genNodesMap","getFocis","linkDistance","forceSimulation","alphaDecay","alphaMin","collideStrength","clustering","clusterNodeStrength","clusterEdgeStrength","clusterEdgeDistance","clusterFociStrength","clusterNodeSize","genericForceLayout","stop","result","formatOutNodes","lastLayoutNodes","formatOutEdges","lastLayoutEdges","lastAssign","lastGraph","layoutEdges","edge","nodeStrength","edgeStrength","onTick","Promise","resolve","clusterForce","edgeForce","overlapProcess","restart","outNodes","outEdges","nodeForce","on","console","warn","simulation","nodeSizeFunc","others","rest","filterOutLinks","unlink","entry","prev","shortcut","dequeue","enqueue","toString","strs","sentinel","curr","JSON","stringify","join","DEFAULT_WEIGHT_FN","removeNode","g","buckets","zeroIdx","collectPredecessors","results","hasNode","getRelatedEdges","weight","uEntry","getNode","w","in","out","assignBucket","wEntry","run","acyclicer","fas","weightFn","state","fasGraph","maxIn","maxOut","addNode","find","updateEdgeData","addEdge","rangeMax","buildState","sources","sinks","concat","doGreedyFAS","filter","flat","greedyFAS","dfsFAS","label","removeEdge","forwardName","name","reversed","stack","visited","dfs","addDummyNode","type","dummy","asNonCompoundGraph","simplified","getChildren","intersectRect","rect","point","sx","sy","Number","dx","dy","h","layeringNodes","rankMax","maxRank","rank","va","vb","valueA","order","valueB","addBorderNode","prefix","minBy","array","func","reduce","a","b","doDFS","postorder","navigator","includes","isDirected","DUMMY_NODE_EDGE_LABEL","longestPath","minlen","slack","tightTree","t","edgeV","tightTreeWithLayer","layer","findMinSlackEdge","shiftRanks","delta","tn","initCutValues","vs","slice","assignCutValue","parent","cutvalue","calcCutValue","childIsTail","graphEdge","cutValue","isOutEdge","other","pointsToHead","otherWeight","isTreeEdge","otherCutValue","initLowLimValues","tree","dfsAssignLowLim","nextLim","low","useNextLim","lim","leaveEdge","enterEdge","vLabel","wLabel","tailLabel","flip","candidates","isDescendant","exchangeEdges","f","existed","updateRanks","flipped","u","rootLabel","longestPathRanker","networkSimplexRanker","og","simplify","start","feasibleTree","networkSimplex","nodeSep","depths","top","bottom","setParent","borderTop","borderBottom","childNode","childTop","childBottom","thisWeight","nestingEdge","getParent","prop","sg","sgNode","borderType","swapWidthHeight","swapWidthHeightOne","reverseYOne","swapXYOne","initOrder","simpleNodes","nodeRanks","layers","orderedVs","fixOrderNodes","fixorder","dfsTree","hasOwnProperty","twoLayerCrossCount","northLayer","southLayer","southPos","values","obj","zipObject","southEntries","unsort","pos","firstIndex","treeSize","fill","cc","weightSum","crossCount","layering","mergeEntries","sum","barycenter","merged","cg","mappedEntries","indegree","tmp","entryV","entryW","sourceSet","pop","reverse","vEntry","filtered","picked","doResolveConflicts","consumeUnsortable","unsortable","last","iindex","sortSubgraph","biasRight","usePrev","keepNodeOrder","movable","bl","borderLeft","br","borderRight","subgraphs","barycenters","inV","nodeU","subgraphResult","mergeBarycenters","expandSubgraphs","parts","collection","fn","lhs","rhs","hasFixOrder","partition","sortable","vsIndex","bias","compareWithBias","getPredecessors","blPred","brPred","vss","buildLayerGraphs","ranks","direction","createRootNode","minRank","updateNodeData","buildLayerGraph","sweepLayerGraphs","layerGraphs","lg","getRoots","sorted","lnode","rootPrev","prevChild","addNodes","addSubgraphConstraints","assignOrder","findType2Conflicts","conflicts","scan","south","southEnd","prevNorthBorder","nextNorthBorder","uNode","addConflict","scanIfNeeded","params","scanCache","cacheKey","getScannedKey","get","set","north","nextNorthPos","prevNorthPos","scanned","Map","southLookahead","predecessors","findOtherInnerSegmentNode","vv","ww","conflictsV","hasConflict","buildBlockGraph","nodesep","edgesep","reverseSep","blockGraph","sepFn","sep","vRoot","uRoot","edgeSep","labelpos","toLowerCase","position","ng","ranksep","prevY","heights","maxHeight","positionY","xs","graphAlign","prevLayer","k0","scanPos","prevLayerLength","lastNode","k1","scanNode","uLabel","uPos","findType1Conflicts","xss","adjustedLayering","vert","horiz","inner","neighborFn","bind","align","prevIdx","ws","mp","il","verticalAlignment","blockG","iterate","setXsFunc","nextNodesFunc","elem","acc","POSITIVE_INFINITY","horizontalCompaction","xsKey","smallestWidth","NEGATIVE_INFINITY","halfWidth","findSmallestWidthAlignment","alignTo","alignToVals","alignToMin","alignToMax","alignment","xsVals","alignCoordinates","ul","balance","runLayout","ranker","rankdir","nodeOrder","removeSelfEdges","depth","treeDepths","maxDepth","sumWeights","nestingRoot","nodeRankFactor","forwardVisited","dfsForward","nextRank","currRank","longestPathWithLayer","tightTreeRanker","injectEdgeLabelProxies","removeEmptyRanks","cleanup","normalizeRanks","assignRankMinMax","removeEdgeLabelProxies","dummyChains","vRank","wRank","labelRank","nodeData","points","originalEdge","normalizeEdge","postorderNums","dfsBothOrder","startV","pathData","lca","vPath","wPath","path","findPath","pathIdx","pathV","ascending","parentDummyChains","addBorderSegments","initDataOrder","mxRank","range1","range2","downLayerGraphs","upLayerGraphs","best","bestCC","lastBest","insertSelfEdges","rd","adjust","positionSelfEdges","removeBorderNodes","currentV","fixupEdgeLabelCoords","reverseY","swapXY","translateGraph","assignNodeIntersects","reversePointsForReversedEdges","undo","nodeNumAttrs","nodeDefaults","edgeNumAttrs","edgeDefaults","labeloffset","edgeAttrs","getEdge","minX","minY","maxX","maxY","marginx","marginX","marginy","marginY","getExtremes","attrs","p","nodeV","nodeW","unshift","selfEdges","orderShift","selfEdge","selfNode","hasEdge","selectNumberAttrs","pickedProperties","canonicalize","newAttrs","edgeLabelSpace","controlPoints","radial","focusNode","genericDagreLayout","ranksepFunc","nodesepFunc","begin","ranksepfunc","nodesepfunc","horisep","vertisep","verti","currG","prevG","prevGraph","prevNode","_order","layoutGraph","inputGraph","defaultNode","defaultAttrs","buildLayoutGraph","makeSpaceForEdgeLabels","message","error","inputLabel","layoutLabel","_rank","updateInputGraph","layout","layoutTopLeft","isHorizontal","Set","layerCoordSort","add","from","point1","point2","ps","getControlPoints","mergeEdgeData","sourceNode","targetNode","layerCoordsArr","isDifferentLayer","filterControlPointsOutOfBoundary","sourceX","sourceY","targetX","targetY","sourceLayer","indexOf","sourceNextLayerCoord","firstControlPoint","insertStartControlPoint","targetLayer","layerDiff","targetLastLayerCoord","lastControlPoints","insertEndControlPoint","accumulate","treeNode","accWeight","accX","accY","accZ","numChildren","q","z","apply","x1","arg1","arg2","arg3","dimensions","x2","dz","len2","len3","param","vz","maxIteration","gravity","factor","coulombDisScale","damping","maxSpeed","minMovement","interval","distanceThresholdMode","timeInterval","judgingDistance","running","clearInterval","lastResult","lastOptions","runOneStep","lastCalcGraph","lastVelMap","updatePosition","formattedOptions","formatOptions","getMass","mass","velMap","calcGraph","formatCentripetal","iter","setInterval","massWeight","degree","sameTypeLeafMap","centripetalOptions","leafCluster","nodeClusterBy","calcNodes","basicCentripetal","leaf","single","clusters","getSameTypeLeafMap","siblingLeaves","sameTypeLeaves","centerPos","item","sameTypeNodes","accMap","calcEdges","monitor","calRepulsive","calAttractive","calGravity","updateVelocity","energy","calTotalEnergy","speed2","coulombDisScale2","weightParam","calcNode","quadtree","octree","visitAfter","visit","y1","y2","computeForce","forceNBody","vecX","vecY","vecZ","vecLength","direX","direY","direZ","sourceMassRatio","targetMassRatio","disX","disY","disZ","getCenter","defaultGravity","inDegree","outDegree","forceCenter","centriCenter","centerStrength","centriX","centriY","centriZ","singleStrength","leafStrength","othersStrength","vLength","param2","fx","fy","fz","distX","distY","distZ","distanceMagnitude","getCoreNodeAndSiblingLeaves","coreNode","relativeNodes","typeName","totalNodes","rx","ry","distanceTo","bo","hypot","setPos","resetForce","addForce","F","quad","contains","nenwMass","Body","xmid","ymid","massCenter","getLength","halfLen","NW","Quad","NE","SW","SE","body","insert","_isExternal","QuadTree","_putBody","updateForce","kr","kg","mode","dissuadeHubs","ks","ksmax","tao","genericForceAtlas2Layout","prune","sizes","getSizes","sourceDegree","targetDegree","postOptions","barnesHut","nodeNum","iteration","forces","preForces","bodies","oneStep","preventOverlapIters","krPrime","getAttrForces","getOptRepGraForces","getRepGraForces","updatePos","dir","eucliDis","fa1","fa2","log","minx","maxx","miny","maxy","quadTree","fg","nodei","degreei","nodej","degreej","fr","swgns","trans","swgG","traG","usingSg","minus","minusNorm","addNorm","preSG","sn","absForce","dnx","dny","speed","clusterGravity","genericFruchtermanLayout","lastClusterMap","clusterMap","clusterValue","cx","cy","propsClusterGravity","area","maxDisplace","k2","displacements","applyCalculate","distLength","gravityForce","limitedDist","vid","uid","lengthSqr","common","dispX","dispY","dispZ","preventOverlapPadding","condense","rows","cols","genericGridLayout","propsRows","propsCols","localeCompare","cells","rcs","splits","round","sm","small","large","cellWidth","cellHeight","nodeH","oNode","res","cellUsed","rc","row","col","id2manPos","rcPos","used","use","getPos","usedRows","usedCols","moveToNextCell","genericMDSLayout","distances","handleInfinity","scaledD","ratio","newRow","scaleMatrix","positions","runMDS","maxDistance","M","rowMeans","mean","colMeans","totalMean","subRowVector","subColumnVector","ret","eigenValues","diagonalMatrix","diagonal","leftSingularVectors","toJSON","splice","getRepulsion","disp","radii","vecx","vecy","sign","updatePositions","strictRadial","focusIdx","maxDisp","di","vpx","vpy","diLength","acos","tdispLength","nfDis","unitRadius","maxPreventOverlapIteration","sortStrength","genericRadialLayout","propsFocusNode","propsUnitRadius","focusIndex","getIndexById","maxToFocus","focusNodeD","semiWidth","semiHeight","maxRadius","maxD","idealDistances","eIdealDisMatrix","weights","getWeightMatrix","mdsResult","dimension","mds","nonoverlapForceParams","Boolean","radialNonoverlapForce","oneIteration","vparam","originDis","reciODis","xMolecule","yMolecule","denominator","edis","reciEdis","idealDis","reciR","iValue","jValue","charCodeAt","step","genericRandomLayout","registry","circular","CircularLayout","concentric","ConcentricLayout","MDSLayout","RandomLayout","grid","GridLayout","RadialLayout","ForceLayout","d3force","D3ForceLayout","fruchterman","FruchtermanLayout","forceAtlas2","ForceAtlas2Layout","dagre","DagreLayout","currentLayout","stopLayout","async","payload","transferables","layoutCtor","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","m","__webpack_exports__","O","chunkIds","priority","notFulfilled","fulfilled","every","definition","o","defineProperty","enumerable","chunkId","all","promises","prototype","call","installedChunks","importScripts","chunkLoadingGlobal","parentChunkLoadingFunction","moreModules","runtime","then"],"mappings":"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","file":"11.index.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Layout\"] = factory();\n\telse\n\t\troot[\"Layout\"] = factory();\n})(this, function() {\nreturn ","var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar [chunkIds, fn, priority] = deferred[i];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tresult = fn();\n\t\t}\n\t}\n\treturn result;\n};","var next = __webpack_require__.x;\n__webpack_require__.x = () => {\n\treturn __webpack_require__.e(435).then(next);\n};","const cacheStringFunction = <T extends (str: string) => string>(fn: T): T => {\n  const cache: Record<string, string> = Object.create(null);\n  return ((str: string) => {\n    const hit = cache[str];\n    return hit || (cache[str] = fn(str));\n  }) as any;\n};\n\nconst camelizeRE = /-(\\w)/g;\nexport const camelize = cacheStringFunction((str: string): string => {\n  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : \"\"));\n});\n\n// export const capitalize = cacheStringFunction(\n//   (str: string) => str.charAt(0).toUpperCase() + str.slice(1),\n// )\n","export const isArray = Array.isArray;\n","import { isNumber } from \"@antv/util\";\nimport type { Matrix, Edge, Node, OutNode, Degree, Point } from \"../types\";\nimport { isArray } from \"./array\";\n\nexport const floydWarshall = (adjMatrix: Matrix[]): Matrix[] => {\n  // initialize\n  const dist: Matrix[] = [];\n  const size = adjMatrix.length;\n  for (let i = 0; i < size; i += 1) {\n    dist[i] = [];\n    for (let j = 0; j < size; j += 1) {\n      if (i === j) {\n        dist[i][j] = 0;\n      } else if (adjMatrix[i][j] === 0 || !adjMatrix[i][j]) {\n        dist[i][j] = Infinity;\n      } else {\n        dist[i][j] = adjMatrix[i][j];\n      }\n    }\n  }\n  // floyd\n  for (let k = 0; k < size; k += 1) {\n    for (let i = 0; i < size; i += 1) {\n      for (let j = 0; j < size; j += 1) {\n        if (dist[i][j] > dist[i][k] + dist[k][j]) {\n          dist[i][j] = dist[i][k] + dist[k][j];\n        }\n      }\n    }\n  }\n  return dist;\n};\n\nexport const getAdjMatrix = (\n  data: { nodes: Node[]; edges: Edge[] },\n  directed: boolean\n): Matrix[] => {\n  const { nodes, edges } = data;\n  const matrix: Matrix[] = [];\n  // map node with index in data.nodes\n  const nodeMap: {\n    [key: string]: number;\n  } = {};\n\n  if (!nodes) {\n    throw new Error(\"invalid nodes data!\");\n  }\n  if (nodes) {\n    nodes.forEach((node, i) => {\n      nodeMap[node.id] = i;\n      const row: number[] = [];\n      matrix.push(row);\n    });\n  }\n\n  edges?.forEach((e) => {\n    const { source, target } = e;\n    const sIndex = nodeMap[source as string];\n    const tIndex = nodeMap[target as string];\n    if (sIndex === undefined || tIndex === undefined) return;\n    matrix[sIndex][tIndex] = 1;\n    if (!directed) {\n      matrix[tIndex][sIndex] = 1;\n    }\n  });\n  return matrix;\n};\n\n/**\n * scale matrix\n * @param matrix [ [], [], [] ]\n * @param ratio\n */\nexport const scaleMatrix = (matrix: Matrix[], ratio: number) => {\n  const result: Matrix[] = [];\n  matrix.forEach((row) => {\n    const newRow: number[] = [];\n    row.forEach((v) => {\n      newRow.push(v * ratio);\n    });\n    result.push(newRow);\n  });\n  return result;\n};\n\n/**\n * depth first traverse, from leaves to root, children in inverse order\n *  if the fn returns false, terminate the traverse\n */\nconst traverseUp = <T extends { children?: T[] }>(\n  data: T,\n  fn: (param: T) => boolean\n) => {\n  if (data && data.children) {\n    for (let i = data.children.length - 1; i >= 0; i--) {\n      if (!traverseUp(data.children[i], fn)) return;\n    }\n  }\n\n  if (!fn(data)) {\n    return false;\n  }\n  return true;\n};\n\n/**\n * depth first traverse, from leaves to root, children in inverse order\n * if the fn returns false, terminate the traverse\n */\nexport const traverseTreeUp = <T extends { children?: T[] }>(\n  data: T,\n  fn: (param: T) => boolean\n) => {\n  if (typeof fn !== \"function\") {\n    return;\n  }\n  traverseUp(data, fn);\n};\n\n/**\n * calculate the bounding box for the nodes according to their x, y, and size\n * @param nodes nodes in the layout\n * @returns\n */\nexport const getLayoutBBox = (nodes: OutNode[]) => {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  nodes.forEach((node) => {\n    let size = node.data.size;\n    if (isArray(size)) {\n      if (size.length === 1) size = [size[0], size[0]];\n    } else if (isNumber(size)) {\n      size = [size, size];\n    } else if (size === undefined || isNaN(size as any)) {\n      size = [30, 30];\n    }\n\n    const halfSize = [size[0] / 2, size[1] / 2];\n    const left = node.data.x - halfSize[0];\n    const right = node.data.x + halfSize[0];\n    const top = node.data.y - halfSize[1];\n    const bottom = node.data.y + halfSize[1];\n\n    if (minX > left) minX = left;\n    if (minY > top) minY = top;\n    if (maxX < right) maxX = right;\n    if (maxY < bottom) maxY = bottom;\n  });\n  return { minX, minY, maxX, maxY };\n};\n\n/**\n * 获取节点集合的平均位置信息\n * @param nodes 节点集合\n * @returns 平局内置\n */\nexport const getAvgNodePosition = (nodes: OutNode[]) => {\n  const totalNodes = { x: 0, y: 0 };\n  nodes.forEach((node) => {\n    totalNodes.x += node.data.x || 0;\n    totalNodes.y += node.data.y || 0;\n  });\n  // 获取均值向量\n  const length = nodes.length || 1;\n  return {\n    x: totalNodes.x / length,\n    y: totalNodes.y / length,\n  };\n};\n\n// 找出指定节点关联的边的起点或终点\nconst getCoreNode = (type: \"source\" | \"target\", node: Node, edges: Edge[]) => {\n  if (type === \"source\") {\n    return (edges?.find((edge) => edge.target === node.id)?.source ||\n      {}) as Node;\n  }\n  return (edges?.find((edge) => edge.source === node.id)?.target || {}) as Node;\n};\n\n// 找出指定节点为起点或终点的所有一度叶子节点\nconst getRelativeNodeIds = (\n  type: \"source\" | \"target\" | \"both\",\n  coreNode: Node,\n  edges: Edge[]\n) => {\n  let relativeNodes: (string | number)[] = [];\n  switch (type) {\n    case \"source\":\n      relativeNodes = edges\n        ?.filter((edge) => edge.source === coreNode.id)\n        .map((edge) => edge.target);\n      break;\n    case \"target\":\n      relativeNodes = edges\n        ?.filter((edge) => edge.target === coreNode.id)\n        .map((edge) => edge.source);\n      break;\n    case \"both\":\n      relativeNodes = edges\n        ?.filter((edge) => edge.source === coreNode.id)\n        .map((edge) => edge.target)\n        .concat(\n          edges\n            ?.filter((edge) => edge.target === coreNode.id)\n            .map((edge) => edge.source)\n        );\n      break;\n    default:\n      break;\n  }\n  // 去重\n  const set = new Set(relativeNodes);\n  return Array.from(set);\n};\n// 找出同类型的节点\nconst getSameTypeNodes = (\n  type: \"leaf\" | \"all\",\n  nodeClusterBy: string,\n  node: Node,\n  relativeNodes: Node[],\n  degreesMap: { [id: string]: Degree }\n) => {\n  const typeName = node[nodeClusterBy as keyof Node] || \"\";\n  let sameTypeNodes =\n    relativeNodes?.filter(\n      (item) => item[nodeClusterBy as keyof Node] === typeName\n    ) || [];\n  if (type === \"leaf\") {\n    sameTypeNodes = sameTypeNodes.filter(\n      (node) => degreesMap[node.id]?.in === 0 || degreesMap[node.id]?.out === 0\n    );\n  }\n  return sameTypeNodes;\n};\n\n// 找出与指定节点关联的边的起点或终点出发的所有一度叶子节点\nexport const getCoreNodeAndRelativeLeafNodes = (\n  type: \"leaf\" | \"all\",\n  node: Node,\n  edges: Edge[],\n  nodeClusterBy: string,\n  degreesMap: { [id: string]: Degree },\n  nodeMap: { [id: string]: Node }\n) => {\n  const { in: inDegree, out: outDegree } = degreesMap[node.id];\n  let coreNode: Node = node;\n  let relativeLeafNodes: Node[] = [];\n  if (inDegree === 0) {\n    // 如果为没有出边的叶子节点，则找出与它关联的边的起点出发的所有一度节点\n    coreNode = getCoreNode(\"source\", node, edges);\n    relativeLeafNodes = getRelativeNodeIds(\"both\", coreNode, edges).map(\n      (nodeId) => nodeMap[nodeId]\n    );\n  } else if (outDegree === 0) {\n    // 如果为没有入边边的叶子节点，则找出与它关联的边的起点出发的所有一度节点\n    coreNode = getCoreNode(\"target\", node, edges);\n    relativeLeafNodes = getRelativeNodeIds(\"both\", coreNode, edges).map(\n      (nodeId) => nodeMap[nodeId]\n    );\n  }\n  relativeLeafNodes = relativeLeafNodes.filter(\n    (node) =>\n      degreesMap[node.id] &&\n      (degreesMap[node.id].in === 0 || degreesMap[node.id].out === 0)\n  );\n  const sameTypeLeafNodes = getSameTypeNodes(\n    type,\n    nodeClusterBy,\n    node,\n    relativeLeafNodes,\n    degreesMap\n  );\n  return { coreNode, relativeLeafNodes, sameTypeLeafNodes };\n};\n\n/**\n * calculate the euclidean distance form p1 to p2\n * @param p1\n * @param p2\n * @returns\n */\nexport const getEuclideanDistance = (p1: Point, p2: Point) =>\n  Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));\n","import { isNumber } from \"@antv/util\";\nimport { Node, Edge } from \"../types\";\n\nexport const clone = <T>(target: T): T => {\n  if (target === null) {\n    return target;\n  }\n  if (target instanceof Date) {\n    return new Date(target.getTime()) as any;\n  }\n  if (target instanceof Array) {\n    const cp = [] as any[];\n    (target as any[]).forEach((v) => {\n      cp.push(v);\n    });\n    return cp.map((n: any) => clone<any>(n)) as any;\n  }\n  if (typeof target === \"object\") {\n    const cp = {} as { [key: string]: any };\n    Object.keys(target).forEach((k) => {\n      cp[k] = clone<any>((target as any)[k]);\n    });\n    return cp as T;\n  }\n  return target;\n};\n\n/**\n * Clone node or edge data and format it\n * @param target node/edge to be cloned\n * @param initRange whether init the x and y in data with the range, which means [xRange, yRange]\n * @returns cloned node/edge\n */\nexport const cloneFormatData = <T extends Node | Edge>(\n  target: T,\n  initRange?: [number, number]\n): T => {\n  const cloned = clone(target);\n  cloned.data = cloned.data || {};\n  if (initRange) {\n    if (!isNumber(cloned.data.x)) cloned.data.x = Math.random() * initRange[0];\n    if (!isNumber(cloned.data.y)) cloned.data.y = Math.random() * initRange[1];\n  }\n  return cloned;\n};\n","import { isFunction, isNumber, isObject } from \"@antv/util\";\nimport { Node } from \"../types\";\nimport { isArray } from \".\";\n\n/**\n * Format value with multiple types into a function returns number.\n * @param defaultValue default value when value is invalid\n * @param value value to be formatted\n * @returns formatted result, a function returns number\n */\nexport function formatNumberFn<T = unknown>(\n  defaultValue: number,\n  value: number | ((d?: T) => number) | undefined\n): (d?: T | undefined) => number {\n  let resultFunc;\n  if (isFunction(value)) {\n    resultFunc = value;\n  } else if (isNumber(value)) {\n    // value is number\n    resultFunc = () => value;\n  } else {\n    // value is not number and function\n    resultFunc = () => defaultValue;\n  }\n  return resultFunc;\n}\n\n/**\n * Format size config with multiple types into a function returns number\n * @param defaultValue default value when value is invalid\n * @param value value to be formatted\n * @param resultIsNumber whether returns number\n * @returns formatted result, a function returns number\n */\nexport function formatSizeFn<T extends Node>(\n  defaultValue: number,\n  value?:\n    | number\n    | number[]\n    | { width: number; height: number }\n    | ((d?: T) => number)\n    | undefined,\n  resultIsNumber: boolean = true\n): (d: T) => number | number[] {\n  if (!value && value !== 0) {\n    return (d) => {\n      const { size } = d.data || {};\n      if (size) {\n        if (isArray(size)) {\n          return size[0] > size[1] ? size[0] : size[1];\n        }\n        if (isObject<{ width: number; height: number }>(size)) {\n          return size.width > size.height ? size.width : size.height;\n        }\n        return size;\n      }\n      return defaultValue;\n    };\n  }\n  if (isFunction(value)) {\n    return value;\n  }\n  if (isNumber(value)) {\n    return () => value;\n  }\n  if (isArray(value)) {\n    return () => {\n      if (resultIsNumber) {\n        const max = Math.max(...value);\n        return isNaN(max) ? defaultValue : max;\n      }\n      return value;\n    };\n  }\n  if (isObject(value)) {\n    return () => {\n      if (resultIsNumber) {\n        const max = Math.max(value.width, value.height);\n        return isNaN(max) ? defaultValue : max;\n      }\n      return [value.width, value.height];\n    };\n  }\n  return () => defaultValue;\n}\n\n/**\n * format the props nodeSize and nodeSpacing to a function\n * @param nodeSize\n * @param nodeSpacing\n * @returns\n */\nexport const formatNodeSize = (\n  nodeSize: number | number[] | undefined,\n  nodeSpacing: number | Function | undefined\n): ((nodeData: Node) => number) => {\n  let nodeSizeFunc;\n  let nodeSpacingFunc: Function;\n  if (isNumber(nodeSpacing)) {\n    nodeSpacingFunc = () => nodeSpacing;\n  } else if (isFunction(nodeSpacing)) {\n    nodeSpacingFunc = nodeSpacing;\n  } else {\n    nodeSpacingFunc = () => 0;\n  }\n\n  if (!nodeSize) {\n    nodeSizeFunc = (d: Node) => {\n      if (d.data?.bboxSize) {\n        return (\n          Math.max(d.data.bboxSize[0], d.data.bboxSize[1]) + nodeSpacingFunc(d)\n        );\n      }\n      if (d.data?.size) {\n        if (isArray(d.data.size)) {\n          return Math.max(d.data.size[0], d.data.size[1]) + nodeSpacingFunc(d);\n        }\n        const dataSize = d.data.size;\n        if (isObject<{ width: number; height: number }>(dataSize)) {\n          const res =\n            dataSize.width > dataSize.height ? dataSize.width : dataSize.height;\n          return res + nodeSpacingFunc(d);\n        }\n        return dataSize + nodeSpacingFunc(d);\n      }\n      return 10 + nodeSpacingFunc(d);\n    };\n  } else if (isArray(nodeSize)) {\n    nodeSizeFunc = (d: Node) => {\n      const res = nodeSize[0] > nodeSize[1] ? nodeSize[0] : nodeSize[1];\n      return res + nodeSpacingFunc(d);\n    };\n  } else {\n    nodeSizeFunc = (d: Node) => nodeSize + nodeSpacingFunc(d);\n  }\n  return nodeSizeFunc;\n};\n","import { PointTuple, Graph } from \"../types\";\n\n/**\n * Assign or only return the result for the graph who has no nodes or only one node.\n * @param graph original graph\n * @param assign whether assign result to original graph\n * @param center the layout center\n * @returns\n */\nexport const handleSingleNodeGraph = (\n  graph: Graph,\n  assign: boolean,\n  center: PointTuple\n) => {\n  const nodes = graph.getAllNodes();\n  const edges = graph.getAllEdges();\n  if (!nodes?.length) {\n    const result = { nodes: [] as any[], edges };\n    return result;\n  }\n  if (nodes.length === 1) {\n    if (assign) {\n      graph.mergeNodeData(nodes[0].id, {\n        x: center[0],\n        y: center[1],\n      });\n    }\n    const result = {\n      nodes: [\n        {\n          ...nodes[0],\n          data: {\n            ...nodes[0].data,\n            x: center[0],\n            y: center[1],\n          },\n        },\n      ],\n      edges,\n    };\n    return result;\n  }\n};\n","import type {\n  Graph,\n  CircularLayoutOptions,\n  Layout,\n  LayoutMapping,\n  PointTuple,\n  OutNode,\n  Node,\n  Edge,\n} from \"./types\";\nimport { formatSizeFn, formatNumberFn, cloneFormatData } from \"./util\";\nimport { handleSingleNodeGraph } from \"./util/common\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<CircularLayoutOptions> = {\n  radius: null,\n  startRadius: null,\n  endRadius: null,\n  startAngle: 0,\n  endAngle: 2 * Math.PI,\n  clockwise: true,\n  divisions: 1,\n  ordering: null,\n  angleRatio: 1,\n};\n\n/**\n * Layout arranging the nodes in a circle.\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new CircularLayout({ radius: 10 });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new CircularLayout({ radius: 10 });\n * const positions = await layout.execute(graph, { radius: 20 }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { radius: 20 });\n */\nexport class CircularLayout implements Layout<CircularLayoutOptions> {\n  id = \"circular\";\n\n  constructor(\n    public options: CircularLayoutOptions = {} as CircularLayoutOptions\n  ) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: CircularLayoutOptions) {\n    return this.genericCircularLayout(false, graph, options);\n  }\n\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: CircularLayoutOptions) {\n    await this.genericCircularLayout(true, graph, options);\n  }\n\n  private async genericCircularLayout(\n    assign: false,\n    graph: Graph,\n    options?: CircularLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericCircularLayout(\n    assign: true,\n    graph: Graph,\n    options?: CircularLayoutOptions\n  ): Promise<void>;\n  private async genericCircularLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: CircularLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n    const {\n      width,\n      height,\n      center,\n      divisions,\n      startAngle = 0,\n      endAngle = 2 * Math.PI,\n      angleRatio,\n      ordering,\n      clockwise,\n      nodeSpacing: paramNodeSpacing,\n      nodeSize: paramNodeSize,\n    } = mergedOptions;\n\n    const nodes: Node[] = graph.getAllNodes();\n    const edges: Edge[] = graph.getAllEdges();\n\n    // Calculate center according to `window` if not provided.\n    const [calculatedWidth, calculatedHeight, calculatedCenter] =\n      calculateCenter(width, height, center);\n    const n = nodes?.length;\n    if (!n || n === 1) {\n      return handleSingleNodeGraph(graph, assign, calculatedCenter);\n    }\n\n    const angleStep = (endAngle - startAngle) / n;\n\n    let { radius, startRadius, endRadius } = mergedOptions;\n    if (paramNodeSpacing) {\n      const nodeSpacing: Function = formatNumberFn(10, paramNodeSpacing);\n      const nodeSize: Function = formatSizeFn(10, paramNodeSize);\n      let maxNodeSize = -Infinity;\n      nodes.forEach((node) => {\n        const nSize = nodeSize(node);\n        if (maxNodeSize < nSize) maxNodeSize = nSize;\n      });\n      let perimeter = 0;\n      nodes.forEach((node, i) => {\n        if (i === 0) perimeter += maxNodeSize || 10;\n        else perimeter += (nodeSpacing(node) || 0) + (maxNodeSize || 10);\n      });\n      radius = perimeter / (2 * Math.PI);\n    } else if (!radius && !startRadius && !endRadius) {\n      radius = Math.min(calculatedHeight, calculatedWidth) / 2;\n    } else if (!startRadius && endRadius) {\n      startRadius = endRadius;\n    } else if (startRadius && !endRadius) {\n      endRadius = startRadius;\n    }\n    const astep = angleStep * angleRatio!;\n\n    // calculated nodes as temporary result\n    let layoutNodes: OutNode[] = [];\n    if (ordering === \"topology\") {\n      // layout according to the topology\n      layoutNodes = topologyOrdering(graph, nodes);\n    } else if (ordering === \"topology-directed\") {\n      // layout according to the topology\n      layoutNodes = topologyOrdering(graph, nodes, true);\n    } else if (ordering === \"degree\") {\n      // layout according to the descent order of degrees\n      layoutNodes = degreeOrdering(graph, nodes);\n    } else {\n      // layout according to the original order in the data.nodes\n      layoutNodes = nodes.map((node) => cloneFormatData(node) as OutNode);\n    }\n\n    const divN = Math.ceil(n / divisions!); // node number in each division\n    for (let i = 0; i < n; ++i) {\n      let r = radius;\n      if (!r && startRadius !== null && endRadius !== null) {\n        r = startRadius! + (i * (endRadius! - startRadius!)) / (n - 1);\n      }\n      if (!r) {\n        r = 10 + (i * 100) / (n - 1);\n      }\n      let angle =\n        startAngle +\n        (i % divN) * astep +\n        ((2 * Math.PI) / divisions!) * Math.floor(i / divN);\n      if (!clockwise) {\n        angle =\n          endAngle -\n          (i % divN) * astep -\n          ((2 * Math.PI) / divisions!) * Math.floor(i / divN);\n      }\n      layoutNodes[i].data.x = calculatedCenter[0] + Math.cos(angle) * r;\n      layoutNodes[i].data.y = calculatedCenter[1] + Math.sin(angle) * r;\n    }\n\n    if (assign) {\n      layoutNodes.forEach((node) => {\n        graph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        });\n      });\n    }\n\n    const result = {\n      nodes: layoutNodes,\n      edges,\n    };\n\n    return result;\n  }\n}\n\n/**\n * order the nodes acoording to the graph topology\n * @param graph\n * @param nodes\n * @param directed\n * @returns\n */\nconst topologyOrdering = (\n  graph: Graph,\n  nodes: Node[],\n  directed: boolean = false\n) => {\n  const orderedCNodes: OutNode[] = [cloneFormatData(nodes[0]) as OutNode];\n  const pickFlags: { [id: string]: boolean } = {};\n  const n = nodes.length;\n  pickFlags[nodes[0].id] = true;\n  // write children into cnodes\n  let k = 0;\n  nodes.forEach((node, i) => {\n    if (i !== 0) {\n      if (\n        (i === n - 1 ||\n          graph.getDegree(node.id, \"both\") !==\n            graph.getDegree(nodes[i + 1].id, \"both\") ||\n          graph.areNeighbors(orderedCNodes[k].id, node.id)) &&\n        !pickFlags[node.id]\n      ) {\n        orderedCNodes.push(cloneFormatData(node) as OutNode);\n        pickFlags[node.id] = true;\n        k++;\n      } else {\n        const children = directed\n          ? graph.getSuccessors(orderedCNodes[k].id)\n          : graph.getNeighbors(orderedCNodes[k].id);\n        let foundChild = false;\n        for (let j = 0; j < children.length; j++) {\n          const child = children[j];\n          if (\n            graph.getDegree(child.id) === graph.getDegree(node.id) &&\n            !pickFlags[child.id]\n          ) {\n            orderedCNodes.push(cloneFormatData(child) as OutNode);\n            pickFlags[child.id] = true;\n            foundChild = true;\n            break;\n          }\n        }\n        let ii = 0;\n        while (!foundChild) {\n          if (!pickFlags[nodes[ii].id]) {\n            orderedCNodes.push(cloneFormatData(nodes[ii]) as OutNode);\n            pickFlags[nodes[ii].id] = true;\n            foundChild = true;\n          }\n          ii++;\n          if (ii === n) {\n            break;\n          }\n        }\n      }\n    }\n  });\n  return orderedCNodes;\n};\n\n/**\n * order the nodes according to their degree\n * @param graph\n * @param nodes\n * @returns\n */\nfunction degreeOrdering(graph: Graph, nodes: Node[]): OutNode[] {\n  const orderedNodes: OutNode[] = [];\n  nodes.forEach((node, i) => {\n    orderedNodes.push(cloneFormatData(node) as OutNode);\n  });\n  orderedNodes.sort(\n    (nodeA: Node, nodeB: Node) =>\n      graph.getDegree(nodeA.id, \"both\") - graph.getDegree(nodeB.id, \"both\")\n  );\n  return orderedNodes;\n}\n\n/**\n * format the invalide width and height, and get the center position\n * @param width\n * @param height\n * @param center\n * @returns\n */\nconst calculateCenter = (\n  width: number | undefined,\n  height: number | undefined,\n  center: PointTuple | undefined\n): [number, number, PointTuple] => {\n  let calculatedWidth = width;\n  let calculatedHeight = height;\n  let calculatedCenter = center;\n  if (!calculatedWidth && typeof window !== \"undefined\") {\n    calculatedWidth = window.innerWidth;\n  }\n  if (!calculatedHeight && typeof window !== \"undefined\") {\n    calculatedHeight = window.innerHeight;\n  }\n  if (!calculatedCenter) {\n    calculatedCenter = [calculatedWidth! / 2, calculatedHeight! / 2];\n  }\n  return [calculatedWidth!, calculatedHeight!, calculatedCenter];\n};\n","import { isFunction, isNumber, isObject, isString } from \"@antv/util\";\nimport type {\n  Graph,\n  Node,\n  LayoutMapping,\n  OutNode,\n  PointTuple,\n  ConcentricLayoutOptions,\n  Layout,\n  IndexMap,\n} from \"./types\";\nimport { cloneFormatData, isArray } from \"./util\";\nimport { handleSingleNodeGraph } from \"./util/common\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<ConcentricLayoutOptions> = {\n  nodeSize: 30,\n  nodeSpacing: 10,\n  preventOverlap: false,\n  sweep: undefined,\n  equidistant: false,\n  startAngle: (3 / 2) * Math.PI,\n  clockwise: true,\n  maxLevelDiff: undefined,\n  sortBy: \"degree\",\n};\n\n/**\n * Layout arranging the nodes in concentrics\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new ConcentricLayout({ nodeSpacing: 10 });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new ConcentricLayout({ nodeSpacing: 10});\n * const positions = await layout.execute(graph, { nodeSpacing: 10 }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { nodeSpacing: 10 });\n */\nexport class ConcentricLayout implements Layout<ConcentricLayoutOptions> {\n  id = \"concentric\";\n\n  constructor(\n    public options: ConcentricLayoutOptions = {} as ConcentricLayoutOptions\n  ) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: ConcentricLayoutOptions) {\n    return this.genericConcentricLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: ConcentricLayoutOptions) {\n    this.genericConcentricLayout(true, graph, options);\n  }\n\n  private async genericConcentricLayout(\n    assign: false,\n    graph: Graph,\n    options?: ConcentricLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericConcentricLayout(\n    assign: true,\n    graph: Graph,\n    options?: ConcentricLayoutOptions\n  ): Promise<void>;\n  private async genericConcentricLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: ConcentricLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n    const {\n      center: propsCenter,\n      width: propsWidth,\n      height: propsHeight,\n      sortBy: propsSortBy,\n      maxLevelDiff: propsMaxLevelDiff,\n      sweep: propsSweep,\n      clockwise,\n      equidistant,\n      preventOverlap,\n      startAngle = (3 / 2) * Math.PI,\n      nodeSize,\n      nodeSpacing,\n    } = mergedOptions;\n\n    const nodes = graph.getAllNodes();\n    const edges = graph.getAllEdges();\n\n    const width =\n      !propsWidth && typeof window !== \"undefined\"\n        ? window.innerWidth\n        : (propsWidth as number);\n    const height =\n      !propsHeight && typeof window !== \"undefined\"\n        ? window.innerHeight\n        : (propsHeight as number);\n    const center = (\n      !propsCenter ? [width / 2, height / 2] : propsCenter\n    ) as PointTuple;\n\n    if (!nodes?.length || nodes.length === 1) {\n      return handleSingleNodeGraph(graph, assign, center);\n    }\n\n    const layoutNodes: OutNode[] = [];\n    let maxNodeSize: number;\n    let maxNodeSpacing: number = 0;\n    if (isArray(nodeSize)) {\n      maxNodeSize = Math.max(nodeSize[0], nodeSize[1]);\n    } else {\n      maxNodeSize = nodeSize as number;\n    }\n    if (isArray(nodeSpacing)) {\n      maxNodeSpacing = Math.max(nodeSpacing[0], nodeSpacing[1]);\n    } else if (isNumber(nodeSpacing)) {\n      maxNodeSpacing = nodeSpacing;\n    }\n    nodes.forEach((node) => {\n      const cnode = cloneFormatData(node) as OutNode;\n      layoutNodes.push(cnode);\n      let nodeSize: number = maxNodeSize;\n      const { data } = cnode;\n      if (isArray(data.size)) {\n        nodeSize = Math.max(data.size[0], data.size[1]);\n      } else if (isNumber(data.size)) {\n        nodeSize = data.size;\n      } else if (isObject(data.size)) {\n        nodeSize = Math.max(\n          (data.size as any).width,\n          (data.size as any).height\n        );\n      }\n      maxNodeSize = Math.max(maxNodeSize, nodeSize);\n\n      if (isFunction(nodeSpacing)) {\n        maxNodeSpacing = Math.max(nodeSpacing(node), maxNodeSpacing);\n      }\n    });\n\n    // layout\n    const nodeIdxMap: IndexMap = {};\n    layoutNodes.forEach((node, i) => {\n      nodeIdxMap[node.id] = i;\n    });\n\n    // get the node degrees\n    let sortBy = propsSortBy!;\n    if (\n      !isString(sortBy) ||\n      (layoutNodes[0] as any).data[sortBy] === undefined\n    ) {\n      sortBy = \"degree\";\n    }\n    if (sortBy === \"degree\") {\n      layoutNodes.sort(\n        (n1: Node, n2: Node) =>\n          graph.getDegree(n2.id, \"both\") - graph.getDegree(n1.id, \"both\")\n      );\n    } else {\n      // sort nodes by value\n      layoutNodes.sort(\n        (n1: Node, n2: Node) =>\n          (n2 as any).data[sortBy] - (n1 as any).data[sortBy]\n      );\n    }\n\n    const maxValueNode = layoutNodes[0];\n    const maxLevelDiff =\n      (propsMaxLevelDiff ||\n        (sortBy === \"degree\"\n          ? graph.getDegree(maxValueNode.id, \"both\")\n          : (maxValueNode as any).data[sortBy])) / 4;\n\n    // put the values into levels\n    const levels: {\n      nodes: OutNode[];\n      r?: number;\n      dTheta?: number;\n    }[] = [{ nodes: [] }];\n    let currentLevel = levels[0];\n    layoutNodes.forEach((node) => {\n      if (currentLevel.nodes.length > 0) {\n        const diff =\n          sortBy === \"degree\"\n            ? Math.abs(\n                graph.getDegree(currentLevel.nodes[0].id, \"both\") -\n                  graph.getDegree(node.id, \"both\")\n              )\n            : Math.abs(\n                (currentLevel.nodes[0].data[sortBy] as number) -\n                  (node as any).data[sortBy]\n              );\n\n        if (maxLevelDiff && diff >= maxLevelDiff) {\n          currentLevel = { nodes: [] };\n          levels.push(currentLevel);\n        }\n      }\n      currentLevel.nodes.push(node);\n    });\n\n    // create positions for levels\n    let minDist = maxNodeSize + maxNodeSpacing; // min dist between nodes\n    if (!preventOverlap) {\n      // then strictly constrain to bb\n      const firstLvlHasMulti = levels.length > 0 && levels[0].nodes.length > 1;\n      const maxR = Math.min(width, height) / 2 - minDist;\n      const rStep = maxR / (levels.length + (firstLvlHasMulti ? 1 : 0));\n\n      minDist = Math.min(minDist, rStep);\n    }\n\n    // find the metrics for each level\n    let r = 0;\n    levels.forEach((level) => {\n      const sweep =\n        propsSweep === undefined\n          ? 2 * Math.PI - (2 * Math.PI) / level.nodes.length\n          : propsSweep;\n      level.dTheta = sweep / Math.max(1, level.nodes.length - 1);\n\n      // calculate the radius\n      if (level.nodes.length > 1 && preventOverlap) {\n        // but only if more than one node (can't overlap)\n        const dcos = Math.cos(level.dTheta) - Math.cos(0);\n        const dsin = Math.sin(level.dTheta) - Math.sin(0);\n        const rMin = Math.sqrt(\n          (minDist * minDist) / (dcos * dcos + dsin * dsin)\n        ); // s.t. no nodes overlapping\n\n        r = Math.max(rMin, r);\n      }\n      level.r = r;\n      r += minDist;\n    });\n\n    if (equidistant) {\n      let rDeltaMax = 0;\n      let rr = 0;\n      for (let i = 0; i < levels.length; i++) {\n        const level = levels[i];\n        const rDelta = (level.r || 0) - rr;\n        rDeltaMax = Math.max(rDeltaMax, rDelta);\n      }\n      rr = 0;\n      levels.forEach((level, i) => {\n        if (i === 0) {\n          rr = level.r || 0;\n        }\n        level.r = rr;\n        rr += rDeltaMax;\n      });\n    }\n\n    // calculate the node positions\n    levels.forEach((level) => {\n      const dTheta = level.dTheta || 0;\n      const rr = level.r || 0;\n      level.nodes.forEach((node: OutNode, j: number) => {\n        const theta = startAngle + (clockwise ? 1 : -1) * dTheta * j;\n        node.data.x = center[0] + rr * Math.cos(theta);\n        node.data.y = center[1] + rr * Math.sin(theta);\n      });\n    });\n\n    if (assign) {\n      layoutNodes.forEach((node) =>\n        graph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        })\n      );\n    }\n\n    const result = {\n      nodes: layoutNodes,\n      edges,\n    };\n\n    return result;\n  }\n}\n","import * as d3Force from \"d3-force\";\n\ninterface INode {\n  id: string;\n  x: number;\n  y: number;\n  vx: number;\n  vy: number;\n  cluster: any;\n}\n\n// https://github.com/john-guerra/forceInABox/blob/master/src/forceInABox.js\nexport default function forceInBox() {\n  function constant(_: any): () => any {\n    return () => _;\n  }\n\n  let groupBy = (d: INode) => {\n    return d.cluster;\n  };\n  let forceNodeSize: (() => number) | ((d: any) => number) = constant(1);\n  let forceCharge: (() => number) | ((d: any) => number) = constant(-1);\n  let forceLinkDistance: (() => number) | ((d: any) => number) = constant(100);\n  let forceLinkStrength: (() => number) | ((d: any) => number) = constant(0.1);\n  let offset = [0, 0];\n\n  let nodes: INode[] = [];\n  let nodesMap: any = {};\n  let links: any[] = [];\n  let centerX = 100;\n  let centerY = 100;\n  let foci: any = {\n    none: {\n      x: 0,\n      y: 0,\n    },\n  };\n  let templateNodes: INode[] = [];\n  let templateForce: any;\n  let template = \"force\";\n  let enableGrouping = true;\n  let strength = 0.1;\n\n  function force(alpha: number) {\n    if (!enableGrouping) {\n      return force;\n    }\n    templateForce.tick();\n    getFocisFromTemplate();\n\n    for (let i = 0, n = nodes.length, node, k = alpha * strength; i < n; ++i) {\n      node = nodes[i];\n      node.vx += (foci[groupBy(node)].x - node.x) * k;\n      node.vy += (foci[groupBy(node)].y - node.y) * k;\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    initializeWithForce();\n  }\n\n  function initializeWithForce() {\n    if (!nodes || !nodes.length) {\n      return;\n    }\n\n    if (groupBy(nodes[0]) === undefined) {\n      throw Error(\n        \"Couldnt find the grouping attribute for the nodes. Make sure to set it up with forceInBox.groupBy('clusterAttr') before calling .links()\"\n      );\n    }\n\n    // checkLinksAsObjects();\n\n    const net = getGroupsGraph();\n    templateForce = d3Force\n      .forceSimulation(net.nodes)\n      .force(\"x\", d3Force.forceX(centerX).strength(0.1))\n      .force(\"y\", d3Force.forceY(centerY).strength(0.1))\n      .force(\"collide\", d3Force.forceCollide((d: any) => d.r).iterations(4))\n      .force(\"charge\", d3Force.forceManyBody().strength(forceCharge))\n      .force(\n        \"links\",\n        d3Force\n          .forceLink(net.nodes.length ? net.links : [])\n          .distance(forceLinkDistance)\n          .strength(forceLinkStrength)\n      );\n\n    templateNodes = templateForce.nodes();\n\n    getFocisFromTemplate();\n  }\n\n  function getGroupsGraph() {\n    const gnodes: any = [];\n    const glinks: any = [];\n    const dNodes: any = {};\n    let clustersList: string[] = [];\n    let clustersCounts: any = {};\n    let clustersLinks: any = [];\n\n    clustersCounts = computeClustersNodeCounts(nodes);\n    clustersLinks = computeClustersLinkCounts(links);\n\n    clustersList = Object.keys(clustersCounts);\n\n    clustersList.forEach((key, index) => {\n      const val = clustersCounts[key];\n      // Uses approx meta-node size\n      gnodes.push({\n        id: key,\n        size: val.count,\n        r: Math.sqrt(val.sumforceNodeSize / Math.PI),\n      });\n      dNodes[key] = index;\n    });\n\n    clustersLinks.forEach((link: any) => {\n      const sourceTerminal = link.source;\n      const targetTerminal = link.target;\n      const source = dNodes[sourceTerminal];\n      const target = dNodes[targetTerminal];\n      if (source !== undefined && target !== undefined) {\n        glinks.push({\n          source,\n          target,\n          count: link.count,\n        });\n      }\n    });\n\n    return {\n      nodes: gnodes,\n      links: glinks,\n    };\n  }\n\n  function computeClustersNodeCounts(nodes: any) {\n    const clustersCounts: any = {};\n\n    nodes.forEach((d: any) => {\n      const key = groupBy(d);\n      if (!clustersCounts[key]) {\n        clustersCounts[key] = {\n          count: 0,\n          sumforceNodeSize: 0,\n        };\n      }\n    });\n    nodes.forEach((d: any) => {\n      const key = groupBy(d);\n      const nodeSize = forceNodeSize(d);\n      const tmpCount = clustersCounts[key];\n      tmpCount.count = tmpCount.count + 1;\n      tmpCount.sumforceNodeSize =\n        tmpCount.sumforceNodeSize + Math.PI * (nodeSize * nodeSize) * 1.3;\n      clustersCounts[key] = tmpCount;\n    });\n\n    return clustersCounts;\n  }\n\n  function computeClustersLinkCounts(links: any) {\n    const dClusterLinks: any = {};\n    const clusterLinks: any = [];\n    links.forEach((l: any) => {\n      const key = getLinkKey(l);\n      let count = 0;\n      if (dClusterLinks[key] !== undefined) {\n        count = dClusterLinks[key];\n      }\n      count += 1;\n      dClusterLinks[key] = count;\n    });\n\n    // @ts-ignore\n    const entries = Object.entries(dClusterLinks);\n\n    entries.forEach(([key, count]: any) => {\n      const source = key.split(\"~\")[0];\n      const target = key.split(\"~\")[1];\n      if (source !== undefined && target !== undefined) {\n        clusterLinks.push({\n          source,\n          target,\n          count,\n        });\n      }\n    });\n\n    return clusterLinks;\n  }\n\n  function getFocisFromTemplate() {\n    foci = {\n      none: {\n        x: 0,\n        y: 0,\n      },\n    };\n    templateNodes.forEach((d) => {\n      foci[d.id] = {\n        x: d.x - offset[0],\n        y: d.y - offset[1],\n      };\n    });\n    return foci;\n  }\n\n  function getLinkKey(link: any) {\n    const source = link.source;\n    const target = link.target;\n    const sourceID = groupBy(nodesMap[source]);\n    const targetID = groupBy(nodesMap[target]);\n\n    return sourceID <= targetID\n      ? `${sourceID}~${targetID}`\n      : `${targetID}~${sourceID}`;\n  }\n\n  function genNodesMap(nodes: any) {\n    nodesMap = {};\n    nodes.forEach((node: any) => {\n      nodesMap[node.id] = node;\n    });\n  }\n\n  function setTemplate(x: any) {\n    if (!arguments.length) return template;\n    template = x;\n    initialize();\n    return force;\n  }\n\n  function setGroupBy(x: any) {\n    if (!arguments.length) return groupBy;\n    if (typeof x === \"string\") {\n      groupBy = (d: any) => {\n        return d[x];\n      };\n      return force;\n    }\n    groupBy = x;\n    return force;\n  }\n\n  function setEnableGrouping(x: any) {\n    if (!arguments.length) return enableGrouping;\n    enableGrouping = x;\n    return force;\n  }\n\n  function setStrength(x: any) {\n    if (!arguments.length) return strength;\n    strength = x;\n    return force;\n  }\n\n  function setCenterX(_: any) {\n    if (arguments.length) {\n      centerX = _;\n      return force;\n    }\n\n    return centerX;\n  }\n\n  function setCenterY(_: any) {\n    if (arguments.length) {\n      centerY = _;\n      return force;\n    }\n\n    return centerY;\n  }\n\n  function setNodes(_: any) {\n    if (arguments.length) {\n      genNodesMap(_ || []);\n      nodes = _ || [];\n      return force;\n    }\n    return nodes;\n  }\n\n  function setLinks(_: any) {\n    if (arguments.length) {\n      links = _ || [];\n      initialize();\n      return force;\n    }\n    return links;\n  }\n\n  function setForceNodeSize(_: any) {\n    if (arguments.length) {\n      if (typeof _ === \"function\") {\n        forceNodeSize = _;\n      } else {\n        forceNodeSize = constant(+_);\n      }\n      initialize();\n      return force;\n    }\n\n    return forceNodeSize;\n  }\n\n  function setForceCharge(_: any) {\n    if (arguments.length) {\n      if (typeof _ === \"function\") {\n        forceCharge = _;\n      } else {\n        forceCharge = constant(+_);\n      }\n      initialize();\n      return force;\n    }\n\n    return forceCharge;\n  }\n\n  function setForceLinkDistance(_: any) {\n    if (arguments.length) {\n      if (typeof _ === \"function\") {\n        forceLinkDistance = _;\n      } else {\n        forceLinkDistance = constant(+_);\n      }\n      initialize();\n      return force;\n    }\n\n    return forceLinkDistance;\n  }\n\n  function setForceLinkStrength(_: any) {\n    if (arguments.length) {\n      if (typeof _ === \"function\") {\n        forceLinkStrength = _;\n      } else {\n        forceLinkStrength = constant(+_);\n      }\n      initialize();\n      return force;\n    }\n\n    return forceLinkStrength;\n  }\n\n  function setOffset(_: any) {\n    if (arguments.length) {\n      offset = _;\n      return force;\n    }\n\n    return offset;\n  }\n\n  force.initialize = (_: any) => {\n    nodes = _;\n    initialize();\n  };\n\n  force.template = setTemplate;\n\n  force.groupBy = setGroupBy;\n\n  force.enableGrouping = setEnableGrouping;\n\n  force.strength = setStrength;\n\n  force.centerX = setCenterX;\n\n  force.centerY = setCenterY;\n\n  force.nodes = setNodes;\n\n  force.links = setLinks;\n\n  force.forceNodeSize = setForceNodeSize;\n\n  // Legacy support\n  force.nodeSize = force.forceNodeSize;\n\n  force.forceCharge = setForceCharge;\n\n  force.forceLinkDistance = setForceLinkDistance;\n\n  force.forceLinkStrength = setForceLinkStrength;\n\n  force.offset = setOffset;\n\n  force.getFocis = getFocisFromTemplate;\n\n  return force;\n}\n","import * as d3Force from \"d3-force\";\nimport { isFunction, isNumber, isObject } from \"@antv/util\";\nimport {\n  Graph,\n  Node,\n  LayoutMapping,\n  OutNode,\n  D3ForceLayoutOptions,\n  Edge,\n  LayoutWithIterations,\n} from \"../types\";\nimport { cloneFormatData, isArray } from \"../util\";\nimport forceInBox from \"./forceInBox\";\n\n/**\n * D3 writes x and y as the first level properties\n */\ninterface CalcNode extends Node {\n  x: number;\n  y: number;\n}\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<D3ForceLayoutOptions> = {\n  center: [0, 0],\n  preventOverlap: false,\n  nodeSize: undefined,\n  nodeSpacing: undefined,\n  linkDistance: 50,\n  forceSimulation: null,\n  alphaDecay: 0.028,\n  alphaMin: 0.001,\n  alpha: 0.3,\n  collideStrength: 1,\n  clustering: false,\n  clusterNodeStrength: -1,\n  clusterEdgeStrength: 0.1,\n  clusterEdgeDistance: 100,\n  clusterFociStrength: 0.8,\n  clusterNodeSize: 10,\n};\n\n/**\n * Layout the nodes' positions with d3's basic classic force\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new D3ForceLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new D3ForceLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { center: [100, 100] });\n */\nexport class D3ForceLayout\n  implements LayoutWithIterations<D3ForceLayoutOptions>\n{\n  id = \"d3force\";\n\n  private forceSimulation: d3Force.Simulation<any, any>;\n\n  private lastLayoutNodes: CalcNode[];\n  private lastLayoutEdges: Edge[];\n  private lastAssign: boolean;\n  private lastGraph: Graph;\n\n  constructor(\n    public options: D3ForceLayoutOptions = {} as D3ForceLayoutOptions\n  ) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: D3ForceLayoutOptions) {\n    return this.genericForceLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: D3ForceLayoutOptions) {\n    this.genericForceLayout(true, graph, options);\n  }\n\n  /**\n   * Stop simulation immediately.\n   */\n  stop() {\n    this.forceSimulation?.stop();\n  }\n\n  /**\n   * Manually steps the simulation by the specified number of iterations.\n   * @see https://github.com/d3/d3-force#simulation_tick\n   */\n  tick(iterations = 1) {\n    this.forceSimulation.tick(iterations);\n\n    const result = {\n      nodes: formatOutNodes(this.lastLayoutNodes),\n      edges: formatOutEdges(this.lastLayoutEdges),\n    };\n\n    if (this.lastAssign) {\n      result.nodes.forEach((node) =>\n        this.lastGraph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        })\n      );\n    }\n\n    return result;\n  }\n\n  private async genericForceLayout(\n    assign: false,\n    graph: Graph,\n    options?: D3ForceLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericForceLayout(\n    assign: true,\n    graph: Graph,\n    options?: D3ForceLayoutOptions\n  ): Promise<void>;\n  private async genericForceLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: D3ForceLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n\n    const nodes = graph.getAllNodes();\n    const edges = graph.getAllEdges();\n    const layoutNodes: CalcNode[] = nodes.map(\n      (node) =>\n        ({\n          ...cloneFormatData(node),\n          x: node.data?.x,\n          y: node.data?.y,\n        } as CalcNode)\n    );\n    const layoutEdges: Edge[] = edges.map((edge) => cloneFormatData(edge));\n\n    // Use them later in `tick`.\n    this.lastLayoutNodes = layoutNodes;\n    this.lastLayoutEdges = layoutEdges;\n    this.lastAssign = assign;\n    this.lastGraph = graph;\n\n    const {\n      alphaMin,\n      alphaDecay,\n      alpha,\n      nodeStrength,\n      edgeStrength,\n      linkDistance,\n      clustering,\n      clusterFociStrength,\n      clusterEdgeDistance,\n      clusterEdgeStrength,\n      clusterNodeStrength,\n      clusterNodeSize,\n      collideStrength = 1,\n      center = [0, 0],\n      preventOverlap,\n      nodeSize,\n      nodeSpacing,\n      onTick,\n    } = mergedOptions;\n    let { forceSimulation } = mergedOptions;\n\n    return new Promise((resolve) => {\n      if (!forceSimulation) {\n        try {\n          // 定义节点的力\n          const nodeForce = d3Force.forceManyBody();\n          if (nodeStrength) {\n            nodeForce.strength(nodeStrength as any);\n          }\n          forceSimulation = d3Force.forceSimulation().nodes(layoutNodes as any);\n\n          if (clustering) {\n            const clusterForce = forceInBox() as any;\n            clusterForce\n              .centerX(center[0])\n              .centerY(center[1])\n              .template(\"force\")\n              .strength(clusterFociStrength);\n            if (layoutEdges) {\n              clusterForce.links(layoutEdges);\n            }\n            if (layoutNodes) {\n              clusterForce.nodes(layoutNodes);\n            }\n            clusterForce\n              .forceLinkDistance(clusterEdgeDistance)\n              .forceLinkStrength(clusterEdgeStrength)\n              .forceCharge(clusterNodeStrength)\n              .forceNodeSize(clusterNodeSize);\n\n            forceSimulation.force(\"group\", clusterForce);\n          }\n          forceSimulation\n            .force(\"center\", d3Force.forceCenter(center[0], center[1]))\n            .force(\"charge\", nodeForce)\n            .alpha(alpha)\n            .alphaDecay(alphaDecay)\n            .alphaMin(alphaMin);\n\n          if (preventOverlap) {\n            this.overlapProcess(forceSimulation, {\n              nodeSize,\n              nodeSpacing,\n              collideStrength,\n            });\n          }\n          // 如果有边，定义边的力\n          if (layoutEdges) {\n            // d3 的 forceLayout 会重新生成边的数据模型，为了避免污染源数据\n            const edgeForce = d3Force\n              .forceLink()\n              .id((d: any) => d.id)\n              .links(layoutEdges);\n            if (edgeStrength) {\n              edgeForce.strength(edgeStrength as any);\n            }\n            if (linkDistance) {\n              edgeForce.distance(linkDistance as any);\n            }\n            forceSimulation.force(\"link\", edgeForce);\n          }\n\n          forceSimulation\n            .on(\"tick\", () => {\n              const outNodes = formatOutNodes(layoutNodes);\n              onTick?.({\n                nodes: outNodes,\n                edges: formatOutEdges(layoutEdges),\n              });\n\n              if (assign) {\n                outNodes.forEach((node) =>\n                  graph.mergeNodeData(node.id, {\n                    x: node.data.x,\n                    y: node.data.y,\n                  })\n                );\n              }\n            })\n            .on(\"end\", () => {\n              const outNodes = formatOutNodes(layoutNodes);\n\n              if (assign) {\n                outNodes.forEach((node) =>\n                  graph.mergeNodeData(node.id, {\n                    x: node.data.x,\n                    y: node.data.y,\n                  })\n                );\n              }\n\n              resolve({\n                nodes: outNodes,\n                edges: formatOutEdges(layoutEdges),\n              });\n            });\n        } catch (e) {\n          console.warn(e);\n        }\n      } else {\n        // forceSimulation is defined\n        if (clustering) {\n          const clusterForce = forceInBox() as any;\n          clusterForce.nodes(layoutNodes);\n          clusterForce.links(layoutEdges);\n        }\n        forceSimulation.nodes(layoutNodes);\n        if (layoutEdges) {\n          // d3 的 forceLayout 会重新生成边的数据模型，为了避免污染源数据\n          const edgeForce = d3Force\n            .forceLink()\n            .id((d: any) => d.id)\n            .links(layoutEdges);\n          if (edgeStrength) {\n            edgeForce.strength(edgeStrength as any);\n          }\n          if (linkDistance) {\n            edgeForce.distance(linkDistance as any);\n          }\n          forceSimulation.force(\"link\", edgeForce);\n        }\n        if (preventOverlap) {\n          this.overlapProcess(forceSimulation, {\n            nodeSize,\n            nodeSpacing,\n            collideStrength,\n          });\n        }\n        forceSimulation.alpha(alpha).restart();\n\n        // since d3 writes x and y as node's first level properties, format them into data\n        const outNodes = formatOutNodes(layoutNodes);\n        const outEdges = formatOutEdges(layoutEdges);\n\n        if (assign) {\n          outNodes.forEach((node) =>\n            graph.mergeNodeData(node.id, {\n              x: node.data.x,\n              y: node.data.y,\n            })\n          );\n        }\n\n        resolve({\n          nodes: outNodes,\n          edges: outEdges,\n        });\n      }\n\n      this.forceSimulation = forceSimulation;\n    });\n  }\n\n  /**\n   * Prevent overlappings.\n   * @param {object} simulation force simulation of d3\n   */\n  public overlapProcess(\n    simulation: d3Force.Simulation<any, any>,\n    options: {\n      nodeSize: number | number[] | ((d?: Node) => number) | undefined;\n      nodeSpacing: number | number[] | ((d?: Node) => number) | undefined;\n      collideStrength: number;\n    }\n  ) {\n    const { nodeSize, nodeSpacing, collideStrength } = options;\n    let nodeSizeFunc: (d: any) => number;\n    let nodeSpacingFunc: any;\n\n    if (isNumber(nodeSpacing)) {\n      nodeSpacingFunc = () => nodeSpacing;\n    } else if (isFunction(nodeSpacing)) {\n      nodeSpacingFunc = nodeSpacing;\n    } else {\n      nodeSpacingFunc = () => 0;\n    }\n\n    if (!nodeSize) {\n      nodeSizeFunc = (d) => {\n        if (d.size) {\n          if (isArray(d.size)) {\n            const res = d.size[0] > d.size[1] ? d.size[0] : d.size[1];\n            return res / 2 + nodeSpacingFunc(d);\n          }\n          if (isObject(d.size)) {\n            const res =\n              d.size.width > d.size.height ? d.size.width : d.size.height;\n            return res / 2 + nodeSpacingFunc(d);\n          }\n          return d.size / 2 + nodeSpacingFunc(d);\n        }\n        return 10 + nodeSpacingFunc(d);\n      };\n    } else if (isFunction(nodeSize)) {\n      nodeSizeFunc = (d) => {\n        const size = nodeSize(d);\n        return size + nodeSpacingFunc(d);\n      };\n    } else if (isArray(nodeSize)) {\n      const larger = nodeSize[0] > nodeSize[1] ? nodeSize[0] : nodeSize[1];\n      const radius = larger / 2;\n      nodeSizeFunc = (d) => radius + nodeSpacingFunc(d);\n    } else if (isNumber(nodeSize)) {\n      const radius = (nodeSize as number) / 2;\n      nodeSizeFunc = (d) => radius + nodeSpacingFunc(d);\n    } else {\n      nodeSizeFunc = () => 10;\n    }\n\n    // forceCollide's parameter is a radius\n    simulation.force(\n      \"collisionForce\",\n      d3Force.forceCollide(nodeSizeFunc).strength(collideStrength)\n    );\n  }\n}\n\n/**\n * Format the calculation nodes into output nodes.\n * Since d3 reads properties in plain node data object which is not compact to the OutNode\n * @param layoutNodes\n * @returns\n */\nconst formatOutNodes = (layoutNodes: CalcNode[]): OutNode[] =>\n  layoutNodes.map((node) => {\n    const { x, y, ...others } = node;\n    return {\n      ...others,\n      data: {\n        ...others.data,\n        x,\n        y,\n      },\n    };\n  });\n\n/**\n * d3 will modify `source` and `target` on edge object.\n */\nconst formatOutEdges = (edges: any[]): Edge[] =>\n  edges.map((edge) => {\n    const { source, target, ...rest } = edge;\n    return {\n      ...rest,\n      source: source.id,\n      target: target.id,\n    };\n  });\n","const filterOutLinks = (k: string, v: string) => {\n  if (k !== \"next\" && k !== \"prev\") {\n    return v;\n  }\n};\n\ntype LinkedNode<T> = {\n  prev?: LinkedNode<T>;\n  next?: LinkedNode<T>;\n} & T;\n\nconst unlink = <T>(entry: LinkedNode<T>) => {\n  entry.prev!.next = entry.next;\n  entry.next!.prev = entry.prev;\n  delete entry.next;\n  delete entry.prev;\n};\n\nexport default class List<T> {\n  // a shortcut that next is head and prev is tail\n  public shortcut: LinkedNode<T>;\n\n  constructor() {\n    const shortcut: LinkedNode<any> = {};\n    shortcut.prev = shortcut;\n    shortcut.next = shortcut.prev;\n    this.shortcut = shortcut;\n  }\n\n  public dequeue() {\n    const shortcut = this.shortcut;\n    const entry = shortcut.prev;\n    if (entry && entry !== shortcut) {\n      unlink(entry);\n      return entry;\n    }\n  }\n\n  public enqueue(entry: LinkedNode<T>) {\n    const shortcut = this.shortcut;\n    if (entry.prev && entry.next) {\n      unlink(entry);\n    }\n    entry.next = shortcut.next;\n    shortcut.next!.prev = entry;\n    shortcut.next = entry;\n    entry.prev = shortcut;\n  }\n\n  public toString() {\n    const strs = [];\n    const sentinel = this.shortcut;\n    let curr = sentinel.prev;\n    while (curr !== sentinel) {\n      strs.push(JSON.stringify(curr, filterOutLinks));\n      curr = curr?.prev;\n    }\n    return `[${strs.join(\", \")}]`;\n  }\n}\n","/*\n * A greedy heuristic for finding a feedback arc set for a graph. A feedback\n * arc set is a set of edges that can be removed to make a graph acyclic.\n * The algorithm comes from: P. Eades, X. Lin, and W. F. Smyth, \"A fast and\n * effective heuristic for the feedback arc set problem.\" This implementation\n * adjusts that from the paper to allow for weighted edges.\n *\n * @see https://github.com/dagrejs/dagre/blob/master/lib/greedy-fas.js\n */\n\nimport { Edge, Graph, ID } from \"@antv/graphlib\";\nimport { EdgeData, Graph as IGraph, NodeData } from \"../types\";\nimport RawList from \"./data/list\";\n\ntype StateNode = {\n  v: ID;\n  w?: ID;\n  in: number;\n  out: number;\n  prev?: StateNode;\n  next?: StateNode;\n};\nclass List extends RawList<StateNode> {}\n\nconst DEFAULT_WEIGHT_FN = () => 1;\n\nexport const greedyFAS = (\n  g: IGraph,\n  weightFn?: (e: Edge<EdgeData>) => number\n) => {\n  if (g.getAllNodes().length <= 1) return [];\n  const state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);\n  const results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);\n\n  return results\n    .map((e) =>\n      g.getRelatedEdges(e.v, \"out\").filter(({ target }) => target === e.w)\n    )\n    ?.flat();\n};\n\nconst doGreedyFAS = (g: IGraph, buckets: List[], zeroIdx: number) => {\n  let results: StateNode[] = [];\n  const sources = buckets[buckets.length - 1];\n  const sinks = buckets[0];\n\n  let entry;\n  while (g.getAllNodes().length) {\n    while ((entry = sinks.dequeue())) {\n      removeNode(g, buckets, zeroIdx, entry);\n    }\n    while ((entry = sources.dequeue())) {\n      removeNode(g, buckets, zeroIdx, entry);\n    }\n    if (g.getAllNodes().length) {\n      for (let i = buckets.length - 2; i > 0; --i) {\n        entry = buckets[i].dequeue();\n        if (entry) {\n          results = results.concat(\n            removeNode(g, buckets, zeroIdx, entry, true)!\n          );\n          break;\n        }\n      }\n    }\n  }\n\n  return results;\n};\n\nconst removeNode = (\n  g: IGraph,\n  buckets: List[],\n  zeroIdx: number,\n  entry: StateNode,\n  collectPredecessors?: boolean\n) => {\n  const results: StateNode[] = [];\n\n  if (g.hasNode(entry.v)) {\n    g.getRelatedEdges(entry.v, \"in\")?.forEach((edge) => {\n      const weight = edge.data.weight!;\n      const uEntry = g.getNode(edge.source)!;\n\n      if (collectPredecessors) {\n        // this result not really care about in or out\n        results.push({ v: edge.source, w: edge.target, in: 0, out: 0 });\n      }\n      if (uEntry.data.out === undefined) uEntry.data.out = 0;\n      // @ts-ignore\n      uEntry.data.out -= weight;\n      assignBucket(buckets, zeroIdx, {\n        v: uEntry.id,\n        ...uEntry.data,\n      } as StateNode);\n    });\n\n    g.getRelatedEdges(entry.v, \"out\")?.forEach((edge) => {\n      const weight = edge.data.weight!;\n      const w = edge.target;\n      const wEntry = g.getNode(w)!;\n      if (wEntry.data.in === undefined) wEntry.data.in = 0;\n      // @ts-ignore\n      wEntry.data.in -= weight;\n      assignBucket(buckets, zeroIdx, {\n        v: wEntry.id,\n        ...wEntry.data,\n      } as StateNode);\n    });\n\n    g.removeNode(entry.v);\n  }\n\n  return collectPredecessors ? results : undefined;\n};\n\nconst buildState = (g: IGraph, weightFn?: (e: Edge<EdgeData>) => number) => {\n  const fasGraph = new Graph<NodeData, EdgeData>();\n  let maxIn = 0;\n  let maxOut = 0;\n\n  g.getAllNodes().forEach((v) => {\n    fasGraph.addNode({\n      id: v.id,\n      data: { v: v.id, in: 0, out: 0 },\n    });\n  });\n\n  // Aggregate weights on nodes, but also sum the weights across multi-edges\n  // into a single edge for the fasGraph.\n  g.getAllEdges().forEach((e) => {\n    const edge = fasGraph\n      .getRelatedEdges(e.source, \"out\")\n      .find((edge) => edge.target === e.target);\n    const weight = weightFn?.(e) || 1;\n    if (!edge) {\n      fasGraph.addEdge({\n        id: e.id,\n        source: e.source,\n        target: e.target,\n        data: {\n          weight,\n        },\n      });\n    } else {\n      fasGraph.updateEdgeData(edge?.id!, {\n        ...edge.data,\n        weight: edge.data.weight! + weight,\n      });\n    }\n    // @ts-ignore\n    maxOut = Math.max(maxOut, (fasGraph.getNode(e.source)!.data.out += weight));\n    // @ts-ignore\n    maxIn = Math.max(maxIn, (fasGraph.getNode(e.target)!.data.in += weight));\n  });\n\n  const buckets: List[] = [];\n  const rangeMax = maxOut + maxIn + 3;\n  for (let i = 0; i < rangeMax; i++) {\n    buckets.push(new List());\n  }\n  const zeroIdx = maxIn + 1;\n\n  fasGraph.getAllNodes().forEach((v) => {\n    assignBucket(buckets, zeroIdx, {\n      v: v.id,\n      ...fasGraph.getNode(v.id).data,\n    } as StateNode);\n  });\n\n  return { buckets, zeroIdx, graph: fasGraph };\n};\n\nconst assignBucket = (buckets: List[], zeroIdx: number, entry: StateNode) => {\n  if (!entry.out) {\n    buckets[0].enqueue(entry);\n  } else if (!entry[\"in\"]) {\n    buckets[buckets.length - 1].enqueue(entry);\n  } else {\n    buckets[entry.out - entry[\"in\"] + zeroIdx].enqueue(entry);\n  }\n};\n","import { ID, Edge } from \"@antv/graphlib\";\nimport { Graph, EdgeData } from \"../types\";\nimport { greedyFAS } from \"./greedy-fas\";\n\nconst run = (g: Graph, acyclicer: string) => {\n  const weightFn = (g: Graph) => {\n    return (e: Edge<EdgeData>) => e.data.weight || 1;\n  };\n  const fas = acyclicer === \"greedy\" ? greedyFAS(g, weightFn(g)) : dfsFAS(g);\n  fas?.forEach((e: Edge<EdgeData>) => {\n    const label = e.data;\n    g.removeEdge(e.id);\n    label.forwardName = e.data.name;\n    label.reversed = true;\n    g.addEdge({\n      id: e.id,\n      source: e.target,\n      target: e.source,\n      data: {\n        ...label,\n      },\n    });\n  });\n};\n\nconst dfsFAS = (g: Graph) => {\n  const fas: Edge<EdgeData>[] = [];\n  const stack: Record<ID, boolean> = {};\n  const visited: Record<ID, boolean> = {};\n\n  const dfs = (v: ID) => {\n    if (visited[v]) {\n      return;\n    }\n    visited[v] = true;\n    stack[v] = true;\n    g.getRelatedEdges(v, \"out\").forEach((e) => {\n      if (stack[e.target]) {\n        fas.push(e);\n      } else {\n        dfs(e.target);\n      }\n    });\n    delete stack[v];\n  };\n\n  g.getAllNodes().forEach((n) => dfs(n.id));\n  return fas;\n};\n\nconst undo = (g: Graph) => {\n  g.getAllEdges().forEach((e) => {\n    const label = e.data;\n    if (label.reversed) {\n      g.removeEdge(e.id);\n\n      const forwardName = label.forwardName;\n      delete label.reversed;\n      delete label.forwardName;\n      g.addEdge({\n        id: e.id,\n        source: e.target,\n        target: e.source,\n        data: { ...label, forwardName },\n      });\n    }\n  });\n};\n\nexport { run, undo };\n","import { ID, Graph, Node } from \"@antv/graphlib\";\nimport { isNumber } from \"@antv/util\";\nimport { EdgeData, Graph as IGraph, NodeData } from \"../types\";\n\nconst safeSort = (valueA?: number, valueB?: number) => {\n  return Number(valueA) - Number(valueB);\n};\n\n/*\n * Adds a dummy node to the graph and return v.\n */\nexport const addDummyNode = (\n  g: IGraph,\n  type: string,\n  data: NodeData,\n  name: string\n): ID => {\n  let v: ID;\n  do {\n    v = `${name}${Math.random()}`;\n  } while (g.hasNode(v));\n\n  data.dummy = type;\n  g.addNode({\n    id: v,\n    data,\n  });\n\n  return v;\n};\n\n/*\n * Returns a new graph with only simple edges. Handles aggregation of data\n * associated with multi-edges.\n */\nexport const simplify = (g: IGraph) => {\n  const simplified = new Graph<NodeData, EdgeData>();\n  g.getAllNodes().forEach((v) => {\n    simplified.addNode({ ...v });\n  });\n  g.getAllEdges().forEach((e) => {\n    const edge = simplified\n      .getRelatedEdges(e.source, \"out\")\n      .find((edge) => edge.target === e.target);\n    if (!edge) {\n      simplified.addEdge({\n        id: e.id,\n        source: e.source,\n        target: e.target,\n        data: {\n          weight: e.data.weight! || 0,\n          minlen: e.data.minlen! || 1,\n        },\n      });\n    } else {\n      simplified.updateEdgeData(edge?.id!, {\n        ...edge.data,\n        weight: edge.data.weight! + e.data.weight! || 0,\n        minlen: Math.max(edge.data.minlen!, e.data.minlen! || 1),\n      });\n    }\n  });\n  return simplified;\n};\n\nexport const asNonCompoundGraph = (g: IGraph): IGraph => {\n  const simplified = new Graph();\n\n  g.getAllNodes().forEach((node) => {\n    if (!g.getChildren(node.id).length) {\n      simplified.addNode({ ...node });\n    }\n  });\n\n  g.getAllEdges().forEach((edge) => {\n    simplified.addEdge(edge);\n  });\n\n  return simplified;\n};\n\nexport const zipObject = <T = any>(keys: ID[], values: T[]) => {\n  return keys?.reduce((obj, key, i) => {\n    obj[key] = values[i];\n    return obj;\n  }, {} as Record<ID, T>);\n};\n\nexport const successorWeights = (g: IGraph) => {\n  const weightsMap: Record<ID, Record<string, number>> = {};\n\n  g.getAllNodes().forEach((node) => {\n    const sucs: Record<ID, number> = {};\n    g.getRelatedEdges(node.id, \"out\").forEach((e) => {\n      sucs[e.target] = (sucs[e.target] || 0) + (e.data.weight || 0);\n    });\n    weightsMap[node.id] = sucs;\n  });\n\n  return weightsMap;\n};\n\nexport const predecessorWeights = (g: IGraph) => {\n  const nodes = g.getAllNodes();\n\n  const weightMap = nodes.map((v) => {\n    const preds: Record<ID, number> = {};\n    g.getRelatedEdges(v.id, \"in\").forEach((e) => {\n      preds[e.source] = (preds[e.source] || 0) + e.data.weight!;\n    });\n    return preds;\n  });\n  return zipObject(\n    nodes.map((n) => n.id),\n    weightMap\n  );\n};\n\n/*\n * Finds where a line starting at point ({x, y}) would intersect a rectangle\n * ({x, y, width, height}) if it were pointing at the rectangle's center.\n */\nexport const intersectRect = (\n  rect: { x?: number; y?: number; width?: number; height?: number },\n  point: { x?: number; y?: number }\n) => {\n  const x = Number(rect.x);\n  const y = Number(rect.y);\n\n  // Rectangle intersection algorithm from:\n  // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes\n  const dx = Number(point.x) - x;\n  const dy = Number(point.y) - y;\n  let w = Number(rect.width) / 2;\n  let h = Number(rect.height) / 2;\n\n  if (!dx && !dy) {\n    // completely overlapped directly, then return points its self\n    return { x: 0, y: 0 };\n  }\n\n  let sx;\n  let sy;\n\n  if (Math.abs(dy) * w > Math.abs(dx) * h) {\n    // Intersection is top or bottom of rect.\n    if (dy < 0) {\n      h = -h;\n    }\n    sx = (h * dx) / dy;\n    sy = h;\n  } else {\n    // Intersection is left or right of rect.\n    if (dx < 0) {\n      w = -w;\n    }\n    sx = w;\n    sy = (w * dy) / dx;\n  }\n\n  return { x: x + sx, y: y + sy };\n};\n\n/*\n * Given a DAG with each node assigned \"rank\" and \"order\" properties, this\n * const will produce a matrix with the ids of each node.\n */\nexport const buildLayerMatrix = (g: IGraph) => {\n  const layeringNodes: ID[][] = [];\n  const rankMax = maxRank(g) + 1;\n  for (let i = 0; i < rankMax; i++) {\n    layeringNodes.push([]);\n  }\n\n  // const layering = _.map(_.range(maxRank(g) + 1), function() { return []; });\n  g.getAllNodes().forEach((node) => {\n    const rank = node.data.rank!;\n    if (rank !== undefined && layeringNodes[rank]) {\n      layeringNodes[rank].push(node.id);\n    }\n  });\n\n  for (let i = 0; i < rankMax; i++) {\n    layeringNodes[i] = layeringNodes[i].sort((va: ID, vb: ID) =>\n      safeSort(g.getNode(va).data.order!, g.getNode(vb).data.order!)\n    );\n  }\n\n  return layeringNodes;\n};\n\n/*\n * Adjusts the ranks for all nodes in the graph such that all nodes v have\n * rank(v) >= 0 and at least one node w has rank(w) = 0.\n */\nexport const normalizeRanks = (g: IGraph) => {\n  const nodeRanks = g\n    .getAllNodes()\n    .filter((v) => v.data.rank !== undefined)\n    .map((v) => v.data.rank!);\n  const min = Math.min(...nodeRanks);\n  g.getAllNodes().forEach((v) => {\n    if (v.data.hasOwnProperty(\"rank\") && min !== Infinity) {\n      v.data.rank! -= min;\n    }\n  });\n};\n\nexport const removeEmptyRanks = (g: IGraph, nodeRankFactor: number = 0) => {\n  // Ranks may not start at 0, so we need to offset them\n  const nodes = g.getAllNodes();\n  const nodeRanks = nodes\n    .filter((v) => v.data.rank !== undefined)\n    .map((v) => v.data.rank!);\n\n  const offset = Math.min(...nodeRanks);\n  const layers: ID[][] = [];\n\n  nodes.forEach((v) => {\n    const rank = (v.data.rank! || 0) - offset;\n\n    if (!layers[rank]) {\n      layers[rank] = [];\n    }\n    layers[rank].push(v.id);\n  });\n\n  let delta = 0;\n  for (let i = 0; i < layers.length; i++) {\n    const vs = layers[i];\n    if (vs === undefined) {\n      if (i % nodeRankFactor !== 0) {\n        delta -= 1;\n      }\n    } else if (delta) {\n      vs?.forEach((v: ID) => {\n        const node = g.getNode(v);\n        if (node) {\n          node.data.rank = node.data.rank || 0;\n          node.data.rank! += delta;\n        }\n      });\n    }\n  }\n};\n\nexport const addBorderNode = (\n  g: IGraph,\n  prefix: string,\n  rank?: number,\n  order?: number\n) => {\n  const node: NodeData = {\n    width: 0,\n    height: 0,\n  };\n  if (isNumber(rank) && isNumber(order)) {\n    node.rank = rank;\n    node.order = order;\n  }\n  return addDummyNode(g, \"border\", node, prefix);\n};\n\nexport const maxRank = (g: IGraph) => {\n  let maxRank: number;\n  g.getAllNodes().forEach((v) => {\n    const rank = v.data.rank!;\n    if (rank !== undefined) {\n      if (maxRank === undefined || rank > maxRank) {\n        maxRank = rank;\n      }\n    }\n  });\n\n  if (!maxRank!) {\n    maxRank = 0;\n  }\n  return maxRank;\n};\n\n/*\n * Partition a collection into two groups: `lhs` and `rhs`. If the supplied\n * const returns true for an entry it goes into `lhs`. Otherwise it goes\n * into `rhs.\n */\nexport const partition = <T = any>(\n  collection: T[],\n  fn: (val: T) => boolean\n) => {\n  const result = { lhs: [] as T[], rhs: [] as T[] };\n  collection?.forEach((value) => {\n    if (fn(value)) {\n      result.lhs.push(value);\n    } else {\n      result.rhs.push(value);\n    }\n  });\n  return result;\n};\n\nexport const minBy = <T = any>(array: T[], func: (param: T) => number) => {\n  return array.reduce((a, b) => {\n    const valA = func(a);\n    const valB = func(b);\n    return valA > valB ? b : a;\n  });\n};\n\nconst doDFS = (\n  graph: IGraph,\n  node: Node<NodeData>,\n  postorder: boolean,\n  visited: ID[],\n  navigator: (n: ID) => Node<NodeData>[],\n  result: ID[]\n) => {\n  if (!visited.includes(node.id)) {\n    visited.push(node.id);\n    if (!postorder) {\n      result.push(node.id);\n    }\n    navigator(node.id).forEach((n) =>\n      doDFS(graph, n, postorder, visited, navigator, result)\n    );\n    if (postorder) {\n      result.push(node.id);\n    }\n  }\n};\n\n/**\n * @description DFS traversal.\n * @description.zh-CN DFS 遍历。\n */\nexport const dfs = (\n  graph: IGraph,\n  node: Node<NodeData> | Node<NodeData>[],\n  order: \"pre\" | \"post\",\n  isDirected: boolean\n) => {\n  const nodes = Array.isArray(node) ? node : [node];\n  const navigator = (n: ID) =>\n    (isDirected ? graph.getSuccessors(n) : graph.getNeighbors(n))!;\n  const results: ID[] = [];\n  const visited: ID[] = [];\n  nodes.forEach((node) => {\n    if (!graph.hasNode(node.id)) {\n      throw new Error(`Graph does not have node: ${node}`);\n    } else {\n      doDFS(graph, node, order === \"post\", visited, navigator, results);\n    }\n  });\n\n  return results;\n};\n","import { Edge, ID } from \"@antv/graphlib\";\nimport { EdgeData, Graph as IGraph } from \"../types\";\nimport { addDummyNode } from \"./util\";\n\n/*\n * Breaks any long edges in the graph into short segments that span 1 layer\n * each. This operation is undoable with the denormalize function.\n *\n * Pre-conditions:\n *\n *    1. The input graph is a DAG.\n *    2. Each node in the graph has a \"rank\" property.\n *\n * Post-condition:\n *\n *    1. All edges in the graph have a length of 1.\n *    2. Dummy nodes are added where edges have been split into segments.\n *    3. The graph is augmented with a \"dummyChains\" attribute which contains\n *       the first dummy in each chain of dummy nodes produced.\n */\n\nconst DUMMY_NODE_EDGE = \"edge\";\nconst DUMMY_NODE_EDGE_LABEL = \"edge-label\";\n\nconst run = (g: IGraph, dummyChains: ID[]) => {\n  g.getAllEdges().forEach((edge) => normalizeEdge(g, edge, dummyChains));\n};\n\nconst normalizeEdge = (g: IGraph, e: Edge<EdgeData>, dummyChains: ID[]) => {\n  let v = e.source;\n  let vRank = g.getNode(v)!.data.rank!;\n  const w = e.target;\n  const wRank = g.getNode(w)!.data.rank!;\n  const labelRank = e.data.labelRank;\n\n  if (wRank === vRank + 1) return;\n\n  g.removeEdge(e.id);\n\n  let dummy: ID;\n  let nodeData: {\n    width: number;\n    height: number;\n    originalEdge: Edge<EdgeData>;\n    rank: number;\n    dummy?: string;\n    labelpos?: string;\n  };\n  let i;\n  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {\n    e.data.points = [];\n    nodeData = {\n      originalEdge: e,\n      width: 0,\n      height: 0,\n      rank: vRank,\n    };\n\n    dummy = addDummyNode(g, DUMMY_NODE_EDGE, nodeData, \"_d\");\n\n    if (vRank === labelRank) {\n      nodeData.width = e.data.width!;\n      nodeData.height = e.data.height!;\n      nodeData.dummy = DUMMY_NODE_EDGE_LABEL;\n      nodeData.labelpos = e.data.labelpos as string;\n    }\n\n    g.addEdge({\n      id: `e${Math.random()}`,\n      source: v,\n      target: dummy,\n      data: { weight: e.data.weight },\n    });\n    if (i === 0) {\n      dummyChains.push(dummy);\n    }\n    v = dummy;\n  }\n\n  g.addEdge({\n    id: `e${Math.random()}`,\n    source: v,\n    target: w,\n    data: { weight: e.data.weight },\n  });\n};\n\nconst undo = (g: IGraph, dummyChains: ID[]) => {\n  dummyChains.forEach((v) => {\n    let node = g.getNode(v)!;\n    const { data } = node;\n    const originalEdge = data.originalEdge as Edge<EdgeData>;\n\n    let w;\n    // Restore original edge.\n    if (originalEdge) {\n      g.addEdge(originalEdge);\n    }\n\n    let currentV = v;\n    while (node.data.dummy) {\n      w = g.getSuccessors(currentV)![0];\n      g.removeNode(currentV);\n      originalEdge.data.points!.push({\n        x: node.data.x!,\n        y: node.data.y!,\n      });\n      if (node.data.dummy === DUMMY_NODE_EDGE_LABEL) {\n        originalEdge.data.x = node.data.x;\n        originalEdge.data.y = node.data.y;\n        originalEdge.data.width = node.data.width;\n        originalEdge.data.height = node.data.height;\n      }\n      currentV = w.id;\n      node = g.getNode(currentV)!;\n    }\n  });\n};\n\nexport { run, undo };\n","import { Edge, ID } from \"@antv/graphlib\";\nimport { EdgeData, Graph } from \"../../types\";\n\n/*\n * Initializes ranks for the input graph using the longest path algorithm. This\n * algorithm scales well and is fast in practice, it yields rather poor\n * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom\n * ranks wide and leaving edges longer than necessary. However, due to its\n * speed, this algorithm is good for getting an initial ranking that can be fed\n * into other algorithms.\n *\n * This algorithm does not normalize layers because it will be used by other\n * algorithms in most cases. If using this algorithm directly, be sure to\n * run normalize at the end.\n *\n * Pre-conditions:\n *\n *    1. Input graph is a DAG.\n *    2. Input graph node labels can be assigned properties.\n *\n * Post-conditions:\n *\n *    1. Each node will be assign an (unnormalized) \"rank\" property.\n */\nconst longestPath = (g: Graph) => {\n  const visited: Record<ID, boolean> = {};\n\n  const dfs = (v: ID) => {\n    const label = g.getNode(v)!;\n    if (!label) return 0;\n    if (visited[v]) {\n      return label.data.rank!;\n    }\n    visited[v] = true;\n\n    let rank: number;\n\n    g.getRelatedEdges(v, \"out\")?.forEach((e) => {\n      const wRank = dfs(e.target);\n      const minLen = e.data.minlen!;\n      const r = wRank - minLen;\n      if (r) {\n        if (rank === undefined || r < rank) {\n          rank = r;\n        }\n      }\n    });\n\n    if (!rank!) {\n      rank = 0;\n    }\n\n    label.data.rank = rank;\n    return rank;\n  };\n\n  g.getAllNodes()\n    .filter((n) => g.getRelatedEdges(n.id, \"in\").length === 0)\n    .forEach((source) => dfs(source.id));\n};\n\nconst longestPathWithLayer = (g: Graph) => {\n  // 用longest path，找出最深的点\n  const visited: Record<ID, boolean> = {};\n  let minRank: number;\n\n  const dfs = (v: ID) => {\n    const label = g.getNode(v)!;\n    if (!label) return 0;\n    if (visited[v]) {\n      return label.data.rank!;\n    }\n    visited[v] = true;\n\n    let rank: number;\n\n    g.getRelatedEdges(v, \"out\")?.forEach((e) => {\n      const wRank = dfs(e.target);\n      const minLen = e.data.minlen!;\n      const r = wRank - minLen;\n      if (r) {\n        if (rank === undefined || r < rank) {\n          rank = r;\n        }\n      }\n    });\n\n    if (!rank!) {\n      rank = 0;\n    }\n\n    if (minRank === undefined || rank < minRank) {\n      minRank = rank;\n    }\n\n    label.data.rank = rank;\n    return rank;\n  };\n\n  g.getAllNodes()\n    .filter((n) => g.getRelatedEdges(n.id, \"in\").length === 0)\n    .forEach((source) => {\n      if (source) dfs(source.id);\n    });\n\n  if (minRank! === undefined) {\n    minRank = 0;\n  }\n\n  // minRank += 1; // NOTE: 最小的层级是dummy root，+1\n\n  // forward一遍，赋值层级\n  const forwardVisited: Record<string, boolean> = {};\n  const dfsForward = (v: ID, nextRank: number) => {\n    const label = g.getNode(v)!;\n\n    const currRank = !isNaN(label.data.layer!) ? label.data.layer! : nextRank;\n\n    // 没有指定，取最大值\n    if (label.data.rank === undefined || label.data.rank! < currRank) {\n      label.data.rank = currRank;\n    }\n\n    if (forwardVisited[v]) return;\n    forwardVisited[v] = true;\n\n    // DFS遍历子节点\n    g.getRelatedEdges(v, \"out\")?.forEach((e) => {\n      dfsForward(e.target, currRank + e.data.minlen!);\n    });\n  };\n\n  // 指定层级的，更新下游\n  g.getAllNodes().forEach((n) => {\n    const label = n.data;\n    if (!label) return;\n    if (!isNaN(label.layer!)) {\n      dfsForward(n.id, label.layer!); // 默认的dummy root所在层的rank是-1\n    } else {\n      label.rank! -= minRank;\n    }\n  });\n};\n\n/*\n * Returns the amount of slack for the given edge. The slack is defined as the\n * difference between the length of the edge and its minimum length.\n */\nconst slack = (g: Graph, e: Edge<EdgeData>) => {\n  return (\n    g.getNode(e.target).data.rank! -\n    g.getNode(e.source).data.rank! -\n    e.data.minlen!\n  );\n};\n\nexport { longestPath, longestPathWithLayer, slack };\n","import { slack } from \"./util\";\nimport { minBy } from \"../util\";\nimport { Edge, Graph, ID } from \"@antv/graphlib\";\nimport { EdgeData, Graph as IGraph } from \"../../types\";\n\n/*\n * Constructs a spanning tree with tight edges and adjusted the input node's\n * ranks to achieve this. A tight edge is one that is has a length that matches\n * its \"minlen\" attribute.\n *\n * The basic structure for this function is derived from Gansner, et al., \"A\n * Technique for Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a DAG.\n *    2. Graph must be connected.\n *    3. Graph must have at least one node.\n *    5. Graph nodes must have been previously assigned a \"rank\" property that\n *       respects the \"minlen\" property of incident edges.\n *    6. Graph edges must have a \"minlen\" property.\n *\n * Post-conditions:\n *\n *    - Graph nodes will have their rank adjusted to ensure that all edges are\n *      tight.\n *\n * Returns a tree (undirected graph) that is constructed using only \"tight\"\n * edges.\n */\nconst feasibleTree = (g: IGraph) => {\n  const t = new Graph({\n    tree: [],\n  });\n\n  // Choose arbitrary node from which to start our tree\n  const start = g.getAllNodes()[0];\n  const size = g.getAllNodes().length;\n  t.addNode(start);\n\n  let edge: Edge<EdgeData>;\n  let delta: number;\n  while (tightTree(t, g) < size) {\n    edge = findMinSlackEdge(t, g);\n    delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);\n    shiftRanks(t, g, delta);\n  }\n\n  return t;\n};\n\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nconst tightTree = (t: IGraph, g: IGraph) => {\n  const dfs = (v: ID) => {\n    g.getRelatedEdges(v, \"both\").forEach((e) => {\n      const edgeV = e.source;\n      const w = v === edgeV ? e.target : edgeV;\n      if (!t.hasNode(w) && !slack(g, e)) {\n        t.addNode({\n          id: w,\n          data: {},\n        });\n        t.addEdge({\n          id: e.id,\n          source: v,\n          target: w,\n          data: {},\n        });\n        dfs(w);\n      }\n    });\n  };\n\n  t.getAllNodes().forEach((n) => dfs(n.id));\n  return t.getAllNodes().length;\n};\n\n/*\n * Constructs a spanning tree with tight edges and adjusted the input node's\n * ranks to achieve this. A tight edge is one that is has a length that matches\n * its \"minlen\" attribute.\n *\n * The basic structure for this function is derived from Gansner, et al., \"A\n * Technique for Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a DAG.\n *    2. Graph must be connected.\n *    3. Graph must have at least one node.\n *    5. Graph nodes must have been previously assigned a \"rank\" property that\n *       respects the \"minlen\" property of incident edges.\n *    6. Graph edges must have a \"minlen\" property.\n *\n * Post-conditions:\n *\n *    - Graph nodes will have their rank adjusted to ensure that all edges are\n *      tight.\n *\n * Returns a tree (undirected graph) that is constructed using only \"tight\"\n * edges.\n */\nconst feasibleTreeWithLayer = (g: IGraph) => {\n  const t = new Graph({ tree: [] });\n\n  // Choose arbitrary node from which to start our tree\n  const start = g.getAllNodes()[0];\n  const size = g.getAllNodes().length;\n  t.addNode(start);\n\n  let edge: Edge<EdgeData>;\n  let delta: number;\n  while (tightTreeWithLayer(t, g)! < size) {\n    edge = findMinSlackEdge(t, g);\n    delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);\n    shiftRanks(t, g, delta);\n  }\n\n  return t;\n};\n\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nconst tightTreeWithLayer = (t: IGraph, g: IGraph) => {\n  const dfs = (v: ID) => {\n    g.getRelatedEdges(v, \"both\")?.forEach((e) => {\n      const edgeV = e.source;\n      const w = v === edgeV ? e.target : edgeV;\n      // 对于指定layer的，直接加入tight-tree，不参与调整\n      if (\n        !t.hasNode(w) &&\n        (g.getNode(w)!.data.layer !== undefined || !slack(g, e))\n      ) {\n        t.addNode({\n          id: w,\n          data: {},\n        });\n        t.addEdge({\n          id: e.id,\n          source: v,\n          target: w,\n          data: {},\n        });\n        dfs(w);\n      }\n    });\n  };\n\n  t.getAllNodes().forEach((n) => dfs(n.id));\n  return t.getAllNodes().length;\n};\n\n/*\n * Finds the edge with the smallest slack that is incident on tree and returns\n * it.\n */\nconst findMinSlackEdge = (t: IGraph, g: IGraph) => {\n  return minBy(g.getAllEdges(), (e) => {\n    if (t.hasNode(e.source) !== t.hasNode(e.target)) {\n      return slack(g, e);\n    }\n    return Infinity;\n  });\n};\n\nconst shiftRanks = (t: IGraph, g: IGraph, delta: number) => {\n  t.getAllNodes().forEach((tn) => {\n    const v = g.getNode(tn.id);\n    if (!v.data.rank) v.data.rank = 0;\n    v.data.rank! += delta;\n  });\n};\n\nexport { feasibleTree, feasibleTreeWithLayer };\n","import { Edge, ID, Node } from \"@antv/graphlib\";\nimport { EdgeData, Graph as IGraph, NodeData } from \"../../types\";\nimport { feasibleTree } from \"./feasible-tree\";\nimport { slack, longestPath as initRank } from \"./util\";\nimport { dfs, minBy, simplify } from \"../util\";\n\n/*\n * The network simplex algorithm assigns ranks to each node in the input graph\n * and iteratively improves the ranking to reduce the length of edges.\n *\n * Preconditions:\n *\n *    1. The input graph must be a DAG.\n *    2. All nodes in the graph must have an object value.\n *    3. All edges in the graph must have \"minlen\" and \"weight\" attributes.\n *\n * Postconditions:\n *\n *    1. All nodes in the graph will have an assigned \"rank\" attribute that has\n *       been optimized by the network simplex algorithm. Ranks start at 0.\n *\n *\n * A rough sketch of the algorithm is as follows:\n *\n *    1. Assign initial ranks to each node. We use the longest path algorithm,\n *       which assigns ranks to the lowest position possible. In general this\n *       leads to very wide bottom ranks and unnecessarily long edges.\n *    2. Construct a feasible tight tree. A tight tree is one such that all\n *       edges in the tree have no slack (difference between length of edge\n *       and minlen for the edge). This by itself greatly improves the assigned\n *       rankings by shorting edges.\n *    3. Iteratively find edges that have negative cut values. Generally a\n *       negative cut value indicates that the edge could be removed and a new\n *       tree edge could be added to produce a more compact graph.\n *\n * Much of the algorithms here are derived from Gansner, et al., \"A Technique\n * for Drawing Directed Graphs.\" The structure of the file roughly follows the\n * structure of the overall algorithm.\n */\nexport const networkSimplex = (og: IGraph) => {\n  const g = simplify(og);\n  initRank(g);\n  const t = feasibleTree(g);\n  initLowLimValues(t);\n  initCutValues(t, g);\n\n  let e: Edge<EdgeData> | undefined;\n  let f: Edge<EdgeData>;\n  while ((e = leaveEdge(t))) {\n    f = enterEdge(t, g, e);\n    exchangeEdges(t, g, e, f);\n  }\n};\n\n/*\n * Initializes cut values for all edges in the tree.\n */\nexport const initCutValues = (t: IGraph, g: IGraph) => {\n  let vs = dfs(t, t.getAllNodes(), \"post\", false);\n  vs = vs.slice(0, vs?.length - 1);\n  vs.forEach((v: ID) => {\n    assignCutValue(t, g, v);\n  });\n};\n\nconst assignCutValue = (t: IGraph, g: IGraph, child: ID) => {\n  const childLab = t.getNode(child)!;\n  const parent = childLab.data.parent! as ID;\n\n  // FIXME: use undirected edge?\n  const edge = t\n    .getRelatedEdges(child, \"both\")\n    .find((e) => e.target === parent || e.source === parent)!;\n  edge.data.cutvalue = calcCutValue(t, g, child);\n};\n\n/*\n * Given the tight tree, its graph, and a child in the graph calculate and\n * return the cut value for the edge between the child and its parent.\n */\nexport const calcCutValue = (t: IGraph, g: IGraph, child: ID) => {\n  const childLab = t.getNode(child)!;\n  const parent = childLab.data.parent as ID;\n  // True if the child is on the tail end of the edge in the directed graph\n  let childIsTail = true;\n  // The graph's view of the tree edge we're inspecting\n\n  let graphEdge = g\n    .getRelatedEdges(child, \"out\")\n    .find((e) => e.target === parent)!;\n  // The accumulated cut value for the edge between this node and its parent\n  let cutValue = 0;\n\n  if (!graphEdge) {\n    childIsTail = false;\n    graphEdge = g\n      .getRelatedEdges(parent, \"out\")\n      .find((e) => e.target === child)!;\n  }\n\n  cutValue = graphEdge.data.weight!;\n\n  g.getRelatedEdges(child, \"both\").forEach((e) => {\n    const isOutEdge = e.source === child;\n    const other = isOutEdge ? e.target : e.source;\n\n    if (other !== parent) {\n      const pointsToHead = isOutEdge === childIsTail;\n      const otherWeight = e.data.weight!;\n\n      cutValue += pointsToHead ? otherWeight : -otherWeight;\n      if (isTreeEdge(t, child, other)) {\n        // FIXME: use undirected edge?\n        const otherCutValue = t\n          .getRelatedEdges(child, \"both\")\n          .find((e) => e.source === other || e.target === other)!.data\n          .cutvalue!;\n        cutValue += pointsToHead ? -otherCutValue : otherCutValue;\n      }\n    }\n  });\n\n  return cutValue;\n};\n\nexport const initLowLimValues = (\n  tree: IGraph,\n  root: ID = tree.getAllNodes()[0].id\n) => {\n  dfsAssignLowLim(tree, {}, 1, root);\n};\n\nconst dfsAssignLowLim = (\n  tree: IGraph,\n  visited: Record<ID, boolean>,\n  nextLim: number,\n  v: ID,\n  parent?: ID\n) => {\n  const low = nextLim;\n  let useNextLim = nextLim;\n  const label = tree.getNode(v)!;\n\n  visited[v] = true;\n  tree.getNeighbors(v)?.forEach((w) => {\n    if (!visited[w.id]) {\n      useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w.id, v);\n    }\n  });\n\n  label.data.low = low;\n  label.data.lim = useNextLim++;\n  if (parent) {\n    label.data.parent = parent;\n  } else {\n    // TODO should be able to remove this when we incrementally update low lim\n    delete label.data.parent;\n  }\n\n  return useNextLim;\n};\n\nexport const leaveEdge = (tree: IGraph) => {\n  return tree.getAllEdges().find((e) => {\n    return e.data.cutvalue! < 0;\n  });\n};\n\nexport const enterEdge = (t: IGraph, g: IGraph, edge: Edge<EdgeData>) => {\n  let v = edge.source;\n  let w = edge.target;\n\n  // For the rest of this function we assume that v is the tail and w is the\n  // head, so if we don't have this edge in the graph we should flip it to\n  // match the correct orientation.\n  if (!g.getRelatedEdges(v, \"out\").find((e) => e.target === w)) {\n    v = edge.target;\n    w = edge.source;\n  }\n\n  const vLabel = t.getNode(v)!;\n  const wLabel = t.getNode(w)!;\n  let tailLabel = vLabel;\n  let flip = false;\n\n  // If the root is in the tail of the edge then we need to flip the logic that\n  // checks for the head and tail nodes in the candidates function below.\n  if (vLabel.data.lim! > wLabel.data.lim!) {\n    tailLabel = wLabel;\n    flip = true;\n  }\n\n  const candidates = g.getAllEdges().filter((edge) => {\n    return (\n      flip === isDescendant(t.getNode(edge.source), tailLabel) &&\n      flip !== isDescendant(t.getNode(edge.target), tailLabel)\n    );\n  });\n\n  return minBy(candidates, (edge) => {\n    return slack(g, edge);\n  });\n};\n\n/**\n *\n * @param t\n * @param g\n * @param e edge to remove\n * @param f edge to add\n */\nexport const exchangeEdges = (\n  t: IGraph,\n  g: IGraph,\n  e: Edge<EdgeData>,\n  f: Edge<EdgeData>\n) => {\n  // FIXME: use undirected edge?\n  const existed = t\n    .getRelatedEdges(e.source, \"both\")\n    .find((edge) => edge.source === e.target || edge.target === e.target);\n  if (existed) {\n    t.removeEdge(existed.id);\n  }\n\n  t.addEdge({\n    id: `e${Math.random()}`,\n    source: f.source,\n    target: f.target,\n    data: {},\n  });\n\n  initLowLimValues(t);\n  initCutValues(t, g);\n  updateRanks(t, g);\n};\n\nconst updateRanks = (t: IGraph, g: IGraph) => {\n  const root = t.getAllNodes().find((v) => {\n    return !v.data.parent;\n  })!;\n\n  let vs = dfs(t, root, \"pre\", false);\n  vs = vs.slice(1);\n  vs.forEach((v: ID) => {\n    const parent = t.getNode(v).data.parent as ID;\n    let edge = g.getRelatedEdges(v, \"out\").find((e) => e.target === parent);\n    // let edge = g.edgeFromArgs(v, parent);\n    let flipped = false;\n\n    if (!edge && g.hasNode(parent)) {\n      // edge = g.edgeFromArgs(parent, v)!;\n      edge = g.getRelatedEdges(parent, \"out\").find((e) => e.target === v);\n      flipped = true;\n    }\n\n    g.getNode(v).data.rank =\n      ((g.hasNode(parent) && g.getNode(parent).data.rank!) || 0) +\n      (flipped ? edge?.data.minlen! : -edge?.data.minlen!);\n  });\n};\n\n/*\n * Returns true if the edge is in the tree.\n */\nconst isTreeEdge = (tree: IGraph, u: ID, v: ID) => {\n  // FIXME: use undirected edge?\n  return tree\n    .getRelatedEdges(u, \"both\")\n    .find((e) => e.source === v || e.target === v);\n};\n\n/*\n * Returns true if the specified node is descendant of the root node per the\n * assigned low and lim attributes in the tree.\n */\nconst isDescendant = (vLabel: Node<NodeData>, rootLabel: Node<NodeData>) => {\n  return (\n    rootLabel.data.low! <= vLabel.data.lim! &&\n    vLabel.data.lim! <= rootLabel.data.lim!\n  );\n};\n","import { Graph as IGraph } from \"../../types\";\nimport { longestPath, longestPathWithLayer } from \"./util\";\nimport { feasibleTreeWithLayer as feasibleTree } from \"./feasible-tree\";\nimport { networkSimplex } from \"./network-simplex\";\n\n/*\n * Assigns a rank to each node in the input graph that respects the \"minlen\"\n * constraint specified on edges between nodes.\n *\n * This basic structure is derived from Gansner, et al., \"A Technique for\n * Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a connected DAG\n *    2. Graph nodes must be objects\n *    3. Graph edges must have \"weight\" and \"minlen\" attributes\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have a \"rank\" attribute based on the results of the\n *       algorithm. Ranks can start at any index (including negative), we'll\n *       fix them up later.\n */\nexport const rank = (\n  g: IGraph,\n  ranker: \"network-simplex\" | \"tight-tree\" | \"longest-path\"\n) => {\n  switch (ranker) {\n    case \"network-simplex\":\n      networkSimplexRanker(g);\n      break;\n    case \"tight-tree\":\n      tightTreeRanker(g);\n      break;\n    case \"longest-path\":\n      longestPathRanker(g);\n      break;\n    // default: networkSimplexRanker(g);\n    default:\n      tightTreeRanker(g);\n  }\n};\n\n// A fast and simple ranker, but results are far from optimal.\nconst longestPathRanker = longestPath;\n\nconst tightTreeRanker = (g: IGraph) => {\n  longestPathWithLayer(g);\n  feasibleTree(g);\n};\n\nconst networkSimplexRanker = (g: IGraph) => {\n  networkSimplex(g);\n};\n","import { ID } from \"@antv/graphlib\";\nimport { Graph as IGraph } from \"../types\";\nimport { addBorderNode, addDummyNode } from \"./util\";\n\n/*\n * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,\n * adds appropriate edges to ensure that all cluster nodes are placed between\n * these boundries, and ensures that the graph is connected.\n *\n * In addition we ensure, through the use of the minlen property, that nodes\n * and subgraph border nodes to not end up on the same rank.\n *\n * Preconditions:\n *\n *    1. Input graph is a DAG\n *    2. Nodes in the input graph has a minlen attribute\n *\n * Postconditions:\n *\n *    1. Input graph is connected.\n *    2. Dummy nodes are added for the tops and bottoms of subgraphs.\n *    3. The minlen attribute for nodes is adjusted to ensure nodes do not\n *       get placed on the same rank as subgraph border nodes.\n *\n * The nesting graph idea comes from Sander, \"Layout of Compound Directed\n * Graphs.\"\n */\nconst run = (g: IGraph) => {\n  const root = addDummyNode(g, \"root\", {}, \"_root\");\n  const depths = treeDepths(g);\n  let maxDepth = Math.max(...Object.values(depths));\n\n  if (Math.abs(maxDepth) === Infinity) {\n    maxDepth = 1;\n  }\n\n  const height = maxDepth - 1; // Note: depths is an Object not an array\n  const nodeSep = 2 * height + 1;\n\n  // g.graph().nestingRoot = root;\n\n  // Multiply minlen by nodeSep to align nodes on non-border ranks.\n  g.getAllEdges().forEach((e) => {\n    e.data.minlen! *= nodeSep;\n  });\n\n  // Calculate a weight that is sufficient to keep subgraphs vertically compact\n  const weight = sumWeights(g) + 1;\n\n  // Create border nodes and link them up\n  // g.children()?.forEach((child) => {\n  //   dfs(g, root, nodeSep, weight, height, depths, child);\n  // });\n  g.getRoots().forEach((child) => {\n    dfs(g, root, nodeSep, weight, height, depths, child.id);\n  });\n\n  // Save the multiplier for node layers for later removal of empty border\n  // layers.\n  // g.graph().nodeRankFactor = nodeSep;\n\n  return {\n    nestingRoot: root,\n    nodeRankFactor: nodeSep,\n  };\n};\n\nconst dfs = (\n  g: IGraph,\n  root: ID,\n  nodeSep: number,\n  weight: number,\n  height: number,\n  depths: Record<string, number>,\n  v: ID\n) => {\n  const children = g.getChildren(v);\n  if (!children?.length) {\n    if (v !== root) {\n      // g.setEdge(root, v, { weight: 0, minlen: nodeSep });\n      g.addEdge({\n        id: `e${Math.random()}`,\n        source: root,\n        target: v,\n        data: { weight: 0, minlen: nodeSep },\n      });\n    }\n    return;\n  }\n\n  const top = addBorderNode(g, \"_bt\");\n  const bottom = addBorderNode(g, \"_bb\");\n  const label = g.getNode(v)!;\n\n  g.setParent(top, v);\n  label.data.borderTop = top;\n  g.setParent(bottom, v);\n  label.data.borderBottom = bottom;\n\n  children?.forEach((childNode) => {\n    dfs(g, root, nodeSep, weight, height, depths, childNode.id);\n\n    const childTop = childNode.data.borderTop\n      ? (childNode.data.borderTop as ID)\n      : childNode.id;\n    const childBottom = childNode.data.borderBottom\n      ? (childNode.data.borderBottom as ID)\n      : childNode.id;\n    const thisWeight = childNode.data.borderTop ? weight : 2 * weight;\n    const minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;\n\n    g.addEdge({\n      id: `e${Math.random()}`,\n      source: top,\n      target: childTop,\n      data: {\n        minlen,\n        weight: thisWeight,\n        nestingEdge: true,\n      },\n    });\n\n    g.addEdge({\n      id: `e${Math.random()}`,\n      source: childBottom,\n      target: bottom,\n      data: {\n        minlen,\n        weight: thisWeight,\n        nestingEdge: true,\n      },\n    });\n  });\n\n  if (!g.getParent(v)) {\n    g.addEdge({\n      id: `e${Math.random()}`,\n      source: root,\n      target: top,\n      data: {\n        weight: 0,\n        minlen: height + depths[v],\n      },\n    });\n  }\n};\n\nconst treeDepths = (g: IGraph) => {\n  const depths: Record<ID, number> = {};\n  const dfs = (v: ID, depth: number) => {\n    const children = g.getChildren(v);\n    children?.forEach((child) => dfs(child.id, depth + 1));\n    depths[v] = depth;\n  };\n  // g.children()?.forEach((v) => dfs(v, 1));\n\n  g.getRoots().forEach((v) => dfs(v.id, 1));\n  return depths;\n};\n\nconst sumWeights = (g: IGraph) => {\n  let result = 0;\n  g.getAllEdges().forEach((e) => {\n    result += e.data.weight!;\n  });\n  return result;\n};\n\nconst cleanup = (g: IGraph, nestingRoot?: ID) => {\n  // const graphLabel = g.graph();\n  // graphLabel.nestingRoot && g.removeNode(graphLabel.nestingRoot);\n  // delete graphLabel.nestingRoot;\n  if (nestingRoot) {\n    g.removeNode(nestingRoot);\n  }\n\n  g.getAllEdges().forEach((e) => {\n    if (e.data.nestingEdge) {\n      g.removeEdge(e.id);\n    }\n  });\n};\n\nexport { run, cleanup };\n","import { ID, Node } from \"@antv/graphlib\";\nimport { Graph, NodeData } from \"../types\";\nimport { addDummyNode } from \"./util\";\n\nexport const addBorderSegments = (g: Graph) => {\n  const dfs = (v: ID) => {\n    const children = g.getChildren(v);\n    const node = g.getNode(v)!;\n    if (children?.length) {\n      children.forEach((child) => dfs(child.id));\n    }\n\n    if (node.data.hasOwnProperty(\"minRank\")) {\n      node.data.borderLeft = [];\n      node.data.borderRight = [];\n      for (\n        let rank = node.data.minRank!, maxRank = node.data.maxRank! + 1;\n        rank < maxRank;\n        rank += 1\n      ) {\n        addBorderNode(g, \"borderLeft\", \"_bl\", v, node, rank);\n        addBorderNode(g, \"borderRight\", \"_br\", v, node, rank);\n      }\n    }\n  };\n\n  g.getRoots().forEach((child) => dfs(child.id));\n};\n\nconst addBorderNode = (\n  g: Graph,\n  prop: string,\n  prefix: string,\n  sg: ID,\n  sgNode: Node<NodeData>,\n  rank: number\n) => {\n  const label: NodeData = { rank, borderType: prop, width: 0, height: 0 };\n  // @ts-ignore\n  const prev = sgNode.data[prop][rank - 1];\n  const curr = addDummyNode(g, \"border\", label, prefix);\n  // @ts-ignore\n  sgNode.data[prop][rank] = curr;\n  g.setParent(curr, sg);\n  if (prev) {\n    g.addEdge({\n      id: `e${Math.random()}`,\n      source: prev,\n      target: curr,\n      data: { weight: 1 },\n    });\n  }\n};\n","import { Node } from \"@antv/graphlib\";\nimport { DagreRankdir, Graph, NodeData } from \"../types\";\n\nconst adjust = (g: Graph, rankdir: DagreRankdir) => {\n  const rd = rankdir.toLowerCase();\n  if (rd === \"lr\" || rd === \"rl\") {\n    swapWidthHeight(g);\n  }\n};\n\nconst undo = (g: Graph, rankdir: DagreRankdir) => {\n  const rd = rankdir.toLowerCase();\n  if (rd === \"bt\" || rd === \"rl\") {\n    reverseY(g);\n  }\n\n  if (rd === \"lr\" || rd === \"rl\") {\n    swapXY(g);\n    swapWidthHeight(g);\n  }\n};\n\nconst swapWidthHeight = (g: Graph) => {\n  g.getAllNodes().forEach((v) => {\n    swapWidthHeightOne(v);\n  });\n  g.getAllEdges().forEach((e) => {\n    swapWidthHeightOne(e);\n  });\n};\n\nconst swapWidthHeightOne = (node: Node<NodeData>) => {\n  const w = node.data.width;\n  node.data.width = node.data.height;\n  node.data.height = w;\n};\n\nconst reverseY = (g: Graph) => {\n  g.getAllNodes().forEach((v) => {\n    reverseYOne(v.data);\n  });\n\n  g.getAllEdges().forEach((edge) => {\n    edge.data.points?.forEach((point) => reverseYOne(point));\n    if (edge.data.hasOwnProperty(\"y\")) {\n      reverseYOne(edge.data);\n    }\n  });\n};\n\nconst reverseYOne = (node: { x?: number; y?: number }) => {\n  if (node?.y) {\n    node.y = -node.y;\n  }\n};\n\nconst swapXY = (g: Graph) => {\n  g.getAllNodes().forEach((v) => {\n    swapXYOne(v.data);\n  });\n\n  g.getAllEdges().forEach((edge) => {\n    edge.data.points?.forEach((point) => swapXYOne(point));\n    if (edge.data.hasOwnProperty(\"x\")) {\n      swapXYOne(edge.data);\n    }\n  });\n};\n\nconst swapXYOne = (node: { x?: number; y?: number }) => {\n  const x = node.x;\n  node.x = node.y;\n  node.y = x;\n};\n\nexport { adjust, undo };\n","import { ID } from \"@antv/graphlib\";\nimport { Graph } from \"../../types\";\n\n/*\n * Assigns an initial order value for each node by performing a DFS search\n * starting from nodes in the first rank. Nodes are assigned an order in their\n * rank as they are first visited.\n *\n * This approach comes from Gansner, et al., \"A Technique for Drawing Directed\n * Graphs.\"\n *\n * Returns a layering matrix with an array per layer and each layer sorted by\n * the order of its nodes.\n */\nexport const initOrder = (g: Graph) => {\n  const visited: Record<string, boolean> = {};\n  // const simpleNodes = g.getAllNodes().filter((v) => {\n  //   return !g.getChildren(v.id)?.length;\n  // });\n  const simpleNodes = g.getAllNodes();\n  const nodeRanks = simpleNodes.map((v) => v.data.rank! ?? -Infinity);\n\n  const maxRank = Math.max(...nodeRanks);\n  const layers: ID[][] = [];\n  for (let i = 0; i < maxRank + 1; i++) {\n    layers.push([]);\n  }\n\n  const orderedVs = simpleNodes.sort(\n    (a, b) => g.getNode(a.id).data.rank! - g.getNode(b.id).data.rank!\n  );\n  // const orderedVs = _.sortBy(simpleNodes, function(v) { return g.node(v)!.rank; });\n\n  // 有fixOrder的，直接排序好放进去\n  const beforeSort = orderedVs.filter((n) => {\n    return g.getNode(n.id).data.fixorder !== undefined;\n  });\n  const fixOrderNodes = beforeSort.sort(\n    (a, b) => g.getNode(a.id).data.fixorder! - g.getNode(b.id).data.fixorder!\n  );\n  fixOrderNodes?.forEach((n) => {\n    if (!isNaN(g.getNode(n.id).data.rank!)) {\n      layers[g.getNode(n.id).data.rank!].push(n.id);\n    }\n    visited[n.id] = true;\n  });\n\n  orderedVs?.forEach((n) =>\n    g.dfsTree(n.id, (node) => {\n      if (visited.hasOwnProperty(node.id)) return true;\n      visited[node.id] = true;\n      if (!isNaN(node.data.rank!)) {\n        layers[node.data.rank!].push(node.id);\n      }\n    })\n  );\n\n  return layers;\n};\n","/*\n * A function that takes a layering (an array of layers, each with an array of\n * ordererd nodes) and a graph and returns a weighted crossing count.\n *\n * Pre-conditions:\n *\n *    1. Input graph must be simple (not a multigraph), directed, and include\n *       only simple edges.\n *    2. Edges in the input graph must have assigned weights.\n *\n * Post-conditions:\n *\n *    1. The graph and layering matrix are left unchanged.\n *\n * This algorithm is derived from Barth, et al., \"Bilayer Cross Counting.\"\n */\n\nimport { ID } from \"@antv/graphlib\";\nimport { Graph } from \"../../types\";\nimport { zipObject } from \"../util\";\n\nconst twoLayerCrossCount = (g: Graph, northLayer: ID[], southLayer: ID[]) => {\n  // Sort all of the edges between the north and south layers by their position\n  // in the north layer and then the south. Map these edges to the position of\n  // their head in the south layer.\n  const southPos = zipObject(\n    southLayer,\n    southLayer.map((v, i) => i)\n  );\n  const unflat = northLayer.map((v) => {\n    const unsort = g.getRelatedEdges(v, \"out\").map((e) => {\n      return { pos: southPos[e.target] || 0, weight: e.data.weight };\n    });\n    return unsort?.sort((a, b) => a.pos - b.pos);\n  });\n  const southEntries = unflat.flat().filter((entry) => entry !== undefined);\n\n  // Build the accumulator tree\n  let firstIndex = 1;\n  while (firstIndex < southLayer.length) firstIndex <<= 1;\n  const treeSize = 2 * firstIndex - 1;\n  firstIndex -= 1;\n  const tree = Array(treeSize).fill(0, 0, treeSize);\n\n  // Calculate the weighted crossings\n  let cc = 0;\n  southEntries?.forEach((entry) => {\n    if (entry) {\n      let index = entry.pos + firstIndex;\n      tree[index] += entry.weight;\n      let weightSum = 0;\n      while (index > 0) {\n        if (index % 2) {\n          weightSum += tree[index + 1];\n        }\n        index = (index - 1) >> 1;\n        tree[index] += entry.weight;\n      }\n      cc += entry.weight! * weightSum;\n    }\n  });\n\n  return cc;\n};\n\nexport const crossCount = (g: Graph, layering: ID[][]) => {\n  let cc = 0;\n  for (let i = 1; i < layering?.length; i += 1) {\n    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);\n  }\n  return cc;\n};\n","/*\n * Given a list of entries of the form {v, barycenter, weight} and a\n * constraint graph this function will resolve any conflicts between the\n * constraint graph and the barycenters for the entries. If the barycenters for\n * an entry would violate a constraint in the constraint graph then we coalesce\n * the nodes in the conflict into a new node that respects the contraint and\n * aggregates barycenter and weight information.\n *\n * This implementation is based on the description in Forster, \"A Fast and\n * Simple Hueristic for Constrained Two-Level Crossing Reduction,\" thought it\n * differs in some specific details.\n *\n * Pre-conditions:\n *\n *    1. Each entry has the form {v, barycenter, weight}, or if the node has\n *       no barycenter, then {v}.\n *\n * Returns:\n *\n *    A new list of entries of the form {vs, i, barycenter, weight}. The list\n *    `vs` may either be a singleton or it may be an aggregation of nodes\n *    ordered such that they do not violate constraints from the constraint\n *    graph. The property `i` is the lowest original index of any of the\n *    elements in `vs`.\n */\n\nimport { ID } from \"@antv/graphlib\";\nimport { Graph } from \"../../types\";\n\nexport type ConflictEntry = {\n  i: number;\n  indegree?: number;\n  in?: ConflictEntry[];\n  out?: ConflictEntry[];\n  vs: ID[];\n  barycenter?: number;\n  weight?: number;\n  merged?: boolean;\n  fixorder?: number;\n  order?: number;\n};\n\nconst resolveConflicts = (\n  entries: {\n    v: ID;\n    barycenter?: number;\n    weight?: number;\n  }[],\n  cg: Graph\n) => {\n  const mappedEntries: Record<string, ConflictEntry> = {};\n  entries?.forEach((entry, i: number) => {\n    mappedEntries[entry.v] = {\n      i,\n      indegree: 0,\n      in: [],\n      out: [],\n      vs: [entry.v],\n    };\n    const tmp = mappedEntries[entry.v];\n    if (entry.barycenter !== undefined) {\n      tmp.barycenter = entry.barycenter;\n      tmp.weight = entry.weight;\n    }\n  });\n\n  cg.getAllEdges()?.forEach((e) => {\n    const entryV = mappedEntries[e.source];\n    const entryW = mappedEntries[e.target];\n    if (entryV !== undefined && entryW !== undefined) {\n      entryW.indegree!++;\n      entryV.out!.push(mappedEntries[e.target]);\n    }\n  });\n\n  const sourceSet = Object.values(mappedEntries).filter?.(\n    (entry: ConflictEntry) => !entry.indegree\n  );\n\n  return doResolveConflicts(sourceSet);\n};\n\nconst doResolveConflicts = (sourceSet: ConflictEntry[]) => {\n  const entries = [];\n\n  const handleIn = (vEntry: ConflictEntry) => {\n    return (uEntry: ConflictEntry) => {\n      if (uEntry.merged) return;\n      if (\n        uEntry.barycenter === undefined ||\n        vEntry.barycenter === undefined ||\n        uEntry.barycenter >= vEntry.barycenter\n      ) {\n        mergeEntries(vEntry, uEntry);\n      }\n    };\n  };\n\n  const handleOut = (vEntry: ConflictEntry) => {\n    return (wEntry: ConflictEntry) => {\n      wEntry[\"in\"]!.push(vEntry);\n      if (--wEntry.indegree! === 0) {\n        sourceSet.push(wEntry);\n      }\n    };\n  };\n\n  while (sourceSet?.length) {\n    const entry = sourceSet.pop()!;\n    entries.push(entry);\n    entry[\"in\"]!.reverse()?.forEach((e: ConflictEntry) => handleIn(entry)(e));\n    entry.out?.forEach((e: ConflictEntry) => handleOut(entry)(e));\n  }\n\n  const filtered = entries.filter((entry) => !entry.merged);\n  const keys: (\"vs\" | \"i\" | \"barycenter\" | \"weight\")[] = [\n    \"vs\",\n    \"i\",\n    \"barycenter\",\n    \"weight\",\n  ];\n  return filtered.map((entry) => {\n    const picked: Record<string, any> = {};\n    keys?.forEach((key) => {\n      if (entry[key] === undefined) return;\n      picked[key] = entry[key];\n    });\n    return picked as ConflictEntry;\n  });\n};\n\nconst mergeEntries = (target: ConflictEntry, source: ConflictEntry) => {\n  let sum = 0;\n  let weight = 0;\n\n  if (target.weight) {\n    sum += target.barycenter! * target.weight;\n    weight += target.weight;\n  }\n\n  if (source.weight) {\n    sum += source.barycenter! * source.weight;\n    weight += source.weight;\n  }\n\n  target.vs = source.vs?.concat(target.vs);\n  target.barycenter = sum / weight;\n  target.weight = weight;\n  target.i = Math.min(source.i, target.i);\n  source.merged = true;\n};\n\nexport default resolveConflicts;\n","import { ID } from \"@antv/graphlib\";\nimport { partition } from \"../util\";\nimport { ConflictEntry } from \"./resolve-conflicts\";\n\nexport const sort = (\n  entries: ConflictEntry[],\n  biasRight?: boolean,\n  usePrev?: boolean,\n  keepNodeOrder?: boolean\n) => {\n  const parts = partition(entries, (entry) => {\n    const hasFixOrder =\n      entry.hasOwnProperty(\"fixorder\") && !isNaN(entry.fixorder!);\n    if (keepNodeOrder) {\n      return !hasFixOrder && entry.hasOwnProperty(\"barycenter\");\n    }\n    // NOTE: 有fixorder的也可以排\n    return hasFixOrder || entry.hasOwnProperty(\"barycenter\");\n  });\n  const sortable = parts.lhs;\n  const unsortable = parts.rhs.sort((a, b) => -a.i - -b.i);\n  const vs: ID[][] = [];\n  let sum = 0;\n  let weight = 0;\n  let vsIndex = 0;\n\n  sortable?.sort(compareWithBias(!!biasRight, !!usePrev));\n\n  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);\n\n  sortable?.forEach((entry) => {\n    vsIndex += entry.vs?.length;\n    vs.push(entry.vs);\n    sum += entry.barycenter! * entry.weight!;\n    weight += entry.weight!;\n    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);\n  });\n\n  const result: { vs: ID[]; barycenter?: number; weight?: number } = {\n    vs: vs.flat(),\n  };\n  if (weight) {\n    result.barycenter = sum / weight;\n    result.weight = weight;\n  }\n  return result;\n};\n\nconst consumeUnsortable = (\n  vs: ID[][],\n  unsortable: ConflictEntry[],\n  index: number\n) => {\n  let iindex = index;\n  let last;\n  while (\n    unsortable.length &&\n    (last = unsortable[unsortable.length - 1]).i <= iindex\n  ) {\n    unsortable.pop();\n    vs?.push(last.vs);\n    iindex++;\n  }\n  return iindex;\n};\n\n/**\n * 配置是否考虑使用之前的布局结果\n */\nconst compareWithBias = (bias: boolean, usePrev: boolean) => {\n  return (entryV: ConflictEntry, entryW: ConflictEntry) => {\n    // 排序的时候先判断fixorder，不行再判断重心\n    if (entryV.fixorder !== undefined && entryW.fixorder !== undefined) {\n      return entryV.fixorder - entryW.fixorder;\n    }\n    if (entryV.barycenter! < entryW.barycenter!) {\n      return -1;\n    }\n    if (entryV.barycenter! > entryW.barycenter!) {\n      return 1;\n    }\n    // 重心相同，考虑之前排好的顺序\n    if (usePrev && entryV.order !== undefined && entryW.order !== undefined) {\n      if (entryV.order < entryW.order) {\n        return -1;\n      }\n      if (entryV.order > entryW.order) {\n        return 1;\n      }\n    }\n\n    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;\n  };\n};\n","import { ID } from \"@antv/graphlib\";\nimport { Graph } from \"../../types\";\nimport { barycenter } from \"./barycenter\";\nimport resolveConflicts, { ConflictEntry } from \"./resolve-conflicts\";\nimport { sort } from \"./sort\";\n\nexport const sortSubgraph = (\n  g: Graph,\n  v: ID,\n  cg: Graph,\n  biasRight?: boolean,\n  usePrev?: boolean,\n  keepNodeOrder?: boolean\n) => {\n  let movable = g.getChildren(v).map((n) => n.id);\n  // fixorder的点不参与排序（这个方案不合适，只排了新增节点，和原来的分离）\n  const node = g.getNode(v)!;\n  const bl = node ? (node.data.borderLeft as ID) : undefined;\n  const br = node ? (node.data.borderRight as ID) : undefined;\n  const subgraphs: Record<string, Partial<ConflictEntry>> = {};\n\n  if (bl) {\n    movable = movable?.filter((w) => {\n      return w !== bl && w !== br;\n    });\n  }\n\n  const barycenters = barycenter(g, movable || []);\n  barycenters?.forEach((entry) => {\n    if (g.getChildren(entry.v)?.length) {\n      const subgraphResult = sortSubgraph(\n        g,\n        entry.v,\n        cg,\n        biasRight,\n        keepNodeOrder\n      );\n      subgraphs[entry.v] = subgraphResult;\n      if (subgraphResult.hasOwnProperty(\"barycenter\")) {\n        mergeBarycenters(entry, subgraphResult);\n      }\n    }\n  });\n\n  const entries = resolveConflicts(barycenters, cg);\n  expandSubgraphs(entries, subgraphs);\n\n  // 添加fixorder信息到entries里边\n  // TODO: 不考虑复合情况，只用第一个点的fixorder信息，后续考虑更完备的实现\n  entries\n    .filter((e) => e.vs.length > 0)\n    ?.forEach((e) => {\n      const node = g.getNode(e.vs[0])!;\n      if (node) {\n        e.fixorder = node.data.fixorder!;\n        e.order = node.data.order!;\n      }\n    });\n\n  const result = sort(entries, biasRight, usePrev, keepNodeOrder);\n\n  if (bl) {\n    result.vs = [bl, result.vs, br].flat() as ID[];\n    if (g.getPredecessors(bl)?.length) {\n      const blPred = g.getNode(g.getPredecessors(bl)?.[0].id || \"\")!;\n      const brPred = g.getNode(g.getPredecessors(br!)?.[0].id || \"\")!;\n      if (!result.hasOwnProperty(\"barycenter\")) {\n        result.barycenter = 0;\n        result.weight = 0;\n      }\n      result.barycenter =\n        (result.barycenter! * result.weight! +\n          blPred.data.order! +\n          brPred.data.order!) /\n        (result.weight! + 2);\n      result.weight! += 2;\n    }\n  }\n\n  return result;\n};\n\nconst expandSubgraphs = (\n  entries: ConflictEntry[],\n  subgraphs: Record<string, Partial<ConflictEntry>>\n) => {\n  entries?.forEach((entry) => {\n    const vss = entry.vs?.map((v: string) => {\n      if (subgraphs[v]) {\n        return subgraphs[v].vs!;\n      }\n      return v;\n    });\n    entry.vs = vss.flat();\n  });\n};\n\nconst mergeBarycenters = (\n  target: { weight?: number; barycenter?: number },\n  other: { weight?: number; barycenter?: number }\n) => {\n  if (target.barycenter !== undefined) {\n    target.barycenter =\n      (target.barycenter * target.weight! + other.barycenter! * other.weight!) /\n      (target.weight! + other.weight!);\n    target.weight! += other.weight!;\n  } else {\n    target.barycenter = other.barycenter;\n    target.weight = other.weight;\n  }\n};\n","import { ID } from \"@antv/graphlib\";\nimport { Graph } from \"../../types\";\n\n/**\n * TODO: The median method consistently performs better than the barycenter method and has a slight theoretical advantage\n */\nexport const barycenter = (g: Graph, movable: ID[]) => {\n  return movable.map((v) => {\n    const inV = g.getRelatedEdges(v, \"in\");\n    if (!inV?.length) {\n      return { v };\n    }\n\n    const result = { sum: 0, weight: 0 };\n    inV?.forEach((e) => {\n      const nodeU = g.getNode(e.source)!;\n      result.sum += e.data.weight! * nodeU.data.order!;\n      result.weight += e.data.weight!;\n    });\n    return {\n      v,\n      barycenter: result.sum / result.weight,\n      weight: result.weight,\n    };\n  });\n};\n","import { initOrder } from \"./init-order\";\nimport { crossCount } from \"./cross-count\";\nimport { buildLayerGraph } from \"./build-layer-graph\";\nimport { addSubgraphConstraints } from \"./add-subgraph-constraints\";\nimport { sortSubgraph } from \"./sort-subgraph\";\nimport { buildLayerMatrix, maxRank } from \"../util\";\nimport { Graph as IGraph } from \"../../types\";\nimport { Graph, ID } from \"@antv/graphlib\";\nimport { clone } from \"@antv/util\";\n\n/*\n * Applies heuristics to minimize edge crossings in the graph and sets the best\n * order solution as an order attribute on each node.\n *\n * Pre-conditions:\n *\n *    1. Graph must be DAG\n *    2. Graph nodes must be objects with a \"rank\" attribute\n *    3. Graph edges must have the \"weight\" attribute\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have an \"order\" attribute based on the results of the\n *       algorithm.\n */\nexport const order = (g: IGraph, keepNodeOrder?: boolean) => {\n  const mxRank = maxRank(g);\n  const range1 = [];\n  const range2 = [];\n  for (let i = 1; i < mxRank + 1; i++) range1.push(i);\n  for (let i = mxRank - 1; i > -1; i--) range2.push(i);\n  const downLayerGraphs = buildLayerGraphs(g, range1, \"in\");\n  const upLayerGraphs = buildLayerGraphs(g, range2, \"out\");\n\n  let layering = initOrder(g);\n  assignOrder(g, layering);\n\n  let bestCC = Number.POSITIVE_INFINITY;\n  let best: string[][];\n  for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {\n    sweepLayerGraphs(\n      i % 2 ? downLayerGraphs : upLayerGraphs,\n      i % 4 >= 2,\n      false,\n      keepNodeOrder\n    );\n\n    layering = buildLayerMatrix(g);\n    const cc = crossCount(g, layering);\n    if (cc < bestCC) {\n      lastBest = 0;\n      best = clone(layering);\n      bestCC = cc;\n    }\n  }\n\n  // consider use previous result, maybe somewhat reduendant\n  layering = initOrder(g);\n  assignOrder(g, layering);\n  for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {\n    sweepLayerGraphs(\n      i % 2 ? downLayerGraphs : upLayerGraphs,\n      i % 4 >= 2,\n      true,\n      keepNodeOrder\n    );\n\n    layering = buildLayerMatrix(g);\n    const cc = crossCount(g, layering);\n    if (cc < bestCC) {\n      lastBest = 0;\n      best = clone(layering);\n      bestCC = cc;\n    }\n  }\n  assignOrder(g, best!);\n};\n\nconst buildLayerGraphs = (\n  g: IGraph,\n  ranks: number[],\n  direction: \"in\" | \"out\"\n) => {\n  return ranks.map((rank) => {\n    return buildLayerGraph(g, rank, direction);\n  });\n};\n\nconst sweepLayerGraphs = (\n  layerGraphs: IGraph[],\n  biasRight: boolean,\n  usePrev?: boolean,\n  keepNodeOrder?: boolean\n) => {\n  const cg = new Graph();\n  layerGraphs?.forEach((lg) => {\n    // const root = lg.graph().root as string;\n    const root = lg.getRoots()[0].id;\n    const sorted = sortSubgraph(\n      lg,\n      root,\n      cg,\n      biasRight,\n      usePrev,\n      keepNodeOrder\n    );\n    for (let i = 0; i < sorted.vs?.length || 0; i++) {\n      const lnode = lg.getNode(sorted.vs[i]);\n      if (lnode) {\n        lnode.data.order = i;\n      }\n    }\n    addSubgraphConstraints(lg, cg, sorted.vs);\n  });\n};\n\nconst assignOrder = (g: IGraph, layering: ID[][]) => {\n  layering?.forEach((layer) => {\n    layer?.forEach((v: ID, i: number) => {\n      g.getNode(v).data.order = i;\n    });\n  });\n};\n","import { Graph, ID } from \"@antv/graphlib\";\nimport { EdgeData, Graph as IGraph, NodeData } from \"../../types\";\n\n/*\n * Constructs a graph that can be used to sort a layer of nodes. The graph will\n * contain all base and subgraph nodes from the request layer in their original\n * hierarchy and any edges that are incident on these nodes and are of the type\n * requested by the \"relationship\" parameter.\n *\n * Nodes from the requested rank that do not have parents are assigned a root\n * node in the output graph, which is set in the root graph attribute. This\n * makes it easy to walk the hierarchy of movable nodes during ordering.\n *\n * Pre-conditions:\n *\n *    1. Input graph is a DAG\n *    2. Base nodes in the input graph have a rank attribute\n *    3. Subgraph nodes in the input graph has minRank and maxRank attributes\n *    4. Edges have an assigned weight\n *\n * Post-conditions:\n *\n *    1. Output graph has all nodes in the movable rank with preserved\n *       hierarchy.\n *    2. Root nodes in the movable layer are made children of the node\n *       indicated by the root attribute of the graph.\n *    3. Non-movable nodes incident on movable nodes, selected by the\n *       relationship parameter, are included in the graph (without hierarchy).\n *    4. Edges incident on movable nodes, selected by the relationship\n *       parameter, are added to the output graph.\n *    5. The weights for copied edges are aggregated as need, since the output\n *       graph is not a multi-graph.\n */\nexport const buildLayerGraph = (\n  g: IGraph,\n  rank: number,\n  direction: \"in\" | \"out\"\n) => {\n  const root = createRootNode(g);\n  const result = new Graph<NodeData, EdgeData>({\n    tree: [\n      {\n        id: root,\n        children: [],\n        data: {},\n      },\n    ],\n  });\n\n  g.getAllNodes().forEach((v) => {\n    const parent = g.getParent(v.id);\n\n    if (\n      v.data.rank === rank ||\n      (v.data.minRank! <= rank && rank <= v.data.maxRank!)\n    ) {\n      if (!result.hasNode(v.id)) {\n        result.addNode({ ...v });\n      }\n\n      if (parent?.id && !result.hasNode(parent?.id)) {\n        result.addNode({ ...parent });\n      }\n\n      result.setParent(v.id, parent?.id || root);\n\n      // This assumes we have only short edges!\n      g.getRelatedEdges(v.id, direction).forEach((e) => {\n        const u = e.source === v.id ? e.target : e.source;\n        if (!result.hasNode(u)) {\n          result.addNode({ ...g.getNode(u) });\n        }\n\n        const edge = result\n          .getRelatedEdges(u, \"out\")\n          .find(({ target }) => target === v.id);\n        const weight = edge !== undefined ? edge.data.weight! : 0;\n\n        if (!edge) {\n          result.addEdge({\n            id: e.id,\n            source: u,\n            target: v.id,\n            data: {\n              weight: e.data.weight! + weight,\n            },\n          });\n        } else {\n          result.updateEdgeData(edge.id, {\n            ...edge.data,\n            weight: e.data.weight! + weight,\n          });\n        }\n      });\n\n      // console.log(v);\n\n      if (v.data.hasOwnProperty(\"minRank\")) {\n        result.updateNodeData(v.id, {\n          ...v.data,\n          borderLeft: (v.data.borderLeft as ID[])[rank],\n          borderRight: (v.data.borderRight as ID[])[rank],\n        });\n      }\n    }\n  });\n\n  return result;\n};\n\nconst createRootNode = (g: IGraph) => {\n  let v;\n  while (g.hasNode((v = `_root${Math.random()}`)));\n  return v;\n};\n","import { ID } from \"@antv/graphlib\";\nimport { Graph } from \"../../types\";\n\nexport const addSubgraphConstraints = (g: Graph, cg: Graph, vs: ID[]) => {\n  const prev: Record<ID, ID> = {};\n  let rootPrev: ID;\n\n  vs?.forEach((v) => {\n    let child = g.getParent(v);\n    let parent;\n    let prevChild: ID;\n    while (child) {\n      parent = g.getParent(child.id);\n      if (parent) {\n        prevChild = prev[parent.id];\n        prev[parent.id] = child.id;\n      } else {\n        prevChild = rootPrev;\n        rootPrev = child.id;\n      }\n      if (prevChild && prevChild !== child.id) {\n        cg.addNodes([\n          {\n            id: prevChild,\n            data: {},\n          },\n          {\n            id: child.id,\n            data: {},\n          },\n        ]);\n        cg.addEdge({\n          id: `e${prevChild}-${child.id}`,\n          source: prevChild,\n          target: child.id,\n          data: {},\n        });\n        return;\n      }\n      child = parent;\n    }\n  });\n};\n","/*\n * This module provides coordinate assignment based on Brandes and Köpf, \"Fast\n * and Simple Horizontal Coordinate Assignment.\"\n */\nimport { Graph, ID, Node } from \"@antv/graphlib\";\nimport { DagreAlign, EdgeData, Graph as IGraph, NodeData } from \"../../types\";\nimport { buildLayerMatrix, minBy } from \"../util\";\n\n/*\n * Marks all edges in the graph with a type-1 conflict with the \"type1Conflict\"\n * property. A type-1 conflict is one where a non-inner segment crosses an\n * inner segment. An inner segment is an edge with both incident nodes marked\n * with the \"dummy\" property.\n *\n * This algorithm scans layer by layer, starting with the second, for type-1\n * conflicts between the current layer and the previous layer. For each layer\n * it scans the nodes from left to right until it reaches one that is incident\n * on an inner segment. It then scans predecessors to determine if they have\n * edges that cross that inner segment. At the end a final scan is done for all\n * nodes on the current rank to see if they cross the last visited inner\n * segment.\n *\n * This algorithm (safely) assumes that a dummy node will only be incident on a\n * single node in the layers being scanned.\n */\n\ntype Conflicts = Record<ID, Record<ID, boolean>>;\n\nexport const findType1Conflicts = (g: IGraph, layering?: ID[][]) => {\n  const conflicts = {};\n\n  const visitLayer = (prevLayer: ID[], layer: ID[]) => {\n    // last visited node in the previous layer that is incident on an inner\n    // segment.\n    let k0 = 0;\n    // Tracks the last node in this layer scanned for crossings with a type-1\n    // segment.\n    let scanPos = 0;\n    const prevLayerLength = prevLayer.length;\n    const lastNode = layer?.[layer?.length - 1];\n\n    layer?.forEach((v: ID, i: number) => {\n      const w = findOtherInnerSegmentNode(g, v);\n      const k1 = w ? g.getNode(w.id)!.data.order! : prevLayerLength;\n\n      if (w || v === lastNode) {\n        layer.slice(scanPos, i + 1)?.forEach((scanNode) => {\n          g.getPredecessors(scanNode)?.forEach((u) => {\n            const uLabel = g.getNode(u.id)!;\n            const uPos = uLabel.data.order!;\n            if (\n              (uPos < k0 || k1 < uPos) &&\n              !(uLabel.data.dummy && g.getNode(scanNode)?.data.dummy)\n            ) {\n              addConflict(conflicts, u.id, scanNode);\n            }\n          });\n        });\n        scanPos = i + 1;\n        k0 = k1;\n      }\n    });\n\n    return layer;\n  };\n\n  if (layering?.length) {\n    layering.reduce(visitLayer);\n  }\n  return conflicts;\n};\n\nexport const findType2Conflicts = (g: IGraph, layering?: ID[][]) => {\n  const conflicts = {};\n\n  function scan(\n    south: string[],\n    southPos: number,\n    southEnd: number,\n    prevNorthBorder: number,\n    nextNorthBorder: number\n  ) {\n    let v: string;\n    for (let i = southPos; i < southEnd; i++) {\n      v = south[i];\n      if (g.getNode(v)?.data.dummy) {\n        g.getPredecessors(v)?.forEach((u) => {\n          const uNode = g.getNode(u.id)!;\n          if (\n            uNode.data.dummy &&\n            (uNode.data.order! < prevNorthBorder ||\n              uNode.data.order! > nextNorthBorder)\n          ) {\n            addConflict(conflicts, u.id, v);\n          }\n        });\n      }\n    }\n  }\n\n  function getScannedKey(params: Parameters<typeof scan>) {\n    // south数组可能很大，不适合做key\n    return JSON.stringify(params.slice(1));\n  }\n\n  function scanIfNeeded(\n    params: Parameters<typeof scan>,\n    scanCache: Map<string, boolean>\n  ) {\n    const cacheKey = getScannedKey(params);\n\n    if (scanCache.get(cacheKey)) return;\n\n    scan(...params);\n    scanCache.set(cacheKey, true);\n  }\n\n  const visitLayer = (north: string[], south: string[]) => {\n    let prevNorthPos = -1;\n    let nextNorthPos: number;\n    let southPos = 0;\n\n    const scanned = new Map<string, boolean>();\n\n    south?.forEach((v: string, southLookahead: number) => {\n      if (g.getNode(v)?.data.dummy === \"border\") {\n        const predecessors = g.getPredecessors(v) || [];\n        if (predecessors.length) {\n          nextNorthPos = g.getNode(predecessors[0].id)!.data.order!;\n          scanIfNeeded(\n            [south, southPos, southLookahead, prevNorthPos, nextNorthPos],\n            scanned\n          );\n          southPos = southLookahead;\n          prevNorthPos = nextNorthPos;\n        }\n      }\n      scanIfNeeded(\n        [south, southPos, south.length, nextNorthPos, north.length],\n        scanned\n      );\n    });\n\n    return south;\n  };\n\n  if (layering?.length) {\n    layering.reduce(visitLayer);\n  }\n  return conflicts;\n};\n\nexport const findOtherInnerSegmentNode = (g: IGraph, v: ID) => {\n  if (g.getNode(v)?.data.dummy) {\n    return g.getPredecessors(v)?.find((u) => g.getNode(u.id).data.dummy);\n  }\n};\n\nexport const addConflict = (conflicts: Conflicts, v: ID, w: ID) => {\n  let vv = v;\n  let ww = w;\n  if (vv > ww) {\n    const tmp = vv;\n    vv = ww;\n    ww = tmp;\n  }\n\n  let conflictsV = conflicts[vv];\n  if (!conflictsV) {\n    conflicts[vv] = conflictsV = {};\n  }\n  conflictsV[ww] = true;\n};\n\nexport const hasConflict = (conflicts: Conflicts, v: ID, w: ID) => {\n  let vv = v;\n  let ww = w;\n  if (vv > ww) {\n    const tmp = v;\n    vv = ww;\n    ww = tmp;\n  }\n  return !!conflicts[vv];\n};\n\n/*\n * Try to align nodes into vertical \"blocks\" where possible. This algorithm\n * attempts to align a node with one of its median neighbors. If the edge\n * connecting a neighbor is a type-1 conflict then we ignore that possibility.\n * If a previous node has already formed a block with a node after the node\n * we're trying to form a block with, we also ignore that possibility - our\n * blocks would be split in that scenario.\n */\nexport const verticalAlignment = (\n  g: IGraph,\n  layering: ID[][],\n  conflicts: Conflicts,\n  neighborFn: (v: ID) => Node<NodeData>[]\n) => {\n  const root: Record<ID, ID> = {};\n  const align: Record<ID, ID> = {};\n  const pos: Record<ID, number> = {};\n\n  // We cache the position here based on the layering because the graph and\n  // layering may be out of sync. The layering matrix is manipulated to\n  // generate different extreme alignments.\n  layering?.forEach((layer) => {\n    layer?.forEach((v, order: number) => {\n      root[v] = v;\n      align[v] = v;\n      pos[v] = order;\n    });\n  });\n\n  layering?.forEach((layer) => {\n    let prevIdx = -1;\n    layer?.forEach((v) => {\n      let ws = neighborFn(v).map((n) => n.id);\n\n      if (ws.length) {\n        ws = ws.sort((a: ID, b: ID) => pos[a] - pos[b]);\n        const mp = (ws.length - 1) / 2;\n        for (let i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {\n          const w = ws[i];\n          if (\n            align[v] === v &&\n            prevIdx < pos[w] &&\n            !hasConflict(conflicts, v, w)\n          ) {\n            align[w] = v;\n            align[v] = root[v] = root[w];\n            prevIdx = pos[w];\n          }\n        }\n      }\n    });\n  });\n\n  return { root, align };\n};\n\nexport const horizontalCompaction = (\n  g: IGraph,\n  layering: ID[][],\n  root: Record<ID, ID>,\n  align: Record<ID, ID>,\n  nodesep: number,\n  edgesep: number,\n  reverseSep?: boolean\n) => {\n  // This portion of the algorithm differs from BK due to a number of problems.\n  // Instead of their algorithm we construct a new block graph and do two\n  // sweeps. The first sweep places blocks with the smallest possible\n  // coordinates. The second sweep removes unused space by moving blocks to the\n  // greatest coordinates without violating separation.\n  const xs: Record<ID, number> = {};\n  const blockG = buildBlockGraph(\n    g,\n    layering,\n    root,\n    nodesep,\n    edgesep,\n    reverseSep\n  );\n  const borderType = reverseSep ? \"borderLeft\" : \"borderRight\";\n\n  const iterate = (\n    setXsFunc: (param: ID) => void,\n    nextNodesFunc: (param: ID) => Node<NodeData>\n  ) => {\n    let stack = blockG.getAllNodes();\n    let elem = stack.pop();\n    const visited: Record<ID, boolean> = {};\n    while (elem) {\n      if (visited[elem.id]) {\n        setXsFunc(elem.id);\n      } else {\n        visited[elem.id] = true;\n        stack.push(elem);\n        stack = stack.concat(nextNodesFunc(elem.id));\n      }\n\n      elem = stack.pop();\n    }\n  };\n\n  // First pass, assign smallest coordinates\n  const pass1 = (elem: ID) => {\n    xs[elem] = (blockG.getRelatedEdges(elem, \"in\") || []).reduce(\n      (acc: number, e) => {\n        return Math.max(acc, (xs[e.source] || 0) + e.data.weight!);\n      },\n      0\n    );\n  };\n\n  // Second pass, assign greatest coordinates\n  const pass2 = (elem: ID) => {\n    const min = (blockG.getRelatedEdges(elem, \"out\") || []).reduce(\n      (acc: number, e) => {\n        return Math.min(acc, (xs[e.target] || 0) - e.data.weight!);\n      },\n      Number.POSITIVE_INFINITY\n    );\n\n    const node = g.getNode(elem)!;\n    if (\n      min !== Number.POSITIVE_INFINITY &&\n      node.data.borderType !== borderType\n    ) {\n      xs[elem] = Math.max(xs[elem], min);\n    }\n  };\n\n  iterate(pass1, blockG.getPredecessors.bind(blockG));\n  iterate(pass2, blockG.getSuccessors.bind(blockG));\n\n  // Assign x coordinates to all nodes\n  Object.values(align)?.forEach((v) => {\n    xs[v] = xs[root[v]];\n  });\n\n  return xs;\n};\n\nexport const buildBlockGraph = (\n  g: IGraph,\n  layering: ID[][],\n  root: Record<ID, ID>,\n  nodesep: number,\n  edgesep: number,\n  reverseSep?: boolean\n): IGraph => {\n  const blockGraph = new Graph<NodeData, EdgeData>();\n  const sepFn = sep(nodesep, edgesep, reverseSep as boolean);\n\n  layering?.forEach((layer) => {\n    let u: ID;\n    layer?.forEach((v) => {\n      const vRoot = root[v];\n      if (!blockGraph.hasNode(vRoot)) {\n        blockGraph.addNode({\n          id: vRoot,\n          data: {},\n        });\n      }\n      if (u) {\n        const uRoot = root[u];\n\n        const edge = blockGraph\n          .getRelatedEdges(uRoot, \"out\")\n          .find((edge) => edge.target === vRoot);\n        if (!edge) {\n          blockGraph.addEdge({\n            id: `e${Math.random()}`,\n            source: uRoot,\n            target: vRoot,\n            data: {\n              weight: Math.max(sepFn(g, v, u), 0),\n            },\n          });\n        } else {\n          blockGraph.updateEdgeData(edge.id, {\n            ...edge.data,\n            weight: Math.max(sepFn(g, v, u), edge.data.weight! || 0),\n          });\n        }\n      }\n      u = v;\n    });\n  });\n\n  return blockGraph;\n};\n/*\n * Returns the alignment that has the smallest width of the given alignments.\n */\nexport const findSmallestWidthAlignment = (\n  g: IGraph,\n  xss: Record<string, Record<string, number>>\n) => {\n  return minBy(Object.values(xss), (xs) => {\n    let max = Number.NEGATIVE_INFINITY;\n    let min = Number.POSITIVE_INFINITY;\n\n    Object.keys(xs)?.forEach((v: string) => {\n      const x = xs[v];\n      const halfWidth = width(g, v) / 2;\n\n      max = Math.max(x + halfWidth, max);\n      min = Math.min(x - halfWidth, min);\n    });\n\n    return max - min;\n  });\n};\n\n/*\n * Align the coordinates of each of the layout alignments such that\n * left-biased alignments have their minimum coordinate at the same point as\n * the minimum coordinate of the smallest width alignment and right-biased\n * alignments have their maximum coordinate at the same point as the maximum\n * coordinate of the smallest width alignment.\n */\nexport function alignCoordinates(\n  xss: Record<string, Record<string, number>>,\n  alignTo: Record<string, number>\n) {\n  const alignToVals = Object.values(alignTo);\n  const alignToMin = Math.min(...alignToVals);\n  const alignToMax = Math.max(...alignToVals);\n\n  [\"u\", \"d\"].forEach((vert) => {\n    [\"l\", \"r\"].forEach((horiz) => {\n      const alignment = vert + horiz;\n      const xs = xss[alignment];\n      let delta: number;\n      if (xs === alignTo) return;\n\n      const xsVals = Object.values(xs);\n      delta =\n        horiz === \"l\"\n          ? alignToMin - Math.min(...xsVals)\n          : alignToMax - Math.max(...xsVals);\n\n      if (delta) {\n        xss[alignment] = {};\n        Object.keys(xs).forEach((key) => {\n          xss[alignment][key] = xs[key] + delta;\n        });\n      }\n    });\n  });\n}\n\nexport const balance = (\n  xss: Record<string, Record<string, number>>,\n  align?: DagreAlign\n) => {\n  const result: Record<string, number> = {};\n  Object.keys(xss.ul).forEach((key) => {\n    if (align) {\n      result[key] = xss[align.toLowerCase()][key];\n    } else {\n      const values = Object.values(xss).map((x) => x[key]);\n      result[key] = (values[0] + values[1]) / 2; // (ur + ul) / 2\n    }\n  });\n  return result;\n};\n\nexport const positionX = (\n  g: IGraph,\n  options?: Partial<{\n    align: DagreAlign;\n    nodesep: number;\n    edgesep: number;\n  }>\n) => {\n  const { align: graphAlign, nodesep = 0, edgesep = 0 } = options || {};\n\n  const layering = buildLayerMatrix(g);\n  const conflicts = Object.assign(\n    findType1Conflicts(g, layering),\n    findType2Conflicts(g, layering)\n  );\n\n  const xss: Record<string, Record<ID, number>> = {};\n  let adjustedLayering: ID[][];\n  [\"u\", \"d\"].forEach((vert) => {\n    adjustedLayering =\n      vert === \"u\" ? layering : Object.values(layering).reverse();\n    [\"l\", \"r\"].forEach((horiz) => {\n      if (horiz === \"r\") {\n        adjustedLayering = adjustedLayering.map((inner) =>\n          Object.values(inner).reverse()\n        );\n      }\n\n      const neighborFn = (\n        vert === \"u\" ? g.getPredecessors : g.getSuccessors\n      ).bind(g);\n      const align = verticalAlignment(\n        g,\n        adjustedLayering,\n        conflicts,\n        neighborFn\n      );\n      const xs = horizontalCompaction(\n        g,\n        adjustedLayering,\n        align.root,\n        align.align,\n        nodesep,\n        edgesep,\n        horiz === \"r\"\n      );\n      if (horiz === \"r\") {\n        Object.keys(xs).forEach((key) => {\n          xs[key] = -xs[key];\n        });\n      }\n      xss[vert + horiz] = xs;\n    });\n  });\n\n  const smallestWidth = findSmallestWidthAlignment(g, xss);\n  alignCoordinates(xss, smallestWidth);\n  return balance(xss, graphAlign);\n};\n\nexport const sep = (nodeSep: number, edgeSep: number, reverseSep: boolean) => {\n  return (g: IGraph, v: ID, w: ID) => {\n    const vLabel = g.getNode(v)!;\n    const wLabel = g.getNode(w)!;\n    let sum = 0;\n    let delta: number = 0;\n\n    sum += vLabel.data.width! / 2;\n    if (vLabel.data.hasOwnProperty(\"labelpos\")) {\n      switch (((vLabel.data.labelpos as string) || \"\").toLowerCase()) {\n        case \"l\":\n          delta = -vLabel.data.width! / 2;\n          break;\n        case \"r\":\n          delta = vLabel.data.width! / 2;\n          break;\n      }\n    }\n    if (delta) {\n      sum += reverseSep ? delta : -delta;\n    }\n    delta = 0;\n\n    sum += (vLabel.data.dummy ? edgeSep : nodeSep) / 2;\n    sum += (wLabel.data.dummy ? edgeSep : nodeSep) / 2;\n\n    sum += wLabel.data.width! / 2;\n    if (wLabel.data.labelpos) {\n      switch (((wLabel.data.labelpos as string) || \"\").toLowerCase()) {\n        case \"l\":\n          delta = wLabel.data.width! / 2;\n          break;\n        case \"r\":\n          delta = -wLabel.data.width! / 2;\n          break;\n      }\n    }\n    if (delta) {\n      sum += reverseSep ? delta : -delta;\n    }\n    delta = 0;\n\n    return sum;\n  };\n};\n\nexport const width = (g: IGraph, v: ID) => g.getNode(v)!.data.width! || 0;\n","import { ID } from \"@antv/graphlib\";\nimport { DagreAlign, Graph as IGraph } from \"../../types\";\nimport { asNonCompoundGraph, buildLayerMatrix } from \"../util\";\nimport {\n  alignCoordinates,\n  balance,\n  findSmallestWidthAlignment,\n  findType1Conflicts,\n  findType2Conflicts,\n  horizontalCompaction,\n  verticalAlignment,\n} from \"./bk\";\n\nconst positionY = (\n  g: IGraph,\n  options?: Partial<{\n    ranksep: number;\n  }>\n) => {\n  const { ranksep = 0 } = options || {};\n  const layering = buildLayerMatrix(g);\n\n  let prevY = 0;\n  layering?.forEach((layer) => {\n    const heights = layer.map((v) => g.getNode(v).data.height!);\n    const maxHeight = Math.max(...heights, 0);\n    layer?.forEach((v: string) => {\n      g.getNode(v).data.y = prevY + maxHeight / 2;\n    });\n    prevY += maxHeight + ranksep;\n  });\n};\n\nconst positionX = (\n  g: IGraph,\n  options?: Partial<{\n    align: DagreAlign;\n    nodesep: number;\n    edgesep: number;\n  }>\n): Record<ID, number> => {\n  const { align: graphAlign, nodesep = 0, edgesep = 0 } = options || {};\n\n  const layering = buildLayerMatrix(g);\n  const conflicts = Object.assign(\n    findType1Conflicts(g, layering),\n    findType2Conflicts(g, layering)\n  );\n\n  const xss: Record<string, Record<string, number>> = {};\n  let adjustedLayering: ID[][] = [];\n  [\"u\", \"d\"].forEach((vert) => {\n    adjustedLayering =\n      vert === \"u\" ? layering : Object.values(layering).reverse();\n    [\"l\", \"r\"].forEach((horiz) => {\n      if (horiz === \"r\") {\n        adjustedLayering = adjustedLayering.map((inner) =>\n          Object.values(inner).reverse()\n        );\n      }\n\n      const neighborFn = (\n        vert === \"u\" ? g.getPredecessors : g.getSuccessors\n      ).bind(g);\n      const align = verticalAlignment(\n        g,\n        adjustedLayering,\n        conflicts,\n        neighborFn\n      );\n      const xs = horizontalCompaction(\n        g,\n        adjustedLayering,\n        align.root,\n        align.align,\n        nodesep,\n        edgesep,\n        horiz === \"r\"\n      );\n      if (horiz === \"r\") {\n        Object.keys(xs).forEach((xsKey) => (xs[xsKey] = -xs[xsKey]));\n      }\n      xss[vert + horiz] = xs;\n    });\n  });\n\n  const smallestWidth = findSmallestWidthAlignment(g, xss);\n  smallestWidth && alignCoordinates(xss, smallestWidth);\n  return balance(xss, graphAlign);\n};\n\nexport const position = (\n  g: IGraph,\n  options?: Partial<{\n    align: DagreAlign;\n    nodesep: number;\n    edgesep: number;\n    ranksep: number;\n  }>\n) => {\n  const ng = asNonCompoundGraph(g);\n\n  positionY(ng, options);\n  const xs = positionX(ng, options);\n  Object.keys(xs)?.forEach((key: ID) => {\n    ng.getNode(key).data.x = xs[key];\n  });\n};\n","import { Graph, ID } from \"@antv/graphlib\";\nimport { isNil } from \"@antv/util\";\nimport {\n  DagreAlign,\n  DagreRankdir,\n  Graph as IGraph,\n  NodeData,\n  Point,\n} from \"../types\";\nimport { run as runAcyclic, undo as undoAcyclic } from \"./acyclic\";\nimport { run as runNormalize, undo as undoNormalize } from \"./normalize\";\nimport { rank } from \"./rank\";\nimport {\n  normalizeRanks,\n  removeEmptyRanks,\n  asNonCompoundGraph,\n  addDummyNode,\n  intersectRect,\n  buildLayerMatrix,\n} from \"./util\";\nimport { parentDummyChains } from \"./parent-dummy-chains\";\nimport {\n  run as runNestingGraph,\n  cleanup as cleanupNestingGraph,\n} from \"./nesting-graph\";\nimport { addBorderSegments } from \"./add-border-segments\";\nimport {\n  adjust as adjustCoordinateSystem,\n  undo as undoCoordinateSystem,\n} from \"./coordinate-system\";\nimport { order } from \"./order\";\nimport { position } from \"./position\";\nimport { initDataOrder } from \"./order/init-data-order\";\n\n// const graphNumAttrs = [\"nodesep\", \"edgesep\", \"ranksep\", \"marginx\", \"marginy\"];\n// const graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: \"tb\" };\n// const graphAttrs = [\"acyclicer\", \"ranker\", \"rankdir\", \"align\"];\n\nexport const layout = (\n  g: IGraph,\n  options: {\n    keepNodeOrder: boolean;\n    prevGraph: IGraph | null;\n    edgeLabelSpace?: boolean;\n    align?: DagreAlign;\n    nodesep?: number;\n    edgesep?: number;\n    ranksep?: number;\n    acyclicer: string;\n    nodeOrder: ID[];\n    ranker: \"network-simplex\" | \"tight-tree\" | \"longest-path\";\n    rankdir: DagreRankdir;\n  }\n) => {\n  const { edgeLabelSpace, keepNodeOrder, prevGraph, rankdir, ranksep } =\n    options;\n\n  // 如果在原图基础上修改，继承原图的order结果\n  if (!keepNodeOrder && prevGraph) {\n    inheritOrder(g, prevGraph);\n  }\n  const layoutGraph = buildLayoutGraph(g);\n\n  // 控制是否为边的label留位置（这会影响是否在边中间添加dummy node）\n  if (!(!edgeLabelSpace)) {\n    options.ranksep = makeSpaceForEdgeLabels(layoutGraph, {\n      rankdir,\n      ranksep,\n    });\n  }\n  let dimension;\n  // TODO: 暂时处理层级设置不正确时的异常报错，提示设置正确的层级\n  try {\n    dimension = runLayout(layoutGraph, options);\n  } catch (e) {\n    if (\n      e.message === \"Not possible to find intersection inside of the rectangle\"\n    ) {\n      console.error(\n        \"The following error may be caused by improper layer setting, please make sure your manual layer setting does not violate the graph's structure:\\n\",\n        e\n      );\n      return;\n    }\n    throw e;\n  }\n  updateInputGraph(g, layoutGraph);\n  return dimension;\n};\n\nconst runLayout = (\n  g: IGraph,\n  options: {\n    acyclicer: string;\n    keepNodeOrder: boolean;\n    nodeOrder: ID[];\n    ranker: \"network-simplex\" | \"tight-tree\" | \"longest-path\";\n    rankdir: DagreRankdir;\n    align?: DagreAlign;\n    nodesep?: number;\n    edgesep?: number;\n    ranksep?: number;\n  }\n) => {\n  const {\n    acyclicer,\n    ranker,\n    rankdir = \"tb\",\n    nodeOrder,\n    keepNodeOrder,\n    align,\n    nodesep = 50,\n    edgesep = 20,\n    ranksep = 50,\n  } = options;\n\n  removeSelfEdges(g);\n\n  runAcyclic(g, acyclicer);\n\n  const { nestingRoot, nodeRankFactor } = runNestingGraph(g);\n\n  rank(asNonCompoundGraph(g), ranker);\n\n  injectEdgeLabelProxies(g);\n\n  removeEmptyRanks(g, nodeRankFactor);\n\n  cleanupNestingGraph(g, nestingRoot);\n\n  normalizeRanks(g);\n\n  assignRankMinMax(g);\n\n  removeEdgeLabelProxies(g);\n\n  const dummyChains: ID[] = [];\n  runNormalize(g, dummyChains);\n  parentDummyChains(g, dummyChains);\n\n  addBorderSegments(g);\n\n  if (keepNodeOrder) {\n    initDataOrder(g, nodeOrder);\n  }\n\n  order(g, keepNodeOrder);\n\n  insertSelfEdges(g);\n\n  adjustCoordinateSystem(g, rankdir);\n\n  position(g, {\n    align,\n    nodesep,\n    edgesep,\n    ranksep,\n  });\n\n  positionSelfEdges(g);\n\n  removeBorderNodes(g);\n\n  undoNormalize(g, dummyChains);\n\n  fixupEdgeLabelCoords(g);\n\n  undoCoordinateSystem(g, rankdir);\n\n  const { width, height } = translateGraph(g);\n\n  assignNodeIntersects(g);\n\n  reversePointsForReversedEdges(g);\n\n  undoAcyclic(g);\n\n  return { width, height };\n};\n\n/**\n * 继承上一个布局中的order，防止翻转\n * TODO: 暂时没有考虑涉及层级变动的布局，只保证原来布局层级和相对顺序不变\n */\nconst inheritOrder = (currG: IGraph, prevG: IGraph) => {\n  currG.getAllNodes().forEach((n) => {\n    const node = currG.getNode(n.id)!;\n    const prevNode = prevG.getNode(n.id)!;\n    if (prevNode !== undefined) {\n      node.data.fixorder = prevNode.data._order as number;\n      delete prevNode.data._order;\n    } else {\n      delete node.data.fixorder;\n    }\n  });\n};\n\n/*\n * Copies final layout information from the layout graph back to the input\n * graph. This process only copies whitelisted attributes from the layout graph\n * to the input graph, so it serves as a good place to determine what\n * attributes can influence layout.\n */\nconst updateInputGraph = (inputGraph: IGraph, layoutGraph: IGraph) => {\n  inputGraph.getAllNodes().forEach((v) => {\n    const inputLabel = inputGraph.getNode(v.id);\n\n    if (inputLabel) {\n      const layoutLabel = layoutGraph.getNode(v.id)!;\n      inputLabel.data.x = layoutLabel.data.x;\n      inputLabel.data.y = layoutLabel.data.y;\n      inputLabel.data._order = layoutLabel.data.order;\n      inputLabel.data._rank = layoutLabel.data.rank;\n\n      if (layoutGraph.getChildren(v.id)?.length) {\n        inputLabel.data.width = layoutLabel.data.width;\n        inputLabel.data.height = layoutLabel.data.height;\n      }\n    }\n  });\n\n  inputGraph.getAllEdges().forEach((e) => {\n    const inputLabel = inputGraph.getEdge(e.id)!;\n    const layoutLabel = layoutGraph.getEdge(e.id)!;\n\n    inputLabel.data.points = layoutLabel ? layoutLabel.data.points : [];\n    if (layoutLabel && layoutLabel.data.hasOwnProperty(\"x\")) {\n      inputLabel.data.x = layoutLabel.data.x;\n      inputLabel.data.y = layoutLabel.data.y;\n    }\n  });\n\n  // inputGraph.graph().width = layoutGraph.graph().width;\n  // inputGraph.graph().height = layoutGraph.graph().height;\n};\n\nconst nodeNumAttrs = [\"width\", \"height\", \"layer\", \"fixorder\"]; // 需要传入layer, fixOrder作为参数参考\nconst nodeDefaults = { width: 0, height: 0 };\nconst edgeNumAttrs = [\"minlen\", \"weight\", \"width\", \"height\", \"labeloffset\"];\nconst edgeDefaults = {\n  minlen: 1,\n  weight: 1,\n  width: 0,\n  height: 0,\n  labeloffset: 10,\n  labelpos: \"r\",\n};\nconst edgeAttrs = [\"labelpos\"];\n\n/*\n * Constructs a new graph from the input graph, which can be used for layout.\n * This process copies only whitelisted attributes from the input graph to the\n * layout graph. Thus this function serves as a good place to determine what\n * attributes can influence layout.\n */\nconst buildLayoutGraph = (inputGraph: IGraph) => {\n  const g = new Graph({ tree: [] });\n  inputGraph.getAllNodes().forEach((v) => {\n    const node = canonicalize(inputGraph.getNode(v.id).data);\n    const defaultNode = {\n      ...nodeDefaults,\n      ...node,\n    } as NodeData;\n    const defaultAttrs = selectNumberAttrs(defaultNode, nodeNumAttrs) as Node;\n\n    if (!g.hasNode(v.id)) {\n      g.addNode({\n        id: v.id,\n        data: {\n          ...defaultAttrs,\n        },\n      });\n    }\n\n    const parent = inputGraph.getParent(v.id);\n    if (!isNil(parent)) {\n      if (!g.hasNode(parent.id)) {\n        g.addNode({ ...parent });\n      }\n      g.setParent(v.id, parent.id);\n    }\n  });\n\n  inputGraph.getAllEdges().forEach((e) => {\n    const edge = canonicalize(inputGraph.getEdge(e.id).data);\n\n    const pickedProperties: any = {};\n    edgeAttrs?.forEach((key) => {\n      if (edge[key] !== undefined) pickedProperties[key] = edge[key];\n    });\n\n    g.addEdge({\n      id: e.id,\n      source: e.source,\n      target: e.target,\n      data: Object.assign(\n        {},\n        edgeDefaults,\n        selectNumberAttrs(edge, edgeNumAttrs),\n        pickedProperties\n      ),\n    });\n  });\n\n  return g;\n};\n\n/*\n * This idea comes from the Gansner paper: to account for edge labels in our\n * layout we split each rank in half by doubling minlen and halving ranksep.\n * Then we can place labels at these mid-points between nodes.\n *\n * We also add some minimal padding to the width to push the label for the edge\n * away from the edge itself a bit.\n */\nconst makeSpaceForEdgeLabels = (\n  g: IGraph,\n  options: {\n    ranksep?: number;\n    rankdir: string;\n  }\n) => {\n  const { ranksep = 0, rankdir } = options;\n  g.getAllNodes().forEach((node) => {\n    if (!isNaN(node.data.layer!)) {\n      if (!node.data.layer) node.data.layer = 0;\n    }\n  });\n  g.getAllEdges().forEach((edge) => {\n    edge.data.minlen! *= 2;\n    if ((edge.data.labelpos as string)?.toLowerCase() !== \"c\") {\n      if (rankdir === \"TB\" || rankdir === \"BT\") {\n        edge.data.width! += edge.data.labeloffset!;\n      } else {\n        edge.data.height! += edge.data.labeloffset!;\n      }\n    }\n  });\n\n  return ranksep / 2;\n};\n\n/*\n * Creates temporary dummy nodes that capture the rank in which each edge's\n * label is going to, if it has one of non-zero width and height. We do this\n * so that we can safely remove empty ranks while preserving balance for the\n * label's position.\n */\nconst injectEdgeLabelProxies = (g: IGraph) => {\n  g.getAllEdges().forEach((e) => {\n    if (e.data.width && e.data.height) {\n      const v = g.getNode(e.source)!;\n      const w = g.getNode(e.target)!;\n      const label = {\n        e,\n        rank: (w.data.rank! - v.data.rank!) / 2 + v.data.rank!,\n      };\n      addDummyNode(g, \"edge-proxy\", label, \"_ep\");\n    }\n  });\n};\n\nconst assignRankMinMax = (g: IGraph): number => {\n  let maxRank = 0;\n  g.getAllNodes().forEach((node) => {\n    if (node.data.borderTop) {\n      node.data.minRank = g.getNode(node.data.borderTop as ID)?.data.rank;\n      node.data.maxRank = g.getNode(node.data.borderBottom as ID)?.data.rank;\n      maxRank = Math.max(maxRank, node.data.maxRank || -Infinity);\n    }\n  });\n\n  return maxRank;\n};\n\nconst removeEdgeLabelProxies = (g: IGraph) => {\n  g.getAllNodes().forEach((node) => {\n    if (node.data.dummy === \"edge-proxy\") {\n      g.getEdge(node.data.e!.id)!.data.labelRank = node.data.rank;\n      g.removeNode(node.id);\n    }\n  });\n};\n\nconst translateGraph = (\n  g: IGraph,\n  options?: {\n    marginx: number;\n    marginy: number;\n  }\n) => {\n  let minX: number;\n  let maxX = 0;\n  let minY: number;\n  let maxY = 0;\n\n  const { marginx: marginX = 0, marginy: marginY = 0 } = options || {};\n\n  const getExtremes = (attrs: any) => {\n    if (!attrs.data) return;\n    const x = attrs.data.x;\n    const y = attrs.data.y;\n    const w = attrs.data.width;\n    const h = attrs.data.height;\n    if (!isNaN(x) && !isNaN(w)) {\n      if (minX === undefined) {\n        minX = x - w / 2;\n      }\n      minX = Math.min(minX, x - w / 2);\n      maxX = Math.max(maxX, x + w / 2);\n    }\n    if (!isNaN(y) && !isNaN(h)) {\n      if (minY === undefined) {\n        minY = y - h / 2;\n      }\n      minY = Math.min(minY, y - h / 2);\n      maxY = Math.max(maxY, y + h / 2);\n    }\n  };\n\n  g.getAllNodes().forEach((v) => {\n    getExtremes(v);\n  });\n  g.getAllEdges().forEach((e) => {\n    if (e?.data.hasOwnProperty(\"x\")) {\n      getExtremes(e);\n    }\n  });\n\n  minX! -= marginX;\n  minY! -= marginY;\n\n  g.getAllNodes().forEach((node) => {\n    node.data.x! -= minX;\n    node.data.y! -= minY;\n  });\n\n  g.getAllEdges().forEach((edge) => {\n    edge.data.points?.forEach((p) => {\n      p.x -= minX;\n      p.y -= minY;\n    });\n    if (edge.data.hasOwnProperty(\"x\")) {\n      edge.data.x! -= minX;\n    }\n    if (edge.data.hasOwnProperty(\"y\")) {\n      edge.data.y! -= minY;\n    }\n  });\n\n  return {\n    width: maxX - minX! + marginX,\n    height: maxY - minY! + marginY,\n  };\n};\n\nconst assignNodeIntersects = (g: IGraph) => {\n  g.getAllEdges().forEach((e) => {\n    const nodeV = g.getNode(e.source)!;\n    const nodeW = g.getNode(e.target)!;\n    let p1: Point;\n    let p2: Point;\n    if (!e.data.points) {\n      e.data.points = [];\n      p1 = { x: nodeW.data.x!, y: nodeW.data.y! };\n      p2 = { x: nodeV.data.x!, y: nodeV.data.y! };\n    } else {\n      p1 = e.data.points[0];\n      p2 = e.data.points[e.data.points.length - 1];\n    }\n\n    e.data.points.unshift(intersectRect(nodeV.data, p1));\n    e.data.points.push(intersectRect(nodeW.data, p2));\n  });\n};\n\nconst fixupEdgeLabelCoords = (g: IGraph) => {\n  g.getAllEdges().forEach((edge) => {\n    if (edge.data.hasOwnProperty(\"x\")) {\n      if (edge.data.labelpos === \"l\" || edge.data.labelpos === \"r\") {\n        edge.data.width! -= edge.data.labeloffset!;\n      }\n      switch (edge.data.labelpos) {\n        case \"l\":\n          edge.data.x! -= edge.data.width! / 2 + edge.data.labeloffset!;\n          break;\n        case \"r\":\n          edge.data.x! += edge.data.width! / 2 + edge.data.labeloffset!;\n          break;\n      }\n    }\n  });\n};\n\nconst reversePointsForReversedEdges = (g: IGraph) => {\n  g.getAllEdges().forEach((edge) => {\n    if (edge.data.reversed) {\n      edge.data.points?.reverse();\n    }\n  });\n};\n\nconst removeBorderNodes = (g: IGraph) => {\n  g.getAllNodes().forEach((v) => {\n    if (g.getChildren(v.id)?.length) {\n      const node = g.getNode(v.id)!;\n      const t = g.getNode(node.data.borderTop as ID);\n      const b = g.getNode(node.data.borderBottom as ID);\n      const l = g.getNode(\n        (node.data.borderLeft as ID[])[\n          (node.data.borderLeft as ID[])?.length - 1\n        ]\n      );\n      const r = g.getNode(\n        (node.data.borderRight as ID[])[\n          (node.data.borderRight as ID[])?.length - 1\n        ]\n      );\n\n      node.data.width = Math.abs(r?.data.x! - l?.data.x!) || 10;\n      node.data.height = Math.abs(b?.data.y! - t?.data.y!) || 10;\n      node.data.x = (l?.data.x! || 0) + node.data.width! / 2;\n      node.data.y = (t?.data.y! || 0) + node.data.height! / 2;\n    }\n  });\n\n  g.getAllNodes().forEach((n) => {\n    if (n.data.dummy === \"border\") {\n      g.removeNode(n.id);\n    }\n  });\n};\n\nconst removeSelfEdges = (g: IGraph) => {\n  g.getAllEdges().forEach((e) => {\n    if (e.source === e.target) {\n      const node = g.getNode(e.source)!;\n      if (!node.data.selfEdges) {\n        node.data.selfEdges = [];\n      }\n      node.data.selfEdges.push(e);\n      g.removeEdge(e.id);\n    }\n  });\n};\n\nconst insertSelfEdges = (g: IGraph) => {\n  const layers = buildLayerMatrix(g);\n  layers?.forEach((layer: ID[]) => {\n    let orderShift = 0;\n    layer?.forEach((v: ID, i: number) => {\n      const node = g.getNode(v)!;\n      node.data.order = i + orderShift;\n      node.data.selfEdges?.forEach((selfEdge) => {\n        addDummyNode(\n          g,\n          \"selfedge\",\n          {\n            width: selfEdge.data.width,\n            height: selfEdge.data.height,\n            rank: node.data.rank,\n            order: i + ++orderShift,\n            e: selfEdge,\n          },\n          \"_se\"\n        );\n      });\n      delete node.data.selfEdges;\n    });\n  });\n};\n\nconst positionSelfEdges = (g: IGraph) => {\n  g.getAllNodes().forEach((v) => {\n    const node = g.getNode(v.id)!;\n    if (node.data.dummy === \"selfedge\") {\n      const selfNode = g.getNode(node.data.e!.source)!;\n      const x = selfNode.data.x! + selfNode.data.width! / 2;\n      const y = selfNode.data.y!;\n      const dx = node.data.x! - x;\n      const dy = selfNode.data.height! / 2;\n\n      if (g.hasEdge(node.data.e!.id)) {\n        g.updateEdgeData(node.data.e!.id, node.data.e!.data);\n      } else {\n        g.addEdge({\n          id: node.data.e!.id,\n          source: node.data.e!.source,\n          target: node.data.e!.target,\n          data: node.data.e!.data,\n        });\n      }\n      g.removeNode(v.id);\n\n      node.data.e!.data.points = [\n        { x: x + (2 * dx) / 3, y: y - dy },\n        { x: x + (5 * dx) / 6, y: y - dy },\n        { y, x: x + dx },\n        { x: x + (5 * dx) / 6, y: y + dy },\n        { x: x + (2 * dx) / 3, y: y + dy },\n      ];\n\n      node.data.e!.data.x = node.data.x;\n      node.data.e!.data.y = node.data.y;\n    }\n  });\n};\n\nconst selectNumberAttrs = (obj: Record<string, any>, attrs: string[]) => {\n  const pickedProperties: Record<string, any> = {};\n  attrs?.forEach((key: string) => {\n    if (obj[key] === undefined) return;\n    pickedProperties[key] = +obj[key];\n  });\n  return pickedProperties;\n};\n\nconst canonicalize = (attrs: Record<string, any> = {}) => {\n  const newAttrs: Record<string, any> = {};\n  Object.keys(attrs).forEach((k: string) => {\n    newAttrs[k.toLowerCase()] = attrs[k];\n  });\n  return newAttrs;\n};\n","import { Edge, ID } from \"@antv/graphlib\";\nimport { EdgeData, Graph as IGraph } from \"../types\";\n\ntype OrderItem = { low: number; lim: number };\n\n// deep first search with both order low for pre, lim for post\nconst dfsBothOrder = (g: IGraph) => {\n  const result: Record<ID, OrderItem> = {};\n  let lim = 0;\n\n  const dfs = (v: ID) => {\n    const low = lim;\n    g.getChildren(v).forEach((n) => dfs(n.id));\n    result[v] = { low, lim: lim++ };\n  };\n  g.getRoots().forEach((n) => dfs(n.id));\n\n  return result;\n};\n\n// Find a path from v to w through the lowest common ancestor (LCA). Return the\n// full path and the LCA.\nconst findPath = (\n  g: IGraph,\n  postorderNums: Record<ID, OrderItem>,\n  v: ID,\n  w: ID\n) => {\n  const vPath: ID[] = [];\n  const wPath: ID[] = [];\n  const low = Math.min(postorderNums[v].low, postorderNums[w].low);\n  const lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);\n  let parent: ID | undefined;\n  let lca: ID | undefined;\n\n  // Traverse up from v to find the LCA\n  parent = v;\n  do {\n    parent = g.getParent(parent)?.id;\n    vPath.push(parent!);\n  } while (\n    parent &&\n    (postorderNums[parent].low > low || lim > postorderNums[parent].lim)\n  );\n  lca = parent;\n\n  // Traverse from w to LCA\n  parent = w;\n  while (parent && parent !== lca) {\n    wPath.push(parent);\n    parent = g.getParent(parent)?.id;\n  }\n\n  return { lca, path: vPath.concat(wPath.reverse()) };\n};\n\nexport const parentDummyChains = (g: IGraph, dummyChains: ID[]) => {\n  const postorderNums = dfsBothOrder(g);\n\n  dummyChains.forEach((startV) => {\n    let v = startV;\n    let node = g.getNode(v)!;\n    const originalEdge = node.data.originalEdge as Edge<EdgeData>;\n    if (!originalEdge) return;\n    const pathData = findPath(\n      g,\n      postorderNums,\n      originalEdge.source,\n      originalEdge.target\n    );\n    const path = pathData.path;\n    const lca = pathData.lca;\n    let pathIdx = 0;\n    let pathV = path[pathIdx]!;\n    let ascending = true;\n\n    while (v !== originalEdge.target) {\n      node = g.getNode(v)!;\n\n      if (ascending) {\n        while (\n          pathV !== lca &&\n          g.getNode(pathV)?.data.maxRank! < node.data.rank!\n        ) {\n          pathIdx++;\n          pathV = path[pathIdx]!;\n        }\n\n        if (pathV === lca) {\n          ascending = false;\n        }\n      }\n\n      if (!ascending) {\n        while (\n          pathIdx < path.length - 1 &&\n          g.getNode(path[pathIdx + 1]!)?.data.minRank! <= node.data.rank!\n        ) {\n          pathIdx++;\n        }\n        pathV = path[pathIdx]!;\n      }\n\n      if (g.hasNode(pathV)) {\n        g.setParent(v, pathV);\n      }\n\n      v = g.getSuccessors(v)![0].id;\n    }\n  });\n};\n","import { ID } from \"@antv/graphlib\";\nimport { Graph } from \"../../types\";\n\n/**\n * 按照数据中的结果设置fixorder\n */\nexport const initDataOrder = (g: Graph, nodeOrder?: ID[]) => {\n  const simpleNodes = g.getAllNodes().filter((v) => {\n    return !g.getChildren(v.id)?.length;\n  });\n  const ranks = simpleNodes.map((v) => v.data.rank!);\n  const maxRank = Math.max(...ranks);\n  const layers: ID[][] = [];\n  for (let i = 0; i < maxRank + 1; i++) {\n    layers[i] = [];\n  }\n\n  nodeOrder?.forEach((n) => {\n    const node = g.getNode(n);\n    // 只考虑原有节点，dummy节点需要按照后续算法排出\n    if (!node || node.data.dummy) {\n      return;\n    }\n    if (!isNaN(node.data.rank!)) {\n      node.data.fixorder = layers[node.data.rank!].length; // 设置fixorder为当层的顺序\n      layers[node.data.rank!].push(n);\n    }\n  });\n};\n","import { Graph } from \"@antv/graphlib\";\nimport { isNumber } from \"@antv/util\";\nimport { layout } from \"./dagre/layout\";\nimport type {\n  Graph as IGraph,\n  Layout,\n  LayoutMapping,\n  OutNode,\n  Node,\n  Edge,\n  DagreLayoutOptions,\n  NodeData,\n  EdgeData,\n  Point,\n} from \"./types\";\nimport { cloneFormatData, formatNumberFn, formatNodeSize } from \"./util\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<DagreLayoutOptions> = {\n  rankdir: \"TB\",\n  nodesep: 50, // 节点水平间距(px)\n  ranksep: 50, // 每一层节点之间间距\n  edgeLabelSpace: true,\n  controlPoints: false, // 是否保留布局连线的控制点\n  radial: false, // 是否基于 dagre 进行辐射布局\n  focusNode: null, // radial 为 true 时生效，关注的节点\n};\n\n/**\n * Layout arranging the nodes in a circle.\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new CircularLayout({ radius: 10 });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new CircularLayout({ radius: 10 });\n * const positions = await layout.execute(graph, { radius: 20 }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { radius: 20 });\n */\nexport class DagreLayout implements Layout<DagreLayoutOptions> {\n  id = \"dagre\";\n\n  constructor(public options: DagreLayoutOptions = {} as DagreLayoutOptions) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: IGraph, options?: DagreLayoutOptions) {\n    return this.genericDagreLayout(false, graph, options);\n  }\n\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: IGraph, options?: DagreLayoutOptions) {\n    await this.genericDagreLayout(true, graph, options);\n  }\n\n  private async genericDagreLayout(\n    assign: false,\n    graph: IGraph,\n    options?: DagreLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericDagreLayout(\n    assign: true,\n    graph: IGraph,\n    options?: DagreLayoutOptions\n  ): Promise<void>;\n  private async genericDagreLayout(\n    assign: boolean,\n    graph: IGraph,\n    options?: DagreLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n    const {\n      nodeSize,\n      align,\n      rankdir = \"TB\",\n      ranksep,\n      nodesep,\n      ranksepFunc,\n      nodesepFunc,\n      edgeLabelSpace,\n      nodeOrder,\n      begin,\n      controlPoints,\n      radial,\n      // focusNode,\n      // prevGraph,\n    } = mergedOptions;\n\n    const g = new Graph<NodeData, EdgeData>({\n      tree: [],\n    });\n\n    const ranksepfunc = formatNumberFn(ranksep || 50, ranksepFunc);\n    const nodesepfunc = formatNumberFn(nodesep || 50, nodesepFunc);\n    let horisep: (d?: Node | undefined) => number = nodesepfunc;\n    let vertisep: (d?: Node | undefined) => number = ranksepfunc;\n    if (rankdir === \"LR\" || rankdir === \"RL\") {\n      horisep = ranksepfunc;\n      vertisep = nodesepfunc;\n    }\n    const nodeSizeFunc = formatNodeSize(nodeSize, undefined);\n\n    // copy graph to g\n    const nodes: Node[] = graph.getAllNodes();\n    const edges: Edge[] = graph.getAllEdges();\n\n    nodes\n      .forEach((node) => {\n        const size = nodeSizeFunc(node);\n        const verti = vertisep(node);\n        const hori = horisep(node);\n        // FIXME: support 2 dimensions?\n        // const width = size[0] + 2 * hori;\n        // const height = size[1] + 2 * verti;\n        const width = size + 2 * hori;\n        const height = size + 2 * verti;\n        const layer = node.data.layer;\n        if (isNumber(layer)) {\n          // 如果有layer属性，加入到node的label中\n          g.addNode({\n            id: node.id,\n            data: { width, height, layer },\n          });\n        } else {\n          g.addNode({\n            id: node.id,\n            data: { width, height },\n          });\n        }\n\n        // TODO: combo\n        // if (this.sortByCombo && node.comboId) {\n        //   if (!comboMap[node.comboId]) {\n        //     comboMap[node.comboId] = { id: node.comboId };\n        //     g.setNode(node.comboId, {});\n        //   }\n        //   g.setParent(node.id, node.comboId);\n        // }\n      });\n\n    edges.forEach((edge) => {\n      // dagrejs Wiki https://github.com/dagrejs/dagre/wiki#configuring-the-layout\n      g.addEdge({\n        id: edge.id,\n        source: edge.source,\n        target: edge.target,\n        data: {\n          weight: edge.data.weight || 1,\n        },\n      });\n    });\n\n    // TODO: combo & prevGraph\n    layout(g, {\n      prevGraph: null,\n      edgeLabelSpace,\n      keepNodeOrder: !!nodeOrder,\n      nodeOrder: nodeOrder || [],\n      acyclicer: \"greedy\",\n      ranker: \"network-simplex\",\n      rankdir,\n      nodesep,\n      align,\n    });\n\n    const layoutTopLeft = [0, 0];\n    if (begin) {\n      let minX = Infinity;\n      let minY = Infinity;\n      g.getAllNodes().forEach((node) => {\n        if (minX > node.data.x!) minX = node.data.x!;\n        if (minY > node.data.y!) minY = node.data.y!;\n      });\n      g.getAllEdges().forEach((edge) => {\n        edge.data.points?.forEach((point) => {\n          if (minX > point.x) minX = point.x;\n          if (minY > point.y) minY = point.y;\n        });\n      });\n      layoutTopLeft[0] = begin[0] - minX;\n      layoutTopLeft[1] = begin[1] - minY;\n    }\n\n    const isHorizontal = rankdir === \"LR\" || rankdir === \"RL\";\n    if (radial) {\n      // const focusId = (isString(focusNode) ? focusNode : focusNode?.id) as ID;\n      // const focusLayer = focusId ? g.getNode(focusId)?.data._rank as number : 0;\n      // const layers: any[] = [];\n      // const dim = isHorizontal ? \"y\" : \"x\";\n      // const sizeDim = isHorizontal ? \"height\" : \"width\";\n      // // 找到整个图作为环的坐标维度（dim）的最大、最小值，考虑节点宽度\n      // let min = Infinity;\n      // let max = -Infinity;\n      // g.getAllNodes().forEach((node) => {\n      //   const currentNodesep = nodesepfunc(node);\n      //   if (focusLayer === 0) {\n      //     if (!layers[node.data._rank!]) {\n      //       layers[node.data._rank!] = {\n      //         nodes: [],\n      //         totalWidth: 0,\n      //         maxSize: -Infinity,\n      //       };\n      //     }\n      //     layers[node.data._rank!].nodes.push(node);\n      //     layers[node.data._rank!].totalWidth += currentNodesep * 2 + node.data[sizeDim]!;\n      //     if (\n      //       layers[node.data._rank!].maxSize < Math.max(node.data.width!, node.data.height!)\n      //     ) {\n      //       layers[node.data._rank!].maxSize = Math.max(node.data.width!, node.data.height!);\n      //     }\n      //   } else {\n      //     const diffLayer = node.data._rank! - focusLayer!;\n      //     if (diffLayer === 0) {\n      //       if (!layers[diffLayer]) {\n      //         layers[diffLayer] = {\n      //           nodes: [],\n      //           totalWidth: 0,\n      //           maxSize: -Infinity,\n      //         };\n      //       }\n      //       layers[diffLayer].nodes.push(node);\n      //       layers[diffLayer].totalWidth += currentNodesep * 2 + node.data[sizeDim]!;\n      //       if (\n      //         layers[diffLayer].maxSize < Math.max(node.data.width!, node.data.height!)\n      //       ) {\n      //         layers[diffLayer].maxSize = Math.max(node.data.width!, node.data.height!);\n      //       }\n      //     } else {\n      //       const diffLayerAbs = Math.abs(diffLayer);\n      //       if (!layers[diffLayerAbs]) {\n      //         layers[diffLayerAbs] = {\n      //           left: [],\n      //           right: [],\n      //           totalWidth: 0,\n      //           maxSize: -Infinity,\n      //         };\n      //       }\n      //       layers[diffLayerAbs].totalWidth +=\n      //         currentNodesep * 2 + node.data[sizeDim]!;\n      //       if (\n      //         layers[diffLayerAbs].maxSize < Math.max(node.data.width!, node.data.height!)\n      //       ) {\n      //         layers[diffLayerAbs].maxSize = Math.max(\n      //           node.data.width!,\n      //           node.data.height!\n      //         );\n      //       }\n      //       if (diffLayer < 0) {\n      //         layers[diffLayerAbs].left.push(node);\n      //       } else {\n      //         layers[diffLayerAbs].right.push(node);\n      //       }\n      //     }\n      //   }\n      //   const leftPos = node.data[dim]! - node.data[sizeDim]! / 2 - currentNodesep;\n      //   const rightPos = node.data[dim]! + node.data[sizeDim]! / 2 + currentNodesep;\n      //   if (leftPos < min) min = leftPos;\n      //   if (rightPos > max) max = rightPos;\n      // });\n      // // const padding = (max - min) * 0.1; // TODO\n      // // 初始化为第一圈的半径，后面根据每层 ranksep 叠加\n      // let radius = ranksep || 50; // TODO;\n      // const radiusMap: any = {};\n      // // 扩大最大最小值范围，以便为环上留出接缝处的空隙\n      // const rangeLength = (max - min) / 0.9;\n      // const range = [\n      //   (min + max - rangeLength) * 0.5,\n      //   (min + max + rangeLength) * 0.5,\n      // ];\n      // // 根据半径、分布比例，计算节点在环上的位置，并返回该组节点中最大的 ranksep 值\n      // const processNodes = (\n      //   layerNodes: any,\n      //   radius: number,\n      //   propsMaxRanksep = -Infinity,\n      //   arcRange = [0, 1]\n      // ) => {\n      //   let maxRanksep = propsMaxRanksep;\n      //   layerNodes.forEach((node: any) => {\n      //     const coord = g.node(node);\n      //     radiusMap[node] = radius;\n      //     // 获取变形为 radial 后的直角坐标系坐标\n      //     const { x: newX, y: newY } = getRadialPos(\n      //       coord![dim]!,\n      //       range,\n      //       rangeLength,\n      //       radius,\n      //       arcRange\n      //     );\n      //     // 将新坐标写入源数据\n      //     const i = nodes.findIndex((it) => it.id === node);\n      //     if (!nodes[i]) return;\n      //     nodes[i].x = newX + dBegin[0];\n      //     nodes[i].y = newY + dBegin[1];\n      //     // @ts-ignore: pass layer order to data for increment layout use\n      //     nodes[i]._order = coord._order;\n      //     // 找到本层最大的一个 ranksep，作为下一层与本层的间隙，叠加到下一层的半径上\n      //     const currentNodeRanksep = ranksepfunc(nodes[i]);\n      //     if (maxRanksep < currentNodeRanksep) maxRanksep = currentNodeRanksep;\n      //   });\n      //   return maxRanksep;\n      // };\n      // let isFirstLevel = true;\n      // const lastLayerMaxNodeSize = 0;\n      // layers.forEach((layerNodes) => {\n      //   if (\n      //     !layerNodes?.nodes?.length &&\n      //     !layerNodes?.left?.length &&\n      //     !layerNodes?.right?.length\n      //   ) {\n      //     return;\n      //   }\n      //   // 第一层只有一个节点，直接放在圆心，初始半径设定为 0\n      //   if (isFirstLevel && layerNodes.nodes.length === 1) {\n      //     // 将新坐标写入源数据\n      //     const i = nodes.findIndex((it) => it.id === layerNodes.nodes[0]);\n      //     if (i <= -1) return;\n      //     nodes[i].x = dBegin[0];\n      //     nodes[i].y = dBegin[1];\n      //     radiusMap[layerNodes.nodes[0]] = 0;\n      //     radius = ranksepfunc(nodes[i]);\n      //     isFirstLevel = false;\n      //     return;\n      //   }\n      //   // 为接缝留出空隙，半径也需要扩大\n      //   radius = Math.max(radius, layerNodes.totalWidth / (2 * Math.PI)); // / 0.9;\n      //   let maxRanksep = -Infinity;\n      //   if (focusLayer === 0 || layerNodes.nodes?.length) {\n      //     maxRanksep = processNodes(\n      //       layerNodes.nodes,\n      //       radius,\n      //       maxRanksep,\n      //       [0, 1]\n      //     ); // 0.8\n      //   } else {\n      //     const leftRatio =\n      //       layerNodes.left?.length /\n      //       (layerNodes.left?.length + layerNodes.right?.length);\n      //     maxRanksep = processNodes(layerNodes.left, radius, maxRanksep, [\n      //       0,\n      //       leftRatio,\n      //     ]); // 接缝留出 0.05 的缝隙\n      //     maxRanksep = processNodes(layerNodes.right, radius, maxRanksep, [\n      //       leftRatio + 0.05,\n      //       1,\n      //     ]); // 接缝留出 0.05 的缝隙\n      //   }\n      //   radius += maxRanksep;\n      //   isFirstLevel = false;\n      //   lastLayerMaxNodeSize - layerNodes.maxSize;\n      // });\n      // g.edges().forEach((edge: any) => {\n      //   const coord = g.edge(edge);\n      //   const i = edges.findIndex((it) => {\n      //     const source = getEdgeTerminal(it, \"source\");\n      //     const target = getEdgeTerminal(it, \"target\");\n      //     return source === edge.v && target === edge.w;\n      //   });\n      //   if (i <= -1) return;\n      //   if (\n      //     self.edgeLabelSpace &&\n      //     self.controlPoints &&\n      //     edges[i].type !== \"loop\"\n      //   ) {\n      //     const otherDim = dim === \"x\" ? \"y\" : \"x\";\n      //     const controlPoints = coord?.points?.slice(\n      //       1,\n      //       coord.points.length - 1\n      //     );\n      //     const newControlPoints: Point[] = [];\n      //     const sourceOtherDimValue = g.node(edge.v)?.[otherDim]!;\n      //     const otherDimDist =\n      //       sourceOtherDimValue - g.node(edge.w)?.[otherDim]!;\n      //     const sourceRadius = radiusMap[edge.v];\n      //     const radiusDist = sourceRadius - radiusMap[edge.w];\n      //     controlPoints?.forEach((point: any) => {\n      //       // 根据该边的起点、终点半径，及起点、终点、控制点位置关系，确定该控制点的半径\n      //       const cRadius =\n      //         ((point[otherDim] - sourceOtherDimValue) / otherDimDist) *\n      //           radiusDist +\n      //         sourceRadius;\n      //       // 获取变形为 radial 后的直角坐标系坐标\n      //       const newPos = getRadialPos(\n      //         point[dim],\n      //         range,\n      //         rangeLength,\n      //         cRadius\n      //       );\n      //       newControlPoints.push({\n      //         x: newPos.x + dBegin[0],\n      //         y: newPos.y + dBegin[1],\n      //       });\n      //     });\n      //     edges[i].controlPoints = newControlPoints;\n      //   }\n      // });\n    } else {\n      const layerCoords: Set<number> = new Set();\n      const isInvert = rankdir === \"BT\" || rankdir === \"RL\";\n      const layerCoordSort = isInvert\n        ? (a: number, b: number) => b - a\n        : (a: number, b: number) => a - b;\n      g.getAllNodes().forEach((node) => {\n        // let ndata: any = this.nodeMap[node];\n        // if (!ndata) {\n        //   ndata = combos?.find((it) => it.id === node);\n        // }\n        // if (!ndata) return;\n        // ndata.x = node.data.x! + dBegin[0];\n        // ndata.y = node.data.y! + dBegin[1];\n        // //  pass layer order to data for increment layout use\n        // ndata._order = node.data._order;\n        // layerCoords.add(isHorizontal ? ndata.x : ndata.y);\n\n        node.data.x = node.data.x! + layoutTopLeft[0];\n        node.data.y = node.data.y! + layoutTopLeft[1];\n        layerCoords.add(isHorizontal ? node.data.x : node.data.y);\n      });\n      const layerCoordsArr = Array.from(layerCoords).sort(layerCoordSort);\n\n      // pre-define the isHorizontal related functions to avoid redundant calc in interations\n      const isDifferentLayer = isHorizontal\n        ? (point1: Point, point2: Point) => point1.x !== point2.x\n        : (point1: Point, point2: Point) => point1.y !== point2.y;\n      const filterControlPointsOutOfBoundary = isHorizontal\n        ? (ps: Point[], point1: Point, point2: Point) => {\n            const max = Math.max(point1.y, point2.y);\n            const min = Math.min(point1.y, point2.y);\n            return ps.filter((point) => point.y <= max && point.y >= min);\n          }\n        : (ps: Point[], point1: Point, point2: Point) => {\n            const max = Math.max(point1.x, point2.x);\n            const min = Math.min(point1.x, point2.x);\n            return ps.filter((point) => point.x <= max && point.x >= min);\n          };\n\n      g.getAllEdges().forEach((edge, i) => {\n        // const i = edges.findIndex((it) => {\n        //   return it.source === edge.source && it.target === edge.target;\n        // });\n        // if (i <= -1) return;\n        if (edgeLabelSpace && controlPoints && edge.data.type !== \"loop\") {\n          edge.data.controlPoints = getControlPoints(\n            edge.data.points?.map(({ x, y }) => ({\n              x: x + layoutTopLeft[0],\n              y: y + layoutTopLeft[1],\n            })),\n            g.getNode(edge.source),\n            g.getNode(edge.target),\n            layerCoordsArr,\n            isHorizontal,\n            isDifferentLayer,\n            filterControlPointsOutOfBoundary\n          );\n        }\n      });\n    }\n\n    // calculated nodes as temporary result\n    let layoutNodes: OutNode[] = [];\n    // layout according to the original order in the data.nodes\n    layoutNodes = g\n      .getAllNodes()\n      .map((node) => cloneFormatData(node) as OutNode);\n    const layoutEdges = g.getAllEdges();\n\n    if (assign) {\n      layoutNodes.forEach((node) => {\n        graph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        });\n      });\n      layoutEdges.forEach((edge) => {\n        graph.mergeEdgeData(edge.id, {\n          controlPoints: edge.data.controlPoints,\n        });\n      });\n    }\n\n    const result = {\n      nodes: layoutNodes,\n      edges: layoutEdges,\n    };\n\n    return result;\n  }\n}\n\n/**\n * Format controlPoints to avoid polylines crossing nodes\n * @param points\n * @param sourceNode\n * @param targetNode\n * @param layerCoordsArr\n * @param isHorizontal\n * @returns\n */\nconst getControlPoints = (\n  points: Point[] | undefined,\n  sourceNode: Node,\n  targetNode: Node,\n  layerCoordsArr: number[],\n  isHorizontal: boolean,\n  isDifferentLayer: (point1: Point, point2: Point) => boolean,\n  filterControlPointsOutOfBoundary: (\n    ps: Point[],\n    point1: Point,\n    point2: Point\n  ) => Point[]\n) => {\n  let controlPoints = points?.slice(1, points.length - 1) || []; // 去掉头尾\n  // 酌情增加控制点，使折线不穿过跨层的节点\n  if (sourceNode && targetNode) {\n    let { x: sourceX, y: sourceY } = sourceNode.data;\n    let { x: targetX, y: targetY } = targetNode.data;\n    if (isHorizontal) {\n      sourceX = sourceNode.data.y;\n      sourceY = sourceNode.data.x;\n      targetX = targetNode.data.y;\n      targetY = targetNode.data.x;\n    }\n    // 为跨层级的边增加第一个控制点。忽略垂直的/横向的边。\n    // 新控制点 = {\n    //   x: 终点x,\n    //   y: (起点y + 下一层y) / 2,   #下一层y可能不等于终点y\n    // }\n    if (targetY !== sourceY && sourceX !== targetX) {\n      const sourceLayer = layerCoordsArr.indexOf(sourceY!);\n      const sourceNextLayerCoord = layerCoordsArr[sourceLayer + 1];\n      if (sourceNextLayerCoord) {\n        const firstControlPoint = controlPoints[0];\n        const insertStartControlPoint = (\n          isHorizontal\n            ? {\n                x: (sourceY! + sourceNextLayerCoord) / 2,\n                y: firstControlPoint?.y || targetX,\n              }\n            : {\n                x: firstControlPoint?.x || targetX,\n                y: (sourceY! + sourceNextLayerCoord) / 2,\n              }\n        ) as Point;\n        // 当新增的控制点不存在（!=当前第一个控制点）时添加\n        if (\n          !firstControlPoint ||\n          isDifferentLayer(firstControlPoint, insertStartControlPoint)\n        ) {\n          controlPoints.unshift(insertStartControlPoint);\n        }\n      }\n\n      const targetLayer = layerCoordsArr.indexOf(targetY!);\n      const layerDiff = Math.abs(targetLayer - sourceLayer);\n      if (layerDiff === 1) {\n        controlPoints = filterControlPointsOutOfBoundary(\n          controlPoints,\n          sourceNode.data as Point,\n          targetNode.data as Point\n        );\n        // one controlPoint at least\n        if (!controlPoints.length) {\n          controlPoints.push(\n            (isHorizontal\n              ? {\n                  x: (sourceY! + targetY!) / 2,\n                  y: sourceX,\n                }\n              : {\n                  x: sourceX,\n                  y: (sourceY! + targetY!) / 2,\n                }) as Point\n          );\n        }\n      } else if (layerDiff > 1) {\n        const targetLastLayerCoord = layerCoordsArr[targetLayer - 1];\n        if (targetLastLayerCoord) {\n          const lastControlPoints = controlPoints[controlPoints.length - 1];\n          const insertEndControlPoint = (\n            isHorizontal\n              ? {\n                  x: (targetY! + targetLastLayerCoord) / 2,\n                  y: lastControlPoints?.y || targetX,\n                }\n              : {\n                  x: lastControlPoints?.x || sourceX,\n                  y: (targetY! + targetLastLayerCoord) / 2,\n                }\n          ) as Point;\n          // 当新增的控制点不存在（!=当前最后一个控制点）时添加\n          if (\n            !lastControlPoints ||\n            isDifferentLayer(lastControlPoints, insertEndControlPoint)\n          ) {\n            controlPoints.push(insertEndControlPoint);\n          }\n        }\n      }\n    }\n  }\n  return controlPoints;\n};\n","import { quadtree } from \"d3-quadtree\";\n// @ts-ignore\nimport { octree } from \"d3-octree\";\nimport { Point } from \"../types\";\nimport { CalcGraph } from \"./types\";\n\nconst theta2 = 0.81; // Barnes-Hut approximation threshold\nconst epsilon = 0.1; // 为了防止出现除0的情况，加一个epsilon\n\ninterface InternalNode {\n  x: number;\n  y: number;\n  z?: number;\n  vx: number;\n  vy: number;\n  vz?: number;\n  weight: number;\n  size: number;\n}\n\nexport function forceNBody(\n  calcGraph: CalcGraph,\n  factor: number,\n  coulombDisScale2: number,\n  accMap: { [id: string]: Point },\n  dimensions: number,\n) {\n  const weightParam = factor / coulombDisScale2;\n  const calcNodes = calcGraph.getAllNodes();\n  const data = calcNodes.map((calcNode, i) => {\n    const { nodeStrength, x, y, z, size } = calcNode.data;\n    return {\n      x,\n      y,\n      z,\n      size,\n      index: i,\n      vx: 0,\n      vy: 0,\n      vz: 0,\n      weight: weightParam * nodeStrength,\n    };\n  });\n\n  const tree = (dimensions === 2 ? quadtree(\n    data,\n    (d: any) => d.x,\n    (d: any) => d.y\n  ) : octree(\n    data,\n    (d: any) => d.x,\n    (d: any) => d.y,\n    (d: any) => d.z\n  )).visitAfter(accumulate); // init internal node\n\n  data.forEach((n) => {\n    // @ts-ignore\n    computeForce(n, tree, dimensions);\n  });\n\n  data.map((n, i) => {\n    const { id, data } = calcNodes[i];\n    const { mass = 1 } = data;\n    // 从 0 开始，= 初始化 + 加斥力\n    accMap[id] = {\n      x: n.vx / mass,\n      y: n.vy / mass,\n      z: n.vz / mass,\n    };\n  });\n  return accMap;\n}\n\nfunction accumulate(treeNode: any) {\n  let accWeight = 0;\n  let accX = 0;\n  let accY = 0;\n  let accZ = 0;\n  const numChildren = treeNode.length;\n\n  if (numChildren) {\n    // internal node, accumulate 4 child quads\n    for (let i = 0; i < numChildren; i++) {\n      const q = treeNode[i];\n      if (q && q.weight) {\n        accWeight += q.weight;\n        accX += q.x * q.weight;\n        accY += q.y * q.weight;\n        accZ += q.z * q.weight;\n      }\n    }\n    treeNode.x = accX / accWeight;\n    treeNode.y = accY / accWeight;\n    treeNode.z = accZ / accWeight;\n    treeNode.weight = accWeight;\n  } else {\n    // leaf node\n    const q = treeNode;\n    treeNode.x = q.data.x;\n    treeNode.y = q.data.y;\n    treeNode.z = q.data.z;\n    treeNode.weight = q.data.weight;\n  }\n}\n\nconst apply = (\n  treeNode: any,\n  x1: number,\n  arg1: number,\n  arg2: number,\n  arg3: number,\n  node: InternalNode,\n  dimensions: number,\n) => {\n  const x2 = [arg1, arg2, arg3][dimensions - 1];\n\n  const dx = node.x - treeNode.x || epsilon;\n  const dy = node.y - treeNode.y || epsilon;\n  const dz = node.z - treeNode.z || epsilon;\n  const width = x2 - x1;\n  const len2 = dx * dx + dy * dy + dz * dz;\n  const len3 = Math.sqrt(len2) * len2;\n\n  // far node, apply Barnes-Hut approximation\n  if (width * width * theta2 < len2) {\n    const param = treeNode.weight / len3;\n    node.vx += dx * param;\n    node.vy += dy * param;\n    node.vz += dz * param;\n    return true;\n  }\n  // near quad, compute force directly\n  if (treeNode.length) return false; // internal node, visit children\n\n  // leaf node\n\n  if (treeNode.data !== node) {\n    const param = treeNode.data.weight / len3;\n    node.vx += dx * param;\n    node.vy += dy * param;\n    node.vz += dz * param;\n  }\n};\n\n// @ts-ignore\nfunction computeForce(node: InternalNode, tree: any, dimensions: number) {\n  // @ts-ignore\n  tree.visit((treeNode, x1, y1, x2, y2) => apply(treeNode, x1, y1, x2, y2, node, dimensions));\n}\n","import { Graph as IGraph } from \"@antv/graphlib\";\nimport { isNumber, isObject } from \"@antv/util\";\nimport {\n  Graph,\n  Node,\n  Edge,\n  LayoutMapping,\n  ForceLayoutOptions,\n  Point,\n  OutNode,\n  LayoutWithIterations,\n} from \"../types\";\nimport { formatNumberFn, isArray } from \"../util\";\nimport { forceNBody } from \"./forceNBody\";\nimport {\n  CalcNode,\n  CalcEdge,\n  CalcNodeData,\n  CalcEdgeData,\n  CalcGraph,\n  FormatedOptions,\n} from \"./types\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<ForceLayoutOptions> = {\n  dimensions: 2,\n  maxIteration: 500,\n  gravity: 10,\n  factor: 1,\n  edgeStrength: 200,\n  nodeStrength: 1000,\n  coulombDisScale: 0.005,\n  damping: 0.9,\n  maxSpeed: 500,\n  minMovement: 0.4,\n  interval: 0.02,\n  linkDistance: 200,\n  clusterNodeStrength: 20,\n  preventOverlap: true,\n  distanceThresholdMode: \"mean\",\n};\n\n/**\n * Layout with faster force\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new ForceLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new ForceLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { center: [100, 100] });\n */\nexport class ForceLayout implements LayoutWithIterations<ForceLayoutOptions> {\n  id = \"force\";\n  /**\n   * time interval for layout force animations\n   */\n  private timeInterval: number = 0;\n  /**\n   * compare with minMovement to end the nodes' movement\n   */\n  private judgingDistance: number = 0;\n\n  private running: boolean = false;\n  private lastLayoutNodes: OutNode[];\n  private lastLayoutEdges: Edge[];\n  private lastAssign: boolean;\n  private lastCalcGraph: IGraph<CalcNodeData, CalcEdgeData>;\n  private lastGraph: Graph;\n  private lastOptions: FormatedOptions;\n  private lastVelMap: {\n    [id: string]: Point;\n  };\n  private lastResult: LayoutMapping;\n\n  constructor(public options: ForceLayoutOptions = {} as ForceLayoutOptions) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: ForceLayoutOptions) {\n    return this.genericForceLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: ForceLayoutOptions) {\n    this.genericForceLayout(true, graph, options);\n  }\n\n  /**\n   * Stop simulation immediately.\n   */\n  stop() {\n    if (this.timeInterval && typeof window !== \"undefined\") {\n      window.clearInterval(this.timeInterval);\n    }\n    this.running = false;\n  }\n\n  /**\n   * Manually steps the simulation by the specified number of iterations.\n   * @see https://github.com/d3/d3-force#simulation_tick\n   */\n  tick(iterations = this.options.maxIteration || 1) {\n    if (this.lastResult) {\n      return this.lastResult;\n    }\n\n    for (\n      let i = 0;\n      (this.judgingDistance > this.lastOptions.minMovement || i < 1) &&\n      i < iterations;\n      i++\n    ) {\n      this.runOneStep(\n        this.lastCalcGraph,\n        this.lastGraph,\n        i,\n        this.lastVelMap,\n        this.lastOptions\n      );\n      this.updatePosition(\n        this.lastGraph,\n        this.lastCalcGraph,\n        this.lastVelMap,\n        this.lastOptions\n      );\n    }\n\n    const result = {\n      nodes: this.lastLayoutNodes,\n      edges: this.lastLayoutEdges,\n    };\n\n    if (this.lastAssign) {\n      result.nodes.forEach((node) =>\n        this.lastGraph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n          z: this.options.dimensions === 3 ? node.data.z : undefined\n        })\n      );\n    }\n\n    return result;\n  }\n\n  private async genericForceLayout(\n    assign: false,\n    graph: Graph,\n    options?: ForceLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericForceLayout(\n    assign: true,\n    graph: Graph,\n    options?: ForceLayoutOptions\n  ): Promise<void>;\n  private async genericForceLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: ForceLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n\n    const nodes = graph.getAllNodes();\n    const edges = graph.getAllEdges();\n\n    const formattedOptions = this.formatOptions(mergedOptions, graph);\n    const {\n      dimensions,\n      width,\n      height,\n      nodeSize,\n      getMass,\n      nodeStrength,\n      edgeStrength,\n      linkDistance,\n    } = formattedOptions;\n\n    // clones the original data and attaches calculation attributes for this layout algorithm\n    const layoutNodes: CalcNode[] = nodes.map(\n      (node, i) =>\n        ({\n          ...node,\n          data: {\n            ...node.data,\n            // ...randomDistribution(node, dimensions, 30, i),\n            x: isNumber(node.data.x) ? node.data.x : Math.random() * width,\n            y: isNumber(node.data.y) ? node.data.y : Math.random() * height,\n            z: isNumber(node.data.z) ? node.data.z : Math.random() * Math.sqrt(width * height),\n            size: nodeSize(node) || 30,\n            mass: getMass(node),\n            nodeStrength: nodeStrength(node),\n          },\n        } as CalcNode)\n    );\n    const layoutEdges: CalcEdge[] = edges.map((edge) => ({\n      ...edge,\n      data: {\n        ...edge.data,\n        edgeStrength: edgeStrength(edge),\n        linkDistance: linkDistance(\n          edge,\n          graph.getNode(edge.source),\n          graph.getNode(edge.target)\n        ),\n      },\n    }));\n\n    if (!nodes?.length) {\n      this.lastResult = { nodes: [], edges };\n      return { nodes: [], edges };\n    }\n\n    const velMap: { [id: string]: Point } = {};\n    nodes.forEach((node, i) => {\n      velMap[node.id] = {\n        x: 0,\n        y: 0,\n        z: 0,\n      };\n    });\n\n    const calcGraph = new IGraph<CalcNodeData, CalcEdgeData>({\n      nodes: layoutNodes,\n      edges: layoutEdges,\n    });\n\n    this.formatCentripetal(formattedOptions, calcGraph);\n\n    const { maxIteration, minMovement, onTick } = formattedOptions;\n\n    // Use them later in `tick`.\n    this.lastLayoutNodes = layoutNodes;\n    this.lastLayoutEdges = layoutEdges;\n    this.lastAssign = assign;\n    this.lastGraph = graph;\n    this.lastCalcGraph = calcGraph;\n    this.lastOptions = formattedOptions;\n    this.lastVelMap = velMap;\n\n    if (typeof window === \"undefined\") return;\n    let iter = 0;\n\n    return new Promise((resolve) => {\n      // interval for render the result after each iteration\n      this.timeInterval = window.setInterval(() => {\n        if (!nodes || !this.running) {\n          resolve({\n            nodes: formatOutNodes(graph, layoutNodes),\n            edges,\n          });\n        }\n        this.runOneStep(calcGraph, graph, iter, velMap, formattedOptions);\n        this.updatePosition(graph, calcGraph, velMap, formattedOptions);\n        if (assign) {\n          layoutNodes.forEach((node) =>\n            graph.mergeNodeData(node.id, {\n              x: node.data.x,\n              y: node.data.y,\n              z: dimensions === 3 ? node.data.z : undefined\n            })\n          );\n        }\n        onTick?.({\n          nodes: formatOutNodes(graph, layoutNodes),\n          edges,\n        });\n        iter++;\n        if (iter >= maxIteration || this.judgingDistance < minMovement) {\n          window.clearInterval(this.timeInterval);\n\n          resolve({\n            nodes: formatOutNodes(graph, layoutNodes),\n            edges,\n          });\n        }\n      }, 0);\n      this.running = true;\n    });\n  }\n\n  /**\n   * Format merged layout options.\n   * @param options merged layout options\n   * @param graph original graph\n   * @returns\n   */\n  private formatOptions(\n    options: ForceLayoutOptions,\n    graph: Graph\n  ): FormatedOptions {\n    const formattedOptions = options as FormatedOptions;\n    const { width: propsWidth, height: propsHeight, getMass } = options;\n\n    // === formating width, height, and center =====\n    formattedOptions.width =\n      !propsWidth && typeof window !== \"undefined\"\n        ? window.innerWidth\n        : (propsWidth as number);\n    formattedOptions.height =\n      !propsHeight && typeof window !== \"undefined\"\n        ? window.innerHeight\n        : (propsHeight as number);\n    if (!options.center) {\n      formattedOptions.center = [\n        formattedOptions.width / 2,\n        formattedOptions.height / 2,\n      ];\n    }\n\n    // === formating node mass =====\n    if (!getMass) {\n      formattedOptions.getMass = (d?: Node) => {\n        let massWeight = 1;\n        if (isNumber(d?.data.mass)) massWeight = d?.data.mass as number;\n        const degree = graph.getDegree(d!.id, \"both\");\n        return !degree || degree < 5 ? massWeight : degree * 5 * massWeight;\n      };\n    }\n\n    // === formating node size =====\n    if (options.preventOverlap) {\n      const nodeSpacingFunc = formatNumberFn<Node>(0, options.nodeSpacing);\n      if (!options.nodeSize) {\n        formattedOptions.nodeSize = (d?: Node) => {\n          const { size } = d?.data || {};\n          if (size) {\n            if (isArray(size)) {\n              return Math.max(size[0], size[1]) + nodeSpacingFunc(d);\n            }\n            if (isObject<{ width: number; height: number }>(size)) {\n              return Math.max(size.width, size.height) + nodeSpacingFunc(d);\n            }\n            return (size as number) + nodeSpacingFunc(d);\n          }\n          return 10 + nodeSpacingFunc(d);\n        };\n      } else if (isArray(options.nodeSize)) {\n        formattedOptions.nodeSize = (d?: Node) => {\n          const nodeSize = options.nodeSize as [number, number];\n          return Math.max(nodeSize[0], nodeSize[1]) + nodeSpacingFunc(d);\n        };\n      } else {\n        formattedOptions.nodeSize = (d?: Node) =>\n          (options.nodeSize as number) + nodeSpacingFunc(d);\n      }\n    }\n\n    // === formating node / edge strengths =====\n    formattedOptions.linkDistance = options.linkDistance\n      ? formatNumberFn(1, options.linkDistance)\n      : (edge?: Edge) =>\n          1 +\n          formattedOptions.nodeSize(graph.getNode(edge!.source)) +\n          formattedOptions.nodeSize(graph.getNode(edge!.target));\n    formattedOptions.nodeStrength = formatNumberFn(1, options.nodeStrength);\n    formattedOptions.edgeStrength = formatNumberFn(1, options.edgeStrength);\n\n    return options as FormatedOptions;\n  }\n\n  /**\n   * Format centripetalOption in the option.\n   * @param options merged layout options\n   * @param calcGraph calculation graph\n   */\n  private formatCentripetal(options: FormatedOptions, calcGraph: CalcGraph) {\n    const {\n      dimensions,\n      centripetalOptions,\n      center,\n      clusterNodeStrength,\n      leafCluster,\n      clustering,\n      nodeClusterBy,\n    } = options;\n    const calcNodes = calcGraph.getAllNodes();\n    // === formating centripetalOptions =====\n    const basicCentripetal = centripetalOptions || {\n      leaf: 2,\n      single: 2,\n      others: 1,\n      // eslint-disable-next-line\n      center: (n: any) => {\n        return {\n          x: center[0],\n          y: center[1],\n          z: dimensions === 3 ? center[2] : undefined\n        };\n      },\n    };\n    if (typeof clusterNodeStrength !== \"function\") {\n      options.clusterNodeStrength = (node?: Node) =>\n        clusterNodeStrength as number;\n    }\n    let sameTypeLeafMap: any;\n    let clusters: string[] = [];\n    if (leafCluster && nodeClusterBy) {\n      sameTypeLeafMap = getSameTypeLeafMap(calcGraph, nodeClusterBy);\n      clusters =\n        Array.from(\n          new Set(calcNodes?.map((node) => node.data[nodeClusterBy] as string))\n        ) || [];\n      // @ts-ignore\n      options.centripetalOptions = Object.assign(basicCentripetal, {\n        single: 100,\n        leaf: (node: Node) => {\n          // 找出与它关联的边的起点或终点出发的所有一度节点中同类型的叶子节点\n          const { siblingLeaves, sameTypeLeaves } =\n            sameTypeLeafMap[node.id] || {};\n          // 如果都是同一类型或者每种类型只有1个，则施加默认向心力\n          if (\n            sameTypeLeaves?.length === siblingLeaves?.length ||\n            clusters?.length === 1\n          ) {\n            return 1;\n          }\n          return options.clusterNodeStrength(node);\n        },\n        others: 1,\n        center: (node: Node) => {\n          const degree = calcGraph.getDegree(node.id, \"both\");\n          // 孤点默认给1个远离的中心点\n          if (!degree) {\n            return {\n              x: 100,\n              y: 100,\n              z: 0,\n            };\n          }\n          let centerPos: Point | undefined;\n          if (degree === 1) {\n            // 如果为叶子节点\n            // 找出与它关联的边的起点出发的所有一度节点中同类型的叶子节点\n            const { sameTypeLeaves = [] } = sameTypeLeafMap[node.id] || {};\n            if (sameTypeLeaves.length === 1) {\n              // 如果同类型的叶子节点只有1个，中心位置为undefined\n              centerPos = undefined;\n            } else if (sameTypeLeaves.length > 1) {\n              // 找出同类型节点平均位置作为中心\n              centerPos = getAvgNodePosition(sameTypeLeaves);\n            }\n          } else {\n            centerPos = undefined;\n          }\n          return {\n            x: centerPos?.x!,\n            y: centerPos?.y!,\n            z: centerPos?.z!,\n          };\n        },\n      });\n    }\n    if (clustering && nodeClusterBy) {\n      if (!sameTypeLeafMap) {\n        sameTypeLeafMap = getSameTypeLeafMap(calcGraph, nodeClusterBy);\n      }\n      if (!clusters) {\n        clusters = Array.from(\n          new Set(\n            calcNodes.map((node: Node) => node.data[nodeClusterBy] as string)\n          )\n        );\n      }\n      clusters = clusters.filter((item) => item !== undefined);\n\n      const centerInfo: { [key: string]: Point } = {};\n      clusters.forEach((cluster) => {\n        const sameTypeNodes = calcNodes\n          .filter((node) => node.data[nodeClusterBy] === cluster)\n          .map((node) => calcGraph.getNode(node.id));\n        // 找出同类型节点平均位置节点的距离最近的节点作为中心节点\n        centerInfo[cluster] = getAvgNodePosition(sameTypeNodes);\n      });\n      options.centripetalOptions = Object.assign(basicCentripetal, {\n        single: (node: Node) => options.clusterNodeStrength(node),\n        leaf: (node: Node) => options.clusterNodeStrength(node),\n        others: (node: Node) => options.clusterNodeStrength(node),\n        center: (node: Node) => {\n          // 找出同类型节点平均位置节点的距离最近的节点作为中心节点\n          const centerPos = centerInfo[node.data[nodeClusterBy] as string];\n          return {\n            x: centerPos?.x!,\n            y: centerPos?.y!,\n            z: centerPos?.z!,\n          };\n        },\n      });\n    }\n    const { leaf, single, others } = options.centripetalOptions || {};\n    if (leaf && typeof leaf !== \"function\") {\n      options.centripetalOptions.leaf = () => leaf;\n    }\n    if (single && typeof single !== \"function\") {\n      options.centripetalOptions.single = () => single;\n    }\n    if (others && typeof others !== \"function\") {\n      options.centripetalOptions.others = () => others;\n    }\n  }\n\n  /**\n   * One iteration.\n   * @param calcGraph calculation graph\n   * @param graph origin graph\n   * @param iter current iteration index\n   * @param velMap nodes' velocity map\n   * @param options formatted layout options\n   * @returns\n   */\n  private runOneStep(\n    calcGraph: CalcGraph,\n    graph: Graph,\n    iter: number,\n    velMap: { [id: string]: Point },\n    options: FormatedOptions\n  ) {\n    const accMap: { [id: string]: Point } = {};\n    const calcNodes = calcGraph.getAllNodes();\n    const calcEdges = calcGraph.getAllEdges();\n    if (!calcNodes?.length) return;\n    const { monitor } = options;\n    this.calRepulsive(calcGraph, accMap, options);\n    if (calcEdges) this.calAttractive(calcGraph, accMap, options);\n    this.calGravity(calcGraph, graph, accMap, options);\n    this.updateVelocity(calcGraph, accMap, velMap, options);\n\n    /** 如果需要监控信息，则提供给用户 */\n    if (monitor) {\n      const energy = this.calTotalEnergy(accMap, calcNodes);\n      monitor({\n        energy,\n        nodes: graph.getAllNodes(),\n        edges: graph.getAllEdges(),\n        iterations: iter,\n      });\n    }\n  }\n\n  /**\n   * Calculate graph energy for monitoring convergence.\n   * @param accMap acceleration map\n   * @param nodes calculation nodes\n   * @returns energy\n   */\n  private calTotalEnergy(accMap: { [id: string]: Point }, nodes: CalcNode[]) {\n    if (!nodes?.length) return 0;\n    let energy = 0.0;\n\n    nodes.forEach((node, i) => {\n      const vx = accMap[node.id].x;\n      const vy = accMap[node.id].y;\n      const vz = this.options.dimensions === 3 ? accMap[node.id].z : 0;\n      const speed2 = vx * vx + vy * vy + vz * vz;\n      const { mass = 1 } = node.data;\n      energy += mass * speed2 * 0.5; // p = 1/2*(mv^2)\n    });\n\n    return energy;\n  }\n\n  /**\n   * Calculate the repulsive forces according to coulombs law.\n   * @param calcGraph calculation graph\n   * @param accMap acceleration map\n   * @param options formatted layout options\n   */\n  public calRepulsive(\n    calcGraph: CalcGraph,\n    accMap: { [id: string]: Point },\n    options: FormatedOptions\n  ) {\n    const { dimensions, factor, coulombDisScale } = options;\n    forceNBody(calcGraph, factor, coulombDisScale * coulombDisScale, accMap, dimensions);\n  }\n\n  /**\n   * Calculate the attractive forces according to hooks law.\n   * @param calcGraph calculation graph\n   * @param accMap acceleration map\n   */\n  public calAttractive(calcGraph: CalcGraph, accMap: { [id: string]: Point }, options: FormatedOptions) {\n    const { dimensions } = options;\n    calcGraph.getAllEdges().forEach((edge, i) => {\n      const { source, target } = edge;\n      const sourceNode = calcGraph.getNode(source);\n      const targetNode = calcGraph.getNode(target);\n      if (!sourceNode || !targetNode) return;\n      let vecX = targetNode.data.x - sourceNode.data.x;\n      let vecY = targetNode.data.y - sourceNode.data.y;\n      let vecZ = dimensions === 3 ? targetNode.data.z - sourceNode.data.z : 0;\n      if (!vecX && !vecY) {\n        vecX = Math.random() * 0.01;\n        vecY = Math.random() * 0.01;\n\n        if (dimensions === 3 && !vecZ) {\n          vecZ = Math.random() * 0.01;\n        }\n      }\n      const vecLength = Math.sqrt(vecX * vecX + vecY * vecY + vecZ * vecZ);\n      const direX = vecX / vecLength;\n      const direY = vecY / vecLength;\n      const direZ = vecZ / vecLength;\n      const { linkDistance = 200, edgeStrength = 200 } = edge.data || {};\n      const diff = linkDistance - vecLength;\n      const param = diff * edgeStrength;\n      const massSource = sourceNode.data.mass || 1;\n      const massTarget = targetNode.data.mass || 1;\n      // 质量占比越大，对另一端影响程度越大\n      const sourceMassRatio = 1 / massSource;\n      const targetMassRatio = 1 / massTarget;\n      const disX = direX * param;\n      const disY = direY * param;\n      const disZ = direZ * param;\n      accMap[source].x -= disX * sourceMassRatio;\n      accMap[source].y -= disY * sourceMassRatio;\n      accMap[source].z -= disZ * sourceMassRatio;\n      accMap[target].x += disX * targetMassRatio;\n      accMap[target].y += disY * targetMassRatio;\n      accMap[target].z += disZ * targetMassRatio;\n    });\n  }\n\n  /**\n   * Calculate the gravity forces toward center.\n   * @param calcGraph calculation graph\n   * @param graph origin graph\n   * @param accMap acceleration map\n   * @param options formatted layout options\n   */\n  public calGravity(\n    calcGraph: CalcGraph,\n    graph: Graph,\n    accMap: { [id: string]: Point },\n    options: FormatedOptions\n  ) {\n    const { getCenter } = options;\n    const calcNodes = calcGraph.getAllNodes();\n    const nodes = graph.getAllNodes();\n    const edges = graph.getAllEdges();\n    const {\n      width,\n      height,\n      center,\n      gravity: defaultGravity,\n      centripetalOptions,\n    } = options;\n    if (!calcNodes) return;\n    calcNodes.forEach((calcNode) => {\n      const { id, data } = calcNode;\n      const { mass, x, y, z } = data;\n      const node = graph.getNode(id);\n      let vecX = 0;\n      let vecY = 0;\n      let vecZ = 0;\n      let gravity = defaultGravity;\n      const inDegree = calcGraph.getDegree(id, \"in\");\n      const outDegree = calcGraph.getDegree(id, \"out\");\n      const degree = calcGraph.getDegree(id, \"both\");\n      const forceCenter = getCenter?.(node, degree);\n      if (forceCenter) {\n        const [centerX, centerY, strength] = forceCenter;\n        vecX = x - centerX;\n        vecY = y - centerY;\n        gravity = strength;\n      } else {\n        vecX = x - center[0];\n        vecY = y - center[1];\n        vecZ = z - center[2];\n      }\n\n      if (gravity) {\n        accMap[id].x -= (gravity * vecX) / mass;\n        accMap[id].y -= (gravity * vecY) / mass;\n        accMap[id].z -= (gravity * vecZ) / mass;\n      }\n\n      if (centripetalOptions) {\n        const {\n          leaf,\n          single,\n          others,\n          center: centriCenter,\n        } = centripetalOptions;\n        const {\n          x: centriX,\n          y: centriY,\n          z: centriZ,\n          centerStrength,\n        } = centriCenter?.(node, nodes, edges, width, height) || {\n          x: 0,\n          y: 0,\n          z: 0,\n          centerStrength: 0,\n        };\n        if (!isNumber(centriX) || !isNumber(centriY)) return;\n        const vx = (x - centriX) / mass;\n        const vy = (y - centriY) / mass;\n        const vz = (z - centriZ) / mass;\n        if (centerStrength) {\n          accMap[id].x -= centerStrength * vx;\n          accMap[id].y -= centerStrength * vy;\n          accMap[id].z -= centerStrength * vz;\n        }\n\n        // 孤点\n        if (degree === 0) {\n          const singleStrength = single(node);\n          if (!singleStrength) return;\n          accMap[id].x -= singleStrength * vx;\n          accMap[id].y -= singleStrength * vy;\n          accMap[id].z -= singleStrength * vz;\n          return;\n        }\n\n        // 没有出度或没有入度，都认为是叶子节点\n        if (inDegree === 0 || outDegree === 0) {\n          const leafStrength = leaf(node, nodes, edges);\n          if (!leafStrength) return;\n          accMap[id].x -= leafStrength * vx;\n          accMap[id].y -= leafStrength * vy;\n          accMap[id].z -= leafStrength * vz;\n          return;\n        }\n\n        /** others */\n        const othersStrength = others(node);\n        if (!othersStrength) return;\n        accMap[id].x -= othersStrength * vx;\n        accMap[id].y -= othersStrength * vy;\n        accMap[id].z -= othersStrength * vz;\n      }\n    });\n  }\n\n  /**\n   * Update the velocities for nodes.\n   * @param calcGraph calculation graph\n   * @param accMap acceleration map\n   * @param velMap velocity map\n   * @param options formatted layout options\n   * @returns\n   */\n  public updateVelocity(\n    calcGraph: CalcGraph,\n    accMap: { [id: string]: Point },\n    velMap: { [id: string]: Point },\n    options: FormatedOptions\n  ) {\n    const { damping, maxSpeed, interval, dimensions } = options;\n    const calcNodes = calcGraph.getAllNodes();\n    if (!calcNodes?.length) return;\n    calcNodes.forEach((calcNode) => {\n      const { id } = calcNode;\n      let vx = (velMap[id].x + accMap[id].x * interval) * damping || 0.01;\n      let vy = (velMap[id].y + accMap[id].y * interval) * damping || 0.01;\n      let vz = dimensions === 3 ? ((velMap[id].z + accMap[id].z * interval) * damping || 0.01) : 0.0;\n      const vLength = Math.sqrt(vx * vx + vy * vy + vz * vz);\n      if (vLength > maxSpeed) {\n        const param2 = maxSpeed / vLength;\n        vx = param2 * vx;\n        vy = param2 * vy;\n        vz = param2 * vz;\n      }\n      velMap[id] = {\n        x: vx,\n        y: vy,\n        z: vz\n      };\n    });\n  }\n\n  /**\n   * Update nodes' positions.\n   * @param graph origin graph\n   * @param calcGraph calculatition graph\n   * @param velMap velocity map\n   * @param options formatted layou options\n   * @returns\n   */\n  public updatePosition(\n    graph: Graph,\n    calcGraph: CalcGraph,\n    velMap: { [id: string]: Point },\n    options: FormatedOptions\n  ) {\n    const { distanceThresholdMode, interval, dimensions } = options;\n    const calcNodes = calcGraph.getAllNodes();\n    if (!calcNodes?.length) {\n      this.judgingDistance = 0;\n      return;\n    }\n    let sum = 0;\n    if (distanceThresholdMode === \"max\") this.judgingDistance = -Infinity;\n    else if (distanceThresholdMode === \"min\") this.judgingDistance = Infinity;\n\n    calcNodes.forEach((calcNode: CalcNode) => {\n      const { id } = calcNode;\n      const node = graph.getNode(id);\n      if (isNumber(node.data.fx) && isNumber(node.data.fy)) {\n        calcGraph.mergeNodeData(id, {\n          x: node.data.fx,\n          y: node.data.fy,\n          z: dimensions === 3 ? node.data.fz as number : undefined,\n        });\n        return;\n      }\n      const distX = velMap[id].x * interval;\n      const distY = velMap[id].y * interval;\n      const distZ = dimensions === 3 ? velMap[id].z * interval : 0.0;\n      calcGraph.mergeNodeData(id, {\n        x: calcNode.data.x + distX,\n        y: calcNode.data.y + distY,\n        z: calcNode.data.z + distZ,\n      });\n\n      const distanceMagnitude = Math.sqrt(distX * distX + distY * distY + distZ * distZ);\n      switch (distanceThresholdMode) {\n        case \"max\":\n          if (this.judgingDistance < distanceMagnitude) {\n            this.judgingDistance = distanceMagnitude;\n          }\n          break;\n        case \"min\":\n          if (this.judgingDistance > distanceMagnitude) {\n            this.judgingDistance = distanceMagnitude;\n          }\n          break;\n        default:\n          sum = sum + distanceMagnitude;\n          break;\n      }\n    });\n    if (!distanceThresholdMode || distanceThresholdMode === \"mean\") {\n      this.judgingDistance = sum / calcNodes.length;\n    }\n  }\n}\n\ntype SameTypeLeafMap = {\n  [nodeId: string]: {\n    coreNode: Node;\n    siblingLeaves: Node[];\n    sameTypeLeaves: Node[];\n  };\n};\n\n/**\n * Group the leaf nodes according to nodeClusterBy field.\n * @param calcGraph calculation graph\n * @param nodeClusterBy the field name in node.data to ditinguish different node clusters\n * @returns related same group leaf nodes for each leaf node\n */\nconst getSameTypeLeafMap = (\n  calcGraph: CalcGraph,\n  nodeClusterBy: string\n): SameTypeLeafMap => {\n  const calcNodes = calcGraph.getAllNodes();\n  if (!calcNodes?.length) return {};\n  const sameTypeLeafMap: SameTypeLeafMap = {};\n  calcNodes.forEach((node, i) => {\n    const degree = calcGraph.getDegree(node.id, \"both\");\n    if (degree === 1) {\n      sameTypeLeafMap[node.id] = getCoreNodeAndSiblingLeaves(\n        calcGraph,\n        \"leaf\",\n        node,\n        nodeClusterBy\n      );\n    }\n  });\n  return sameTypeLeafMap;\n};\n\n/**\n * Find the successor or predecessor of node as coreNode, the sibling leaf nodes\n * @param calcGraph calculation graph\n * @param type ('all') filter out the not-same-cluster nodes, ('leaf') or filter out the not-leaf nodes in the same time\n * @param node the target node\n * @param nodeClusterBy the field name in node.data to ditinguish different node clusters\n * @returns coreNode, sibling leaf nodes, and grouped sibling leaf nodes\n */\nconst getCoreNodeAndSiblingLeaves = (\n  calcGraph: CalcGraph,\n  type: \"leaf\" | \"all\",\n  node: Node,\n  nodeClusterBy: string\n): {\n  coreNode: Node;\n  siblingLeaves: Node[];\n  sameTypeLeaves: Node[];\n} => {\n  const inDegree = calcGraph.getDegree(node.id, \"in\");\n  const outDegree = calcGraph.getDegree(node.id, \"out\");\n  // node is not a leaf, coreNode is itself, siblingLeaves is empty\n  let coreNode: Node = node;\n  let siblingLeaves: Node[] = [];\n  if (inDegree === 0) {\n    // node is a leaf node without out edges, its related(successor) node is coreNode, siblingLeaves is the neighbors of its related node\n    coreNode = calcGraph.getSuccessors(node.id)[0];\n    siblingLeaves = calcGraph.getNeighbors(coreNode.id);\n  } else if (outDegree === 0) {\n    // node is a leaf node without in edges, its related(predecessor) node is coreNode, siblingLeaves is the neighbors of its related node\n    coreNode = calcGraph.getPredecessors(node.id)[0];\n    siblingLeaves = calcGraph.getNeighbors(coreNode.id);\n  }\n  // siblingLeaves are leaf nodes\n  siblingLeaves = siblingLeaves.filter(\n    (node) =>\n      calcGraph.getDegree(node.id, \"in\") === 0 ||\n      calcGraph.getDegree(node.id, \"out\") === 0\n  );\n  const sameTypeLeaves = getSameTypeNodes(\n    calcGraph,\n    type,\n    nodeClusterBy,\n    node,\n    siblingLeaves\n  );\n  return { coreNode, siblingLeaves, sameTypeLeaves };\n};\n\n/**\n * Find the same type (according to nodeClusterBy field) of node in relativeNodes.\n * @param calcGraph calculation graph\n * @param type ('all') filter out the not-same-cluster nodes, ('leaf') or filter out the not-leaf nodes in the same time\n * @param nodeClusterBy the field name in node.data to ditinguish different node clusters\n * @param node the target node\n * @param relativeNodes node's related ndoes to be filtered\n * @returns related nodes that meet the filtering conditions\n */\nconst getSameTypeNodes = (\n  calcGraph: CalcGraph,\n  type: \"leaf\" | \"all\",\n  nodeClusterBy: string,\n  node: Node,\n  relativeNodes: Node[]\n) => {\n  const typeName = node.data[nodeClusterBy] || \"\";\n  let sameTypeNodes =\n    relativeNodes?.filter((item) => item.data[nodeClusterBy] === typeName) ||\n    [];\n  if (type === \"leaf\") {\n    sameTypeNodes = sameTypeNodes.filter(\n      (item) =>\n        calcGraph.getDegree(item.id, \"in\") === 0 ||\n        calcGraph.getDegree(item.id, \"out\") === 0\n    );\n  }\n  return sameTypeNodes;\n};\n\n/**\n * Get the average position of nodes.\n * @param nodes nodes set\n * @returns average ppsition\n */\nconst getAvgNodePosition = (nodes: CalcNode[]): Point => {\n  const totalNodes = { x: 0, y: 0 };\n  nodes.forEach((node) => {\n    const { x, y } = node.data;\n    totalNodes.x += x || 0;\n    totalNodes.y += y || 0;\n  });\n  // 获取均值向量\n  const length = nodes.length || 1;\n  return {\n    x: totalNodes.x / length,\n    y: totalNodes.y / length,\n  };\n};\n\n/**\n * Format the output nodes from CalcNode[].\n * @param graph origin graph\n * @param layoutNodes calculation nodes\n * @returns output nodes\n */\nconst formatOutNodes = (graph: Graph, layoutNodes: CalcNode[]): OutNode[] =>\n  layoutNodes.map((calcNode) => {\n    const { id, data } = calcNode;\n    const node = graph.getNode(id);\n    return {\n      ...node,\n      data: {\n        ...node.data,\n        x: data.x,\n        y: data.y,\n        z: data.z\n      },\n    } as OutNode;\n  });\n","import Quad from './quad';\n\n/**\n * @fileOverview body\n * @author shiwu.wyy@antfin.com\n */\n\ntype BodyProps = {\n  id?: Number;\n  rx: number;\n  ry: number;\n  fx?: number;\n  fy?: number;\n  mass: number;\n  degree: number;\n  g?: number;\n};\n\n// represents a body(a point mass) and its position\nexport default class Body {\n  public id: Number;\n  public rx: number;\n  public ry: number;\n  public fx: number;\n  public fy: number;\n  public mass: number;\n  public degree: number;\n  public g: number;\n  \n  constructor(params: BodyProps) {\n    /**\n     * the id of this body, the same with the node id\n     * @type  {number}\n     */\n    this.id = params.id || 0;\n    /**\n     * the position of this body\n     * @type  {number}\n     */\n    this.rx = params.rx;\n    /**\n     * the position of this body\n     * @type  {number}\n     */\n    this.ry = params.ry;\n    /**\n     * the force acting on this body\n     * @type  {number}\n     */\n    this.fx = 0;\n    /**\n     * the force acting on this body\n     * @type  {number}\n     */\n    this.fy = 0;\n    /**\n     * the mass of this body, =1 for a node\n     * @type  {number}\n     */\n    this.mass = params.mass;\n    /**\n     * the degree of the node represented by this body\n     * @type  {number}\n     */\n    this.degree = params.degree;\n    /**\n     * the parameter for repulsive force, = kr\n     * @type  {number}\n     */\n    this.g = params.g || 0;\n  }\n  // returns the euclidean distance\n  distanceTo(bo: Body) {\n    const dx = this.rx - bo.rx;\n    const dy = this.ry - bo.ry;\n    return Math.hypot(dx, dy);\n  }\n  setPos(x: number, y: number) {\n    this.rx = x;\n    this.ry = y;\n  }\n  // resets the forces\n  resetForce() {\n    this.fx = 0;\n    this.fy = 0;\n  }\n  addForce(b: Body) {\n    const dx = b.rx - this.rx;\n    const dy = b.ry - this.ry;\n    let dist = Math.hypot(dx, dy);\n    dist = dist < 0.0001 ? 0.0001 : dist;\n    // the repulsive defined by force atlas 2\n    const F = (this.g * (this.degree + 1) * (b.degree + 1)) / dist;\n    this.fx += F * dx / dist;\n    this.fy += F * dy / dist;\n  }\n  // if quad contains this body\n  in(quad: Quad) {\n    return quad.contains(this.rx, this.ry);\n  }\n  // returns a new body\n  add(bo: Body) {\n    const nenwMass = this.mass + bo.mass;\n    const x = (this.rx * this.mass + bo.rx * bo.mass) / nenwMass;\n    const y = (this.ry * this.mass + bo.ry * bo.mass) / nenwMass;\n    const dg = this.degree + bo.degree;\n    const params: BodyProps = {\n      rx: x,\n      ry: y,\n      mass: nenwMass,\n      degree: dg\n    };\n    return new Body(params);\n  }\n}","import { PointTuple } from \"../types\";\n\n/**\n * @fileOverview quad\n * @author shiwu.wyy@antfin.com\n */\n\ntype QuadProps = {\n  xmid: number;\n  ymid: number;\n  length: number;\n  massCenter?: PointTuple;\n  mass?: number;\n};\n\nexport default class Quad {\n  public xmid: number;\n  public ymid: number;\n  public length: number;\n  public massCenter: PointTuple;\n  public mass: number;\n  constructor(params: QuadProps) {\n    /**\n     * the center position of this quad\n     * @type  {number}\n     */\n    this.xmid = params.xmid;\n    /**\n     * the center position of this quad\n     * @type  {number}\n     */\n    this.ymid = params.ymid;\n    /**\n     * the length of this quad\n     * @type  {number}\n     */\n    this.length = params.length;\n    /**\n     * the mass center of this quad\n     * @type  {number}\n     */\n    this.massCenter = params.massCenter || [0, 0];\n    /**\n     * the mass of this quad\n     * @type  {number}\n     */\n    this.mass = params.mass || 1;\n  }\n  getLength() {\n    return this.length;\n  }\n  contains(x: number, y: number) {\n    const halfLen = this.length / 2;\n    return (x <= this.xmid + halfLen &&\n      x >= this.xmid - halfLen &&\n      y <= this.ymid + halfLen &&\n      y >= this.ymid - halfLen);\n  }\n  // northwest quadrant\n  // tslint:disable-next-line\n  NW() {\n    const x = this.xmid - this.length / 4;\n    const y = this.ymid + this.length / 4;\n    const len = this.length / 2;\n    const params: QuadProps = {\n      xmid: x,\n      ymid: y,\n      length: len\n    };\n    const NW = new Quad(params);\n    return NW;\n  }\n  // northeast\n  // tslint:disable-next-line\n  NE() {\n    const x = this.xmid + this.length / 4;\n    const y = this.ymid + this.length / 4;\n    const len = this.length / 2;\n    const params = {\n      xmid: x,\n      ymid: y,\n      length: len\n    };\n    const NE = new Quad(params);\n    return NE;\n  }\n  // southwest\n  // tslint:disable-next-line\n  SW() {\n    const x = this.xmid - this.length / 4;\n    const y = this.ymid - this.length / 4;\n    const len = this.length / 2;\n    const params = {\n      xmid: x,\n      ymid: y,\n      length: len\n    };\n    const SW = new Quad(params);\n    return SW;\n  }\n  // southeast\n  // tslint:disable-next-line\n  SE() {\n    const x = this.xmid + this.length / 4;\n    const y = this.ymid - this.length / 4;\n    const len = this.length / 2;\n    const params = {\n      xmid: x,\n      ymid: y,\n      length: len\n    };\n    const SE = new Quad(params);\n    return SE;\n  }\n}","import Body from './body';\nimport Quad from './quad';\n\n/**\n * @fileOverview quadTree\n * @author shiwu.wyy@antfin.com\n */\n\nexport default class QuadTree {\n  public body: Body | null;\n  public quad: Quad | null;\n  public theta: number;\n  public NW: QuadTree | null;\n  public NE: QuadTree | null;\n  public SW: QuadTree | null;\n  public SE: QuadTree | null;\n\n  // each quadtree represents a quadrant and an aggregate body\n  // that represents all bodies inside the quadrant\n  constructor(param: Quad | null) {\n    /**\n     * (aggregated) body in this quad\n     * @type  {object}\n     */\n    this.body = null;\n    /**\n     * tree representing the northwest quadrant\n     * @type  {object}\n     */\n    this.quad = null;\n    this.NW = null;\n    this.NE = null;\n    this.SW = null;\n    this.SE = null;\n    /**\n     * threshold\n     * @type  {number}\n     */\n    this.theta = 0.5;\n    if (param != null) this.quad = param;\n  }\n  // insert a body(node) into the tree\n  insert(bo: Body) {\n    // if this node does not contain a body, put the new body bo here\n    if (this.body == null) {\n      this.body = bo;\n      return;\n    }\n    // internal node\n    if (!this._isExternal()) {\n      // update mass info\n      this.body = this.body.add(bo);\n      // insert body into quadrant\n      this._putBody(bo);\n    } else { // external node\n      // divide this region into four children\n      if (this.quad) {\n        this.NW = new QuadTree(this.quad.NW());\n        this.NE = new QuadTree(this.quad.NE());\n        this.SW = new QuadTree(this.quad.SW());\n        this.SE = new QuadTree(this.quad.SE());\n      }\n\n      // insert this body and bo\n      this._putBody(this.body);\n      this._putBody(bo);\n      // update the mass info\n      this.body = this.body.add(bo);\n\n    }\n  }\n  // inserts bo into a quad\n  // tslint:disable-next-line\n  _putBody(bo: Body) {\n    if (!this.quad) return;\n    if (bo.in(this.quad.NW()) && this.NW) this.NW.insert(bo);\n    else if (bo.in(this.quad.NE()) && this.NE) this.NE.insert(bo);\n    else if (bo.in(this.quad.SW()) && this.SW )this.SW.insert(bo);\n    else if (bo.in(this.quad.SE()) && this.SE) this.SE.insert(bo);\n  }\n  // tslint:disable-next-line\n  _isExternal() {\n    // four children are null\n    return (this.NW == null && this.NE == null && this.SW == null && this.SE == null);\n  }\n  // update the forces\n  updateForce(bo: Body) {\n    if (this.body == null || bo === this.body) {\n      return;\n    }\n    // if the current node is external\n    if (this._isExternal()) bo.addForce(this.body);\n    // internal nodes\n    else {\n      const s = this.quad ? this.quad.getLength() : 0;\n      const d = this.body.distanceTo(bo);\n      // b is far enough\n      if ((s / d) < this.theta) bo.addForce(this.body);\n      else {\n        this.NW && this.NW.updateForce(bo);\n        this.NE && this.NE.updateForce(bo);\n        this.SW && this.SW.updateForce(bo);\n        this.SE && this.SE.updateForce(bo);\n      }\n    }\n  }\n}","import { isFunction, isNumber, isObject } from \"@antv/util\";\nimport { Graph as GGraph } from \"@antv/graphlib\";\nimport type {\n  Graph,\n  LayoutMapping,\n  Node,\n  Edge,\n  OutNode,\n  PointTuple,\n  ForceAtlas2LayoutOptions,\n  OutNodeData,\n  EdgeData,\n  Layout,\n} from \"../types\";\nimport { cloneFormatData, isArray } from \"../util\";\nimport { handleSingleNodeGraph } from \"../util/common\";\nimport Body from \"./body\";\nimport Quad from \"./quad\";\nimport QuadTree from \"./quadTree\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<ForceAtlas2LayoutOptions> = {\n  center: [0, 0],\n  width: 300,\n  height: 300,\n  kr: 5,\n  kg: 1,\n  mode: \"normal\",\n  preventOverlap: false,\n  dissuadeHubs: false,\n  maxIteration: 0,\n  ks: 0.1,\n  ksmax: 10,\n  tao: 0.1,\n};\n\ninterface FormattedOptions extends ForceAtlas2LayoutOptions {\n  width: number;\n  height: number;\n  maxIteration: number;\n  center: PointTuple;\n  kr: number;\n  kg: number;\n  ks: number;\n  ksmax: number;\n  tao: number;\n}\ntype ForceMap = {\n  [id: string]: PointTuple;\n};\ntype BodyMap = {\n  [id: string]: Body;\n};\ntype SizeMap = { [id: string]: number };\ntype CalcGraph = GGraph<OutNodeData, EdgeData>;\n\n/**\n * Layout nodes with force atlas 2 model\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new ForceAtlas2Layout({ center: [100, 100] });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new ForceAtlas2Layout({ center: [100, 100] });\n * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { center: [100, 100] });\n */\nexport class ForceAtlas2Layout implements Layout<ForceAtlas2LayoutOptions> {\n  id = \"forceAtlas2\";\n\n  constructor(\n    public options: ForceAtlas2LayoutOptions = {} as ForceAtlas2LayoutOptions\n  ) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: ForceAtlas2LayoutOptions) {\n    return this.genericForceAtlas2Layout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: ForceAtlas2LayoutOptions) {\n    this.genericForceAtlas2Layout(true, graph, options);\n  }\n\n  private async genericForceAtlas2Layout(\n    assign: false,\n    graph: Graph,\n    options?: ForceAtlas2LayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericForceAtlas2Layout(\n    assign: true,\n    graph: Graph,\n    options?: ForceAtlas2LayoutOptions\n  ): Promise<void>;\n  private async genericForceAtlas2Layout(\n    assign: boolean,\n    graph: Graph,\n    options?: ForceAtlas2LayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const edges = graph.getAllEdges();\n    const nodes = graph.getAllNodes();\n\n    const mergedOptions = this.formatOptions(options, nodes.length);\n    const { width, height, prune, maxIteration, nodeSize, center } =\n      mergedOptions;\n\n    if (!nodes?.length || nodes.length === 1) {\n      return handleSingleNodeGraph(graph, assign, center);\n    }\n\n    const calcNodes = nodes.map(\n      (node) => cloneFormatData(node, [width, height]) as OutNode\n    );\n    const calcEdges = edges.filter((edge: Edge) => {\n      const { source, target } = edge;\n      return source !== target;\n    });\n    const calcGraph = new GGraph<OutNodeData, EdgeData>({\n      nodes: calcNodes,\n      edges: calcEdges,\n    });\n    const sizes: SizeMap = this.getSizes(calcGraph, graph, nodeSize);\n\n    this.run(calcGraph, graph, maxIteration, sizes, assign, mergedOptions);\n\n    // if prune, place the leaves around their parents, and then re-layout for several iterations.\n    if (prune) {\n      for (let j = 0; j < calcEdges.length; j += 1) {\n        const { source, target } = calcEdges[j];\n        const sourceDegree = calcGraph.getDegree(source);\n        const targetDegree = calcGraph.getDegree(source);\n        if (sourceDegree <= 1) {\n          const targetNode = calcGraph.getNode(target);\n          calcGraph.mergeNodeData(source, {\n            x: targetNode.data.x,\n            y: targetNode.data.y,\n          });\n        } else if (targetDegree <= 1) {\n          const sourceNode = calcGraph.getNode(source);\n          calcGraph.mergeNodeData(target, {\n            x: sourceNode.data.x,\n            y: sourceNode.data.y,\n          });\n        }\n      }\n      const postOptions = {\n        ...mergedOptions,\n        prune: false,\n        barnesHut: false,\n      };\n      this.run(calcGraph, graph, 100, sizes, assign, postOptions);\n    }\n\n    return {\n      nodes: calcNodes,\n      edges,\n    };\n  }\n\n  /**\n   * Init the node positions if there is no initial positions.\n   * And pre-calculate the size (max of width and height) for each node.\n   * @param calcGraph graph for calculation\n   * @param graph origin graph\n   * @param nodeSize node size config from layout options\n   * @returns {SizeMap} node'id mapped to max of its width and height\n   */\n  private getSizes(\n    calcGraph: CalcGraph,\n    graph: Graph,\n    nodeSize?: number | number[] | ((d?: Node) => number)\n  ): SizeMap {\n    const nodes = calcGraph.getAllNodes();\n    const sizes: SizeMap = {};\n    for (let i = 0; i < nodes.length; i += 1) {\n      const { id, data } = nodes[i];\n      sizes[id] = 10;\n      if (isNumber(data.size)) {\n        sizes[id] = data.size;\n      } else if (isArray(data.size)) {\n        if (!isNaN(data.size[0])) sizes[id] = Math.max(data.size[0]);\n        if (!isNaN(data.size[1])) sizes[id] = Math.max(data.size[1]);\n      } else if (isObject(data.size)) {\n        // @ts-ignore\n        sizes[id] = Math.max(data.size.width, data.size.height);\n      } else if (isFunction(nodeSize)) {\n        const originNode = graph.getNode(id);\n        const size = nodeSize(originNode);\n        if (isArray(size)) {\n          sizes[id] = Math.max(...size);\n        } else {\n          sizes[id] = size;\n        }\n      } else if (isArray(nodeSize)) {\n        sizes[id] = Math.max(...nodeSize);\n      } else if (isNumber(nodeSize)) {\n        sizes[id] = nodeSize;\n      }\n    }\n    return sizes;\n  }\n\n  /**\n   * Format the options.\n   * @param options input options\n   * @param nodeNum number of nodes\n   * @returns formatted options\n   */\n  private formatOptions(\n    options: ForceAtlas2LayoutOptions = {},\n    nodeNum: number\n  ): FormattedOptions {\n    const mergedOptions = { ...this.options, ...options } as FormattedOptions;\n    const { center, width, height, barnesHut, prune, maxIteration, kr, kg } =\n      mergedOptions;\n    mergedOptions.width =\n      !width && typeof window !== \"undefined\" ? window.innerWidth : width;\n    mergedOptions.height =\n      !height && typeof window !== \"undefined\" ? window.innerHeight : height;\n    mergedOptions.center = !center\n      ? [mergedOptions.width / 2, mergedOptions.height / 2]\n      : center;\n\n    if (barnesHut === undefined && nodeNum > 250) {\n      mergedOptions.barnesHut = true;\n    }\n    if (prune === undefined && nodeNum > 100) mergedOptions.prune = true;\n    if (maxIteration === 0 && !prune) {\n      mergedOptions.maxIteration = 250;\n      if (nodeNum <= 200 && nodeNum > 100) mergedOptions.maxIteration = 1000;\n      else if (nodeNum > 200) mergedOptions.maxIteration = 1200;\n    } else if (maxIteration === 0 && prune) {\n      mergedOptions.maxIteration = 100;\n      if (nodeNum <= 200 && nodeNum > 100) mergedOptions.maxIteration = 500;\n      else if (nodeNum > 200) mergedOptions.maxIteration = 950;\n    }\n\n    if (!kr) {\n      mergedOptions.kr = 50;\n      if (nodeNum > 100 && nodeNum <= 500) mergedOptions.kr = 20;\n      else if (nodeNum > 500) mergedOptions.kr = 1;\n    }\n    if (!kg) {\n      mergedOptions.kg = 20;\n      if (nodeNum > 100 && nodeNum <= 500) mergedOptions.kg = 10;\n      else if (nodeNum > 500) mergedOptions.kg = 1;\n    }\n\n    return mergedOptions;\n  }\n\n  /**\n   * Loops for fa2.\n   * @param calcGraph graph for calculation\n   * @param graph original graph\n   * @param iteration iteration number\n   * @param sizes nodes' size\n   * @param options formatted layout options\n   * @returns\n   */\n  private run(\n    calcGraph: CalcGraph,\n    graph: Graph,\n    iteration: number,\n    sizes: SizeMap,\n    assign: boolean,\n    options: FormattedOptions\n  ) {\n    const { kr, barnesHut, onTick } = options;\n    const calcNodes = calcGraph.getAllNodes();\n    let sg = 0;\n    let iter = iteration;\n    const forces: ForceMap = {};\n    const preForces: ForceMap = {};\n    const bodies: BodyMap = {};\n\n    for (let i = 0; i < calcNodes.length; i += 1) {\n      const { data, id } = calcNodes[i];\n      forces[id] = [0, 0];\n\n      if (barnesHut) {\n        const params = {\n          id: i,\n          rx: data.x,\n          ry: data.y,\n          mass: 1,\n          g: kr,\n          degree: calcGraph.getDegree(id),\n        };\n        bodies[id] = new Body(params);\n      }\n    }\n\n    while (iter > 0) {\n      sg = this.oneStep(\n        calcGraph,\n        {\n          iter,\n          preventOverlapIters: 50,\n          krPrime: 100,\n          sg,\n          forces,\n          preForces,\n          bodies,\n          sizes,\n        },\n        options\n      );\n      iter--;\n      onTick?.({\n        nodes: calcNodes,\n        edges: graph.getAllEdges(),\n      });\n      // if (assign) {\n      //   calcNodes.forEach(({ id, data }) => graph.mergeNodeData(id, {\n      //     x: data.x,\n      //     y: data.y\n      //   }))\n      // }\n    }\n\n    return calcGraph;\n  }\n\n  /**\n   * One step for a loop.\n   * @param graph graph for calculation\n   * @param params parameters for a loop\n   * @param options formatted layout's input options\n   * @returns\n   */\n  private oneStep(\n    graph: CalcGraph,\n    params: {\n      iter: number;\n      preventOverlapIters: number;\n      krPrime: number;\n      sg: number;\n      forces: ForceMap;\n      preForces: ForceMap;\n      bodies: BodyMap;\n      sizes: SizeMap;\n    },\n    options: FormattedOptions\n  ) {\n    const { iter, preventOverlapIters, krPrime, sg, preForces, bodies, sizes } =\n      params;\n    let { forces } = params;\n    const { preventOverlap, barnesHut } = options;\n    const nodes = graph.getAllNodes();\n    for (let i = 0; i < nodes.length; i += 1) {\n      const { id } = nodes[i];\n      preForces[id] = [...forces[id]];\n      forces[id] = [0, 0];\n    }\n    // attractive forces, existing on every actual edge\n    forces = this.getAttrForces(\n      graph,\n      iter,\n      preventOverlapIters,\n      sizes,\n      forces,\n      options\n    );\n\n    // repulsive forces and Gravity, existing on every node pair\n    // if preventOverlap, using the no-optimized method in the last preventOverlapIters instead.\n    if (\n      barnesHut &&\n      ((preventOverlap && iter > preventOverlapIters) || !preventOverlap)\n    ) {\n      forces = this.getOptRepGraForces(graph, forces, bodies, options);\n    } else {\n      forces = this.getRepGraForces(\n        graph,\n        iter,\n        preventOverlapIters,\n        forces,\n        krPrime,\n        sizes,\n        options\n      );\n    }\n    // update the positions\n    return this.updatePos(graph, forces, preForces, sg, options);\n  }\n\n  /**\n   * Calculate the attract forces for nodes.\n   * @param graph graph for calculation\n   * @param iter current iteration index\n   * @param preventOverlapIters the iteration number for preventing overlappings\n   * @param sizes nodes' sizes\n   * @param forces forces for nodes, which will be modified\n   * @param options formatted layout's input options\n   * @returns\n   */\n  private getAttrForces(\n    graph: CalcGraph,\n    iter: number,\n    preventOverlapIters: number,\n    sizes: SizeMap,\n    forces: ForceMap,\n    options: FormattedOptions\n  ): ForceMap {\n    const { preventOverlap, dissuadeHubs, mode, prune } = options;\n    const edges = graph.getAllEdges();\n    for (let i = 0; i < edges.length; i += 1) {\n      const { source, target } = edges[i];\n      const sourceNode = graph.getNode(source);\n      const targetNode = graph.getNode(target);\n\n      const sourceDegree = graph.getDegree(source);\n      const targetDegree = graph.getDegree(target);\n      if (prune && (sourceDegree <= 1 || targetDegree <= 1)) continue;\n\n      const dir = [\n        targetNode.data.x - sourceNode.data.x,\n        targetNode.data.y - sourceNode.data.y,\n      ];\n      let eucliDis = Math.hypot(dir[0], dir[1]);\n      eucliDis = eucliDis < 0.0001 ? 0.0001 : eucliDis;\n      dir[0] = dir[0] / eucliDis;\n      dir[1] = dir[1] / eucliDis;\n\n      if (preventOverlap && iter < preventOverlapIters) {\n        eucliDis = eucliDis - sizes[source] - sizes[target];\n      }\n      let fa1 = eucliDis;\n      let fa2 = fa1;\n      if (mode === \"linlog\") {\n        fa1 = Math.log(1 + eucliDis);\n        fa2 = fa1;\n      }\n      if (dissuadeHubs) {\n        fa1 = eucliDis / sourceDegree;\n        fa2 = eucliDis / targetDegree;\n      }\n      if (preventOverlap && iter < preventOverlapIters && eucliDis <= 0) {\n        fa1 = 0;\n        fa2 = 0;\n      } else if (preventOverlap && iter < preventOverlapIters && eucliDis > 0) {\n        fa1 = eucliDis;\n        fa2 = eucliDis;\n      }\n      forces[source][0] += fa1 * dir[0];\n      forces[target][0] -= fa2 * dir[0];\n      forces[source][1] += fa1 * dir[1];\n      forces[target][1] -= fa2 * dir[1];\n    }\n    return forces;\n  }\n\n  /**\n   * Calculate the repulsive forces for nodes under barnesHut mode.\n   * @param graph graph for calculatiion\n   * @param forces forces for nodes, which will be modified\n   * @param bodies force body map\n   * @param options formatted layout's input options\n   * @returns\n   */\n  private getOptRepGraForces(\n    graph: CalcGraph,\n    forces: ForceMap,\n    bodies: BodyMap,\n    options: FormattedOptions\n  ) {\n    const { kg, center, prune } = options;\n    const nodes = graph.getAllNodes();\n    const nodeNum = nodes.length;\n    let minx = 9e10;\n    let maxx = -9e10;\n    let miny = 9e10;\n    let maxy = -9e10;\n    for (let i = 0; i < nodeNum; i += 1) {\n      const { id, data } = nodes[i];\n      if (prune && graph.getDegree(id) <= 1) continue;\n      bodies[id].setPos(data.x, data.y);\n      if (data.x >= maxx) maxx = data.x;\n      if (data.x <= minx) minx = data.x;\n      if (data.y >= maxy) maxy = data.y;\n      if (data.y <= miny) miny = data.y;\n    }\n\n    const width = Math.max(maxx - minx, maxy - miny);\n\n    const quadParams = {\n      xmid: (maxx + minx) / 2,\n      ymid: (maxy + miny) / 2,\n      length: width,\n      massCenter: center,\n      mass: nodeNum,\n    };\n    const quad = new Quad(quadParams);\n    const quadTree = new QuadTree(quad);\n\n    // build the tree, insert the nodes(quads) into the tree\n    for (let i = 0; i < nodeNum; i += 1) {\n      const { id } = nodes[i];\n      if (prune && graph.getDegree(id) <= 1) continue;\n\n      if (bodies[id].in(quad)) quadTree.insert(bodies[id]);\n    }\n    // update the repulsive forces and the gravity.\n    for (let i = 0; i < nodeNum; i += 1) {\n      const { id, data } = nodes[i];\n      const degree = graph.getDegree(id);\n      if (prune && degree <= 1) continue;\n\n      bodies[id].resetForce();\n      quadTree.updateForce(bodies[id]);\n      forces[id][0] -= bodies[id].fx;\n      forces[id][1] -= bodies[id].fy;\n\n      // gravity\n      const dir = [data.x - center[0], data.y - center[1]];\n      let eucliDis = Math.hypot(dir[0], dir[1]);\n      eucliDis = eucliDis < 0.0001 ? 0.0001 : eucliDis;\n      dir[0] = dir[0] / eucliDis;\n      dir[1] = dir[1] / eucliDis;\n      const fg = kg * (degree + 1); // tslint:disable-line\n      forces[id][0] -= fg * dir[0];\n      forces[id][1] -= fg * dir[1];\n    }\n    return forces;\n  }\n\n  /**\n   * Calculate the repulsive forces for nodes.\n   * @param graph graph for calculatiion\n   * @param iter current iteration index\n   * @param preventOverlapIters the iteration number for preventing overlappings\n   * @param forces forces for nodes, which will be modified\n   * @param krPrime larger the krPrime, larger the repulsive force\n   * @param sizes nodes' sizes\n   * @param options formatted layout's input options\n   * @returns\n   */\n  private getRepGraForces(\n    graph: CalcGraph,\n    iter: number,\n    preventOverlapIters: number,\n    forces: ForceMap,\n    krPrime: number,\n    sizes: SizeMap,\n    options: FormattedOptions\n  ): ForceMap {\n    const { preventOverlap, kr, kg, center, prune } = options;\n    const nodes = graph.getAllNodes();\n    const nodeNum = nodes.length;\n    for (let i = 0; i < nodeNum; i += 1) {\n      const nodei = nodes[i];\n      const degreei = graph.getDegree(nodei.id);\n      for (let j = i + 1; j < nodeNum; j += 1) {\n        const nodej = nodes[j];\n        const degreej = graph.getDegree(nodej.id);\n\n        if (prune && (degreei <= 1 || degreej <= 1)) continue;\n\n        const dir = [nodej.data.x - nodei.data.x, nodej.data.y - nodei.data.y];\n        let eucliDis = Math.hypot(dir[0], dir[1]);\n        eucliDis = eucliDis < 0.0001 ? 0.0001 : eucliDis;\n        dir[0] = dir[0] / eucliDis;\n        dir[1] = dir[1] / eucliDis;\n\n        if (preventOverlap && iter < preventOverlapIters) {\n          eucliDis = eucliDis - sizes[nodei.id] - sizes[nodej.id];\n        }\n\n        let fr = (kr * (degreei + 1) * (degreej + 1)) / eucliDis;\n\n        if (preventOverlap && iter < preventOverlapIters && eucliDis < 0) {\n          fr = krPrime * (degreei + 1) * (degreej + 1);\n        } else if (\n          preventOverlap &&\n          iter < preventOverlapIters &&\n          eucliDis === 0\n        ) {\n          fr = 0;\n        } else if (\n          preventOverlap &&\n          iter < preventOverlapIters &&\n          eucliDis > 0\n        ) {\n          fr = (kr * (degreei + 1) * (degreej + 1)) / eucliDis;\n        }\n        forces[nodei.id][0] -= fr * dir[0];\n        forces[nodej.id][0] += fr * dir[0];\n        forces[nodei.id][1] -= fr * dir[1];\n        forces[nodej.id][1] += fr * dir[1];\n      }\n\n      // gravity\n      const dir = [nodei.data.x - center[0], nodei.data.y - center[1]];\n      const eucliDis = Math.hypot(dir[0], dir[1]);\n      dir[0] = dir[0] / eucliDis;\n      dir[1] = dir[1] / eucliDis;\n      const fg = kg * (degreei + 1); // tslint:disable-line\n      forces[nodei.id][0] -= fg * dir[0];\n      forces[nodei.id][1] -= fg * dir[1];\n    }\n    return forces;\n  }\n\n  /**\n   * Update node positions.\n   * @param graph graph for calculatiion\n   * @param forces forces for nodes, which will be modified\n   * @param preForces previous forces for nodes, which will be modified\n   * @param sg constant for move distance of one step\n   * @param options formatted layout's input options\n   * @returns\n   */\n  private updatePos(\n    graph: CalcGraph,\n    forces: ForceMap,\n    preForces: ForceMap,\n    sg: number,\n    options: FormattedOptions\n  ): number {\n    const { ks, tao, prune, ksmax } = options;\n    const nodes = graph.getAllNodes();\n    const nodeNum = nodes.length;\n    const swgns = [];\n    const trans = [];\n    // swg(G) and tra(G)\n    let swgG = 0;\n    let traG = 0;\n    let usingSg = sg;\n    for (let i = 0; i < nodeNum; i += 1) {\n      const { id } = nodes[i];\n      const degree = graph.getDegree(id);\n      if (prune && degree <= 1) continue;\n\n      const minus = [\n        forces[id][0] - preForces[id][0],\n        forces[id][1] - preForces[id][1],\n      ];\n      const minusNorm = Math.hypot(minus[0], minus[1]);\n      const add = [\n        forces[id][0] + preForces[id][0],\n        forces[id][1] + preForces[id][1],\n      ];\n      const addNorm = Math.hypot(add[0], add[1]);\n\n      swgns[i] = minusNorm;\n      trans[i] = addNorm / 2;\n\n      swgG += (degree + 1) * swgns[i];\n      traG += (degree + 1) * trans[i];\n    }\n\n    const preSG = usingSg;\n    usingSg = (tao * traG) / swgG;\n    if (preSG !== 0) {\n      usingSg = usingSg > 1.5 * preSG ? 1.5 * preSG : usingSg;\n    }\n    // update the node positions\n    for (let i = 0; i < nodeNum; i += 1) {\n      const { id, data } = nodes[i];\n      const degree = graph.getDegree(id);\n      if (prune && degree <= 1) continue;\n      if (isNumber(data.fx) && isNumber(data.fy)) continue;\n\n      let sn = (ks * usingSg) / (1 + usingSg * Math.sqrt(swgns[i]));\n      let absForce = Math.hypot(forces[id][0], forces[id][1]);\n      absForce = absForce < 0.0001 ? 0.0001 : absForce;\n      const max = ksmax / absForce;\n      sn = sn > max ? max : sn;\n      const dnx = sn * forces[id][0];\n      const dny = sn * forces[id][1];\n      graph.mergeNodeData(id, {\n        x: data.x + dnx,\n        y: data.y + dny,\n      });\n    }\n    return usingSg;\n  }\n}\n","import { isNumber } from \"@antv/util\";\nimport { Graph as IGraph } from \"@antv/graphlib\";\nimport type {\n  Graph,\n  LayoutMapping,\n  OutNode,\n  PointTuple,\n  FruchtermanLayoutOptions,\n  OutNodeData,\n  Edge,\n  EdgeData,\n  Point,\n  LayoutWithIterations,\n} from \"./types\";\nimport { cloneFormatData } from \"./util\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<FruchtermanLayoutOptions> = {\n  maxIteration: 1000,\n  gravity: 10,\n  speed: 5,\n  clustering: false,\n  clusterGravity: 10,\n  width: 300,\n  height: 300,\n  nodeClusterBy: \"cluster\",\n};\nconst SPEED_DIVISOR = 800;\n\ninterface ClusterMap {\n  [clusterName: string]: {\n    name: string;\n    cx: number;\n    cy: number;\n    count: number;\n  };\n}\n\ntype CalcGraph = IGraph<OutNodeData, EdgeData>;\n\ntype DisplacementMap = {\n  [id: string]: Point;\n};\n\ninterface FormattedOptions extends FruchtermanLayoutOptions {\n  width: number;\n  height: number;\n  center: PointTuple;\n  maxIteration: number;\n  nodeClusterBy: string;\n  gravity: number;\n  speed: number;\n}\n\n/**\n * Layout with fructherman force model\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new FruchtermanLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new FruchtermanLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { center: [100, 100] });\n */\nexport class FruchtermanLayout\n  implements LayoutWithIterations<FruchtermanLayoutOptions>\n{\n  id = \"fruchterman\";\n\n  private timeInterval: number = 0;\n\n  private running: boolean = false;\n  private lastLayoutNodes: OutNode[];\n  private lastLayoutEdges: Edge[];\n  private lastAssign: boolean;\n  private lastGraph: IGraph<OutNodeData, EdgeData>;\n  private lastOptions: FormattedOptions;\n  private lastClusterMap: ClusterMap;\n  private lastResult: LayoutMapping;\n\n  constructor(\n    public options: FruchtermanLayoutOptions = {} as FruchtermanLayoutOptions\n  ) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: FruchtermanLayoutOptions) {\n    return this.genericFruchtermanLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: FruchtermanLayoutOptions) {\n    this.genericFruchtermanLayout(true, graph, options);\n  }\n\n  /**\n   * Stop simulation immediately.\n   */\n  stop() {\n    if (this.timeInterval && typeof window !== \"undefined\") {\n      window.clearInterval(this.timeInterval);\n    }\n    this.running = false;\n  }\n\n  /**\n   * Manually steps the simulation by the specified number of iterations.\n   * @see https://github.com/d3/d3-force#simulation_tick\n   */\n  tick(iterations = this.options.maxIteration || 1) {\n    if (this.lastResult) {\n      return this.lastResult;\n    }\n\n    for (let i = 0; i < iterations; i++) {\n      this.runOneStep(this.lastGraph, this.lastClusterMap, this.lastOptions);\n    }\n\n    const result = {\n      nodes: this.lastLayoutNodes,\n      edges: this.lastLayoutEdges,\n    };\n\n    if (this.lastAssign) {\n      result.nodes.forEach((node) =>\n        this.lastGraph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n          z: this.options.dimensions === 3 ? node.data.z : undefined\n        })\n      );\n    }\n\n    return result;\n  }\n\n  private async genericFruchtermanLayout(\n    assign: false,\n    graph: Graph,\n    options?: FruchtermanLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericFruchtermanLayout(\n    assign: true,\n    graph: Graph,\n    options?: FruchtermanLayoutOptions\n  ): Promise<void>;\n  private async genericFruchtermanLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: FruchtermanLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    if (this.running) return;\n\n    const formattedOptions = this.formatOptions(options);\n    const {\n      dimensions,\n      width,\n      height,\n      center,\n      clustering,\n      nodeClusterBy,\n      maxIteration,\n      onTick,\n    } = formattedOptions;\n\n    const nodes = graph.getAllNodes();\n    const edges = graph.getAllEdges();\n\n    if (!nodes?.length) {\n      const result = { nodes: [] as any[], edges };\n      this.lastResult = result;\n      return result;\n    }\n\n    if (nodes.length === 1) {\n      if (assign) {\n        graph.mergeNodeData(nodes[0].id, {\n          x: center[0],\n          y: center[1],\n          z: dimensions === 3 ? center[2] : undefined\n        });\n      }\n      const result = {\n        nodes: [\n          {\n            ...nodes[0],\n            data: {\n              ...nodes[0].data,\n              x: center[0],\n              y: center[1],\n              z: dimensions === 3 ? center[2] : undefined\n            },\n          },\n        ],\n        edges,\n      };\n      this.lastResult = result;\n      return result;\n    }\n\n    const layoutNodes: OutNode[] = nodes.map(\n      (node) => cloneFormatData(node, [width, height]) as OutNode\n    );\n    const calcGraph = new IGraph<OutNodeData, EdgeData>({\n      nodes: layoutNodes,\n      edges,\n    });\n\n    // clustering info\n    const clusterMap: ClusterMap = {};\n    if (clustering) {\n      layoutNodes.forEach((node) => {\n        const clusterValue = node.data[nodeClusterBy] as string;\n        if (!clusterMap[clusterValue]) {\n          clusterMap[clusterValue] = {\n            name: clusterValue,\n            cx: 0,\n            cy: 0,\n            count: 0,\n          };\n        }\n      });\n    }\n\n    // Use them later in `tick`.\n    this.lastLayoutNodes = layoutNodes;\n    this.lastLayoutEdges = edges;\n    this.lastAssign = assign;\n    this.lastGraph = calcGraph;\n    this.lastOptions = formattedOptions;\n    this.lastClusterMap = clusterMap;\n\n    if (typeof window === \"undefined\") return;\n    let iter = 0;\n\n    return new Promise((resolve) => {\n      // interval for render the result after each iteration\n      this.timeInterval = window.setInterval(() => {\n        if (!this.running) {\n          resolve({ nodes: layoutNodes, edges });\n          return;\n        }\n\n        this.runOneStep(calcGraph, clusterMap, formattedOptions);\n        if (assign) {\n          layoutNodes.forEach(({ id, data }) =>\n            graph.mergeNodeData(id, {\n              x: data.x,\n              y: data.y,\n              z: dimensions === 3 ? data.z : undefined\n            })\n          );\n        }\n        onTick?.({\n          nodes: layoutNodes,\n          edges,\n        });\n        iter++;\n        if (iter >= maxIteration) {\n          window.clearInterval(this.timeInterval);\n          resolve({ nodes: layoutNodes, edges });\n        }\n      }, 0);\n      this.running = true;\n    });\n  }\n\n  private formatOptions(\n    options: FruchtermanLayoutOptions = {}\n  ): FormattedOptions {\n    const mergedOptions = { ...this.options, ...options } as FormattedOptions;\n    const { clustering, nodeClusterBy } = mergedOptions;\n\n    const {\n      center: propsCenter,\n      width: propsWidth,\n      height: propsHeight,\n    } = mergedOptions;\n    mergedOptions.width =\n      !propsWidth && typeof window !== \"undefined\"\n        ? window.innerWidth\n        : (propsWidth as number);\n    mergedOptions.height =\n      !propsHeight && typeof window !== \"undefined\"\n        ? window.innerHeight\n        : (propsHeight as number);\n    mergedOptions.center = !propsCenter\n      ? [mergedOptions.width / 2, mergedOptions.height / 2]\n      : (propsCenter as PointTuple);\n\n    mergedOptions.clustering = clustering && !!nodeClusterBy;\n\n    return mergedOptions;\n  }\n\n  private runOneStep(\n    calcGraph: CalcGraph,\n    clusterMap: ClusterMap,\n    options: FormattedOptions\n  ) {\n    const {\n      dimensions,\n      height,\n      width,\n      gravity,\n      center,\n      speed,\n      clustering,\n      nodeClusterBy,\n      clusterGravity: propsClusterGravity,\n    } = options;\n    const area = height * width;\n    const maxDisplace = Math.sqrt(area) / 10;\n    const nodes = calcGraph.getAllNodes();\n    const k2 = area / (nodes.length + 1);\n    const k = Math.sqrt(k2);\n    const displacements: DisplacementMap = {};\n    this.applyCalculate(calcGraph, displacements, k, k2);\n\n    // gravity for clusters\n    if (clustering) {\n      // reset the clustering centers\n      for (const key in clusterMap) {\n        clusterMap[key].cx = 0;\n        clusterMap[key].cy = 0;\n        clusterMap[key].count = 0;\n      }\n      // re-compute clustering centers\n      nodes.forEach((node) => {\n        const { data } = node; // node is one of layoutNodes, which is formatted and data field exists\n        const c = clusterMap[data[nodeClusterBy] as string];\n        if (isNumber(data.x)) {\n          c.cx += data.x;\n        }\n        if (isNumber(data.y)) {\n          c.cy += data.y;\n        }\n        c.count++;\n      });\n      for (const key in clusterMap) {\n        clusterMap[key].cx /= clusterMap[key].count;\n        clusterMap[key].cy /= clusterMap[key].count;\n      }\n\n      // compute the cluster gravity forces\n      const clusterGravity = (propsClusterGravity || gravity) as number;\n      nodes.forEach((node, j) => {\n        const { id, data } = node;\n        if (!isNumber(data.x) || !isNumber(data.y)) return;\n        const c = clusterMap[data[nodeClusterBy] as string];\n        const distLength = Math.sqrt(\n          (data.x - c.cx) * (data.x - c.cx) + (data.y - c.cy) * (data.y - c.cy)\n        );\n        const gravityForce = k * clusterGravity;\n        displacements[id].x -= (gravityForce * (data.x - c.cx)) / distLength;\n        displacements[id].y -= (gravityForce * (data.y - c.cy)) / distLength;\n      });\n    }\n\n    // gravity\n    nodes.forEach((node, j) => {\n      const { id, data } = node;\n      if (!isNumber(data.x) || !isNumber(data.y)) return;\n      const gravityForce = 0.01 * k * gravity;\n      displacements[id].x -= gravityForce * (data.x - center[0]);\n      displacements[id].y -= gravityForce * (data.y - center[1]);\n      if (dimensions === 3) {\n        displacements[id].z -= gravityForce * (data.z - center[2]);\n      }\n    });\n\n    // move\n    nodes.forEach((node: OutNode, j) => {\n      const { id, data } = node;\n      if (isNumber(data.fx) && isNumber(data.fy)) {\n        data.x = data.fx as number;\n        data.y = data.fy as number;\n        if (dimensions === 3) {\n          data.z = data.fz as number;\n        }\n        return;\n      }\n      if (!isNumber(data.x) || !isNumber(data.y)) return;\n      const distLength = Math.sqrt(\n        displacements[id].x * displacements[id].x +\n          displacements[id].y * displacements[id].y + (dimensions === 3 ? displacements[id].z * displacements[id].z : 0)\n      );\n      if (distLength > 0) {\n        // && !n.isFixed()\n        const limitedDist = Math.min(\n          maxDisplace * (speed / SPEED_DIVISOR),\n          distLength\n        );\n        calcGraph.mergeNodeData(id, {\n          x: data.x + (displacements[id].x / distLength) * limitedDist,\n          y: data.y + (displacements[id].y / distLength) * limitedDist,\n          z: dimensions === 3 ? data.z + (displacements[id].z / distLength) * limitedDist : undefined\n        });\n      }\n    });\n  }\n  private applyCalculate(\n    calcGraph: CalcGraph,\n    displacements: DisplacementMap,\n    k: number,\n    k2: number\n  ) {\n    this.calRepulsive(calcGraph, displacements, k2);\n    this.calAttractive(calcGraph, displacements, k);\n  }\n\n  private calRepulsive(\n    calcGraph: CalcGraph,\n    displacements: DisplacementMap,\n    k2: number\n  ) {\n    const nodes = calcGraph.getAllNodes();\n    nodes.forEach(({ data: v, id: vid }, i) => {\n      displacements[vid] = { x: 0, y: 0, z: 0 };\n      nodes.forEach(({ data: u, id: uid }, j) => {\n        if (\n          i <= j ||\n          !isNumber(v.x) ||\n          !isNumber(u.x) ||\n          !isNumber(v.y) ||\n          !isNumber(u.y)\n        ) {\n          return;\n        }\n        let vecX = v.x - u.x;\n        let vecY = v.y - u.y;\n        let vecZ = this.options.dimensions === 3 ? v.z - u.z : 0;\n        let lengthSqr = vecX * vecX + vecY * vecY + vecZ * vecZ;\n        if (lengthSqr === 0) {\n          lengthSqr = 1;\n          vecX = 0.01;\n          vecY = 0.01;\n          vecZ = 0.01;\n        }\n        const common = k2 / lengthSqr;\n        const dispX = vecX * common;\n        const dispY = vecY * common;\n        const dispZ = vecZ * common;\n        displacements[vid].x += dispX;\n        displacements[vid].y += dispY;\n        displacements[uid].x -= dispX;\n        displacements[uid].y -= dispY;\n\n        if (this.options.dimensions === 3) {\n          displacements[vid].z += dispZ;\n          displacements[uid].z -= dispZ;\n        }\n      });\n    });\n  }\n\n  private calAttractive(\n    calcGraph: CalcGraph,\n    displacements: DisplacementMap,\n    k: number\n  ) {\n    const edges = calcGraph.getAllEdges();\n    edges.forEach((e) => {\n      const { source, target } = e;\n      if (!source || !target || source === target) {\n        return;\n      }\n      const { data: u } = calcGraph.getNode(source);\n      const { data: v } = calcGraph.getNode(target);\n      if (\n        !isNumber(v.x) ||\n        !isNumber(u.x) ||\n        !isNumber(v.y) ||\n        !isNumber(u.y)\n      ) {\n        return;\n      }\n      const vecX = v.x - u.x;\n      const vecY = v.y - u.y;\n      const vecZ = this.options.dimensions === 3 ? v.z - u.z : 0;\n      const common = Math.sqrt(vecX * vecX + vecY * vecY + vecZ * vecZ) / k;\n      const dispX = vecX * common;\n      const dispY = vecY * common;\n      const dispZ = vecZ * common;\n      displacements[source].x += dispX;\n      displacements[source].y += dispY;\n      displacements[target].x -= dispX;\n      displacements[target].y -= dispY;\n\n      if (this.options.dimensions === 3) {\n        displacements[source].z += dispZ;\n        displacements[target].z -= dispZ;\n      }\n    });\n  }\n}\n","import { isString, isNumber } from \"@antv/util\";\nimport { isArray, formatSizeFn, formatNumberFn, cloneFormatData } from \"./util\";\nimport type {\n  Graph,\n  GridLayoutOptions,\n  LayoutMapping,\n  PointTuple,\n  Layout,\n  OutNode,\n  Node,\n  Edge,\n} from \"./types\";\nimport { handleSingleNodeGraph } from \"./util/common\";\n\ntype RowsAndCols = {\n  rows: number;\n  cols: number;\n};\n\ntype RowAndCol = {\n  row: number;\n  col: number;\n};\n\ntype IdMapRowAndCol = {\n  [id: string]: RowAndCol;\n};\n\ntype VisitMap = {\n  [id: string]: boolean;\n};\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<GridLayoutOptions> = {\n  begin: [0, 0],\n  preventOverlap: true,\n  preventOverlapPadding: 10,\n  condense: false,\n  rows: undefined,\n  cols: undefined,\n  position: undefined,\n  sortBy: \"degree\",\n  nodeSize: 30,\n  width: 300,\n  height: 300,\n};\n\n/**\n * Layout arranging the nodes in a grid.\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new GridLayout({ rows: 10 });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new GridLayout({ rows: 10 });\n * const positions = await layout.execute(graph, { rows: 20 }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { rows: 20 });\n */\nexport class GridLayout implements Layout<GridLayoutOptions> {\n  id = \"grid\";\n\n  constructor(public options: GridLayoutOptions = {} as GridLayoutOptions) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: GridLayoutOptions) {\n    return this.genericGridLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: GridLayoutOptions) {\n    this.genericGridLayout(true, graph, options);\n  }\n\n  private async genericGridLayout(\n    assign: false,\n    graph: Graph,\n    options?: GridLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericGridLayout(\n    assign: true,\n    graph: Graph,\n    options?: GridLayoutOptions\n  ): Promise<void>;\n  private async genericGridLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: GridLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n    const {\n      begin = [0, 0],\n      condense,\n      preventOverlapPadding,\n      preventOverlap,\n      rows: propsRows,\n      cols: propsCols,\n      nodeSpacing: paramNodeSpacing,\n      nodeSize: paramNodeSize,\n      width: propsWidth,\n      height: propsHeight,\n      position,\n    } = mergedOptions;\n    let { sortBy } = mergedOptions;\n\n    const nodes: Node[] = graph.getAllNodes();\n    const edges: Edge[] = graph.getAllEdges();\n\n    const n = nodes?.length;\n\n    // Need no layout if there is no node.\n    if (!n || n === 1) {\n      return handleSingleNodeGraph(graph, assign, begin);\n    }\n\n    const layoutNodes: OutNode[] = nodes.map(\n      (node) => cloneFormatData(node) as OutNode\n    );\n\n    if (\n      // `id` should be reserved keyword\n      sortBy !== \"id\" &&\n      (!isString(sortBy) || (layoutNodes[0] as any).data[sortBy] === undefined)\n    ) {\n      sortBy = \"degree\";\n    }\n\n    if (sortBy === \"degree\") {\n      layoutNodes.sort(\n        (n1, n2) =>\n          graph.getDegree(n2.id, \"both\") - graph.getDegree(n1.id, \"both\")\n      );\n    } else if (sortBy === \"id\") {\n      // sort nodes by ID\n      layoutNodes.sort((n1, n2) => {\n        if (isNumber(n2.id) && isNumber(n1.id)) {\n          return n2.id - n1.id;\n        }\n        return `${n1.id}`.localeCompare(`${n2.id}`);\n      });\n    } else {\n      // sort nodes by value\n      layoutNodes.sort(\n        (n1, n2) => (n2 as any).data[sortBy!] - (n1 as any).data[sortBy!]\n      );\n    }\n    const width =\n      !propsWidth && typeof window !== \"undefined\"\n        ? window.innerWidth\n        : (propsWidth as number);\n    const height =\n      !propsHeight && typeof window !== \"undefined\"\n        ? window.innerHeight\n        : (propsHeight as number);\n\n    const cells = n;\n    const rcs = { rows: propsRows, cols: propsCols } as RowsAndCols;\n\n    // if rows or columns were set in self, use those values\n    if (propsRows != null && propsCols != null) {\n      rcs.rows = propsRows;\n      rcs.cols = propsCols;\n    } else if (propsRows != null && propsCols == null) {\n      rcs.rows = propsRows;\n      rcs.cols = Math.ceil(cells / rcs.rows);\n    } else if (propsRows == null && propsCols != null) {\n      rcs.cols = propsCols;\n      rcs.rows = Math.ceil(cells / rcs.cols);\n    } else {\n      // otherwise use the automatic values and adjust accordingly\t      // otherwise use the automatic values and adjust accordingly\n      // width/height * splits^2 = cells where splits is number of times to split width\n      const splits = Math.sqrt((cells * height) / width);\n      rcs.rows = Math.round(splits);\n      rcs.cols = Math.round((width / height) * splits);\n    }\n    rcs.rows = Math.max(rcs.rows, 1);\n    rcs.cols = Math.max(rcs.cols, 1);\n    if (rcs.cols * rcs.rows > cells) {\n      // otherwise use the automatic values and adjust accordingly\n      // if rounding was up, see if we can reduce rows or columns\n      const sm = small(rcs) as number;\n      const lg = large(rcs) as number;\n\n      // reducing the small side takes away the most cells, so try it first\n      if ((sm - 1) * lg >= cells) {\n        small(rcs, sm - 1);\n      } else if ((lg - 1) * sm >= cells) {\n        large(rcs, lg - 1);\n      }\n    } else {\n      // if rounding was too low, add rows or columns\n      while (rcs.cols * rcs.rows < cells) {\n        const sm = small(rcs) as number;\n        const lg = large(rcs) as number;\n\n        // try to add to larger side first (adds less in multiplication)\n        if ((lg + 1) * sm >= cells) {\n          large(rcs, lg + 1);\n        } else {\n          small(rcs, sm + 1);\n        }\n      }\n    }\n\n    let cellWidth = condense ? 0 : width / rcs.cols;\n    let cellHeight = condense ? 0 : height / rcs.rows;\n\n    if (preventOverlap || paramNodeSpacing) {\n      const nodeSpacing: Function = formatNumberFn(\n        10,\n        paramNodeSpacing as number\n      );\n      const nodeSize: Function = formatSizeFn(30, paramNodeSize, false);\n      layoutNodes.forEach((node) => {\n        if (!node.data.x || !node.data.y) {\n          // for bb\n          node.data.x = 0;\n          node.data.y = 0;\n        }\n\n        const oNode = graph.getNode(node.id);\n        const res = nodeSize(oNode) || 30;\n\n        let nodeW;\n        let nodeH;\n\n        if (isArray(res)) {\n          nodeW = res[0];\n          nodeH = res[1];\n        } else {\n          nodeW = res;\n          nodeH = res;\n        }\n\n        const p =\n          nodeSpacing !== undefined ? nodeSpacing(node) : preventOverlapPadding;\n\n        const w = nodeW + p;\n        const h = nodeH + p;\n\n        cellWidth = Math.max(cellWidth, w);\n        cellHeight = Math.max(cellHeight, h);\n      });\n    }\n\n    const cellUsed: VisitMap = {}; // e.g. 'c-0-2' => true\n\n    // to keep track of current cell position\n    const rc = { row: 0, col: 0 };\n\n    // get a cache of all the manual positions\n    const id2manPos: IdMapRowAndCol = {};\n    for (let i = 0; i < layoutNodes.length; i++) {\n      const node = layoutNodes[i];\n      let rcPos;\n      if (position) {\n        // TODO: not sure the api name\n        rcPos = position(graph.getNode(node.id));\n      }\n\n      if (rcPos && (rcPos.row !== undefined || rcPos.col !== undefined)) {\n        // must have at least row or col def'd\n        const pos = {\n          row: rcPos.row,\n          col: rcPos.col,\n        } as RowAndCol;\n\n        if (pos.col === undefined) {\n          // find unused col\n          pos.col = 0;\n\n          while (used(cellUsed, pos)) {\n            pos.col++;\n          }\n        } else if (pos.row === undefined) {\n          // find unused row\n          pos.row = 0;\n\n          while (used(cellUsed, pos)) {\n            pos.row++;\n          }\n        }\n\n        id2manPos[node.id] = pos as RowAndCol;\n        use(cellUsed, pos);\n      }\n      getPos(node, begin, cellWidth, cellHeight, id2manPos, rcs, rc, cellUsed);\n    }\n    const result = {\n      nodes: layoutNodes,\n      edges,\n    };\n\n    if (assign) {\n      layoutNodes.forEach((node) => {\n        graph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        });\n      });\n    }\n    return result;\n  }\n}\n\nconst small = (\n  rcs: { rows: number; cols: number },\n  val?: number\n): number | undefined => {\n  let res: number | undefined;\n  const rows = rcs.rows || 5;\n  const cols = rcs.cols || 5;\n  if (val == null) {\n    res = Math.min(rows, cols);\n  } else {\n    const min = Math.min(rows, cols);\n    if (min === rcs.rows) {\n      rcs.rows = val;\n    } else {\n      rcs.cols = val;\n    }\n  }\n  return res;\n};\n\nconst large = (rcs: RowsAndCols, val?: number): number | undefined => {\n  let result: number | undefined;\n  const usedRows = rcs.rows || 5;\n  const usedCols = rcs.cols || 5;\n  if (val == null) {\n    result = Math.max(usedRows, usedCols);\n  } else {\n    const max = Math.max(usedRows, usedCols);\n    if (max === rcs.rows) {\n      rcs.rows = val;\n    } else {\n      rcs.cols = val;\n    }\n  }\n  return result;\n};\n\nconst used = (cellUsed: VisitMap, rc: RowAndCol) =>\n  cellUsed[`c-${rc.row}-${rc.col}`] || false;\n\nconst use = (cellUsed: VisitMap, rc: RowAndCol) =>\n  (cellUsed[`c-${rc.row}-${rc.col}`] = true);\n\nconst moveToNextCell = (rcs: RowsAndCols, rc: RowAndCol) => {\n  const cols = rcs.cols || 5;\n  rc.col++;\n  if (rc.col >= cols) {\n    rc.col = 0;\n    rc.row++;\n  }\n};\n\nconst getPos = (\n  node: OutNode,\n  begin: PointTuple,\n  cellWidth: number,\n  cellHeight: number,\n  id2manPos: IdMapRowAndCol,\n  rcs: RowsAndCols,\n  rc: RowAndCol,\n  cellUsed: VisitMap\n) => {\n  let x: number;\n  let y: number;\n\n  // see if we have a manual position set\n  const rcPos = id2manPos[node.id];\n  if (rcPos) {\n    x = rcPos.col * cellWidth + cellWidth / 2 + begin[0];\n    y = rcPos.row * cellHeight + cellHeight / 2 + begin[1];\n  } else {\n    // otherwise set automatically\n\n    while (used(cellUsed, rc)) {\n      moveToNextCell(rcs, rc);\n    }\n\n    x = rc.col * cellWidth + cellWidth / 2 + begin[0];\n    y = rc.row * cellHeight + cellHeight / 2 + begin[1];\n    use(cellUsed, rc);\n\n    moveToNextCell(rcs, rc);\n  }\n  node.data.x = x;\n  node.data.y = y;\n};\n","import { Matrix as MLMatrix, SingularValueDecomposition } from \"ml-matrix\";\nimport type {\n  Graph,\n  LayoutMapping,\n  OutNode,\n  PointTuple,\n  MDSLayoutOptions,\n  Layout,\n  Matrix,\n} from \"./types\";\nimport {\n  cloneFormatData,\n  floydWarshall,\n  getAdjMatrix,\n  scaleMatrix,\n} from \"./util\";\nimport { handleSingleNodeGraph } from \"./util/common\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<MDSLayoutOptions> = {\n  center: [0, 0],\n  linkDistance: 50,\n};\n\n/**\n * Layout arranging the nodes with multiple dimensional scaling algorithm\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new MDSLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new MDSLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph, { rows: 20 }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { center: [100, 100] });\n */\nexport class MDSLayout implements Layout<MDSLayoutOptions> {\n  id = \"mds\";\n\n  constructor(public options: MDSLayoutOptions = {} as MDSLayoutOptions) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: MDSLayoutOptions) {\n    return this.genericMDSLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: MDSLayoutOptions) {\n    this.genericMDSLayout(true, graph, options);\n  }\n\n  private async genericMDSLayout(\n    assign: false,\n    graph: Graph,\n    options?: MDSLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericMDSLayout(\n    assign: true,\n    graph: Graph,\n    options?: MDSLayoutOptions\n  ): Promise<void>;\n  private async genericMDSLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: MDSLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n    const { center = [0, 0], linkDistance = 50 } = mergedOptions;\n\n    const nodes = graph.getAllNodes();\n    const edges = graph.getAllEdges();\n\n    if (!nodes?.length || nodes.length === 1) {\n      return handleSingleNodeGraph(graph, assign, center);\n    }\n\n    // the graph-theoretic distance (shortest path distance) matrix\n    const adjMatrix = getAdjMatrix({ nodes, edges }, false);\n    const distances = floydWarshall(adjMatrix);\n    handleInfinity(distances);\n\n    // scale the ideal edge length acoording to linkDistance\n    const scaledD = scaleMatrix(distances, linkDistance);\n\n    // get positions by MDS\n    const positions = runMDS(scaledD);\n    const layoutNodes: OutNode[] = [];\n    positions.forEach((p: number[], i: number) => {\n      const cnode = cloneFormatData(nodes[i]) as OutNode;\n      cnode.data.x = p[0] + center[0];\n      cnode.data.y = p[1] + center[1];\n      layoutNodes.push(cnode);\n    });\n\n    if (assign) {\n      layoutNodes.forEach((node) =>\n        graph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        })\n      );\n    }\n\n    const result = {\n      nodes: layoutNodes,\n      edges,\n    };\n\n    return result;\n  }\n}\n\nconst handleInfinity = (distances: Matrix[]) => {\n  let maxDistance = -999999;\n  distances.forEach((row) => {\n    row.forEach((value) => {\n      if (value === Infinity) {\n        return;\n      }\n      if (maxDistance < value) {\n        maxDistance = value;\n      }\n    });\n  });\n  distances.forEach((row, i) => {\n    row.forEach((value, j) => {\n      if (value === Infinity) {\n        distances[i][j] = maxDistance;\n      }\n    });\n  });\n};\n\n/**\n * mds 算法\n * @return {array} positions 计算后的节点位置数组\n */\nconst runMDS = (distances: Matrix[]): PointTuple[] => {\n  const dimension = 2;\n\n  // square distances\n  const M = MLMatrix.mul(MLMatrix.pow(distances, 2), -0.5);\n\n  // double centre the rows/columns\n  const rowMeans = M.mean(\"row\");\n  const colMeans = M.mean(\"column\");\n  const totalMean = M.mean();\n  M.add(totalMean).subRowVector(rowMeans).subColumnVector(colMeans);\n\n  // take the SVD of the double centred matrix, and return the\n  // points from it\n  const ret = new SingularValueDecomposition(M);\n  const eigenValues = MLMatrix.sqrt(ret.diagonalMatrix).diagonal();\n  return ret.leftSingularVectors.toJSON().map((row: number[]) => {\n    return MLMatrix.mul([row], [eigenValues])\n      .toJSON()[0]\n      .splice(0, dimension) as PointTuple;\n  });\n};\n","import type { Graph, Node, Point } from \"../types\";\n\nconst SPEED_DIVISOR = 800;\n\nexport type RadialNonoverlapForceOptions = {\n  positions: Point[];\n  focusIdx: number;\n  radii: number[];\n  iterations: number;\n  height: number;\n  width: number;\n  k: number;\n  strictRadial: boolean;\n  nodes: Node[];\n  speed?: number;\n  gravity?: number;\n  nodeSizeFunc: (node: Node) => number;\n};\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<RadialNonoverlapForceOptions> = {\n  iterations: 10,\n  height: 10,\n  width: 10,\n  speed: 100,\n  gravity: 10,\n  k: 5\n};\n\nexport const radialNonoverlapForce = (graph: Graph, options: RadialNonoverlapForceOptions): Point[] => {\n  const mergedOptions = { ...DEFAULTS_LAYOUT_OPTIONS, ...options };\n  const { positions, iterations, width, k, speed = 100, strictRadial, focusIdx, radii = [], nodeSizeFunc } = mergedOptions;\n\n  const nodes = graph.getAllNodes();\n\n  const disp: Point[] = [];\n  const maxDisplace = width / 10;\n\n  for (let i = 0; i < iterations; i++) {\n    positions.forEach((_: Point, k: number) => {\n      disp[k] = { x: 0, y: 0 };\n    });\n    // 给重叠的节点增加斥力\n    getRepulsion(nodes, positions, disp, k, radii, nodeSizeFunc);\n    updatePositions(positions, disp, speed, strictRadial, focusIdx, maxDisplace, width, radii);\n  }\n  return positions;\n};\n\nconst getRepulsion = (nodes: Node[], positions: Point[], disp: Point[], k: number, radii: number[], nodeSizeFunc: (node: Node) => number) => {\n  positions.forEach((v: Point, i: number) => {\n    disp[i] = { x: 0, y: 0 };\n    positions.forEach((u: Point, j: number) => {\n      if (i === j) {\n        return;\n      }\n      // v and u are not on the same circle, return\n      if (radii[i] !== radii[j]) {\n        return;\n      }\n      let vecx = v.x - u.x;\n      let vecy = v.y - u.y;\n      let vecLength = Math.sqrt(vecx * vecx + vecy * vecy);\n      if (vecLength === 0) {\n        vecLength = 1;\n        const sign = i > j ? 1 : -1;\n        vecx = 0.01 * sign;\n        vecy = 0.01 * sign;\n      }\n      // these two nodes overlap\n      if (vecLength < nodeSizeFunc(nodes[i]) / 2 + nodeSizeFunc(nodes[j]) / 2) {\n        const common = (k * k) / vecLength;\n        disp[i].x += (vecx / vecLength) * common;\n        disp[i].y += (vecy / vecLength) * common;\n      }\n    });\n  });\n};\n\nconst updatePositions = (positions: Point[], disp: Point[], speed: number, strictRadial: boolean, focusIdx: number, maxDisplace: number, width: number, radii: number[]) => {\n  const maxDisp = maxDisplace || width / 10;\n  if (strictRadial) {\n    disp.forEach((di, i) => {\n      const vx = positions[i].x - positions[focusIdx].x;\n      const vy = positions[i].y - positions[focusIdx].y;\n      const vLength = Math.sqrt(vx * vx + vy * vy);\n      let vpx = vy / vLength;\n      let vpy = -vx / vLength;\n      const diLength = Math.sqrt(di.x * di.x + di.y * di.y);\n      let alpha = Math.acos((vpx * di.x + vpy * di.y) / diLength);\n      if (alpha > Math.PI / 2) {\n        alpha -= Math.PI / 2;\n        vpx *= -1;\n        vpy *= -1;\n      }\n      const tdispLength = Math.cos(alpha) * diLength;\n      di.x = vpx * tdispLength;\n      di.y = vpy * tdispLength;\n    });\n  }\n\n  // move\n  positions.forEach((n, i) => {\n    if (i === focusIdx) {\n      return;\n    }\n    const distLength = Math.sqrt(disp[i].x * disp[i].x + disp[i].y * disp[i].y);\n    if (distLength > 0 && i !== focusIdx) {\n      const limitedDist = Math.min(maxDisp * (speed / SPEED_DIVISOR), distLength);\n      n.x += (disp[i].x / distLength) * limitedDist;\n      n.y += (disp[i].y / distLength) * limitedDist;\n      if (strictRadial) {\n        let vx = n.x - positions[focusIdx].x;\n        let vy = n.y - positions[focusIdx].y;\n        const nfDis = Math.sqrt(vx * vx + vy * vy);\n        vx = (vx / nfDis) * radii[i];\n        vy = (vy / nfDis) * radii[i];\n        n.x = positions[focusIdx].x + vx;\n        n.y = positions[focusIdx].y + vy;\n      }\n    }\n  });\n  return positions;\n};","import { isString } from \"@antv/util\";\nimport type {\n  Graph,\n  Node,\n  LayoutMapping,\n  Matrix,\n  OutNode,\n  PointTuple,\n  RadialLayoutOptions,\n  Layout,\n  Point,\n} from \"../types\";\nimport {\n  cloneFormatData,\n  floydWarshall,\n  getAdjMatrix,\n  getEuclideanDistance,\n  formatNodeSize,\n} from \"../util\";\nimport { handleSingleNodeGraph } from \"../util/common\";\nimport { mds } from \"./mds\";\nimport {\n  radialNonoverlapForce,\n  RadialNonoverlapForceOptions,\n} from \"./radial-nonoverlap-force\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<RadialLayoutOptions> = {\n  maxIteration: 1000,\n  focusNode: null,\n  unitRadius: null,\n  linkDistance: 50,\n  preventOverlap: false,\n  strictRadial: true,\n  maxPreventOverlapIteration: 200,\n  sortStrength: 10,\n};\n\n/**\n * Layout arranging the nodes' on a radial shape\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new RadialLayout({ focusNode: 'node0' });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new RadialLayout({ focusNode: 'node0' });\n * const positions = await layout.execute(graph, { focusNode: 'node0' }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { focusNode: 'node0' });\n */\nexport class RadialLayout implements Layout<RadialLayoutOptions> {\n  id = \"radial\";\n\n  constructor(public options: RadialLayoutOptions = {} as RadialLayoutOptions) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: RadialLayoutOptions) {\n    return this.genericRadialLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: RadialLayoutOptions) {\n    this.genericRadialLayout(true, graph, options);\n  }\n\n  private async genericRadialLayout(\n    assign: false,\n    graph: Graph,\n    options?: RadialLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericRadialLayout(\n    assign: true,\n    graph: Graph,\n    options?: RadialLayoutOptions\n  ): Promise<void>;\n  private async genericRadialLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: RadialLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n    const {\n      width: propsWidth,\n      height: propsHeight,\n      center: propsCenter,\n      focusNode: propsFocusNode,\n      unitRadius: propsUnitRadius,\n      nodeSize,\n      nodeSpacing,\n      strictRadial,\n      preventOverlap,\n      maxPreventOverlapIteration,\n      sortBy,\n      linkDistance = 50,\n      sortStrength = 10,\n      maxIteration = 1000,\n    } = mergedOptions;\n\n    const nodes = graph.getAllNodes();\n    const edges = graph.getAllEdges();\n\n    const width =\n      !propsWidth && typeof window !== \"undefined\"\n        ? window.innerWidth\n        : propsWidth!;\n    const height =\n      !propsHeight && typeof window !== \"undefined\"\n        ? window.innerHeight\n        : propsHeight!;\n    const center = (\n      !propsCenter ? [width / 2, height / 2] : propsCenter\n    ) as PointTuple;\n\n    if (!nodes?.length || nodes.length === 1) {\n      return handleSingleNodeGraph(graph, assign, center);\n    }\n\n    let focusNode = nodes[0];\n    if (isString(propsFocusNode)) {\n      for (let i = 0; i < nodes.length; i++) {\n        if (nodes[i].id === propsFocusNode) {\n          focusNode = nodes[i];\n          break;\n        }\n      }\n    } else {\n      focusNode = propsFocusNode || nodes[0];\n    }\n\n    // the index of the focusNode in data\n    const focusIndex = getIndexById(nodes, focusNode.id);\n\n    // the graph-theoretic distance (shortest path distance) matrix\n    const adjMatrix = getAdjMatrix({ nodes, edges }, false);\n    const distances = floydWarshall(adjMatrix);\n    const maxDistance = maxToFocus(distances, focusIndex);\n    // replace first node in unconnected component to the circle at (maxDistance + 1)\n    handleInfinity(distances, focusIndex, maxDistance + 1);\n\n    // the shortest path distance from each node to focusNode\n    const focusNodeD = distances[focusIndex];\n    let semiWidth =\n      width - center[0] > center[0] ? center[0] : width - center[0];\n    let semiHeight =\n      height - center[1] > center[1] ? center[1] : height - center[1];\n    if (semiWidth === 0) {\n      semiWidth = width / 2;\n    }\n    if (semiHeight === 0) {\n      semiHeight = height / 2;\n    }\n    // the maxRadius of the graph\n    const maxRadius = Math.min(semiWidth, semiHeight);\n    const maxD = Math.max(...focusNodeD);\n    // the radius for each nodes away from focusNode\n    const radii: number[] = [];\n    const unitRadius = !propsUnitRadius ? maxRadius / maxD : propsUnitRadius;\n    focusNodeD.forEach((value, i) => {\n      radii[i] = value * unitRadius;\n    });\n\n    const idealDistances = eIdealDisMatrix(\n      nodes,\n      distances,\n      linkDistance,\n      radii,\n      unitRadius,\n      sortBy,\n      sortStrength\n    );\n    // the weight matrix, Wij = 1 / dij^(-2)\n    const weights = getWeightMatrix(idealDistances);\n\n    // the initial positions from mds, move the graph to origin, centered at focusNode\n    const mdsResult = mds(linkDistance, idealDistances, linkDistance);\n    let positions = mdsResult.map(([x, y]) => ({\n      x:\n        (isNaN(x) ? Math.random() * linkDistance : x) -\n        mdsResult[focusIndex][0],\n      y:\n        (isNaN(y) ? Math.random() * linkDistance : y) -\n        mdsResult[focusIndex][1],\n    }));\n\n    this.run(\n      maxIteration,\n      positions,\n      weights,\n      idealDistances,\n      radii,\n      focusIndex\n    );\n    let nodeSizeFunc;\n    // stagger the overlapped nodes\n    if (preventOverlap) {\n      nodeSizeFunc = formatNodeSize(nodeSize, nodeSpacing);\n      const nonoverlapForceParams: RadialNonoverlapForceOptions = {\n        nodes,\n        nodeSizeFunc,\n        positions,\n        radii,\n        height,\n        width,\n        strictRadial: Boolean(strictRadial),\n        focusIdx: focusIndex,\n        iterations: maxPreventOverlapIteration || 200,\n        k: positions.length / 4.5,\n      };\n      positions = radialNonoverlapForce(graph, nonoverlapForceParams);\n    }\n    // move the graph to center\n    const layoutNodes: OutNode[] = [];\n    positions.forEach((p: Point, i: number) => {\n      const cnode = cloneFormatData(nodes[i]) as OutNode;\n      cnode.data.x = p.x + center[0];\n      cnode.data.y = p.y + center[1];\n      layoutNodes.push(cnode);\n    });\n\n    if (assign) {\n      layoutNodes.forEach((node) =>\n        graph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        })\n      );\n    }\n\n    const result = {\n      nodes: layoutNodes,\n      edges,\n    };\n\n    return result;\n  }\n  private run(\n    maxIteration: number,\n    positions: Point[],\n    weights: Matrix[],\n    idealDistances: Matrix[],\n    radii: number[],\n    focusIndex: number\n  ) {\n    for (let i = 0; i <= maxIteration; i++) {\n      const param = i / maxIteration;\n      this.oneIteration(\n        param,\n        positions,\n        radii,\n        idealDistances,\n        weights,\n        focusIndex\n      );\n    }\n  }\n  private oneIteration(\n    param: number,\n    positions: Point[],\n    radii: number[],\n    distances: Matrix[],\n    weights: Matrix[],\n    focusIndex: number\n  ) {\n    const vparam = 1 - param;\n    positions.forEach((v: Point, i: number) => {\n      // v\n      const originDis = getEuclideanDistance(v, { x: 0, y: 0 });\n      const reciODis = originDis === 0 ? 0 : 1 / originDis;\n      if (i === focusIndex) {\n        return;\n      }\n      let xMolecule = 0;\n      let yMolecule = 0;\n      let denominator = 0;\n      positions.forEach((u, j) => {\n        // u\n        if (i === j) {\n          return;\n        }\n        // the euclidean distance between v and u\n        const edis = getEuclideanDistance(v, u);\n        const reciEdis = edis === 0 ? 0 : 1 / edis;\n        const idealDis = distances[j][i];\n        // same for x and y\n        denominator += weights[i][j];\n        // x\n        xMolecule += weights[i][j] * (u.x + idealDis * (v.x - u.x) * reciEdis);\n        // y\n        yMolecule += weights[i][j] * (u.y + idealDis * (v.y - u.y) * reciEdis);\n      });\n      const reciR = radii[i] === 0 ? 0 : 1 / radii[i];\n      denominator *= vparam;\n      denominator += param * reciR * reciR;\n      // x\n      xMolecule *= vparam;\n      xMolecule += param * reciR * v.x * reciODis;\n      v.x = xMolecule / denominator;\n      // y\n      yMolecule *= vparam;\n      yMolecule += param * reciR * v.y * reciODis;\n      v.y = yMolecule / denominator;\n    });\n  }\n}\n\nconst eIdealDisMatrix = (\n  nodes: Node[],\n  distances: Matrix[],\n  linkDistance: number,\n  radii: number[],\n  unitRadius: number,\n  sortBy: string | undefined,\n  sortStrength: number\n): Matrix[] => {\n  if (!nodes) return [];\n  const result: Matrix[] = [];\n  if (distances) {\n    // cache the value of field sortBy for nodes to avoid dupliate calculation\n    const sortValueCache: {\n      [id: string]: number;\n    } = {};\n    distances.forEach((row: number[], i: number) => {\n      const newRow: Matrix = [];\n      row.forEach((v, j) => {\n        if (i === j) {\n          newRow.push(0);\n        } else if (radii[i] === radii[j]) {\n          // i and j are on the same circle\n          if (sortBy === \"data\") {\n            // sort the nodes on the same circle according to the ordering of the data\n            newRow.push(\n              (v * (Math.abs(i - j) * sortStrength)) / (radii[i] / unitRadius)\n            );\n          } else if (sortBy) {\n            // sort the nodes on the same circle according to the attributes\n            let iValue: number;\n            let jValue: number;\n            if (sortValueCache[nodes[i].id]) {\n              iValue = sortValueCache[nodes[i].id];\n            } else {\n              const value =\n                (sortBy === \"id\"\n                  ? nodes[i].id\n                  : (nodes[i].data?.[sortBy] as number | string)) || 0;\n              if (isString(value)) {\n                iValue = value.charCodeAt(0);\n              } else {\n                iValue = value;\n              }\n              sortValueCache[nodes[i].id] = iValue;\n            }\n\n            if (sortValueCache[nodes[j].id]) {\n              jValue = sortValueCache[nodes[j].id];\n            } else {\n              const value =\n                (sortBy === \"id\"\n                  ? nodes[j].id\n                  : (nodes[j].data?.[sortBy] as number | string)) || 0;\n              if (isString(value)) {\n                jValue = value.charCodeAt(0);\n              } else {\n                jValue = value;\n              }\n              sortValueCache[nodes[j].id] = jValue;\n            }\n            newRow.push(\n              (v * (Math.abs(iValue - jValue) * sortStrength)) /\n                (radii[i] / unitRadius)\n            );\n          } else {\n            newRow.push((v * linkDistance) / (radii[i] / unitRadius));\n          }\n        } else {\n          // i and j are on different circles\n          const link = (linkDistance + unitRadius) / 2;\n          newRow.push(v * link);\n        }\n      });\n      result.push(newRow);\n    });\n  }\n  return result;\n};\n\nconst getWeightMatrix = (idealDistances: Matrix[]) => {\n  const rows = idealDistances.length;\n  const cols = idealDistances[0].length;\n  const result: number[][] = [];\n  for (let i = 0; i < rows; i++) {\n    const row: number[] = [];\n    for (let j = 0; j < cols; j++) {\n      if (idealDistances[i][j] !== 0) {\n        row.push(1 / (idealDistances[i][j] * idealDistances[i][j]));\n      } else {\n        row.push(0);\n      }\n    }\n    result.push(row);\n  }\n  return result;\n};\n\nconst getIndexById = (array: any[], id: string | number) => {\n  let index = -1;\n  array.forEach((a, i) => {\n    if (a.id === id) {\n      index = i;\n    }\n  });\n  return Math.max(index, 0);\n};\n\nconst handleInfinity = (matrix: Matrix[], focusIndex: number, step: number) => {\n  const length = matrix.length;\n  // 遍历 matrix 中遍历 focus 对应行\n  for (let i = 0; i < length; i++) {\n    // matrix 关注点对应行的 Inf 项\n    if (matrix[focusIndex][i] === Infinity) {\n      matrix[focusIndex][i] = step;\n      matrix[i][focusIndex] = step;\n      // 遍历 matrix 中的 i 行，i 行中非 Inf 项若在 focus 行为 Inf，则替换 focus 行的那个 Inf\n      for (let j = 0; j < length; j++) {\n        if (matrix[i][j] !== Infinity && matrix[focusIndex][j] === Infinity) {\n          matrix[focusIndex][j] = step + matrix[i][j];\n          matrix[j][focusIndex] = step + matrix[i][j];\n        }\n      }\n    }\n  }\n  // 处理其他行的 Inf。根据该行对应点与 focus 距离以及 Inf 项点 与 focus 距离，决定替换值\n  for (let i = 0; i < length; i++) {\n    if (i === focusIndex) {\n      continue;\n    }\n    for (let j = 0; j < length; j++) {\n      if (matrix[i][j] === Infinity) {\n        let minus = Math.abs(matrix[focusIndex][i] - matrix[focusIndex][j]);\n        minus = minus === 0 ? 1 : minus;\n        matrix[i][j] = minus;\n      }\n    }\n  }\n};\n\nconst maxToFocus = (matrix: Matrix[], focusIndex: number): number => {\n  let max = 0;\n  for (let i = 0; i < matrix[focusIndex].length; i++) {\n    if (matrix[focusIndex][i] === Infinity) {\n      continue;\n    }\n    max = matrix[focusIndex][i] > max ? matrix[focusIndex][i] : max;\n  }\n  return max;\n};\n","import { Matrix as MLMatrix, SingularValueDecomposition } from 'ml-matrix';\nimport type { PointTuple, Matrix } from '../types';\n\nexport const mds = (dimension: number, distances: Matrix[], linkDistance: number): PointTuple[] => {\n  try {\n    // square distances\n    const M = MLMatrix.mul(MLMatrix.pow(distances, 2), -0.5);\n\n    // double centre the rows/columns\n    const rowMeans = M.mean('row');\n    const colMeans = M.mean('column');\n    const totalMean = M.mean();\n    M.add(totalMean).subRowVector(rowMeans).subColumnVector(colMeans);\n\n    // take the SVD of the double centred matrix, and return the\n    // points from it\n    const ret = new SingularValueDecomposition(M);\n    const eigenValues = MLMatrix.sqrt(ret.diagonalMatrix).diagonal();\n    return ret.leftSingularVectors.toJSON().map((row: number[]) => {\n      return MLMatrix.mul([row], [eigenValues]).toJSON()[0].splice(0, dimension) as PointTuple;\n    });\n  } catch {\n    const res: PointTuple[] = [];\n    for (let i = 0; i < distances.length; i++) {\n      const x = Math.random() * linkDistance;\n      const y = Math.random() * linkDistance;\n      res.push([x, y]);\n    }\n    return res;\n  }\n};","import type {\n  Graph,\n  LayoutMapping,\n  OutNode,\n  PointTuple,\n  RandomLayoutOptions,\n  Layout,\n} from \"./types\";\n\nconst DEFAULTS_LAYOUT_OPTIONS: Partial<RandomLayoutOptions> = {\n  center: [0, 0],\n  width: 300,\n  height: 300,\n};\n\n/**\n * Layout randomizing the nodes' position\n *\n * @example\n * // Assign layout options when initialization.\n * const layout = new RandomLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph); // { nodes: [], edges: [] }\n *\n * // Or use different options later.\n * const layout = new RandomLayout({ center: [100, 100] });\n * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }\n *\n * // If you want to assign the positions directly to the nodes, use assign method.\n * await layout.assign(graph, { center: [100, 100] });\n */\nexport class RandomLayout implements Layout<RandomLayoutOptions> {\n  id = \"random\";\n\n  constructor(public options: RandomLayoutOptions = {} as RandomLayoutOptions) {\n    this.options = {\n      ...DEFAULTS_LAYOUT_OPTIONS,\n      ...options,\n    };\n  }\n\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  async execute(graph: Graph, options?: RandomLayoutOptions) {\n    return this.genericRandomLayout(false, graph, options);\n  }\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  async assign(graph: Graph, options?: RandomLayoutOptions) {\n    this.genericRandomLayout(true, graph, options);\n  }\n\n  private async genericRandomLayout(\n    assign: false,\n    graph: Graph,\n    options?: RandomLayoutOptions\n  ): Promise<LayoutMapping>;\n  private async genericRandomLayout(\n    assign: true,\n    graph: Graph,\n    options?: RandomLayoutOptions\n  ): Promise<void>;\n  private async genericRandomLayout(\n    assign: boolean,\n    graph: Graph,\n    options?: RandomLayoutOptions\n  ): Promise<LayoutMapping | void> {\n    const mergedOptions = { ...this.options, ...options };\n    const {\n      center: propsCenter,\n      width: propsWidth,\n      height: propsHeight,\n    } = mergedOptions;\n\n    const nodes = graph.getAllNodes();\n    const layoutScale = 0.9;\n    const width =\n      !propsWidth && typeof window !== \"undefined\"\n        ? window.innerWidth\n        : (propsWidth as number);\n    const height =\n      !propsHeight && typeof window !== \"undefined\"\n        ? window.innerHeight\n        : (propsHeight as number);\n    const center = !propsCenter\n      ? [width / 2, height / 2]\n      : (propsCenter as PointTuple);\n\n    const layoutNodes: OutNode[] = [];\n    if (nodes) {\n      nodes.forEach((node) => {\n        layoutNodes.push({\n          id: node.id,\n          data: {\n            x: (Math.random() - 0.5) * layoutScale * width + center[0],\n            y: (Math.random() - 0.5) * layoutScale * height + center[1],\n          },\n        });\n      });\n    }\n\n    if (assign) {\n      layoutNodes.forEach((node) =>\n        graph.mergeNodeData(node.id, {\n          x: node.data.x,\n          y: node.data.y,\n        })\n      );\n    }\n\n    const result = {\n      nodes: layoutNodes,\n      edges: graph.getAllEdges(),\n    };\n\n    return result;\n  }\n}\n","import { CircularLayout } from \"./circular\";\nimport { ConcentricLayout } from \"./concentric\";\nimport { D3ForceLayout } from \"./d3Force\";\nimport { DagreLayout } from \"./dagre\";\nimport { ForceLayout } from \"./force\";\nimport { ForceAtlas2Layout } from \"./forceAtlas2\";\nimport { FruchtermanLayout } from \"./fruchterman\";\nimport { GridLayout } from \"./grid\";\nimport { MDSLayout } from \"./mds\";\nimport { RadialLayout } from \"./radial\";\nimport { RandomLayout } from \"./random\";\nimport type { LayoutConstructor } from \"./types\";\n\nexport const registry: Record<string, LayoutConstructor<any>> = {\n  circular: CircularLayout,\n  concentric: ConcentricLayout,\n  mds: MDSLayout,\n  random: RandomLayout,\n  grid: GridLayout,\n  radial: RadialLayout,\n  force: ForceLayout,\n  d3force: D3ForceLayout,\n  fruchterman: FruchtermanLayout,\n  forceAtlas2: ForceAtlas2Layout,\n  dagre: DagreLayout,\n};\n","import { Graph } from \"@antv/graphlib\";\nimport * as Comlink from \"comlink\";\nimport { registry } from \"./registry\";\nimport { isLayoutWithIterations } from \"./types\";\n\nlet currentLayout;\n\nconst obj = {\n  stopLayout() {\n    if (currentLayout?.stop) {\n      currentLayout.stop();\n    }\n  },\n  async calculateLayout(payload, transferables) {\n    const {\n      layout: { id, options, iterations },\n      nodes,\n      edges,\n    } = payload;\n\n    // Sync graph on the worker side.\n    // TODO: Use transferable objects like ArrayBuffer for nodes & edges,\n    // in which case we don't need the whole graph.\n    // @see https://github.com/graphology/graphology/blob/master/src/layout-noverlap/webworker.tpl.js#L32\n    const graph = new Graph({\n      nodes,\n      edges,\n    });\n\n    /**\n     * Create layout instance on the worker side.\n     */\n\n    const layoutCtor = registry[id];\n    if (layoutCtor) {\n      currentLayout = new layoutCtor(options);\n    } else {\n      throw new Error(`Unknown layout id: ${id}`);\n    }\n\n    let positions = await currentLayout.execute(graph);\n    if (isLayoutWithIterations(currentLayout)) {\n      currentLayout.stop();\n      positions = currentLayout.tick(iterations);\n    }\n    return [positions, transferables];\n  },\n};\n\nComlink.expose(obj);\n","import {\n  Graph as IGraph,\n  Node as INode,\n  Edge as IEdge,\n  PlainObject,\n  GraphView as IGraphView,\n  ID,\n} from \"@antv/graphlib\";\n\nexport interface NodeData extends PlainObject {\n  size?: number | number[];\n  bboxSize?: number[];\n  borderLeft?: ID | ID[];\n  borderRight?: ID | ID[];\n  x?: number;\n  y?: number;\n  z?: number;\n  height?: number;\n  width?: number;\n  e?: IEdge<EdgeData>;\n  selfEdges?: IEdge<EdgeData>[];\n  rank?: number;\n  _rank?: number;\n  order?: number;\n  fixorder?: number;\n  minRank?: number;\n  maxRank?: number;\n  layout?: boolean;\n  layer?: number;\n  low?: number;\n  lim?: number;\n}\n\nexport interface OutNodeData extends NodeData {\n  x: number;\n  y: number;\n  z?: number;\n}\n\nexport interface EdgeData extends PlainObject {\n  // temp edges e.g. the edge generated for releated collapsed combo\n  virtual?: boolean;\n  weight?: number;\n  x?: number;\n  y?: number;\n  height?: number;\n  width?: number;\n  points?: Point[];\n  controlPoints?: Point[];\n  minlen?: number;\n  cutvalue?: number;\n  labeloffset?: number;\n}\n\n/** input node */\nexport type Node = INode<NodeData>;\n/** output node */\nexport type OutNode = INode<OutNodeData>;\n/** input and output edge */\nexport type Edge = IEdge<EdgeData>;\n\nexport type Degree = {\n  in: number;\n  out: number;\n  all: number;\n};\n\n// maps node's id and its index in the nodes array\nexport type IndexMap = {\n  [nodeId: string]: number;\n};\n\nexport type Graph = IGraph<NodeData, EdgeData>;\nexport type GraphView = IGraphView<NodeData, EdgeData>;\n\nexport type PointTuple = [number, number] | [number, number, number];\nexport type Point = { x: number; y: number; z?: number };\nexport type Matrix = number[];\nexport type LayoutMapping = { nodes: OutNode[]; edges: Edge[] };\n\nexport interface Layout<LayoutOptions> {\n  /**\n   * To directly assign the positions to the nodes.\n   */\n  assign(graph: Graph, options?: LayoutOptions): Promise<void>;\n  /**\n   * Return the positions of nodes and edges(if needed).\n   */\n  execute(graph: Graph, options?: LayoutOptions): Promise<LayoutMapping>;\n  /**\n   * Layout options, can be changed in runtime.\n   */\n  options: LayoutOptions;\n  /**\n   * Unique ID, it will get registered and used on the webworker-side.\n   */\n  id: string;\n}\n\nexport function isLayoutWithIterations(\n  layout: any\n): layout is LayoutWithIterations<any> {\n  return !!layout.tick && !!layout.stop;\n}\n\nexport interface LayoutWithIterations<LayoutOptions>\n  extends Layout<LayoutOptions> {\n  /**\n   * Some layout algorithm has n iterations so that the simulation needs to be stopped at any time.\n   * This method is useful for running the simulation manually.\n   * @see https://github.com/d3/d3-force#simulation_stop\n   */\n  stop: () => void;\n\n  /**\n   * Manually steps the simulation by the specified number of iterations.\n   * @see https://github.com/d3/d3-force#simulation_tick\n   */\n  tick: (iterations?: number) => LayoutMapping;\n}\n\nexport interface LayoutConstructor<LayoutOptions> {\n  new (options?: LayoutOptions): Layout<LayoutOptions>;\n}\n\nexport interface LayoutSupervisor {\n  execute(): Promise<LayoutMapping>;\n  stop(): void;\n  kill(): void;\n  isRunning(): boolean;\n}\n\nexport interface CircularLayoutOptions {\n  center?: PointTuple;\n  width?: number;\n  height?: number;\n  radius?: number | null;\n  startRadius?: number | null;\n  endRadius?: number | null;\n  clockwise?: boolean;\n  divisions?: number;\n  ordering?: \"topology\" | \"topology-directed\" | \"degree\" | null;\n  angleRatio?: number;\n  startAngle?: number;\n  endAngle?: number;\n  nodeSpacing?: ((node?: Node) => number) | number;\n  nodeSize?: number | number[];\n}\n\nexport interface GridLayoutOptions {\n  width?: number;\n  height?: number;\n  begin?: PointTuple;\n  preventOverlap?: boolean;\n  nodeSize?: number | number[];\n  preventOverlapPadding?: number;\n  condense?: boolean;\n  rows?: number;\n  cols?: number;\n  sortBy?: string;\n  position?: (node?: Node) => { row?: number; col?: number };\n  nodeSpacing?: ((node?: Node) => number) | number;\n}\n\nexport interface RandomLayoutOptions {\n  center?: PointTuple;\n  width?: number;\n  height?: number;\n}\n\nexport interface MDSLayoutOptions {\n  center?: PointTuple;\n  linkDistance?: number;\n}\n\nexport interface ConcentricLayoutOptions {\n  center?: PointTuple;\n  preventOverlap?: boolean;\n  nodeSize?: number | PointTuple;\n  sweep?: number;\n  equidistant?: boolean;\n  startAngle?: number;\n  clockwise?: boolean;\n  maxLevelDiff?: number;\n  sortBy?: string;\n  width?: number;\n  height?: number;\n  nodeSpacing?: number | number[] | ((node?: Node) => number);\n}\n\nexport interface RadialLayoutOptions {\n  center?: PointTuple;\n  width?: number;\n  height?: number;\n  linkDistance?: number;\n  maxIteration?: number;\n  focusNode?: string | Node | null;\n  unitRadius?: number | null;\n  preventOverlap?: boolean;\n  nodeSize?: number | number[];\n  nodeSpacing?: number | Function;\n  maxPreventOverlapIteration?: number;\n  strictRadial?: boolean;\n  sortBy?: string;\n  sortStrength?: number;\n}\n\nexport type DagreRankdir =\n  | \"TB\"\n  | \"BT\"\n  | \"LR\"\n  | \"RL\"\n  | \"tb\"\n  | \"lr\"\n  | \"rl\"\n  | \"bt\";\nexport type DagreAlign = \"UL\" | \"UR\" | \"DL\" | \"DR\";\n\nexport interface DagreLayoutOptions {\n  rankdir?: DagreRankdir;\n  align?: DagreAlign;\n  begin?: PointTuple;\n  nodeSize?: number | number[];\n  nodesep?: number;\n  ranksep?: number;\n  controlPoints?: boolean;\n  sortByCombo?: boolean;\n  edgeLabelSpace?: boolean;\n  nodeOrder?: string[];\n  radial?: boolean; // 是否基于 dagre 进行辐射布局\n  focusNode?: ID | Node | null; // radial 为 true 时生效，关注的节点\n  preset?: {\n    nodes: OutNode[];\n    edges: Edge[];\n  };\n  nodesepFunc?: (d?: Node) => number;\n  ranksepFunc?: (d?: Node) => number;\n}\n\nexport interface D3ForceLayoutOptions {\n  center?: PointTuple;\n  linkDistance?: number | ((edge?: Edge) => number);\n  edgeStrength?: number | ((edge?: Edge) => number);\n  nodeStrength?: number | ((node?: Node) => number);\n  preventOverlap?: boolean;\n  collideStrength?: number;\n  nodeSize?: number | number[] | ((node?: Node) => number);\n  nodeSpacing?: number | number[] | ((node?: Node) => number);\n  alpha?: number;\n  alphaDecay?: number;\n  alphaMin?: number;\n  clustering?: boolean;\n  clusterNodeStrength?: number;\n  clusterEdgeStrength?: number;\n  clusterEdgeDistance?: number;\n  clusterNodeSize?: number;\n  clusterFociStrength?: number;\n  forceSimulation?: any;\n  onTick?: (data: LayoutMapping) => void;\n}\n\nexport interface CentripetalOptions {\n  /** Force strength for leaf nodes. */\n  leaf?: number | ((node: Node, nodes: Node[], edges: Edge[]) => number);\n  /** Force strength for single nodes. */\n  single?: number | ((node: Node) => number);\n  /** Force strength for other nodes. */\n  others?: number | ((node: Node) => number);\n  /** Centri force's position and sterngth, points to the canvas center by default */\n  center?: (\n    node: Node,\n    nodes: Node[],\n    edges: Edge[],\n    width: number,\n    height: number\n  ) => {\n    x: number;\n    y: number;\n    z?: number;\n    centerStrength?: number;\n  };\n}\n\ninterface CommonForceLayoutOptions {\n  dimensions?: number;\n  center?: PointTuple;\n  minMovement?: number;\n  maxIteration?: number;\n  distanceThresholdMode?: \"mean\" | \"max\" | \"min\";\n\n  /**\n   * If distance is specified, sets the maximum distance between nodes over which this force is considered. \n   * If distance is not specified, returns the current maximum distance, which defaults to infinity. \n   * Specifying a finite maximum distance improves performance and produces a more localized layout.\n   */\n  maxDistance?: number;\n}\n\nexport interface ForceLayoutOptions extends CommonForceLayoutOptions {\n  width?: number;\n  height?: number;\n  linkDistance?: number | ((edge?: Edge, source?: any, target?: any) => number);\n  nodeStrength?: number | ((d?: Node) => number);\n  edgeStrength?: number | ((d?: Edge) => number);\n  preventOverlap?: boolean;\n  nodeSize?: number | number[] | ((d?: Node) => number);\n  nodeSpacing?: number | ((d?: Node) => number);\n  damping?: number;\n  maxSpeed?: number;\n  coulombDisScale?: number;\n  gravity?: number;\n  factor?: number;\n  interval?: number;\n  centripetalOptions?: CentripetalOptions;\n  leafCluster?: boolean;\n  clustering?: boolean;\n  nodeClusterBy?: string;\n  clusterNodeStrength?: number | ((node: Node) => number);\n  collideStrength?: number;\n  onTick?: (data: LayoutMapping) => void;\n  getMass?: (node?: Node) => number;\n  getCenter?: (node?: Node, degree?: number) => number[];\n  monitor?: (params: {\n    energy: number;\n    nodes: Node[];\n    edges: Edge[];\n    iterations: number;\n  }) => void;\n}\n\nexport interface ForceAtlas2LayoutOptions extends CommonForceLayoutOptions {\n  width?: number;\n  height?: number;\n  kr?: number;\n  kg?: number;\n  ks?: number;\n  ksmax?: number;\n  tao?: number;\n  mode?: \"normal\" | \"linlog\";\n  preventOverlap?: boolean;\n  dissuadeHubs?: boolean;\n  barnesHut?: boolean;\n  prune?: boolean;\n  nodeSize?: number | number[] | ((node?: Node) => number);\n  onTick?: (data: LayoutMapping) => void;\n}\nexport interface FruchtermanLayoutOptions extends CommonForceLayoutOptions {\n  width?: number;\n  height?: number;\n  gravity?: number;\n  speed?: number;\n  clustering?: boolean;\n  clusterGravity?: number;\n  nodeClusterBy?: string;\n  onTick?: (data: LayoutMapping) => void;\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n// the startup function\n__webpack_require__.x = () => {\n\t// Load entry module and return exports\n\t// This entry module depends on other loaded chunks and execution need to be delayed\n\tvar __webpack_exports__ = __webpack_require__.O(undefined, [435], () => (__webpack_require__(7011)))\n\t__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n\treturn __webpack_exports__;\n};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks and sibling chunks for the entrypoint\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".index.min.js\";\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","__webpack_require__.p = \"\";","// no baseURI\n\n// object to store loaded chunks\n// \"1\" means \"already loaded\"\nvar installedChunks = {\n\t11: 1\n};\n\n// importScripts chunk loading\nvar installChunk = (data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\tfor(var moduleId in moreModules) {\n\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t}\n\t}\n\tif(runtime) runtime(__webpack_require__);\n\twhile(chunkIds.length)\n\t\tinstalledChunks[chunkIds.pop()] = 1;\n\tparentChunkLoadingFunction(data);\n};\n__webpack_require__.f.i = (chunkId, promises) => {\n\t// \"1\" is the signal for \"already loaded\"\n\tif(!installedChunks[chunkId]) {\n\t\tif(true) { // all chunks have JS\n\t\t\timportScripts(__webpack_require__.p + __webpack_require__.u(chunkId));\n\t\t}\n\t}\n};\n\nvar chunkLoadingGlobal = this[\"webpackChunkLayout\"] = this[\"webpackChunkLayout\"] || [];\nvar parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);\nchunkLoadingGlobal.push = installChunk;\n\n// no HMR\n\n// no HMR manifest","// run startup\nvar __webpack_exports__ = __webpack_require__.x();\n"],"sourceRoot":""}