cx-viewer 1.0.2 → 1.0.4

package/dist/assets/swimlanes-5IMT3BWC-_30OXwXy.js

@@ -0,0 +1,2 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./sizeCapture-X5ZJPWSS-B4OVmPqu.js","./mermaid.core-Cy9iVxov.js","./vendor-mdxeditor-4PbKH6K7.js","./vendor-antd-Bzi1WuBb.js","./vendor-codemirror-CKTrJd47.js","./vendor-markdown-BN3QLsBu.js"])))=>i.map(i=>d[i]);
+import{_ as __vitePreload}from"./vendor-mdxeditor-4PbKH6K7.js";import{c as clear$2}from"./chunk-RYQCIY6F-BK2jDXwB.js";import{al as markers_default,am as clear2,an as clear,ao as clear$1,l as log,c as getConfig2,af as insertNode,ae as insertCluster,ag as positionNode,as as insertEdge,au as insertEdgeLabel,z as getConfig,ar as getSubGraphTitleMargins,av as edgeLabels,y as utils_default,aw as terminalLabels,_ as __name,ax as markerOffsets}from"./mermaid.core-Cy9iVxov.js";import{G as Graph}from"./graph-CnJdn47S.js";import"./vendor-antd-Bzi1WuBb.js";import"./vendor-codemirror-CKTrJd47.js";import"./map-DQeg2hXV.js";import"./vendor-markdown-BN3QLsBu.js";async function createGraphWithElements(element,data4Layout){const graph=new Graph({multigraph:!0,compound:!0}),edgesToProcess=[...data4Layout.edges],config=getConfig2(),rootGroups=element.insert("g").attr("class","root"),clusters=rootGroups.insert("g").attr("class","clusters"),edgePaths=rootGroups.insert("g").attr("class","edges edgePath"),edgeLabels2=rootGroups.insert("g").attr("class","edgeLabels"),nodesGroup=rootGroups.insert("g").attr("class","nodes"),nodeElements=new Map,hasDom=null!=element.node();await Promise.all(data4Layout.nodes.map(async node=>{var _a;if(node.isGroup)graph.setNode(node.id,{...node});else{if(hasDom){const childNodeEl=await insertNode(nodesGroup,node,{config:config,dir:node.dir}),boundingBox=(null==(_a=childNodeEl.node())?void 0:_a.getBBox())??{width:0,height:0};nodeElements.set(node.id,childNodeEl),node.width=boundingBox.width,node.height=boundingBox.height}graph.setNode(node.id,{...node})}}));for(const edge of edgesToProcess){graph.setEdge(edge.start,edge.end,{...edge},edge.id);data4Layout.edges.some(existingEdge=>existingEdge.id===edge.id)||data4Layout.edges.push(edge)}if(globalThis.mermaidCaptureSizes){const{captureNodeSizes:captureNodeSizes}=await __vitePreload(async()=>{const{captureNodeSizes:captureNodeSizes2}=await import("./sizeCapture-X5ZJPWSS-B4OVmPqu.js");return{captureNodeSizes:captureNodeSizes2}},__vite__mapDeps([0,1,2,3,4,5]),import.meta.url);captureNodeSizes(element,data4Layout)}return{graph:graph,groups:{clusters:clusters,edgePaths:edgePaths,edgeLabels:edgeLabels2,nodes:nodesGroup,rootGroups:rootGroups},nodeElements:nodeElements}}__name(createGraphWithElements,"createGraphWithElements");function buildSegmentList(points){const segments=[];for(let i=0;i<points.length-1;i++)segments.push({a:points[i],b:points[i+1]});return segments}function segmentIntersection(a1,a2,b1,b2){const dxA=a2.x-a1.x,dyA=a2.y-a1.y,dxB=b2.x-b1.x,dyB=b2.y-b1.y,denom=dxA*dyB-dyA*dxB;if(0===denom)return null;const dx=b1.x-a1.x,dy=b1.y-a1.y,tA=(dx*dyB-dy*dxB)/denom,tB=(dx*dyA-dy*dxA)/denom;return tA<=1e-6||tA>=.999999||tB<=1e-6||tB>=.999999?null:{point:{x:a1.x+tA*dxA,y:a1.y+tA*dyA},tA:tA,tB:tB}}function isHorizontalSeg(seg){return Math.abs(seg.b.x-seg.a.x)>=Math.abs(seg.b.y-seg.a.y)}function findEdgeIntersections(edges){const crossings=[];for(let i=0;i<edges.length;i++){const edgeA=edges[i],segmentsA=buildSegmentList(edgeA.points);for(let j=i+1;j<edges.length;j++){const edgeB=edges[j],segmentsB=buildSegmentList(edgeB.points);for(const[si,segA]of segmentsA.entries())for(const[sj,segB]of segmentsB.entries()){const hit=segmentIntersection(segA.a,segA.b,segB.a,segB.b);if(!hit)continue;const aHoriz=isHorizontalSeg(segA);!!(aHoriz!==isHorizontalSeg(segB))&&aHoriz?crossings.push({jumpEdgeId:edgeA.id,otherEdgeId:edgeB.id,segIndex:si,t:hit.tA,point:hit.point}):crossings.push({jumpEdgeId:edgeB.id,otherEdgeId:edgeA.id,segIndex:sj,t:hit.tB,point:hit.point})}}}return crossings}function fmt(n){const rounded=Math.round(1e3*n)/1e3;return Number.isInteger(rounded),`${rounded}`}function pointToString(p){return`${fmt(p.x)},${fmt(p.y)}`}function getArcSweepFlag(seg){const dx=seg.b.x-seg.a.x,dy=seg.b.y-seg.a.y;return Math.abs(dx)>=Math.abs(dy)?dx>=0?1:0:dy>=0?1:0}__name(buildSegmentList,"buildSegmentList"),__name(segmentIntersection,"segmentIntersection"),__name(isHorizontalSeg,"isHorizontalSeg"),__name(findEdgeIntersections,"findEdgeIntersections"),__name(fmt,"fmt"),__name(pointToString,"pointToString"),__name(getArcSweepFlag,"getArcSweepFlag");function applyMarkerOffsets(points,edge){if(points.length<2)return points.map(p=>({...p}));const out=points.map(p=>({...p})),startOff=edge.arrowTypeStart&&markerOffsets[edge.arrowTypeStart];if(startOff){const a=points[0],b=points[1],ang=Math.atan2(b.y-a.y,b.x-a.x);out[0].x=a.x+startOff*Math.cos(ang),out[0].y=a.y+startOff*Math.sin(ang)}const endOff=edge.arrowTypeEnd&&markerOffsets[edge.arrowTypeEnd];if(endOff){const n=points.length,a=points[n-2],b=points[n-1],ang=Math.atan2(b.y-a.y,b.x-a.x);out[n-1].x=b.x-endOff*Math.cos(ang),out[n-1].y=b.y-endOff*Math.sin(ang)}return out}function emitJump(jump,ux,uy,sweep,style){const cx=jump.point.x,cy=jump.point.y,pre={x:cx-ux*jump.r,y:cy-uy*jump.r},post={x:cx+ux*jump.r,y:cy+uy*jump.r},out=[`L${pointToString(pre)}`];return"arc"===style?out.push(`A${fmt(jump.r)},${fmt(jump.r)} 0 0 ${sweep} ${pointToString(post)}`):out.push(`M${pointToString(post)}`),out}function computeRoundedCorner(prev,curr,next,radius){const dx1=curr.x-prev.x,dy1=curr.y-prev.y,dx2=next.x-curr.x,dy2=next.y-curr.y,len1=Math.hypot(dx1,dy1),len2=Math.hypot(dx2,dy2);if(len1<1e-5||len2<1e-5)return null;const nx1=dx1/len1,ny1=dy1/len1,nx2=dx2/len2,ny2=dy2/len2,dot=nx1*nx2+ny1*ny2,clamped=Math.max(-1,Math.min(1,dot)),angle=Math.acos(clamped);if(angle<1e-5||Math.abs(Math.PI-angle)<1e-5)return null;const cutLen=Math.min(radius/Math.sin(angle/2),len1/2,len2/2);return{startX:curr.x-nx1*cutLen,startY:curr.y-ny1*cutLen,endX:curr.x+nx2*cutLen,endY:curr.y+ny2*cutLen,ctrlX:curr.x,ctrlY:curr.y,cutLen:cutLen}}function rewriteEdgePath(edge,jumps,config){const rawPoints=edge.points;if(rawPoints.length<2)return"";const points=applyMarkerOffsets(rawPoints,edge),rounded="rounded"===edge.curve,segments=buildSegmentList(points),bySeg=new Map;for(const j of jumps){const seg=segments[j.segIndex];if(!seg)continue;const segLen=Math.hypot(seg.b.x-seg.a.x,seg.b.y-seg.a.y),list=bySeg.get(j.segIndex)??[];list.push({t:j.t,point:j.point,d:j.t*segLen,r:config.jumpRadius}),bySeg.set(j.segIndex,list)}const parts=[`M${pointToString(points[0])}`];for(let i=0;i<segments.length;i++){const seg=segments[i],segLen=Math.hypot(seg.b.x-seg.a.x,seg.b.y-seg.a.y),ux=0===segLen?0:(seg.b.x-seg.a.x)/segLen,uy=0===segLen?0:(seg.b.y-seg.a.y)/segLen,sweep=getArcSweepFlag(seg);let segStartConsumed=0;if(rounded&&i>0){const corner=computeRoundedCorner(points[i-1],points[i],points[i+1]??points[i],5);corner&&(segStartConsumed=corner.cutLen)}let segEndStop=segLen,upcomingCorner=null;rounded&&i<segments.length-1&&(upcomingCorner=computeRoundedCorner(points[i],points[i+1],points[i+2]??points[i+1],5),upcomingCorner&&(segEndStop=segLen-upcomingCorner.cutLen));const segJumps=[...bySeg.get(i)??[]].sort((a,b)=>a.t-b.t);for(const j of segJumps)j.r=Math.min(j.r,j.d-segStartConsumed,segEndStop-j.d);for(let k=0;k<segJumps.length-1;k++){const gap=segJumps[k+1].d-segJumps[k].d;if(segJumps[k].r+segJumps[k+1].r>gap){const half=gap/2;segJumps[k].r=Math.min(segJumps[k].r,half),segJumps[k+1].r=Math.min(segJumps[k+1].r,half)}}for(const j of segJumps)j.r<.001||parts.push(...emitJump(j,ux,uy,sweep,config.jumpStyle));rounded&&upcomingCorner?(parts.push(`L${fmt(upcomingCorner.startX)},${fmt(upcomingCorner.startY)}`),parts.push(`Q${fmt(upcomingCorner.ctrlX)},${fmt(upcomingCorner.ctrlY)} ${fmt(upcomingCorner.endX)},${fmt(upcomingCorner.endY)}`)):parts.push(`L${pointToString(seg.b)}`)}return parts.join(" ")}function isStraightPath(d){return/^[\d\s+,.LMelm-]*$/.test(d)}function curveSupportsLineHops(curve){return!curve||("linear"===curve||"rounded"===curve||"step"===curve||"stepBefore"===curve||"stepAfter"===curve)}function decodeDataPoints(raw){if(!raw)return null;try{const json="function"==typeof atob?atob(raw):Buffer.from(raw,"base64").toString(),parsed=JSON.parse(json);if(!Array.isArray(parsed))return null;const pts=[];for(const p of parsed)p&&"number"==typeof p.x&&"number"==typeof p.y&&pts.push({x:p.x,y:p.y});return pts.length>=2?pts:null}catch{return null}}function applyLineJumpsToSvg(edgePathsGroup,edges,config){if(!config.enabled)return;const groupNode=edgePathsGroup.node();if(!groupNode)return;const edgeMeta=new Map;for(const e of edges)edgeMeta.set(e.id,e);const renderedEdges=[],pathById=new Map;for(const e of edges){const escapedId="undefined"!=typeof CSS&&CSS.escape?CSS.escape(e.id):e.id,pathEl=groupNode.querySelector(`path[data-id="${escapedId}"]`);if(!pathEl)continue;pathById.set(e.id,pathEl);const points=decodeDataPoints(pathEl.getAttribute("data-points"))??e.points;renderedEdges.push({...e,points:points})}const crossings=findEdgeIntersections(renderedEdges);if(0===crossings.length)return;const jumpsByEdge=new Map;for(const c of crossings){const list=jumpsByEdge.get(c.jumpEdgeId)??[];list.push(c),jumpsByEdge.set(c.jumpEdgeId,list)}for(const renderedEdge of renderedEdges){const jumps=jumpsByEdge.get(renderedEdge.id);if(!jumps||0===jumps.length)continue;const meta=edgeMeta.get(renderedEdge.id),curveHint=null==meta?void 0:meta.curve;if(void 0!==curveHint&&!curveSupportsLineHops(curveHint))continue;const pathEl=pathById.get(renderedEdge.id);if(!pathEl)continue;if(void 0===curveHint){if(!isStraightPath(pathEl.getAttribute("d")??""))continue}const originalStyle=pathEl.getAttribute("style")??"",dasharrayMatch=/stroke-dasharray\s*:\s*0\s+([\d.]+)\s+[\d.]+\s+([\d.]+)/.exec(originalStyle),preservedOValueS=dasharrayMatch?Number.parseFloat(dasharrayMatch[1]):null,preservedOValueE=dasharrayMatch?Number.parseFloat(dasharrayMatch[2]):null,newD=rewriteEdgePath(renderedEdge,jumps,config);if(pathEl.setAttribute("d",newD),null!==preservedOValueS&&null!==preservedOValueE&&"function"==typeof pathEl.getTotalLength){const newLen=pathEl.getTotalLength(),newDasharray=`0 ${preservedOValueS} ${Math.max(0,newLen-preservedOValueS-preservedOValueE)} ${preservedOValueE}`,cleaned=originalStyle.replace(/stroke-dasharray\s*:[^;]*;?/g,`stroke-dasharray: ${newDasharray};`).replace(/;\s*;+/g,";");pathEl.setAttribute("style",cleaned)}}}async function adjustLayout(data4Layout,groups){var _a,_b;for(const node of data4Layout.nodes)node.isGroup?await insertCluster(groups.clusters,node):positionNode(node);const nodeById=new Map;for(const node of data4Layout.nodes)(null==node?void 0:node.id)&&nodeById.set(node.id,node);for(const edge of data4Layout.edges){const startNode=edge.start?nodeById.get(edge.start)??{}:{},endNode=edge.end?nodeById.get(edge.end)??{}:{},paths=insertEdge(groups.edgePaths,{...edge},{},data4Layout.type,startNode,endNode,data4Layout.diagramId);edge.label&&await insertEdgeLabel(groups.rootGroups,edge),edge.label&&positionEdgeLabel(edge,paths)}const lineHopsConfig=null==(_b=null==(_a=data4Layout.config)?void 0:_a.swimlane)?void 0:_b.lineHops;if(!1!==lineHopsConfig){const jumpStyle="gap"===lineHopsConfig?"gap":"arc",edgeGeometries=data4Layout.edges.filter(e=>Array.isArray(e.points)&&e.points.length>=2).map(e=>({id:e.id,points:e.points,curve:e.curve,arrowTypeStart:e.arrowTypeStart,arrowTypeEnd:e.arrowTypeEnd}));applyLineJumpsToSvg(groups.edgePaths,edgeGeometries,{enabled:!0,jumpRadius:6,jumpStyle:jumpStyle})}}function positionEdgeLabel(edge,paths){const path=(null==paths?void 0:paths.updatedPath)??(null==paths?void 0:paths.originalPath),siteConfig=getConfig(),{subGraphTitleTotalMargin:subGraphTitleTotalMargin}=getSubGraphTitleMargins({flowchart:siteConfig.flowchart??{}});if(edge.label){const el=edgeLabels.get(edge.id);let x=edge.x,y=edge.y;if(path){const pos=utils_default.calcLabelPosition(path);log.debug("Moving label "+edge.label+" from (",x,",",y,") to (",pos.x,",",pos.y,") abc88"),paths&&(x=pos.x,y=pos.y)}el.attr("transform",`translate(${x}, ${y+subGraphTitleTotalMargin/2})`)}if(null==edge?void 0:edge.startLabelLeft){const el=terminalLabels.get(edge.id).startLeft;let x=null==edge?void 0:edge.x,y=null==edge?void 0:edge.y;if(path){const pos=utils_default.calcTerminalLabelPosition(edge.arrowTypeStart?10:0,"start_left",path);x=pos.x,y=pos.y}el.attr("transform",`translate(${x}, ${y})`)}if(edge.startLabelRight){const el=terminalLabels.get(edge.id).startRight;let x=edge.x,y=edge.y;if(path){const pos=utils_default.calcTerminalLabelPosition(edge.arrowTypeStart?10:0,"start_right",path);x=pos.x,y=pos.y}el.attr("transform",`translate(${x}, ${y})`)}if(edge.endLabelLeft){const el=terminalLabels.get(edge.id).endLeft;let x=edge.x,y=edge.y;if(path){const pos=utils_default.calcTerminalLabelPosition(edge.arrowTypeEnd?10:0,"end_left",path);x=pos.x,y=pos.y}el.attr("transform",`translate(${x}, ${y})`)}if(edge.endLabelRight){const el=terminalLabels.get(edge.id).endRight;let x=edge.x,y=edge.y;if(path){const pos=utils_default.calcTerminalLabelPosition(edge.arrowTypeEnd?10:0,"end_right",path);x=pos.x,y=pos.y}el.attr("transform",`translate(${x}, ${y})`)}}__name(applyMarkerOffsets,"applyMarkerOffsets"),__name(emitJump,"emitJump"),__name(computeRoundedCorner,"computeRoundedCorner"),__name(rewriteEdgePath,"rewriteEdgePath"),__name(isStraightPath,"isStraightPath"),__name(curveSupportsLineHops,"curveSupportsLineHops"),__name(decodeDataPoints,"decodeDataPoints"),__name(applyLineJumpsToSvg,"applyLineJumpsToSvg"),__name(adjustLayout,"adjustLayout"),__name(positionEdgeLabel,"positionEdgeLabel");function topLaneHorizontalPadding(lane){return Math.max(lane.padding??20,20)}function assignTopLaneTitleRect(lane){const{x:x,y:y,width:width,height:height}=lane,contentTop=lane.swimlaneContentTop;if("number"!=typeof x||"number"!=typeof y||"number"!=typeof width||"number"!=typeof height||"number"!=typeof contentTop||!Number.isFinite(x)||!Number.isFinite(y)||!Number.isFinite(width)||!Number.isFinite(height)||!Number.isFinite(contentTop)||width<=0||height<=0)return void delete lane.groupTitleRect;const top=y-height/2,headerBottom=Math.min(contentTop,y+height/2),bottom=top+Math.min(21,Math.max(0,headerBottom-top));bottom<=top?delete lane.groupTitleRect:lane.groupTitleRect={left:x-width/2,right:x+width/2,top:top,bottom:bottom}}function prepareLayoutForSwimlanes(layout){const direction=layout.direction,nodes=layout.nodes??(layout.nodes=[]);for(const node of layout.nodes??[])node.isGroup&&!node.parentId&&(node.shape="swimlane",direction&&(node.direction=direction));const looseNodes=nodes.filter(node=>!node.isGroup&&!node.parentId);if(0===looseNodes.length)return;let defaultLane=nodes.find(node=>"__swimlane_default__"===node.id);defaultLane?defaultLane.isGroup&&(defaultLane.shape="swimlane",direction&&(defaultLane.direction=direction)):(defaultLane={id:"__swimlane_default__",label:"",isGroup:!0,shape:"swimlane",padding:20,...direction?{direction:direction}:{}},nodes.push(defaultLane));for(const node of looseNodes)node.parentId="__swimlane_default__"}function toGraphView(layout){const nodeById=new Map;for(const n of layout.nodes??[])nodeById.set(n.id,n);const edges=[];for(const e of layout.edges??[]){const src="string"==typeof e.start?e.start:void 0,dst="string"==typeof e.end?e.end:void 0;src&&dst&&(e.labelNodeId||edges.push({id:e.id,src:src,dst:dst,ref:e}))}const allNodes=layout.nodes??[],groupNodes=allNodes.filter(n=>n.isGroup),nonGroupNodes=allNodes.filter(n=>!n.isGroup);return{nodes:[...[...groupNodes].reverse(),...nonGroupNodes].map(n=>n.id),edges:edges,layout:layout,nodeById:nodeById}}function writeBackToLayoutData(g,ordered,coords,opts){const{layout:layout}=g,nodeMap=g.nodeById,layerGap=(null==opts?void 0:opts.layerGap)??100,nodeGap=(null==opts?void 0:opts.nodeGap)??40;let layerIndex=0;for(const layer of ordered.layers){let orderIndex=0;for(const id of layer){const node=nodeMap.get(id);if(!node){orderIndex++;continue}node.layer=layerIndex,node.order=orderIndex;const x=coords.x[id]??orderIndex*nodeGap,y=coords.y[id]??layerIndex*layerGap;node.x=x,node.y=y,orderIndex++}layerIndex++}const allNodes=layout.nodes??[],groupBounds=new Map,topLevelGroups=[];for(const group of allNodes){if(!(null==group?void 0:group.isGroup))continue;group.parentId||topLevelGroups.push(group);const children=allNodes.filter(n=>n.parentId===group.id);let minX=1/0,maxX=-1/0,minY=1/0,maxY=-1/0;for(const child of children){const cx=child.x??coords.x[child.id],cy=child.y??coords.y[child.id],cw=child.width??0,ch=child.height??0;null!=cx&&null!=cy&&(minX=Math.min(minX,cx-cw/2),maxX=Math.max(maxX,cx+cw/2),minY=Math.min(minY,cy-ch/2),maxY=Math.max(maxY,cy+ch/2))}if(minX===1/0||minY===1/0)group.x=group.x??0,group.y=group.y??0,group.width=group.width??0,group.height=group.height??0;else{const pad=group.padding??20,horizontalPad=group.parentId?pad:2*topLaneHorizontalPadding(group),verticalPad=pad,w=Math.max(0,maxX-minX)+horizontalPad,h=Math.max(0,maxY-minY)+verticalPad,cx=(minX+maxX)/2,cy=(minY+maxY)/2;group.x=cx,group.y=cy,group.width=w,group.height=h,groupBounds.set(group.id,{minX:minX,maxX:maxX,minY:minY,maxY:maxY})}}if(topLevelGroups.length>0&&groupBounds.size>0){let globalMinY=1/0,globalMaxY=-1/0,maxPad=0;for(const lane of topLevelGroups){const pad=lane.padding??20;pad>maxPad&&(maxPad=pad);const b=groupBounds.get(lane.id);b&&(globalMinY=Math.min(globalMinY,b.minY),globalMaxY=Math.max(globalMaxY,b.maxY))}if(globalMinY!==1/0&&globalMaxY!==-1/0){const minHeaderMargin=36,laneHeight=Math.max(0,globalMaxY-globalMinY)+2*Math.max(maxPad,minHeaderMargin),centerY=(globalMinY+globalMaxY)/2;for(const lane of topLevelGroups)lane.y=centerY,lane.height=laneHeight,lane.swimlaneContentTop=globalMinY;const sortedLanes=[...topLevelGroups].sort((a,b)=>(a.x??0)-(b.x??0)),laneIds=[],centers=[],baseWidths=[];for(const lane of sortedLanes){const b=groupBounds.get(lane.id);if(!b)continue;const contentWidth=Math.max(0,b.maxX-b.minX)+2*topLaneHorizontalPadding(lane),cx=(b.minX+b.maxX)/2;laneIds.push(lane.id),centers.push(cx),baseWidths.push(contentWidth)}const count=laneIds.length;if(count>0){const laneWidths=new Map;if(1===count)laneWidths.set(laneIds[0],baseWidths[0]);else{const d=[];for(let i=0;i<count-1;i++)d.push(centers[i+1]-centers[i]);const u=new Array(count);u[0]=0;for(let i=0;i<count-1;i++)u[i+1]=2*d[i]-u[i];let lowerBound=0,upperBound=Number.POSITIVE_INFINITY;for(let i=0;i<count;i++){const baseW=baseWidths[i];i%2==0?lowerBound=Math.max(lowerBound,baseW-u[i]):upperBound=Math.min(upperBound,u[i]-baseW)}let x=lowerBound;x=lowerBound<=upperBound?(lowerBound+upperBound)/2:lowerBound;for(let i=0;i<count;i++){const w=u[i]+(i%2==0?x:-x),finalWidth=Math.max(baseWidths[i],w);laneWidths.set(laneIds[i],finalWidth)}}for(const lane of topLevelGroups){const w=laneWidths.get(lane.id);null!=w&&(lane.width=w),assignTopLaneTitleRect(lane)}}}}}__name(topLaneHorizontalPadding,"topLaneHorizontalPadding"),__name(assignTopLaneTitleRect,"assignTopLaneTitleRect"),__name(prepareLayoutForSwimlanes,"prepareLayoutForSwimlanes"),__name(toGraphView,"toGraphView"),__name(writeBackToLayoutData,"writeBackToLayoutData");function createEdgeLabelNodes(data){const nodesToAdd=[],layoutOnlyEdges=[],nodeById=new Map;for(const node of data.nodes)nodeById.set(node.id,node);for(const edge of data.edges){if(!edge.label||0===edge.label.length)continue;if(edge.isLayoutOnly)continue;if(edge.labelNodeId)continue;const sourceNode=edge.start?nodeById.get(edge.start):void 0,targetNode=edge.end?nodeById.get(edge.end):void 0;if(!sourceNode||!targetNode){log.warn("[EdgeLabelNodes]",`Edge ${edge.id} has missing source or target node`);continue}const labelNodeId=`edge-label-${edge.start}-${edge.end}-${edge.id}`,labelLane=sourceNode.parentId!==targetNode.parentId?targetNode.parentId:sourceNode.parentId,labelNode={id:labelNodeId,label:edge.label,edgeStart:edge.start??"",edgeEnd:edge.end??"",shape:"labelRect",width:0,height:0,isEdgeLabel:!0,isDummy:!0,parentId:labelLane,isGroup:!1,labelStyle:Array.isArray(edge.labelStyle)?edge.labelStyle[0]:edge.labelStyle??"",...sourceNode.dir?{dir:sourceNode.dir}:{}};nodesToAdd.push(labelNode),edge.labelNodeId=labelNodeId,edge.label=void 0,edge.text=void 0;const toLabelVirtual={id:`${edge.id}-to-label`,start:edge.start,end:labelNodeId,type:"normal",isLayoutOnly:!0},fromLabelVirtual={id:`${edge.id}-from-label`,start:labelNodeId,end:edge.end,type:"normal",isLayoutOnly:!0};layoutOnlyEdges.push(toLabelVirtual,fromLabelVirtual)}const newNodes=[...data.nodes,...nodesToAdd],newEdges=[...data.edges,...layoutOnlyEdges];return{...data,nodes:newNodes,edges:newEdges}}__name(createEdgeLabelNodes,"createEdgeLabelNodes");var EPS=.001;function measuredNodeRect(node){const cx=node.x??0,cy=node.y??0,width=node.width??0,height=node.height??0;return width>0&&height>0?{cx:cx,cy:cy,rect:rectFromCenterSize(cx,cy,width,height)}:void 0}function nodeBoundsInfoFor(node){if(node.isGroup)return;const measured=measuredNodeRect(node);if(!measured)return;return{id:String(node.id??""),cx:measured.cx,cy:measured.cy,rect:measured.rect}}function samePoint(a,b,epsilon=EPS){return Math.abs(a.x-b.x)<epsilon&&Math.abs(a.y-b.y)<epsilon}function sameX(a,b,epsilon=EPS){return Math.abs(a.x-b.x)<epsilon}function sameY(a,b,epsilon=EPS){return Math.abs(a.y-b.y)<epsilon}function isHorizontalSegment(a,b,epsilon=EPS){return sameY(a,b,epsilon)&&Math.abs(a.x-b.x)>epsilon}function isVerticalSegment(a,b,epsilon=EPS){return sameX(a,b,epsilon)&&Math.abs(a.y-b.y)>epsilon}function overlapLength(a1,a2,b1,b2){return Math.max(0,Math.min(Math.max(a1,a2),Math.max(b1,b2))-Math.max(Math.min(a1,a2),Math.min(b1,b2)))}function sameAxisSegmentOverlapLength(a,b,epsilon=EPS){return a.horizontal&&b.horizontal&&sameY(a.a,b.a,epsilon)?overlapLength(a.a.x,a.b.x,b.a.x,b.b.x):a.vertical&&b.vertical&&sameX(a.a,b.a,epsilon)?overlapLength(a.a.y,a.b.y,b.a.y,b.b.y):0}function orthogonalSegmentsForPoints(points,epsilon=EPS){const result=[];for(let i=0;i<points.length-1;i++){const a=points[i],b=points[i+1],horizontal=isHorizontalSegment(a,b,epsilon),vertical=isVerticalSegment(a,b,epsilon);(horizontal||vertical)&&result.push({index:i,a:a,b:b,horizontal:horizontal,vertical:vertical})}return result}function countOrthogonalBends(points,epsilon=EPS){const segments=orthogonalSegmentsForPoints(points,epsilon);let bends=0;for(let i=1;i<segments.length;i++)segments[i-1].horizontal!==segments[i].horizontal&&bends++;return bends}function dedupeConsecutivePoints(points,epsilon=EPS){const result=[];for(const point of points){const last=result.length>0?result[result.length-1]:void 0;last&&samePoint(last,point,epsilon)||result.push({x:point.x,y:point.y})}return result}function classifyThreeSegmentRoute(points,epsilon=EPS){if(!points||4!==points.length)return;const[p0,p1,p2,p3]=points;if(isHorizontalSegment(p0,p1,epsilon)&&isVerticalSegment(p1,p2,epsilon)&&isHorizontalSegment(p2,p3,epsilon))return{kind:"HVH",p0:p0,p1:p1,p2:p2,p3:p3};return isVerticalSegment(p0,p1,epsilon)&&isHorizontalSegment(p1,p2,epsilon)&&isVerticalSegment(p2,p3,epsilon)?{kind:"VHV",p0:p0,p1:p1,p2:p2,p3:p3}:void 0}function segmentBoundsOverlapRect(a,b,rect,buffer=0){const segMinX=Math.min(a.x,b.x),segMaxX=Math.max(a.x,b.x),segMinY=Math.min(a.y,b.y),segMaxY=Math.max(a.y,b.y);return segMaxX>rect.left-buffer&&segMinX<rect.right+buffer&&segMaxY>rect.top-buffer&&segMinY<rect.bottom+buffer}function pointInsideRect(point,rect,buffer=0){return point.x>rect.left+buffer&&point.x<rect.right-buffer&&point.y>rect.top+buffer&&point.y<rect.bottom-buffer}function rectContainsRect(outer,inner){return outer.left<=inner.left&&outer.right>=inner.right&&outer.top<=inner.top&&outer.bottom>=inner.bottom}function rectsOverlap(a,b){return a.left<b.right&&a.right>b.left&&a.top<b.bottom&&a.bottom>b.top}function inflateRect(rect,margin){return{left:rect.left-margin,right:rect.right+margin,top:rect.top-margin,bottom:rect.bottom+margin}}function rectFromCenterSize(cx,cy,width,height){return{left:cx-width/2,right:cx+width/2,top:cy-height/2,bottom:cy+height/2}}function rectOfNodeBounds(node){var _a;return null==(_a=measuredNodeRect(node))?void 0:_a.rect}function portForRectSide(node,side){switch(side){case"top":return{x:node.cx,y:node.rect.top};case"bottom":return{x:node.cx,y:node.rect.bottom};case"left":return{x:node.rect.left,y:node.cy};case"right":return{x:node.rect.right,y:node.cy}}}function buildOrthogonalPortPath(src,srcSide,dst,dstSide,anchor,epsilon=EPS){const srcH="left"===srcSide||"right"===srcSide,dstH="left"===dstSide||"right"===dstSide;if(srcH&&dstH){if("right"===srcSide&&"left"===dstSide&&src.x<dst.x||"left"===srcSide&&"right"===dstSide&&src.x>dst.x){if(sameY(src,dst,epsilon))return[src,dst];const midX=(src.x+dst.x)/2;return[src,{x:midX,y:src.y},{x:midX,y:dst.y},dst]}if(srcSide===dstSide){if(sameY(src,dst,epsilon))return;const intX="left"===srcSide?Math.min(src.x,dst.x)-anchor:Math.max(src.x,dst.x)+anchor;return[src,{x:intX,y:src.y},{x:intX,y:dst.y},dst]}return}if(!srcH&&!dstH){if(srcSide===dstSide){if(sameX(src,dst,epsilon))return;const intY="top"===srcSide?Math.min(src.y,dst.y)-anchor:Math.max(src.y,dst.y)+anchor;return[src,{x:src.x,y:intY},{x:dst.x,y:intY},dst]}if(!("bottom"===srcSide&&"top"===dstSide&&src.y<dst.y||"top"===srcSide&&"bottom"===dstSide&&src.y>dst.y))return;if(sameX(src,dst,epsilon))return[src,dst];const midY=(src.y+dst.y)/2;return[src,{x:src.x,y:midY},{x:dst.x,y:midY},dst]}if(srcH&&!dstH){const sameDirSrc2="right"===srcSide&&dst.x>src.x||"left"===srcSide&&dst.x<src.x,sameDirDst2="top"===dstSide&&src.y<dst.y||"bottom"===dstSide&&src.y>dst.y;return sameDirSrc2&&sameDirDst2?[src,{x:dst.x,y:src.y},dst]:void 0}const sameDirSrc="bottom"===srcSide&&dst.y>src.y||"top"===srcSide&&dst.y<src.y,sameDirDst="left"===dstSide&&src.x<dst.x||"right"===dstSide&&src.x>dst.x;return sameDirSrc&&sameDirDst?[src,{x:src.x,y:dst.y},dst]:void 0}function buildSameSideTrackPath(src,side,dst,track){return"left"===side||"right"===side?[src,{x:track,y:src.y},{x:track,y:dst.y},dst]:[src,{x:src.x,y:track},{x:dst.x,y:track},dst]}function collectRealNodeBounds(nodes){const nodeInfoById=new Map,realNodeRects=[];for(const node of nodes){if(node.isEdgeLabel)continue;const info=nodeBoundsInfoFor(node);info&&(nodeInfoById.set(info.id,info),realNodeRects.push({id:info.id,rect:info.rect}))}return{nodeInfoById:nodeInfoById,realNodeRects:realNodeRects}}function collectNodeRectEntries(nodes){const realNodeRects=[],labelNodeRects=[];for(const node of nodes){const info=nodeBoundsInfoFor(node);if(!info)continue;const entry={id:info.id,rect:info.rect};node.isEdgeLabel?labelNodeRects.push(entry):realNodeRects.push(entry)}return{realNodeRects:realNodeRects,labelNodeRects:labelNodeRects}}function collectLayoutNodeRects(nodes,{includeEdgeLabels:includeEdgeLabels=!0}={}){const result=[];for(const node of nodes){if(node.isGroup||!includeEdgeLabels&&node.isEdgeLabel)continue;const cx=node.x??0,cy=node.y??0,width=node.width??0,height=node.height??0;result.push({nodeId:node.id,...rectFromCenterSize(cx,cy,width,height)})}return result}function getNodePairGeometry(edge,nodeInfoById,epsilon=EPS){const srcId=edge.start,dstId=edge.end;if(!srcId||!dstId)return;const srcInfo=nodeInfoById.get(srcId),dstInfo=nodeInfoById.get(dstId);return srcInfo&&dstInfo?{srcId:srcId,dstId:dstId,srcInfo:srcInfo,dstInfo:dstInfo,collinearX:Math.abs(srcInfo.cx-dstInfo.cx)<epsilon,collinearY:Math.abs(srcInfo.cy-dstInfo.cy)<epsilon}:void 0}function segmentHitsAnyRect(a,b,rects,excludeIds=[],shrink=0){for(const entry of rects)if(!excludeIds.includes(entry.id)&&segmentBoundsOverlapRect(a,b,entry.rect,-shrink))return!0;return!1}function orthogonalSegmentsCross(a1,b1,a2,b2,epsilon=EPS,endpointTolerance=1e-6){const s1H=sameY(a1,b1,epsilon),s1V=sameX(a1,b1,epsilon),s2H=sameY(a2,b2,epsilon),s2V=sameX(a2,b2,epsilon);if(s1H&&s2H||s1V&&s2V)return!1;if(!s1H&&!s1V||!s2H&&!s2V)return!1;const horiz=s1H?{a:a1,b:b1}:{a:a2,b:b2},vert=s1V?{a:a1,b:b1}:{a:a2,b:b2},hY=horiz.a.y,hX1=Math.min(horiz.a.x,horiz.b.x),hX2=Math.max(horiz.a.x,horiz.b.x),vX=vert.a.x,vY1=Math.min(vert.a.y,vert.b.y),vY2=Math.max(vert.a.y,vert.b.y);if(vX<hX1||vX>hX2||hY<vY1||hY>vY2)return!1;const matchesHorizEndpoint=Math.abs(vX-horiz.a.x)<endpointTolerance&&Math.abs(hY-horiz.a.y)<endpointTolerance||Math.abs(vX-horiz.b.x)<endpointTolerance&&Math.abs(hY-horiz.b.y)<endpointTolerance,matchesVertEndpoint=Math.abs(vX-vert.a.x)<endpointTolerance&&Math.abs(hY-vert.a.y)<endpointTolerance||Math.abs(vX-vert.b.x)<endpointTolerance&&Math.abs(hY-vert.b.y)<endpointTolerance;return!(matchesHorizEndpoint&&matchesVertEndpoint)}function sameAxisSegmentsOverlap(a1,b1,a2,b2,epsilon=EPS){const s1H=sameY(a1,b1,epsilon),s1V=sameX(a1,b1,epsilon),s2H=sameY(a2,b2,epsilon),s2V=sameX(a2,b2,epsilon);return s1V&&s2V&&sameX(a1,a2,epsilon)?overlapLength(a1.y,b1.y,a2.y,b2.y)>epsilon:!!(s1H&&s2H&&sameY(a1,a2,epsilon))&&overlapLength(a1.x,b1.x,a2.x,b2.x)>epsilon}function segmentConflictsWithAnyEdge(a,b,edges,excludeEdge,{epsilon:epsilon=EPS,skipDegenerateOther:skipDegenerateOther=!1}={}){for(const other of edges){if(other===excludeEdge||other.isLayoutOnly)continue;const points=other.points;if(points&&!(points.length<2))for(let i=0;i<points.length-1;i++){const oa=points[i],ob=points[i+1];if((!skipDegenerateOther||!samePoint(oa,ob,epsilon))&&(orthogonalSegmentsCross(a,b,oa,ob,epsilon)||sameAxisSegmentsOverlap(a,b,oa,ob,epsilon)))return!0}}return!1}function orthogonalSegmentsStrictlyCross(a1,b1,a2,b2,epsilon=EPS){const aHoriz=sameY(a1,b1,epsilon),aVert=sameX(a1,b1,epsilon),bHoriz=sameY(a2,b2,epsilon),bVert=sameX(a2,b2,epsilon);if(!(aHoriz&&bVert||aVert&&bHoriz))return!1;const horiz=aHoriz?{a:a1,b:b1}:{a:a2,b:b2},vert=aHoriz?{a:a2,b:b2}:{a:a1,b:b1},hY=horiz.a.y,hXmin=Math.min(horiz.a.x,horiz.b.x),hXmax=Math.max(horiz.a.x,horiz.b.x),vX=vert.a.x,vYmin=Math.min(vert.a.y,vert.b.y),vYmax=Math.max(vert.a.y,vert.b.y);return vX>hXmin+epsilon&&vX<hXmax-epsilon&&hY>vYmin+epsilon&&hY<vYmax-epsilon}function strictlyBetween(value,a,b){const lo=Math.min(a,b),hi=Math.max(a,b);return value>lo+EPS&&value<hi-EPS}function isCollinearIntermediate(prev,cur,next){return sameX(prev,cur)&&sameX(cur,next)?strictlyBetween(cur.y,prev.y,next.y):!(!sameY(prev,cur)||!sameY(cur,next))&&strictlyBetween(cur.x,prev.x,next.x)}function simplifyPolylineOnce(points){let changed=!1;const out=[];for(let i=0;i<points.length;i++){const prev=out[out.length-1],cur=points[i],next=i+1<points.length?points[i+1]:void 0;if(prev&&next){if(samePoint(prev,next)){i++,changed=!0;continue}if(isCollinearIntermediate(prev,cur,next)){changed=!0;continue}}out.push(cur)}return{points:out,changed:changed}}function orthogonalizePolyline(pts){const cleaned=[pts[0]];for(let i=1;i<pts.length;i++){const prev=cleaned[cleaned.length-1],curr=pts[i];if(!sameX(prev,curr)&&!sameY(prev,curr)){const prevPrev=cleaned.length>=2?cleaned[cleaned.length-2]:void 0,corner=!!prevPrev&&sameX(prevPrev,prev)?{x:prev.x,y:curr.y}:{x:curr.x,y:prev.y};cleaned.push(corner)}cleaned.push(curr)}const deduped=[];for(const p of cleaned){const last=deduped[deduped.length-1];last&&samePoint(last,p)||deduped.push(p)}return deduped}function simplifyPolyline(pts){if(pts.length<3)return pts;let work=[...pts];for(let guard=0;guard<32;guard++){const result=simplifyPolylineOnce(work);if(work=result.points,!result.changed)break}return work}__name(measuredNodeRect,"measuredNodeRect"),__name(nodeBoundsInfoFor,"nodeBoundsInfoFor"),__name(samePoint,"samePoint"),__name(sameX,"sameX"),__name(sameY,"sameY"),__name(isHorizontalSegment,"isHorizontalSegment"),__name(isVerticalSegment,"isVerticalSegment"),__name(overlapLength,"overlapLength"),__name(sameAxisSegmentOverlapLength,"sameAxisSegmentOverlapLength"),__name(orthogonalSegmentsForPoints,"orthogonalSegmentsForPoints"),__name(countOrthogonalBends,"countOrthogonalBends"),__name(dedupeConsecutivePoints,"dedupeConsecutivePoints"),__name(classifyThreeSegmentRoute,"classifyThreeSegmentRoute"),__name(segmentBoundsOverlapRect,"segmentBoundsOverlapRect"),__name(pointInsideRect,"pointInsideRect"),__name(rectContainsRect,"rectContainsRect"),__name(rectsOverlap,"rectsOverlap"),__name(inflateRect,"inflateRect"),__name(rectFromCenterSize,"rectFromCenterSize"),__name(rectOfNodeBounds,"rectOfNodeBounds"),__name(portForRectSide,"portForRectSide"),__name(buildOrthogonalPortPath,"buildOrthogonalPortPath"),__name(buildSameSideTrackPath,"buildSameSideTrackPath"),__name(collectRealNodeBounds,"collectRealNodeBounds"),__name(collectNodeRectEntries,"collectNodeRectEntries"),__name(collectLayoutNodeRects,"collectLayoutNodeRects"),__name(getNodePairGeometry,"getNodePairGeometry"),__name(segmentHitsAnyRect,"segmentHitsAnyRect"),__name(orthogonalSegmentsCross,"orthogonalSegmentsCross"),__name(sameAxisSegmentsOverlap,"sameAxisSegmentsOverlap"),__name(segmentConflictsWithAnyEdge,"segmentConflictsWithAnyEdge"),__name(orthogonalSegmentsStrictlyCross,"orthogonalSegmentsStrictlyCross"),__name(strictlyBetween,"strictlyBetween"),__name(isCollinearIntermediate,"isCollinearIntermediate"),__name(simplifyPolylineOnce,"simplifyPolylineOnce"),__name(orthogonalizePolyline,"orthogonalizePolyline"),__name(simplifyPolyline,"simplifyPolyline");var EPS2=.001;function endpointContextFor(edge,nodeByIdMap,minPoints){const candidate=edge;if(candidate.isLayoutOnly||!candidate.points||candidate.points.length<minPoints)return;const src=candidate.start?nodeByIdMap.get(candidate.start):void 0,dst=candidate.end?nodeByIdMap.get(candidate.end):void 0;return{edge:candidate,points:candidate.points,srcRect:src?rectOfNodeBounds(src):void 0,dstRect:dst?rectOfNodeBounds(dst):void 0}}function segmentEnterPoint(outside,inside,r){if(sameY(outside,inside,EPS2)){return{x:outside.x<r.left?r.left:r.right,y:outside.y}}if(sameX(outside,inside,EPS2)){const y=outside.y<r.top?r.top:r.bottom;return{x:outside.x,y:y}}return{x:Math.min(r.right,Math.max(r.left,outside.x)),y:Math.min(r.bottom,Math.max(r.top,outside.y))}}function clipEndpoint(points,rect,atStart){const step=atStart?1:-1;let outsideIndex=atStart?0:points.length-1;for(;outsideIndex>=0&&outsideIndex<points.length&&pointInsideRect(points[outsideIndex],rect,.5);)outsideIndex+=step;if(outsideIndex<0||outsideIndex>=points.length)return points;const insideIndex=outsideIndex-step;if(insideIndex<0||insideIndex>=points.length)return points;const entry=segmentEnterPoint(points[outsideIndex],points[insideIndex],rect);return atStart?[entry,...points.slice(outsideIndex)]:[...points.slice(0,outsideIndex+1),entry]}function clipEdgeEndpointsToNodeBoundaries(edges,nodeByIdMap){for(const edge of edges){const context=endpointContextFor(edge,nodeByIdMap,2);if(!context)continue;let next=[...context.points];context.srcRect&&(next=clipEndpoint(next,context.srcRect,!0)),context.dstRect&&(next=clipEndpoint(next,context.dstRect,!1)),next=simplifyPolyline(orthogonalizePolyline(next)),next=clearStraightEndpointCornerConnections(next,context.srcRect,context.dstRect),context.edge.points=simplifyPolyline(orthogonalizePolyline(next))}}function snapEndpointToBoundary(inner,endpoint,r,useApproachSide=!1){if(sameY(inner,endpoint,EPS2)){if(endpoint.y<r.top-EPS2||endpoint.y>r.bottom+EPS2)return endpoint;if(useApproachSide){if(inner.x<r.left-EPS2)return{x:r.left,y:inner.y};if(inner.x>r.right+EPS2)return{x:r.right,y:inner.y}}return{x:Math.abs(endpoint.x-r.left)<=Math.abs(endpoint.x-r.right)?r.left:r.right,y:inner.y}}if(sameX(inner,endpoint,EPS2)){if(endpoint.x<r.left-EPS2||endpoint.x>r.right+EPS2)return endpoint;if(useApproachSide){if(inner.y<r.top-EPS2)return{x:inner.x,y:r.top};if(inner.y>r.bottom+EPS2)return{x:inner.x,y:r.bottom}}const toTop=Math.abs(endpoint.y-r.top)<=Math.abs(endpoint.y-r.bottom);return{x:inner.x,y:toTop?r.top:r.bottom}}return endpoint}function firstDistinctAdjacent(points,endpointIndex,step){const endpoint=points[endpointIndex];for(let index=endpointIndex+step;index>=0&&index<points.length;index+=step){const candidate=points[index];if(!samePoint(candidate,endpoint,EPS2))return candidate}return points[endpointIndex+step]}function cornerClearanceRange(min,max){const lo=min+4,hi=max-4;return lo<=hi?{lo:lo,hi:hi}:{lo:(min+max)/2,hi:(min+max)/2}}function clampToCornerClearance(value,min,max){const{lo:lo,hi:hi}=cornerClearanceRange(min,max);return Math.min(hi,Math.max(lo,value))}function intersectRanges(ranges){const lo=Math.max(...ranges.map(range=>range.lo)),hi=Math.min(...ranges.map(range=>range.hi));if(!(lo>hi))return{lo:lo,hi:hi}}function clearanceRangeForSide(r,side){return"left"===side||"right"===side?cornerClearanceRange(r.top,r.bottom):cornerClearanceRange(r.left,r.right)}function terminalSideForSegment(endpoint,adjacent,r){const yWithin=endpoint.y>=r.top-EPS2&&endpoint.y<=r.bottom+EPS2,xWithin=endpoint.x>=r.left-EPS2&&endpoint.x<=r.right+EPS2;if(sameY(endpoint,adjacent,EPS2)&&yWithin){if(Math.abs(endpoint.x-r.left)<EPS2)return"left";if(Math.abs(endpoint.x-r.right)<EPS2)return"right"}if(sameX(endpoint,adjacent,EPS2)&&xWithin){if(Math.abs(endpoint.y-r.top)<EPS2)return"top";if(Math.abs(endpoint.y-r.bottom)<EPS2)return"bottom"}}function isHorizontalSide(side){return"left"===side||"right"===side}function straightClearanceRange(start,end,srcRect,dstRect,horizontal){const ranges=[],srcSide=srcRect?terminalSideForSegment(start,end,srcRect):void 0,dstSide=dstRect?terminalSideForSegment(end,start,dstRect):void 0;return srcRect&&srcSide&&isHorizontalSide(srcSide)===horizontal&&ranges.push(clearanceRangeForSide(srcRect,srcSide)),dstRect&&dstSide&&isHorizontalSide(dstSide)===horizontal&&ranges.push(clearanceRangeForSide(dstRect,dstSide)),ranges.length>0?intersectRanges(ranges):void 0}function clearStraightEndpointCornerAxis(start,end,srcRect,dstRect,horizontal){const range=straightClearanceRange(start,end,srcRect,dstRect,horizontal);if(!range)return;const current=horizontal?start.y:start.x,next=Math.min(range.hi,Math.max(range.lo,current));return Math.abs(next-current)<EPS2?void 0:horizontal?[{x:start.x,y:next},{x:end.x,y:next}]:[{x:next,y:start.y},{x:next,y:end.y}]}function clearStraightEndpointCornerConnections(points,srcRect,dstRect){if(2!==points.length)return points;const[start,end]=points;return sameY(start,end,EPS2)?clearStraightEndpointCornerAxis(start,end,srcRect,dstRect,!0)??points:sameX(start,end,EPS2)?clearStraightEndpointCornerAxis(start,end,srcRect,dstRect,!1)??points:points}function cornerClearedEndpoint(endpoint,r,side){return isHorizontalSide(side)?{x:endpoint.x,y:clampToCornerClearance(endpoint.y,r.top,r.bottom)}:{x:clampToCornerClearance(endpoint.x,r.left,r.right),y:endpoint.y}}function moveCollinearEndpointRun(points,endpointIndex,step,endpoint,adjusted,horizontalTerminal){const next=points.map(point=>({...point}));for(let index=endpointIndex;index>=0&&index<points.length;index+=step){const point=points[index];if(horizontalTerminal&&!sameY(point,endpoint,EPS2))break;if(!horizontalTerminal&&!sameX(point,endpoint,EPS2))break;horizontalTerminal?next[index].y=adjusted.y:next[index].x=adjusted.x}return next}function clearEndpointCornerConnection(points,r,atStart){if(points.length<2)return points;const endpointIndex=atStart?0:points.length-1,step=atStart?1:-1,endpoint=points[endpointIndex],adjacent=firstDistinctAdjacent(points,endpointIndex,step);if(!adjacent)return points;const side=terminalSideForSegment(endpoint,adjacent,r);if(!side)return points;const horizontalTerminal=isHorizontalSide(side),adjusted=cornerClearedEndpoint(endpoint,r,side);return samePoint(endpoint,adjusted,EPS2)?points:moveCollinearEndpointRun(points,endpointIndex,step,endpoint,adjusted,horizontalTerminal)}function borderSideForSegment(a,b,r){const xWithin=Math.min(a.x,b.x)>=r.left-EPS2&&Math.max(a.x,b.x)<=r.right+EPS2,yWithin=Math.min(a.y,b.y)>=r.top-EPS2&&Math.max(a.y,b.y)<=r.bottom+EPS2;return Math.abs(a.y-r.top)<EPS2&&Math.abs(b.y-r.top)<EPS2&&xWithin?"top":Math.abs(a.y-r.bottom)<EPS2&&Math.abs(b.y-r.bottom)<EPS2&&xWithin?"bottom":Math.abs(a.x-r.left)<EPS2&&Math.abs(b.x-r.left)<EPS2&&yWithin?"left":Math.abs(a.x-r.right)<EPS2&&Math.abs(b.x-r.right)<EPS2&&yWithin?"right":void 0}function leavesOutward(side,from,to,r){switch(side){case"top":return sameX(from,to,EPS2)&&to.y<r.top-EPS2;case"bottom":return sameX(from,to,EPS2)&&to.y>r.bottom+EPS2;case"left":return sameY(from,to,EPS2)&&to.x<r.left-EPS2;case"right":return sameY(from,to,EPS2)&&to.x>r.right+EPS2}}function collapseOwnBorderStub(points,r,atStart){if(points.length<3)return points;if(atStart){const side2=borderSideForSegment(points[0],points[1],r);return side2&&leavesOutward(side2,points[1],points[2],r)?points.slice(1):points}const last=points.length-1,side=borderSideForSegment(points[last-1],points[last],r);return side&&leavesOutward(side,points[last-1],points[last-2],r)?points.slice(0,last):points}function snapAndCollapseEndpoints(points,srcRect,dstRect){let next=points;if(srcRect){const adjacent=firstDistinctAdjacent(next,0,1);if(adjacent){const snapped=snapEndpointToBoundary(adjacent,next[0],srcRect);snapped!==next[0]&&(next=[snapped,...next.slice(1)])}next=collapseOwnBorderStub(next,srcRect,!0)}if(dstRect){const last=next.length-1,adjacent=firstDistinctAdjacent(next,last,-1);if(adjacent){const snapped=snapEndpointToBoundary(adjacent,next[last],dstRect,!0);snapped!==next[last]&&(next=[...next.slice(0,last),snapped])}next=collapseOwnBorderStub(next,dstRect,!1)}const straightCleared=clearStraightEndpointCornerConnections(next,srcRect,dstRect);return straightCleared!==next||2===next.length?straightCleared:(srcRect&&(next=clearEndpointCornerConnection(next,srcRect,!0)),dstRect&&(next=clearEndpointCornerConnection(next,dstRect,!1)),next)}function prepareEdgeEndpointsForRenderer(edges,nodeByIdMap){for(const edge of edges){const context=endpointContextFor(edge,nodeByIdMap,2);if(!context)continue;const newPts=snapAndCollapseEndpoints(dedupeConsecutivePoints(context.points,EPS2),context.srcRect,context.dstRect);if(newPts.length<3){context.edge.points=newPts;continue}const duplicated=[newPts[0],{...newPts[0]},...newPts.slice(1,-1),newPts[newPts.length-1],{...newPts[newPts.length-1]}];context.edge.points=duplicated}}function buildNodeMap(nodes){return new Map(nodes.map(node=>[node.id,node]))}function resolveTopLevelGroupId(node,nodeById){let parentId=node.parentId,topLevelGroupId=null;for(;parentId;){const parent=nodeById.get(parentId);if(!(null==parent?void 0:parent.isGroup))break;topLevelGroupId=parent.id,parentId=parent.parentId}return topLevelGroupId}function groupDepth(group,nodeById){let depth=0,parentId=group.parentId;for(;parentId;){const parent=nodeById.get(parentId);if(!(null==parent?void 0:parent.isGroup))break;depth++,parentId=parent.parentId}return depth}function boundsForChildren(children){let minX=1/0,maxX=-1/0,minY=1/0,maxY=-1/0;for(const child of children){const cx=child.x,cy=child.y;if("number"!=typeof cx||"number"!=typeof cy)continue;const w=child.width??0,h=child.height??0;minX=Math.min(minX,cx-w/2),maxX=Math.max(maxX,cx+w/2),minY=Math.min(minY,cy-h/2),maxY=Math.max(maxY,cy+h/2)}return minX===1/0||minY===1/0?null:{minX:minX,maxX:maxX,minY:minY,maxY:maxY}}function applyGroupBounds(group,bounds){const pad=group.padding??20;group.x=(bounds.minX+bounds.maxX)/2,group.y=(bounds.minY+bounds.maxY)/2,group.width=Math.max(0,bounds.maxX-bounds.minX)+pad,group.height=Math.max(0,bounds.maxY-bounds.minY)+pad}function recomputeNestedGroupBounds(nodes){const nodeById=buildNodeMap(nodes),groupsByDepth=nodes.filter(node=>node.isGroup&&node.parentId).sort((a,b)=>groupDepth(b,nodeById)-groupDepth(a,nodeById));for(const group of groupsByDepth){const bounds=boundsForChildren(nodes.filter(node=>node.parentId===group.id));bounds&&applyGroupBounds(group,bounds)}}function mirrorAxis(layout,axis){const nodes=layout.nodes??[],edges=layout.edges??[],contentNodes=nodes.filter(node=>!node.isGroup);let min=1/0,max=-1/0;for(const node of contentNodes){const value=node[axis];"number"==typeof value&&(min=Math.min(min,value),max=Math.max(max,value))}if(!Number.isFinite(min)||!Number.isFinite(max))return!1;const mirror=__name(value=>min+max-value,"mirror");for(const node of nodes){const value=node[axis];"number"==typeof value&&(node[axis]=mirror(value));const titleRect=node.groupTitleRect;titleRect&&(node.groupTitleRect="x"===axis?{...titleRect,left:mirror(titleRect.right),right:mirror(titleRect.left)}:{...titleRect,top:mirror(titleRect.bottom),bottom:mirror(titleRect.top)})}for(const edge of edges)for(const point of edge.points??[])point[axis]=mirror(point[axis]);return!0}function applyBtDirectionTransform(layout){return!(layout.nodes??[]).some(node=>!node.isGroup)||mirrorAxis(layout,"y")}function applyLrDirectionTransform(layout,direction="LR"){const nodes=layout.nodes??[],edges=layout.edges??[],contentNodes=nodes.filter(n=>!n.isGroup);let minX=1/0,minY=1/0;for(const n of contentNodes){const x0=n.x??0,y0=n.y??0;x0<minX&&(minX=x0),y0<minY&&(minY=y0)}if(!Number.isFinite(minX)||!Number.isFinite(minY))return!1;let totalWidth=0,totalHeight=0;for(const n of contentNodes)totalWidth+=n.width??0,totalHeight+=n.height??0;const avgWidth=totalWidth/contentNodes.length,avgHeight=totalHeight/contentNodes.length,horizontalScaleFactor=avgHeight>0?Math.max(1,avgWidth/avgHeight):1;for(const n of contentNodes){const x0=n.x??0,newX=((n.y??0)-minY)*horizontalScaleFactor+36,newY=x0-minX;n.x=newX,n.y=newY}for(const e of edges)if(e.points)for(const p of e.points){const x0=p.x,newX=(p.y-minY)*horizontalScaleFactor+36,newY=x0-minX;p.x=newX,p.y=newY}recomputeNestedGroupBounds(nodes);const laneNodes=nodes.filter(n=>n.isGroup&&!n.parentId);if(0===laneNodes.length)return"RL"===direction&&mirrorAxis(layout,"x"),!0;const nodeById=buildNodeMap(nodes),childrenByLane=new Map;for(const n of nodes){if(n.isGroup)continue;const laneId=resolveTopLevelGroupId(n,nodeById);if(!laneId)continue;const bucket=childrenByLane.get(laneId)??[];bucket.push(n),childrenByLane.set(laneId,bucket)}let maxPad=0;for(const lane of laneNodes){const pad=lane.padding??0;pad>maxPad&&(maxPad=pad)}const laneBounds=[];let globalMinXChild=1/0,globalMaxXChild=-1/0;for(const lane of laneNodes){const bounds=boundsForChildren(childrenByLane.get(lane.id)??[]);bounds&&(globalMinXChild=Math.min(globalMinXChild,bounds.minX),globalMaxXChild=Math.max(globalMaxXChild,bounds.maxX),laneBounds.push({lane:lane,contentTop:bounds.minY,contentBottom:bounds.maxY,centerY:(bounds.minY+bounds.maxY)/2}))}if(globalMinXChild===1/0||globalMaxXChild===-1/0)return!0;const bodyWidth=Math.max(0,globalMaxXChild-globalMinXChild)+2*Math.max(maxPad,10),laneWidth=36+bodyWidth,laneLeft=(globalMinXChild+globalMaxXChild)/2-bodyWidth/2-36,centerX=laneLeft+laneWidth/2,verticalMargin=Math.max(maxPad,36);laneBounds.sort((a,b)=>a.centerY-b.centerY);for(let i=0;i<laneBounds.length;i++){const curr=laneBounds[i];let laneTop,laneBottom;if(0===i)laneTop=curr.contentTop-verticalMargin;else{laneTop=(laneBounds[i-1].contentBottom+curr.contentTop)/2}if(i===laneBounds.length-1)laneBottom=curr.contentBottom+verticalMargin;else{const next=laneBounds[i+1];laneBottom=(curr.contentBottom+next.contentTop)/2}const laneHeight=Math.max(0,laneBottom-laneTop),centerY=(laneTop+laneBottom)/2;curr.lane.x=centerX,curr.lane.y=centerY,curr.lane.width=laneWidth,curr.lane.height=laneHeight,curr.lane.swimlaneContentTop=curr.contentTop,curr.lane.groupTitleRect={left:laneLeft,right:laneLeft+36,top:laneTop,bottom:laneBottom}}return"RL"===direction&&mirrorAxis(layout,"x"),!0}__name(endpointContextFor,"endpointContextFor"),__name(segmentEnterPoint,"segmentEnterPoint"),__name(clipEndpoint,"clipEndpoint"),__name(clipEdgeEndpointsToNodeBoundaries,"clipEdgeEndpointsToNodeBoundaries"),__name(snapEndpointToBoundary,"snapEndpointToBoundary"),__name(firstDistinctAdjacent,"firstDistinctAdjacent"),__name(cornerClearanceRange,"cornerClearanceRange"),__name(clampToCornerClearance,"clampToCornerClearance"),__name(intersectRanges,"intersectRanges"),__name(clearanceRangeForSide,"clearanceRangeForSide"),__name(terminalSideForSegment,"terminalSideForSegment"),__name(isHorizontalSide,"isHorizontalSide"),__name(straightClearanceRange,"straightClearanceRange"),__name(clearStraightEndpointCornerAxis,"clearStraightEndpointCornerAxis"),__name(clearStraightEndpointCornerConnections,"clearStraightEndpointCornerConnections"),__name(cornerClearedEndpoint,"cornerClearedEndpoint"),__name(moveCollinearEndpointRun,"moveCollinearEndpointRun"),__name(clearEndpointCornerConnection,"clearEndpointCornerConnection"),__name(borderSideForSegment,"borderSideForSegment"),__name(leavesOutward,"leavesOutward"),__name(collapseOwnBorderStub,"collapseOwnBorderStub"),__name(snapAndCollapseEndpoints,"snapAndCollapseEndpoints"),__name(prepareEdgeEndpointsForRenderer,"prepareEdgeEndpointsForRenderer"),__name(buildNodeMap,"buildNodeMap"),__name(resolveTopLevelGroupId,"resolveTopLevelGroupId"),__name(groupDepth,"groupDepth"),__name(boundsForChildren,"boundsForChildren"),__name(applyGroupBounds,"applyGroupBounds"),__name(recomputeNestedGroupBounds,"recomputeNestedGroupBounds"),__name(mirrorAxis,"mirrorAxis"),__name(applyBtDirectionTransform,"applyBtDirectionTransform"),__name(applyLrDirectionTransform,"applyLrDirectionTransform");var EPS3=1e-6,TRY_DELTAS=[0,8,-8,16,-16];function portSwapToLShape(edges,nodes){const{nodeInfoById:nodeInfoById,realNodeRects:realNodeRects}=collectRealNodeBounds(nodes);for(const edge of edges){if(edge.isLayoutOnly)continue;const pts=edge.points;if(!pts||pts.length<4)continue;const route=classifyThreeSegmentRoute(dedupeConsecutivePoints(pts,EPS3),EPS3);if(!route)continue;const{p3:p3}=route,isHVH="HVH"===route.kind,nodePair=getNodePairGeometry(edge,nodeInfoById,EPS3);if(!nodePair)continue;const{srcId:srcId,dstId:dstId,srcInfo:srcInfo,dstInfo:dstInfo,collinearX:collinearX,collinearY:collinearY}=nodePair;if(collinearX||collinearY)continue;let newPts;const srcRect=srcInfo.rect;for(const delta of TRY_DELTAS){let np0,np1,np2;if(isHVH){const newSrcY=dstInfo.cy>srcInfo.cy?srcRect.bottom:srcRect.top,newSrcX=srcInfo.cx+delta;if(newSrcX<=srcRect.left+EPS3||newSrcX>=srcRect.right-EPS3)continue;np0={x:newSrcX,y:newSrcY},np1={x:newSrcX,y:p3.y},np2={x:p3.x,y:p3.y}}else{const newSrcX=dstInfo.cx>srcInfo.cx?srcRect.right:srcRect.left,newSrcY=srcInfo.cy+delta;if(newSrcY<=srcRect.top+EPS3||newSrcY>=srcRect.bottom-EPS3)continue;np0={x:newSrcX,y:newSrcY},np1={x:p3.x,y:newSrcY},np2={x:p3.x,y:p3.y}}const firstSegDegenerate=samePoint(np0,np1,EPS3),secondSegDegenerate=samePoint(np1,np2,EPS3);if(firstSegDegenerate&&secondSegDegenerate)continue;if(!firstSegDegenerate&&segmentHitsAnyRect(np0,np1,realNodeRects,[srcId],1))continue;if(!secondSegDegenerate&&segmentHitsAnyRect(np1,np2,realNodeRects,[dstId],1))continue;const firstSegConflicts=!firstSegDegenerate&&segmentConflictsWithAnyEdge(np0,np1,edges,edge,{epsilon:EPS3,skipDegenerateOther:!0}),secondSegConflicts=!secondSegDegenerate&&segmentConflictsWithAnyEdge(np1,np2,edges,edge,{epsilon:EPS3,skipDegenerateOther:!0});if(!firstSegConflicts&&!secondSegConflicts){newPts=firstSegDegenerate?[np1,np2]:secondSegDegenerate?[np0,np1]:[np0,np1,np2];break}}newPts&&(edge.points=newPts)}}function collapseShortTerminalStub(edges,nodeByIdMap){const{realNodeRects:realNodeRects,labelNodeRects:labelRects}=collectNodeRectEntries(nodeByIdMap.values());for(const edge of edges){if(edge.isLayoutOnly)continue;const rawPts=edge.points;if(!rawPts||rawPts.length<4)continue;const pts=dedupeConsecutivePoints(rawPts,.001);if(pts.length<4)continue;const nLast=pts.length-1,endPt=pts[nLast],penultPt=pts[nLast-1],prevPt=pts[nLast-2],lastDx=endPt.x-penultPt.x,lastDy=endPt.y-penultPt.y,lastLen=Math.hypot(lastDx,lastDy);if(lastLen>=10||lastLen<.001)continue;const penultDx=penultPt.x-prevPt.x,penultDy=penultPt.y-prevPt.y;if(Math.hypot(penultDx,penultDy)<.001)continue;const lastIsHoriz=isHorizontalSegment(penultPt,endPt,.001),lastIsVert=isVerticalSegment(penultPt,endPt,.001),penultIsHoriz=isHorizontalSegment(prevPt,penultPt,.001),penultIsVert=isVerticalSegment(prevPt,penultPt,.001);if(!(lastIsHoriz&&penultIsVert||lastIsVert&&penultIsHoriz))continue;const dstId=edge.end,srcId=edge.start,dst=dstId?nodeByIdMap.get(dstId):void 0;if(!dst)continue;const dstCx=dst.x??0,dstCy=dst.y??0,dstRect=rectOfNodeBounds(dst);if(!dstRect)continue;let newPrev,newEnd;if(penultIsVert){const approachFromBelow=penultDy<0;newPrev={x:dstCx,y:prevPt.y},newEnd={x:dstCx,y:approachFromBelow?dstRect.bottom:dstRect.top}}else{const approachFromLeft=penultDx>0;newPrev={x:prevPt.x,y:dstCy},newEnd={x:approachFromLeft?dstRect.right:dstRect.left,y:dstCy}}if(segmentHitsAnyRect(newPrev,newEnd,realNodeRects,dstId?[dstId]:[],-2))continue;if(segmentHitsAnyRect(newPrev,newEnd,labelRects,[],-2))continue;if(srcId){const src=nodeByIdMap.get(srcId),srcRect=src?rectOfNodeBounds(src):void 0;if(srcRect&&pointInsideRect(newPrev,srcRect,2))continue}const ownSegmentKey=__name((a,b)=>`${a.x.toFixed(3)},${a.y.toFixed(3)}|${b.x.toFixed(3)},${b.y.toFixed(3)}`,"ownSegmentKey"),selfSegments=new Set;for(let i=0;i<pts.length-1;i++)selfSegments.add(ownSegmentKey(pts[i],pts[i+1]));const segmentCrossesOtherEdge=__name((from,to)=>{for(const other of edges){if(other===edge)continue;if(other.isLayoutOnly)continue;const oPts=other.points;if(oPts&&!(oPts.length<2))for(let i=0;i<oPts.length-1;i++){const a=oPts[i],b=oPts[i+1];if(!selfSegments.has(ownSegmentKey(a,b))&&orthogonalSegmentsStrictlyCross(from,to,a,b,.001))return!0}}return!1},"segmentCrossesOtherEdge");if(segmentCrossesOtherEdge(newPrev,newEnd))continue;if(nLast-3>=0){const beforePrev=pts[nLast-3];if(segmentHitsAnyRect(beforePrev,newPrev,realNodeRects,[srcId,dstId].filter(id=>Boolean(id)),-2))continue;if(segmentCrossesOtherEdge(beforePrev,newPrev))continue}const newPts=[...pts.slice(0,nLast-2),newPrev,newEnd];edge.points=newPts;const labelId=edge.labelNodeId;if(labelId){const labelNode=nodeByIdMap.get(labelId);if(labelNode){const lw=labelNode.width??0,lh=labelNode.height??0;if(lw>0&&lh>0){let bestMidX,bestMidY,bestLen=-1;for(let i=0;i<newPts.length-1;i++){const a=newPts[i],b=newPts[i+1],segLen=Math.hypot(b.x-a.x,b.y-a.y),isHoriz=sameY(a,b,.001),isVert=sameX(a,b,.001);(isHoriz&&segLen>=lw+2||isVert&&segLen>=lh+2)&&(segLen>bestLen&&(bestLen=segLen,bestMidX=(a.x+b.x)/2,bestMidY=(a.y+b.y)/2))}void 0!==bestMidX&&void 0!==bestMidY&&(labelNode.x=bestMidX,labelNode.y=bestMidY)}}}}}__name(portSwapToLShape,"portSwapToLShape"),__name(collapseShortTerminalStub,"collapseShortTerminalStub");var segmentsFor=orthogonalSegmentsForPoints,orthogonallyAligned=__name((a,b)=>sameX(a,b,.001)||sameY(a,b,.001),"orthogonallyAligned");function separateSharedRenderedTerminalLanes(edges,nodeByIdMap){const rectIntersect=__name((node,point)=>{const x=node.x??0,y=node.y??0,dx=point.x-x,dy=point.y-y;let w=(node.width??0)/2,h=(node.height??0)/2;return Math.abs(dy)*w>Math.abs(dx)*h?(dy<0&&(h=-h),{x:x+(0===dy?0:h*dx/dy),y:y+h}):(dx<0&&(w=-w),{x:x+w,y:y+(0===dx?0:w*dy/dx)})},"rectIntersect"),terminalLaneFor=__name((edge,atStart)=>{const points=dedupeConsecutivePoints(edge.points??[]);if(points.length<2)return;const nodeId=atStart?edge.start:edge.end,node=nodeId?nodeByIdMap.get(nodeId):void 0,rect=node?rectOfNodeBounds(node):void 0;if(!node||!nodeId||!rect)return;const endpoint=atStart?points[0]:points[points.length-1],adjacent=atStart?points[1]:points[points.length-2],boundary=rectIntersect(node,endpoint);let railEnd=endpoint;return orthogonallyAligned(adjacent,boundary)&&(railEnd=adjacent),sameX(boundary,railEnd,.001)?{edge:edge,edgeId:String(edge.id??""),nodeId:nodeId,atStart:atStart,orientation:"V",coord:boundary.x,min:Math.min(boundary.y,railEnd.y),max:Math.max(boundary.y,railEnd.y),boundary:boundary,railEnd:railEnd,rect:rect}:sameY(boundary,railEnd,.001)?{edge:edge,edgeId:String(edge.id??""),nodeId:nodeId,atStart:atStart,orientation:"H",coord:boundary.y,min:Math.min(boundary.x,railEnd.x),max:Math.max(boundary.x,railEnd.x),boundary:boundary,railEnd:railEnd,rect:rect}:void 0},"terminalLaneFor"),projectedOverlapLength=__name((a,b)=>Math.max(0,Math.min(a.max,b.max)-Math.max(a.min,b.min)),"projectedOverlapLength"),sameTerminalFace=__name((a,b)=>{if(a.nodeId!==b.nodeId||a.orientation!==b.orientation)return!1;if("H"===a.orientation){return(Math.abs(a.boundary.x-a.rect.left)<1||Math.abs(a.boundary.x-a.rect.right)<1)&&sameX(a.boundary,b.boundary,1)}return(Math.abs(a.boundary.y-a.rect.top)<1||Math.abs(a.boundary.y-a.rect.bottom)<1)&&sameY(a.boundary,b.boundary,1)},"sameTerminalFace"),exactTerminalLaneConflict=__name((a,b)=>{if(a.nodeId!==b.nodeId||a.orientation!==b.orientation)return!1;return projectedOverlapLength(a,b)>=8&&Math.abs(a.coord-b.coord)<.5},"exactTerminalLaneConflict"),nearTerminalLaneConflict=__name((a,b)=>{if(a.nodeId!==b.nodeId||a.orientation!==b.orientation||"H"!==a.orientation||a.atStart===b.atStart)return!1;const shared=projectedOverlapLength(a,b);if(shared<8)return!1;const faceSpan=a.rect.bottom-a.rect.top;return!(shared<faceSpan||shared>2*faceSpan)&&(sameTerminalFace(a,b)&&Math.abs(a.coord-b.coord)<16)},"nearTerminalLaneConflict"),shiftedCandidate=__name((lane,shift)=>{const points=dedupeConsecutivePoints(lane.edge.points??[]);if(points.length<2)return;const shiftedBoundary="V"===lane.orientation?{x:lane.boundary.x+shift,y:lane.boundary.y}:{x:lane.boundary.x,y:lane.boundary.y+shift},shiftedRailEnd="V"===lane.orientation?{x:lane.railEnd.x+shift,y:lane.railEnd.y}:{x:lane.railEnd.x,y:lane.railEnd.y+shift};if(!__name(()=>Math.abs(lane.boundary.y-lane.rect.top)<1||Math.abs(lane.boundary.y-lane.rect.bottom)<1?sameY(shiftedBoundary,lane.boundary,.001)&&shiftedBoundary.x>=lane.rect.left+1&&shiftedBoundary.x<=lane.rect.right-1:(Math.abs(lane.boundary.x-lane.rect.left)<1||Math.abs(lane.boundary.x-lane.rect.right)<1)&&(sameX(shiftedBoundary,lane.boundary,.001)&&shiftedBoundary.y>=lane.rect.top+1&&shiftedBoundary.y<=lane.rect.bottom-1),"boundaryStaysOnSameFace")())return;if(lane.atStart){const railEndIsAdjacent2=points.length>1&&samePoint(points[1],lane.railEnd,.001),rest=points.slice(railEndIsAdjacent2?2:1),next=rest[0];if(next&&!orthogonallyAligned(next,shiftedRailEnd))return;return[shiftedBoundary,shiftedRailEnd,...rest]}const railEndIsAdjacent=points.length>1&&samePoint(points[points.length-2],lane.railEnd,.001),before=points.slice(0,railEndIsAdjacent?-2:-1),previous=before[before.length-1];return!previous||orthogonallyAligned(previous,shiftedRailEnd)?[...before,shiftedRailEnd,shiftedBoundary]:void 0},"shiftedCandidate"),laneIsStraightCollinearConnector=__name(lane=>{const edge=lane.edge,points=dedupeConsecutivePoints(edge.points??[]);if(2!==points.length)return!1;const startId=edge.start,endId=edge.end,start=startId?nodeByIdMap.get(startId):void 0,end=endId?nodeByIdMap.get(endId):void 0;if(!start||!end)return!1;const startX=start.x??0,startY=start.y??0,endX=end.x??0,endY=end.y??0,[a,b]=points;return sameY(a,b,.001)&&Math.abs(startY-endY)<1&&Math.abs(startX-endX)>1||sameX(a,b,.001)&&Math.abs(startX-endX)<1&&Math.abs(startY-endY)>1},"laneIsStraightCollinearConnector"),shifts=[-7,7,-14,14,-21,21];for(let iteration=0;iteration<8;iteration++){const lanes=edges.filter(edge=>!edge.isLayoutOnly).flatMap(edge=>[terminalLaneFor(edge,!0),terminalLaneFor(edge,!1)]).filter(lane=>Boolean(lane));let fixed=!1;for(let i=0;i<lanes.length&&!fixed;i++)for(let j=i+1;j<lanes.length&&!fixed;j++){const first=lanes[i],second=lanes[j];if(first.edge===second.edge||!exactTerminalLaneConflict(first,second)&&!nearTerminalLaneConflict(first,second))continue;const fixingNearConflict=!exactTerminalLaneConflict(first,second),candidates=[first,second].sort((a,b)=>{const aPreservesStraight=laneIsStraightCollinearConnector(a),bPreservesStraight=laneIsStraightCollinearConnector(b);return aPreservesStraight!==bPreservesStraight?Number(aPreservesStraight)-Number(bPreservesStraight):Number(!b.atStart)-Number(!a.atStart)});for(const lane of candidates){for(const shift of shifts){const candidate=shiftedCandidate(lane,shift);if(!candidate)continue;const nextLane=terminalLaneFor({...lane.edge,points:candidate},lane.atStart);if(nextLane&&!lanes.some(other=>other.edge!==lane.edge&&(exactTerminalLaneConflict(nextLane,other)||fixingNearConflict&&nearTerminalLaneConflict(nextLane,other)))){lane.edge.points=candidate,fixed=!0;break}}if(fixed)break}}if(!fixed)return}}function collapseRedundantRectangularDoglegs(edges,nodeByIdMap){const{realNodeRects:realNodeRects,labelNodeRects:labelRects}=collectNodeRectEntries(nodeByIdMap.values()),candidateIsSafe=__name((edge,candidate)=>{const sourceId=edge.start,targetId=edge.end,candidateSegments=segmentsFor(candidate);if(candidateSegments.length!==candidate.length-1)return!1;const endpointIds=[sourceId,targetId].filter(id=>Boolean(id));for(const segment of candidateSegments){if(segmentHitsAnyRect(segment.a,segment.b,realNodeRects,endpointIds,-2))return!1;if(segmentHitsAnyRect(segment.a,segment.b,labelRects,[],-2))return!1}for(const other of edges){if(other===edge||other.isLayoutOnly)continue;const otherPoints=other.points;if(otherPoints&&!(otherPoints.length<2))for(const candidateSegment of candidateSegments)for(const otherSegment of segmentsFor(dedupeConsecutivePoints(otherPoints))){if(sameAxisSegmentOverlapLength(candidateSegment,otherSegment,.5)>=8)return!1;if(orthogonalSegmentsStrictlyCross(candidateSegment.a,candidateSegment.b,otherSegment.a,otherSegment.b,.001))return!1}}return!0},"candidateIsSafe"),withoutDogleg=__name((points,i)=>{if(i+4>=points.length)return;const p0=points[i],p1=points[i+1],p2=points[i+2],p3=points[i+3],p4=points[i+4],terminalVerticalDogleg=isHorizontalSegment(p0,p1)&&isVerticalSegment(p1,p2)&&isHorizontalSegment(p2,p3)&&isVerticalSegment(p3,p4)&&sameX(p0,p3,.001)&&sameX(p0,p4,.001)&&sameX(p1,p2,.001)&&(p1.x-p0.x)*(p3.x-p2.x)<0,terminalHorizontalDogleg=isVerticalSegment(p0,p1)&&isHorizontalSegment(p1,p2)&&isVerticalSegment(p2,p3)&&isHorizontalSegment(p3,p4)&&sameY(p0,p3,.001)&&sameY(p0,p4,.001)&&sameY(p1,p2,.001)&&(p1.y-p0.y)*(p3.y-p2.y)<0;if(terminalVerticalDogleg||terminalHorizontalDogleg)return dedupeConsecutivePoints([...points.slice(0,i+1),p4,...points.slice(i+5)]);if(i+5>=points.length)return;const p5=points[i+5],verticalDogleg=isVerticalSegment(p0,p1)&&isHorizontalSegment(p1,p2)&&isVerticalSegment(p2,p3)&&isHorizontalSegment(p3,p4)&&isVerticalSegment(p4,p5)&&sameX(p0,p4,.001)&&sameX(p0,p5,.001)&&sameX(p2,p3,.001)&&(p2.x-p1.x)*(p4.x-p3.x)<0,horizontalDogleg=isHorizontalSegment(p0,p1)&&isVerticalSegment(p1,p2)&&isHorizontalSegment(p2,p3)&&isVerticalSegment(p3,p4)&&isHorizontalSegment(p4,p5)&&sameY(p0,p4,.001)&&sameY(p0,p5,.001)&&sameY(p2,p3,.001)&&(p2.y-p1.y)*(p4.y-p3.y)<0;return verticalDogleg||horizontalDogleg?dedupeConsecutivePoints([...points.slice(0,i+1),p5,...points.slice(i+6)]):void 0},"withoutDogleg");for(let iteration=0;iteration<8;iteration++){let fixed=!1;for(const edge of edges){if(edge.isLayoutOnly)continue;const points=dedupeConsecutivePoints(edge.points??[]);for(let i=0;i<=points.length-5;i++){const candidate=withoutDogleg(points,i);if(candidate&&candidateIsSafe(edge,candidate)){edge.points=candidate,fixed=!0;break}}if(fixed)break}if(!fixed)return}}function liftObstacleHuggingSameSideRails(edges,nodeByIdMap){const{realNodeRects:realNodeRects,labelNodeRects:labelRects}=collectNodeRectEntries(nodeByIdMap.values()),visibleEdges=edges.filter(edge=>!edge.isLayoutOnly),pointsFor=__name((edge,replacementEdge,replacement)=>dedupeConsecutivePoints(edge===replacementEdge?replacement??[]:edge.points??[]),"pointsFor"),strictCrossingCount=__name((replacementEdge,replacement)=>{let count=0;for(let i=0;i<visibleEdges.length;i++){const firstSegments=segmentsFor(pointsFor(visibleEdges[i],replacementEdge,replacement));for(let j=i+1;j<visibleEdges.length;j++){const secondSegments=segmentsFor(pointsFor(visibleEdges[j],replacementEdge,replacement));for(const firstSegment of firstSegments)for(const secondSegment of secondSegments)orthogonalSegmentsStrictlyCross(firstSegment.a,firstSegment.b,secondSegment.a,secondSegment.b,.001)&&count++}}return count},"strictCrossingCount"),middleRail=__name(points=>{const segments=segmentsFor(points);if(3!==segments.length)return;const middle=segments[1];return segments[0].horizontal!==middle.horizontal&&segments[2].horizontal!==middle.horizontal?{index:middle.index,horizontal:middle.horizontal,vertical:middle.vertical,segment:middle}:void 0},"middleRail"),blockingRectsFor=__name((edge,rail)=>{const endpointIds=[edge.start,edge.end].filter(id=>Boolean(id));return realNodeRects.filter(entry=>{if(endpointIds.includes(entry.id))return!1;const rect=entry.rect;if(rail.horizontal){return overlapLength(rail.a.x,rail.b.x,rect.left,rect.right)>=8&&rail.a.y>=rect.top-2&&rail.a.y<=rect.bottom+2}return overlapLength(rail.a.y,rail.b.y,rect.top,rect.bottom)>=8&&rail.a.x>=rect.left-2&&rail.a.x<=rect.right+2})},"blockingRectsFor"),candidateByMovingRail=__name((points,rail,coord)=>{const candidate=points.map(point=>({...point}));if(rail.horizontal)candidate[rail.index].y=coord,candidate[rail.index+1].y=coord;else{if(!rail.vertical)return;candidate[rail.index].x=coord,candidate[rail.index+1].x=coord}const simplified=simplifyPolyline(dedupeConsecutivePoints(candidate));return segmentsFor(simplified).length===simplified.length-1?simplified:void 0},"candidateByMovingRail"),candidateIsSafe=__name((edge,candidate,currentCrossings)=>{const endpointIds=[edge.start,edge.end].filter(id=>Boolean(id)),candidateSegments=segmentsFor(candidate);if(candidateSegments.length!==candidate.length-1)return!1;for(const segment of candidateSegments){if(segmentHitsAnyRect(segment.a,segment.b,realNodeRects,endpointIds,-2))return!1;if(segmentHitsAnyRect(segment.a,segment.b,labelRects,[],-2))return!1}for(const other of visibleEdges)if(other!==edge)for(const candidateSegment of candidateSegments)for(const otherSegment of segmentsFor(pointsFor(other)))if(sameAxisSegmentOverlapLength(candidateSegment,otherSegment,.5)>=8)return!1;return strictCrossingCount(edge,candidate)<=currentCrossings},"candidateIsSafe");for(let iteration=0;iteration<8;iteration++){const currentCrossings=strictCrossingCount();let fixed=!1;for(const edge of visibleEdges){const points=pointsFor(edge),rail=middleRail(points);if(!rail)continue;const blockers=blockingRectsFor(edge,rail.segment);if(0===blockers.length)continue;const coords=rail.horizontal?[Math.min(...blockers.map(entry=>entry.rect.top))-20,Math.max(...blockers.map(entry=>entry.rect.bottom))+20]:[Math.min(...blockers.map(entry=>entry.rect.left))-20,Math.max(...blockers.map(entry=>entry.rect.right))+20];for(const coord of coords){const candidate=candidateByMovingRail(points,rail.segment,coord);if(candidate&&candidateIsSafe(edge,candidate,currentCrossings)){edge.points=candidate,fixed=!0;break}}if(fixed)break}if(!fixed)return}}function liftTopLaneTitleBandsAboveRails(edges,nodeByIdMap){const validTitleRect=__name(node=>{const rect=node.groupTitleRect;if(rect&&"number"==typeof rect.left&&"number"==typeof rect.right&&"number"==typeof rect.top&&"number"==typeof rect.bottom&&Number.isFinite(rect.left)&&Number.isFinite(rect.right)&&Number.isFinite(rect.top)&&Number.isFinite(rect.bottom)&&!(rect.right<=rect.left)&&!(rect.bottom<=rect.top))return{left:rect.left,right:rect.right,top:rect.top,bottom:rect.bottom}},"validTitleRect"),topLaneTitleFor=__name(node=>{if(!node.isGroup||node.parentId)return;const rawDirection=node.direction,direction="string"==typeof rawDirection?rawDirection.toUpperCase():"";if("LR"===direction||"RL"===direction||"BT"===direction)return;const rect=validTitleRect(node),y=node.y,height=node.height;if(!rect||"number"!=typeof y||"number"!=typeof height||!Number.isFinite(y)||!Number.isFinite(height)||height<=0)return;const titleWidth=rect.right-rect.left,titleHeight=rect.bottom-rect.top;return titleHeight<=0||titleWidth<titleHeight?void 0:{node:node,rect:rect}},"topLaneTitleFor"),horizontalSegmentIntersectsTitle=__name((segment,rect)=>{if(!segment.horizontal)return!1;const y=segment.a.y;return!(y<=rect.top+.001||y>=rect.bottom-.001)&&overlapLength(segment.a.x,segment.b.x,rect.left,rect.right)>=8},"horizontalSegmentIntersectsTitle"),lanes=[...nodeByIdMap.values()].map(topLaneTitleFor).filter(lane=>Boolean(lane));if(0===lanes.length)return;let topDelta=0;for(const edge of edges){if(edge.isLayoutOnly)continue;const points=dedupeConsecutivePoints(edge.points??[]);for(const segment of segmentsFor(points))for(const lane of lanes)horizontalSegmentIntersectsTitle(segment,lane.rect)&&(topDelta=Math.max(topDelta,lane.rect.bottom-segment.a.y+4))}if(!(topDelta<=.001))for(const lane of lanes){const y=lane.node.y,height=lane.node.height;"number"!=typeof y||"number"!=typeof height||!Number.isFinite(y)||!Number.isFinite(height)||height<=0||(lane.node.y=y-topDelta/2,lane.node.height=height+topDelta,lane.node.groupTitleRect={...lane.rect,top:lane.rect.top-topDelta,bottom:lane.rect.bottom-topDelta})}}function shiftLeftLaneTitleBandsLeftOfRails(edges,nodeByIdMap){const validTitleRect=__name(node=>{const rect=node.groupTitleRect;if(rect&&"number"==typeof rect.left&&"number"==typeof rect.right&&"number"==typeof rect.top&&"number"==typeof rect.bottom&&Number.isFinite(rect.left)&&Number.isFinite(rect.right)&&Number.isFinite(rect.top)&&Number.isFinite(rect.bottom)&&!(rect.right<=rect.left)&&!(rect.bottom<=rect.top))return{left:rect.left,right:rect.right,top:rect.top,bottom:rect.bottom}},"validTitleRect"),leftLaneTitleFor=__name(node=>{if(!node.isGroup||node.parentId)return;if("LR"!==node.direction)return;const rect=validTitleRect(node),x=node.x,width=node.width;if(!rect||"number"!=typeof x||"number"!=typeof width||!Number.isFinite(x)||!Number.isFinite(width)||width<=0)return;const titleWidth=rect.right-rect.left,titleHeight=rect.bottom-rect.top;return titleWidth<=0||titleHeight<titleWidth?void 0:{node:node,rect:rect}},"leftLaneTitleFor"),verticalSegmentIntersectsTitle=__name((segment,rect)=>{if(!segment.vertical)return!1;const x=segment.a.x;return!(x<=rect.left+.001||x>=rect.right-.001)&&overlapLength(segment.a.y,segment.b.y,rect.top,rect.bottom)>=8},"verticalSegmentIntersectsTitle"),horizontalSegmentIntersectsTitle=__name((segment,rect)=>{if(!segment.horizontal)return!1;const y=segment.a.y;return!(y<=rect.top+.001||y>=rect.bottom-.001)&&overlapLength(segment.a.x,segment.b.x,rect.left,rect.right)>=8},"horizontalSegmentIntersectsTitle"),lanes=[...nodeByIdMap.values()].map(leftLaneTitleFor).filter(lane=>Boolean(lane));if(0===lanes.length)return;let leftDelta=0;for(const edge of edges){if(edge.isLayoutOnly)continue;const points=dedupeConsecutivePoints(edge.points??[]);for(const segment of segmentsFor(points))for(const lane of lanes)if(verticalSegmentIntersectsTitle(segment,lane.rect))leftDelta=Math.max(leftDelta,lane.rect.right-segment.a.x+4);else if(horizontalSegmentIntersectsTitle(segment,lane.rect)){const segmentLeft=Math.min(segment.a.x,segment.b.x);leftDelta=Math.max(leftDelta,lane.rect.right-segmentLeft+4)}}if(!(leftDelta<=.001))for(const lane of lanes){const x=lane.node.x,width=lane.node.width;"number"!=typeof x||"number"!=typeof width||!Number.isFinite(x)||!Number.isFinite(width)||width<=0||(lane.node.x=x-leftDelta/2,lane.node.width=width+leftDelta,lane.node.groupTitleRect={...lane.rect,left:lane.rect.left-leftDelta,right:lane.rect.right-leftDelta})}}function swapDestinationTerminalTailsToReduceCrossings(edges,nodeByIdMap){const{realNodeRects:realNodeRects}=collectNodeRectEntries(nodeByIdMap.values()),visibleEdges=edges.filter(edge=>!edge.isLayoutOnly),replacementPointsFor=__name((edge,replacements=new Map)=>dedupeConsecutivePoints(replacements.get(edge)??edge.points??[]),"replacementPointsFor"),crossingCount=__name((replacements=new Map)=>{let count=0;for(let i=0;i<visibleEdges.length;i++){const firstSegments=segmentsFor(replacementPointsFor(visibleEdges[i],replacements));for(let j=i+1;j<visibleEdges.length;j++){const secondSegments=segmentsFor(replacementPointsFor(visibleEdges[j],replacements));for(const firstSegment of firstSegments)for(const secondSegment of secondSegments)orthogonalSegmentsStrictlyCross(firstSegment.a,firstSegment.b,secondSegment.a,secondSegment.b,.001)&&count++}}return count},"crossingCount"),totalBends=__name((replacements=new Map)=>visibleEdges.reduce((sum,edge)=>sum+countOrthogonalBends(replacementPointsFor(edge,replacements)),0),"totalBends"),terminalTailFor=__name(edge=>{const points=replacementPointsFor(edge);if(points.length<4)return;const tailStart=points[points.length-2],terminal=points[points.length-1];return isHorizontalSegment(tailStart,terminal,.001)||isVerticalSegment(tailStart,terminal,.001)?{tailStart:tailStart,terminal:terminal}:void 0},"terminalTailFor"),candidateWithDestinationTail=__name((edge,tail)=>{const points=replacementPointsFor(edge);if(points.length<3)return;const start=points[0],firstTurn=points[1];let connector;if(isHorizontalSegment(start,firstTurn,.001))connector={x:firstTurn.x,y:tail.tailStart.y};else{if(!isVerticalSegment(start,firstTurn,.001))return;connector={x:tail.tailStart.x,y:firstTurn.y}}const candidate=simplifyPolyline(dedupeConsecutivePoints([start,firstTurn,connector,tail.tailStart,tail.terminal]));return segmentsFor(candidate).length===candidate.length-1?candidate:void 0},"candidateWithDestinationTail"),pathHasNodeHit=__name((edge,path)=>{const endpointIds=[edge.start,edge.end].filter(id=>Boolean(id));for(const segment of segmentsFor(path))if(segmentHitsAnyRect(segment.a,segment.b,realNodeRects,endpointIds,-2))return!0;return!1},"pathHasNodeHit"),pathHasSharedTrack=__name((edge,path,replacements)=>{for(const other of visibleEdges)if(other!==edge)for(const candidateSegment of segmentsFor(path))for(const otherSegment of segmentsFor(replacementPointsFor(other,replacements)))if(sameAxisSegmentOverlapLength(candidateSegment,otherSegment,.5)>=8)return!0;return!1},"pathHasSharedTrack"),candidateIsSafe=__name((edge,path,replacements)=>!pathHasNodeHit(edge,path)&&!pathHasSharedTrack(edge,path,replacements),"candidateIsSafe"),edgesByDestination=__name(()=>{const result=new Map;for(const edge of visibleEdges){const dstId=edge.end;if(!dstId||!nodeByIdMap.has(dstId))continue;if(replacementPointsFor(edge).length<4)continue;const bucket=result.get(dstId)??[];bucket.push(edge),result.set(dstId,bucket)}return result},"edgesByDestination");for(let iteration=0;iteration<4;iteration++){const currentCrossings=crossingCount();if(0===currentCrossings)return;let bestReplacements,bestCrossings=currentCrossings,bestBends=totalBends();for(const destinationEdges of edgesByDestination().values())for(let i=0;i<destinationEdges.length;i++)for(let j=i+1;j<destinationEdges.length;j++){const first=destinationEdges[i],second=destinationEdges[j],firstTail=terminalTailFor(first),secondTail=terminalTailFor(second);if(!firstTail||!secondTail)continue;const firstCandidate=candidateWithDestinationTail(first,secondTail),secondCandidate=candidateWithDestinationTail(second,firstTail);if(!firstCandidate||!secondCandidate)continue;const replacements=new Map([[first,firstCandidate],[second,secondCandidate]]);if(!candidateIsSafe(first,firstCandidate,replacements)||!candidateIsSafe(second,secondCandidate,replacements))continue;const candidateCrossings=crossingCount(replacements),candidateBends=totalBends(replacements);candidateCrossings>=currentCrossings||(candidateCrossings>bestCrossings||candidateCrossings===bestCrossings&&candidateBends>=bestBends||(bestReplacements=replacements,bestCrossings=candidateCrossings,bestBends=candidateBends))}if(!bestReplacements)return;for(const[edge,points]of bestReplacements)edge.points=points}}function reassignCrossingExternalRailChannels(edges,nodeByIdMap){const{realNodeRects:realNodeRects,labelNodeRects:labelRects}=collectNodeRectEntries(nodeByIdMap.values()),visibleEdges=edges.filter(edge=>!edge.isLayoutOnly),replacementPointsFor=__name((edge,replacements=new Map)=>dedupeConsecutivePoints(replacements.get(edge)??edge.points??[]),"replacementPointsFor"),strictCrossingCount=__name((replacements=new Map)=>{let count=0;for(let i=0;i<visibleEdges.length;i++){const firstSegments=segmentsFor(replacementPointsFor(visibleEdges[i],replacements));for(let j=i+1;j<visibleEdges.length;j++){const secondSegments=segmentsFor(replacementPointsFor(visibleEdges[j],replacements));for(const firstSegment of firstSegments)for(const secondSegment of secondSegments)orthogonalSegmentsStrictlyCross(firstSegment.a,firstSegment.b,secondSegment.a,secondSegment.b,.001)&&count++}}return count},"strictCrossingCount"),totalBends=__name((replacements=new Map)=>visibleEdges.reduce((sum,edge)=>sum+countOrthogonalBends(replacementPointsFor(edge,replacements)),0),"totalBends"),endpointRectsFor=__name(edge=>{const srcId=edge.start,dstId=edge.end,srcNode=srcId?nodeByIdMap.get(srcId):void 0,dstNode=dstId?nodeByIdMap.get(dstId):void 0,src=srcNode?rectOfNodeBounds(srcNode):void 0,dst=dstNode?rectOfNodeBounds(dstNode):void 0;return src&&dst?{src:src,dst:dst}:void 0},"endpointRectsFor"),externalRailForSegment=__name((edge,points,segment)=>{if(segment.index<=0||segment.index+1>=points.length-1)return;const endpointRects=endpointRectsFor(edge);if(endpointRects){if(segment.vertical){const coord=segment.a.x,leftBound=Math.min(endpointRects.src.left,endpointRects.dst.left),rightBound=Math.max(endpointRects.src.right,endpointRects.dst.right),side=coord<leftBound-.001?"left":coord>rightBound+.001?"right":void 0;if(!side)return;return{edge:edge,points:points,segmentIndex:segment.index,axis:"vertical",side:side,coord:coord,min:Math.min(segment.a.y,segment.b.y),max:Math.max(segment.a.y,segment.b.y)}}if(segment.horizontal){const coord=segment.a.y,topBound=Math.min(endpointRects.src.top,endpointRects.dst.top),bottomBound=Math.max(endpointRects.src.bottom,endpointRects.dst.bottom),side=coord<topBound-.001?"top":coord>bottomBound+.001?"bottom":void 0;if(!side)return;return{edge:edge,points:points,segmentIndex:segment.index,axis:"horizontal",side:side,coord:coord,min:Math.min(segment.a.x,segment.b.x),max:Math.max(segment.a.x,segment.b.x)}}}},"externalRailForSegment"),collectExternalRails=__name(()=>{const rails=[];for(const edge of visibleEdges){const points=replacementPointsFor(edge);for(const segment of segmentsFor(points)){const rail=externalRailForSegment(edge,points,segment);rail&&rails.push(rail)}}return rails},"collectExternalRails"),railsInteract=__name((a,b)=>a.edge!==b.edge&&a.axis===b.axis&&a.side===b.side&&overlapLength(a.min,a.max,b.min,b.max)>=8,"railsInteract"),connectedComponents=__name(rails=>{const result=[],seen=new Set;for(const rail of rails){if(seen.has(rail))continue;const queue=[rail],component=[];for(seen.add(rail);queue.length>0;){const current=queue.pop();component.push(current);for(const next of rails)!seen.has(next)&&railsInteract(current,next)&&(seen.add(next),queue.push(next))}component.length>1&&result.push(component)}return result},"connectedComponents"),uniqueCoordsFor=__name(component=>{const coords=[];for(const rail of component)coords.some(coord=>Math.abs(coord-rail.coord)<.001)||coords.push(rail.coord);for(;coords.length<component.length;){const min=Math.min(...coords),max=Math.max(...coords),side=component[0].side;coords.push("left"===side||"top"===side?min-12*(component.length-coords.length):max+12*(component.length-coords.length))}return coords},"uniqueCoordsFor"),coordinateAssignmentsFor=__name(component=>{const current=component.map(rail=>rail.coord),coords=uniqueCoordsFor(component),assignments=[];if(component.length<=6){const used=new Array(coords.length).fill(!1),next=[],visit=__name(()=>{if(next.length!==component.length)for(const[i,coord]of coords.entries())used[i]||(used[i]=!0,next.push(coord),visit(),next.pop(),used[i]=!1);else next.some((coord,index)=>Math.abs(coord-current[index])>=.001)&&assignments.push([...next])},"visit");return visit(),assignments}for(let i=0;i<current.length;i++)for(let j=i+1;j<current.length;j++){const assignment=[...current];[assignment[i],assignment[j]]=[assignment[j],assignment[i]],assignments.push(assignment)}return assignments},"coordinateAssignmentsFor"),replacementsForAssignment=__name((component,assignment)=>{const draftByEdge=new Map;for(const[i,rail]of component.entries()){const coord=assignment[i],points=draftByEdge.get(rail.edge)??rail.points.map(point=>({x:point.x,y:point.y}));"vertical"===rail.axis?(points[rail.segmentIndex].x=coord,points[rail.segmentIndex+1].x=coord):(points[rail.segmentIndex].y=coord,points[rail.segmentIndex+1].y=coord),draftByEdge.set(rail.edge,points)}const replacements=new Map;for(const[edge,points]of draftByEdge){const simplified=simplifyPolyline(dedupeConsecutivePoints(points));if(segmentsFor(simplified).length!==simplified.length-1)return;replacements.set(edge,simplified)}return replacements},"replacementsForAssignment"),candidateIsSafe=__name(replacements=>{for(const[edge,points]of replacements){const endpointIds=[edge.start,edge.end].filter(id=>Boolean(id));for(const segment of segmentsFor(points)){if(segmentHitsAnyRect(segment.a,segment.b,realNodeRects,endpointIds,-2))return!1;if(segmentHitsAnyRect(segment.a,segment.b,labelRects,[],-2))return!1}}for(let i=0;i<visibleEdges.length;i++){const first=visibleEdges[i],firstChanged=replacements.has(first),firstSegments=segmentsFor(replacementPointsFor(first,replacements));for(let j=i+1;j<visibleEdges.length;j++){const second=visibleEdges[j];if(!firstChanged&&!replacements.has(second))continue;const secondSegments=segmentsFor(replacementPointsFor(second,replacements));for(const firstSegment of firstSegments)for(const secondSegment of secondSegments)if(sameAxisSegmentOverlapLength(firstSegment,secondSegment,.5)>=8)return!1}}return!0},"candidateIsSafe");for(let iteration=0;iteration<4;iteration++){const currentCrossings=strictCrossingCount();if(0===currentCrossings)return;let bestReplacements,bestCrossings=currentCrossings,bestBends=totalBends(),bestDisplacement=Number.POSITIVE_INFINITY;for(const component of connectedComponents(collectExternalRails()))for(const assignment of coordinateAssignmentsFor(component)){const replacements=replacementsForAssignment(component,assignment);if(!replacements||!candidateIsSafe(replacements))continue;const candidateCrossings=strictCrossingCount(replacements);if(candidateCrossings>=currentCrossings)continue;const candidateBends=totalBends(replacements),candidateDisplacement=component.reduce((sum,rail,index)=>sum+Math.abs(assignment[index]-rail.coord),0);candidateCrossings>bestCrossings||candidateCrossings===bestCrossings&&(candidateBends>bestBends||candidateBends===bestBends&&candidateDisplacement>=bestDisplacement)||(bestReplacements=replacements,bestCrossings=candidateCrossings,bestBends=candidateBends,bestDisplacement=candidateDisplacement)}if(!bestReplacements)return;for(const[edge,points]of bestReplacements)edge.points=points}}function shortcutRedundantOrthogonalJogs(edges,nodeByIdMap){const{realNodeRects:realNodeRects,labelNodeRects:labelRects}=collectNodeRectEntries(nodeByIdMap.values()),visibleEdges=edges.filter(edge=>!edge.isLayoutOnly),pointsFor=__name((edge,replacementEdge,replacement)=>dedupeConsecutivePoints(edge===replacementEdge?replacement??[]:edge.points??[]),"pointsFor"),pathLength=__name(points=>segmentsFor(points).reduce((sum,segment)=>{const dx=segment.a.x-segment.b.x,dy=segment.a.y-segment.b.y;return sum+Math.hypot(dx,dy)},0),"pathLength"),strictCrossingCount=__name((replacementEdge,replacement)=>{let count=0;for(let i=0;i<visibleEdges.length;i++){const firstSegments=segmentsFor(pointsFor(visibleEdges[i],replacementEdge,replacement));for(let j=i+1;j<visibleEdges.length;j++){const secondSegments=segmentsFor(pointsFor(visibleEdges[j],replacementEdge,replacement));for(const firstSegment of firstSegments)for(const secondSegment of secondSegments)orthogonalSegmentsStrictlyCross(firstSegment.a,firstSegment.b,secondSegment.a,secondSegment.b,.001)&&count++}}return count},"strictCrossingCount"),segmentRunsAlongRectBorder=__name((segment,rect)=>{if(segment.horizontal){const y=segment.a.y;return(Math.abs(y-rect.top)<1||Math.abs(y-rect.bottom)<1)&&overlapLength(segment.a.x,segment.b.x,rect.left,rect.right)>=8}if(segment.vertical){const x=segment.a.x;return(Math.abs(x-rect.left)<1||Math.abs(x-rect.right)<1)&&overlapLength(segment.a.y,segment.b.y,rect.top,rect.bottom)>=8}return!1},"segmentRunsAlongRectBorder"),endpointRectsFor=__name(edge=>{const endpointIds=[edge.start,edge.end].filter(id=>Boolean(id)),rects=[];for(const id of endpointIds){const node=nodeByIdMap.get(id),rect=node?rectOfNodeBounds(node):void 0;rect&&rects.push(rect)}return rects},"endpointRectsFor"),shortcutCandidatesAt=__name((points,index)=>{if(index+3>=points.length)return[];const p0=points[index],p1=points[index+1],p2=points[index+2],p3=points[index+3],isHVH=isHorizontalSegment(p0,p1,.001)&&isVerticalSegment(p1,p2,.001)&&isHorizontalSegment(p2,p3,.001),isVHV=isVerticalSegment(p0,p1,.001)&&isHorizontalSegment(p1,p2,.001)&&isVerticalSegment(p2,p3,.001);if(!isHVH&&!isVHV)return[];if(!(isHVH?Math.sign(p1.x-p0.x)!==Math.sign(p3.x-p2.x):Math.sign(p1.y-p0.y)!==Math.sign(p3.y-p2.y)))return[];const corners=sameX(p0,p3,.001)||sameY(p0,p3,.001)?[]:[{x:p0.x,y:p3.y},{x:p3.x,y:p0.y}],rawCandidates=0===corners.length?[[...points.slice(0,index+1),...points.slice(index+3)]]:corners.map(corner=>[...points.slice(0,index+1),corner,...points.slice(index+3)]),seen=new Set;return rawCandidates.map(candidate=>simplifyPolyline(dedupeConsecutivePoints(candidate))).filter(candidate=>{if(segmentsFor(candidate).length!==candidate.length-1)return!1;if(!candidate.some(point=>samePoint(point,p3,.001)))return!1;const key=candidate.map(point=>`${point.x.toFixed(3)},${point.y.toFixed(3)}`).join("|");return!seen.has(key)&&(seen.add(key),!0)})},"shortcutCandidatesAt"),candidateIsSafe=__name((edge,candidate,currentCrossings)=>{const endpointIds=[edge.start,edge.end].filter(id=>Boolean(id)),endpointRects=endpointRectsFor(edge);for(const segment of segmentsFor(candidate)){if(segmentHitsAnyRect(segment.a,segment.b,realNodeRects,endpointIds,-2))return!1;if(segmentHitsAnyRect(segment.a,segment.b,labelRects,[],-2))return!1;if(endpointRects.some(rect=>segmentRunsAlongRectBorder(segment,rect)))return!1}for(const other of visibleEdges)if(other!==edge)for(const candidateSegment of segmentsFor(candidate))for(const otherSegment of segmentsFor(pointsFor(other)))if(sameAxisSegmentOverlapLength(candidateSegment,otherSegment,.5)>=8)return!1;return strictCrossingCount(edge,candidate)<=currentCrossings},"candidateIsSafe");for(let iteration=0;iteration<8;iteration++){const currentCrossings=strictCrossingCount();let bestEdge,bestPath,bestCrossings=currentCrossings,bestBends=Number.POSITIVE_INFINITY,bestLength=Number.POSITIVE_INFINITY;for(const edge of visibleEdges){const currentPoints=pointsFor(edge),currentBends=countOrthogonalBends(currentPoints,.001),currentLength=pathLength(currentPoints);for(let index=0;index<=currentPoints.length-4;index++)for(const candidate of shortcutCandidatesAt(currentPoints,index)){const candidateBends=countOrthogonalBends(candidate,.001),candidateLength=pathLength(candidate);if(!(candidateBends<currentBends||candidateBends===currentBends&&candidateLength<currentLength-.001)||!candidateIsSafe(edge,candidate,currentCrossings))continue;const candidateCrossings=strictCrossingCount(edge,candidate);candidateCrossings>bestCrossings||candidateCrossings===bestCrossings&&(candidateBends>bestBends||candidateBends===bestBends&&candidateLength>=bestLength)||(bestEdge=edge,bestPath=candidate,bestCrossings=candidateCrossings,bestBends=candidateBends,bestLength=candidateLength)}}if(!bestEdge||!bestPath)return;bestEdge.points=bestPath}}function resolveRenderedOrthogonalCrossings(edges,nodeByIdMap){const realNodes=[];for(const node of nodeByIdMap.values()){if(node.isGroup||node.isEdgeLabel)continue;const cx=node.x??0,cy=node.y??0,rect=rectOfNodeBounds(node);rect&&realNodes.push({id:String(node.id??""),cx:cx,cy:cy,rect:rect})}if(0===realNodes.length)return;const nodeInfoById=new Map(realNodes.map(node=>[node.id,node])),realNodeRects=realNodes.map(node=>({id:node.id,rect:node.rect})),sides=["top","bottom","left","right"],outsideTracks={top:Math.min(...realNodes.map(node=>node.rect.top))-20,bottom:Math.max(...realNodes.map(node=>node.rect.bottom))+20,left:Math.min(...realNodes.map(node=>node.rect.left))-20,right:Math.max(...realNodes.map(node=>node.rect.right))+20},visibleEdges=edges.filter(edge=>!edge.isLayoutOnly),edgeIndex=new Map(visibleEdges.map((edge,index)=>[edge,index])),outwardTracksForSide=__name(side=>{const outward="left"===side||"top"===side?-1:1,tracks=[];for(let channel=0;channel<=2;channel++)tracks.push(outsideTracks[side]+20*outward*channel);return tracks},"outwardTracksForSide"),replacementPointsFor=__name((edge,replacements=new Map)=>dedupeConsecutivePoints(replacements.get(edge)??edge.points??[]),"replacementPointsFor"),crossingCountBetweenSegments=__name((firstSegments,secondSegments)=>{let count=0;for(const firstSegment of firstSegments)for(const secondSegment of secondSegments)orthogonalSegmentsStrictlyCross(firstSegment.a,firstSegment.b,secondSegment.a,secondSegment.b,.001)&&count++;return count},"crossingCountBetweenSegments"),crossingCountBetweenPaths=__name((first,second)=>crossingCountBetweenSegments(segmentsFor(first),segmentsFor(second)),"crossingCountBetweenPaths"),crossingSnapshot=__name((replacements=new Map)=>{let count=0;const pairs=[],edgeSet=new Set,edgeOrder=[],addEdge=__name(edge=>{edgeSet.has(edge)||(edgeSet.add(edge),edgeOrder.push(edge))},"addEdge");for(let i=0;i<visibleEdges.length;i++){const first=visibleEdges[i],firstPoints=replacementPointsFor(first,replacements);for(let j=i+1;j<visibleEdges.length;j++){const second=visibleEdges[j],pairCount=crossingCountBetweenPaths(firstPoints,replacementPointsFor(second,replacements));pairCount>0&&(count+=pairCount,pairs.push({first:first,second:second,count:pairCount}),addEdge(first),addEdge(second))}}return edgeOrder.sort((a,b)=>(edgeIndex.get(a)??0)-(edgeIndex.get(b)??0)),{count:count,pairs:pairs,edgeSet:edgeSet,edges:edgeOrder}},"crossingSnapshot"),crossingCountWithReplacements=__name((current,replacements)=>{const changed=new Set(replacements.keys());if(0===changed.size)return current.count;let currentAffected=0;for(const pair of current.pairs)(changed.has(pair.first)||changed.has(pair.second))&&(currentAffected+=pair.count);let replacementAffected=0;for(let i=0;i<visibleEdges.length;i++){const first=visibleEdges[i],firstChanged=changed.has(first),firstPoints=replacementPointsFor(first,replacements);for(let j=i+1;j<visibleEdges.length;j++){const second=visibleEdges[j];(firstChanged||changed.has(second))&&(replacementAffected+=crossingCountBetweenPaths(firstPoints,replacementPointsFor(second,replacements)))}}return current.count-currentAffected+replacementAffected},"crossingCountWithReplacements"),crossingComponents=__name(snapshot=>{const neighbors=new Map;for(const pair of snapshot.pairs){const firstNeighbors=neighbors.get(pair.first)??new Set;firstNeighbors.add(pair.second),neighbors.set(pair.first,firstNeighbors);const secondNeighbors=neighbors.get(pair.second)??new Set;secondNeighbors.add(pair.first),neighbors.set(pair.second,secondNeighbors)}const components=[],seen=new Set;for(const edge of snapshot.edges){if(seen.has(edge))continue;const queue=[edge],component=[];for(seen.add(edge);queue.length>0;){const current=queue.pop();component.push(current);for(const next of neighbors.get(current)??[])seen.has(next)||(seen.add(next),queue.push(next))}component.sort((a,b)=>(edgeIndex.get(a)??0)-(edgeIndex.get(b)??0)),component.length>1&&components.push(component)}return components},"crossingComponents"),endpointIdsFor=__name(edge=>[edge.start,edge.end].filter(id=>Boolean(id)),"endpointIdsFor"),pairSearchGroups=__name(snapshot=>{const groups=[];for(const component of crossingComponents(snapshot)){const componentSet=new Set(component),componentEndpointIds=new Set(component.flatMap(edge=>endpointIdsFor(edge))),group=[...component];for(const edge of visibleEdges)componentSet.has(edge)||endpointIdsFor(edge).some(id=>componentEndpointIds.has(id))&&group.push(edge);group.sort((a,b)=>(edgeIndex.get(a)??0)-(edgeIndex.get(b)??0)),groups.push(group)}return groups},"pairSearchGroups"),crossingCountWithSingleReplacement=__name((current,edge,replacement)=>crossingCountWithReplacements(current,new Map([[edge,replacement]])),"crossingCountWithSingleReplacement"),currentCrossingsByEdge=__name(current=>{const result=new Map;for(const pair of current.pairs)result.set(pair.first,(result.get(pair.first)??0)+pair.count),result.set(pair.second,(result.get(pair.second)??0)+pair.count);return result},"currentCrossingsByEdge"),pathLength=__name(points=>points.slice(1).reduce((sum,point,index)=>{const previous=points[index];return sum+Math.abs(point.x-previous.x)+Math.abs(point.y-previous.y)},0),"pathLength"),totalBends=__name((replacements=new Map)=>visibleEdges.reduce((sum,edge)=>sum+countOrthogonalBends(replacementPointsFor(edge,replacements)),0),"totalBends"),totalLength=__name((replacements=new Map)=>visibleEdges.reduce((sum,edge)=>sum+pathLength(replacementPointsFor(edge,replacements)),0),"totalLength"),pathHasSegmentConflict=__name((edge,path,replacements=new Map)=>{const pathSegments=segmentsFor(path);for(const other of visibleEdges)if(other!==edge)for(const candidateSegment of pathSegments)for(const otherSegment of segmentsFor(replacementPointsFor(other,replacements)))if(sameAxisSegmentOverlapLength(candidateSegment,otherSegment,.5)>=8)return!0;return!1},"pathHasSegmentConflict"),pathHitsNode=__name((edge,path)=>{const endpointIds=[edge.start,edge.end].filter(id=>Boolean(id));for(const segment of segmentsFor(path))if(segmentHitsAnyRect(segment.a,segment.b,realNodeRects,endpointIds,-2))return!0;return!1},"pathHitsNode"),pushOrthogonalCandidate=__name((candidates,points)=>{const candidate=simplifyPolyline(dedupeConsecutivePoints(points));segmentsFor(candidate).length===candidate.length-1&&candidates.push(candidate)},"pushOrthogonalCandidate"),sideIsHorizontal=__name(side=>"left"===side||"right"===side,"sideIsHorizontal"),localTrackForSameSide=__name((src,side,dst)=>{switch(side){case"left":return Math.min(src.x,dst.x)-20;case"right":return Math.max(src.x,dst.x)+20;case"top":return Math.min(src.y,dst.y)-20;case"bottom":return Math.max(src.y,dst.y)+20}},"localTrackForSameSide"),addSameSideCandidates=__name((candidates,src,srcSide,dst)=>{const outward="left"===srcSide||"top"===srcSide?-1:1,trackSeeds=[localTrackForSameSide(src,srcSide,dst),outsideTracks[srcSide]];for(const seed of trackSeeds)for(let channel=0;channel<=2;channel++)pushOrthogonalCandidate(candidates,buildSameSideTrackPath(src,srcSide,dst,seed+20*outward*channel))},"addSameSideCandidates"),addHorizontalToVerticalCandidates=__name((candidates,src,srcSide,dst,dstSide)=>{for(const xTrack of outwardTracksForSide(srcSide))for(const yTrack of outwardTracksForSide(dstSide))pushOrthogonalCandidate(candidates,[src,{x:xTrack,y:src.y},{x:xTrack,y:yTrack},{x:dst.x,y:yTrack},dst])},"addHorizontalToVerticalCandidates"),addVerticalToHorizontalCandidates=__name((candidates,src,srcSide,dst,dstSide)=>{for(const yTrack of outwardTracksForSide(srcSide))for(const xTrack of outwardTracksForSide(dstSide))pushOrthogonalCandidate(candidates,[src,{x:src.x,y:yTrack},{x:xTrack,y:yTrack},{x:xTrack,y:dst.y},dst])},"addVerticalToHorizontalCandidates"),addHorizontalPairCandidates=__name((candidates,src,srcSide,dst,dstSide)=>{const yTracks=[...outwardTracksForSide("top"),...outwardTracksForSide("bottom")];for(const srcTrack of outwardTracksForSide(srcSide))for(const dstTrack of outwardTracksForSide(dstSide))for(const yTrack of yTracks)pushOrthogonalCandidate(candidates,[src,{x:srcTrack,y:src.y},{x:srcTrack,y:yTrack},{x:dstTrack,y:yTrack},{x:dstTrack,y:dst.y},dst])},"addHorizontalPairCandidates"),addVerticalPairCandidates=__name((candidates,src,srcSide,dst,dstSide)=>{const xTracks=[...outwardTracksForSide("left"),...outwardTracksForSide("right")];for(const srcTrack of outwardTracksForSide(srcSide))for(const dstTrack of outwardTracksForSide(dstSide))for(const xTrack of xTracks)pushOrthogonalCandidate(candidates,[src,{x:src.x,y:srcTrack},{x:xTrack,y:srcTrack},{x:xTrack,y:dstTrack},{x:dst.x,y:dstTrack},dst])},"addVerticalPairCandidates"),dedupeCandidatePaths=__name(candidates=>{const seen=new Set;return candidates.map(candidate=>dedupeConsecutivePoints(candidate)).filter(candidate=>{const key=candidate.map(point=>`${point.x.toFixed(3)},${point.y.toFixed(3)}`).join("|");return!(seen.has(key)||candidate.length<2)&&(seen.add(key),!0)})},"dedupeCandidatePaths"),buildCandidatesForSides=__name((src,srcSide,dst,dstSide)=>{const candidates=[],base=buildOrthogonalPortPath(src,srcSide,dst,dstSide,20,.001);base&&pushOrthogonalCandidate(candidates,base),srcSide===dstSide&&addSameSideCandidates(candidates,src,srcSide,dst);const srcHorizontal=sideIsHorizontal(srcSide),dstHorizontal=sideIsHorizontal(dstSide);return srcHorizontal&&!dstHorizontal?addHorizontalToVerticalCandidates(candidates,src,srcSide,dst,dstSide):!srcHorizontal&&dstHorizontal?addVerticalToHorizontalCandidates(candidates,src,srcSide,dst,dstSide):srcHorizontal?addHorizontalPairCandidates(candidates,src,srcSide,dst,dstSide):addVerticalPairCandidates(candidates,src,srcSide,dst,dstSide),dedupeCandidatePaths(candidates)},"buildCandidatesForSides"),addVerticalDepartureOuterTrackCandidates=__name((candidates,first,departure,dstNode)=>{const externalXTracks=[...outwardTracksForSide("left"),...outwardTracksForSide("right")],externalYTracks=[...outwardTracksForSide("top"),...outwardTracksForSide("bottom")];for(const side of sides){const dst=portForRectSide(dstNode,side),targetYTracks="top"===side||"bottom"===side?outwardTracksForSide(side):externalYTracks;for(const track of externalXTracks){pushOrthogonalCandidate(candidates,[first,departure,{x:track,y:departure.y},{x:track,y:dst.y},dst]);for(const targetTrack of targetYTracks)pushOrthogonalCandidate(candidates,[first,departure,{x:track,y:departure.y},{x:track,y:targetTrack},{x:dst.x,y:targetTrack},dst])}}},"addVerticalDepartureOuterTrackCandidates"),addHorizontalDepartureOuterTrackCandidates=__name((candidates,first,departure,dstNode)=>{const externalXTracks=[...outwardTracksForSide("left"),...outwardTracksForSide("right")],externalYTracks=[...outwardTracksForSide("top"),...outwardTracksForSide("bottom")];for(const side of sides){const dst=portForRectSide(dstNode,side),targetXTracks="left"===side||"right"===side?outwardTracksForSide(side):externalXTracks;for(const track of externalYTracks){pushOrthogonalCandidate(candidates,[first,departure,{x:departure.x,y:track},{x:dst.x,y:track},dst]);for(const targetTrack of targetXTracks)pushOrthogonalCandidate(candidates,[first,departure,{x:departure.x,y:track},{x:targetTrack,y:track},{x:targetTrack,y:dst.y},dst])}}},"addHorizontalDepartureOuterTrackCandidates"),terminalPreservingOuterTrackCandidates=__name(edge=>{const srcId=edge.start,dstId=edge.end,dstNode=dstId?nodeInfoById.get(dstId):void 0;if(!srcId||!dstNode)return[];const points=dedupeConsecutivePoints(edge.points??[]);if(points.length<4)return[];const first=points[0],departure=points[1],candidates=[];return isVerticalSegment(first,departure,.001)?addVerticalDepartureOuterTrackCandidates(candidates,first,departure,dstNode):isHorizontalSegment(first,departure,.001)&&addHorizontalDepartureOuterTrackCandidates(candidates,first,departure,dstNode),candidates},"terminalPreservingOuterTrackCandidates"),candidatePathsFor=__name(edge=>{const srcId=edge.start,dstId=edge.end,srcNode=srcId?nodeInfoById.get(srcId):void 0,dstNode=dstId?nodeInfoById.get(dstId):void 0;if(!srcNode||!dstNode)return[];const candidates=[];for(const srcSide of sides){const srcPort=portForRectSide(srcNode,srcSide);for(const dstSide of sides)candidates.push(...buildCandidatesForSides(srcPort,srcSide,portForRectSide(dstNode,dstSide),dstSide))}return candidates.push(...terminalPreservingOuterTrackCandidates(edge)),candidates},"candidatePathsFor"),currentSegmentsByEdge=__name(()=>new Map(visibleEdges.map(edge=>[edge,segmentsFor(replacementPointsFor(edge))])),"currentSegmentsByEdge"),sharedTrackConflictsFor=__name((edge,candidateSegments,baseSegments)=>{const conflicts=new Set;for(const other of visibleEdges){if(other===edge)continue;const otherSegments=baseSegments.get(other)??segmentsFor(replacementPointsFor(other));candidateSegments.some(candidateSegment=>otherSegments.some(otherSegment=>sameAxisSegmentOverlapLength(candidateSegment,otherSegment,.5)>=8))&&conflicts.add(other)}return conflicts},"sharedTrackConflictsFor"),pairCandidatesFor=__name((edge,current,baseSegments,crossingCountByEdge)=>{const seen=new Set;return candidatePathsFor(edge).map(candidate=>simplifyPolyline(dedupeConsecutivePoints(candidate))).filter(candidate=>{if(pathHitsNode(edge,candidate))return!1;const key=candidate.map(point=>`${point.x.toFixed(3)},${point.y.toFixed(3)}`).join("|");return!(seen.has(key)||candidate.length<2)&&(seen.add(key),!0)}).map(candidate=>{const candidateSegments=segmentsFor(candidate);let replacementAffected=0;for(const other of visibleEdges)other!==edge&&(replacementAffected+=crossingCountBetweenSegments(candidateSegments,baseSegments.get(other)??segmentsFor(replacementPointsFor(other))));return{candidate:candidate,candidateSegments:candidateSegments,crossings:current.count-(crossingCountByEdge.get(edge)??0)+replacementAffected,bends:countOrthogonalBends(candidate,.001),totalBends:countOrthogonalBends(candidate),length:pathLength(candidate)}}).filter(({crossings:crossings})=>crossings<=current.count).sort((a,b)=>a.crossings-b.crossings||a.bends-b.bends||a.length-b.length).slice(0,48).map(candidate=>({path:candidate.candidate,segments:candidate.candidateSegments,sharedTrackConflicts:sharedTrackConflictsFor(edge,candidate.candidateSegments,baseSegments),totalBends:candidate.totalBends,length:candidate.length}))},"pairCandidatesFor"),pairCrossingCount=__name((current,firstEdge,firstCandidate,secondEdge,secondCandidate,baseSegments)=>{let currentAffected=0;for(const pair of current.pairs)pair.first!==firstEdge&&pair.second!==firstEdge&&pair.first!==secondEdge&&pair.second!==secondEdge||(currentAffected+=pair.count);let replacementAffected=crossingCountBetweenSegments(firstCandidate.segments,secondCandidate.segments);for(const other of visibleEdges){if(other===firstEdge||other===secondEdge)continue;const otherSegments=baseSegments.get(other)??segmentsFor(replacementPointsFor(other));replacementAffected+=crossingCountBetweenSegments(firstCandidate.segments,otherSegments)+crossingCountBetweenSegments(secondCandidate.segments,otherSegments)}return current.count-currentAffected+replacementAffected},"pairCrossingCount"),conflictsOnlyWith=__name((candidate,edge)=>{for(const conflict of candidate.sharedTrackConflicts)if(conflict!==edge)return!1;return!0},"conflictsOnlyWith"),candidatesShareTrack=__name((firstCandidate,secondCandidate)=>firstCandidate.segments.some(firstSegment=>secondCandidate.segments.some(secondSegment=>sameAxisSegmentOverlapLength(firstSegment,secondSegment,.5)>=8)),"candidatesShareTrack"),pairCandidatesAreCompatible=__name((first,firstCandidate,second,secondCandidate)=>conflictsOnlyWith(firstCandidate,second.edge)&&conflictsOnlyWith(secondCandidate,first.edge)&&!candidatesShareTrack(firstCandidate,secondCandidate),"pairCandidatesAreCompatible"),scorePairReplacement=__name((context,first,firstCandidate,second,secondCandidate)=>{const crossings=pairCrossingCount(context.current,first.edge,firstCandidate,second.edge,secondCandidate,context.baseSegments);if(!(crossings>=context.current.count))return{replacements:new Map([[first.edge,firstCandidate.path],[second.edge,secondCandidate.path]]),crossings:crossings,bends:context.currentBends-(context.baseBendsByEdge.get(first.edge)??0)-(context.baseBendsByEdge.get(second.edge)??0)+firstCandidate.totalBends+secondCandidate.totalBends,length:context.currentLength-(context.baseLengthByEdge.get(first.edge)??0)-(context.baseLengthByEdge.get(second.edge)??0)+firstCandidate.length+secondCandidate.length}},"scorePairReplacement"),pairScoreIsBetter=__name((candidate,best)=>candidate.crossings<best.crossings||candidate.crossings===best.crossings&&(candidate.bends<best.bends||candidate.bends===best.bends&&candidate.length<best.length),"pairScoreIsBetter"),bestScoreForOptionPair=__name((context,first,second,best)=>{let pairBest=best;for(const firstCandidate of first.candidates)for(const secondCandidate of second.candidates){if(!pairCandidatesAreCompatible(first,firstCandidate,second,secondCandidate))continue;const score=scorePairReplacement(context,first,firstCandidate,second,secondCandidate);score&&pairScoreIsBetter(score,pairBest)&&(pairBest=score)}return pairBest},"bestScoreForOptionPair"),bestPairedReplacement=__name(current=>{const currentBends=totalBends(),currentLength=totalLength(),baseSegments=currentSegmentsByEdge(),crossingCountByEdge=currentCrossingsByEdge(current),baseBendsByEdge=new Map(visibleEdges.map(edge=>[edge,countOrthogonalBends(replacementPointsFor(edge))])),baseLengthByEdge=new Map(visibleEdges.map(edge=>[edge,pathLength(replacementPointsFor(edge))])),optionsByEdge=new Map,groups=pairSearchGroups(current);for(const group of groups)for(const edge of group){if(optionsByEdge.has(edge))continue;const candidates=pairCandidatesFor(edge,current,baseSegments,crossingCountByEdge);candidates.length>0&&optionsByEdge.set(edge,{edge:edge,candidates:candidates})}let best={replacements:new Map,crossings:current.count,bends:currentBends,length:currentLength};const scoringContext={current:current,currentBends:currentBends,currentLength:currentLength,baseBendsByEdge:baseBendsByEdge,baseLengthByEdge:baseLengthByEdge,baseSegments:baseSegments};for(const group of groups){const crossingEdgeSet=new Set(group.filter(edge=>current.edgeSet.has(edge))),options=group.map(edge=>optionsByEdge.get(edge)).filter(option=>Boolean(option));for(let i=0;i<options.length;i++){const first=options[i];for(let j=i+1;j<options.length;j++){const second=options[j];(crossingEdgeSet.has(first.edge)||crossingEdgeSet.has(second.edge))&&(best=bestScoreForOptionPair(scoringContext,first,second,best))}}}return best.replacements.size>0?best.replacements:void 0},"bestPairedReplacement");for(let iteration=0;iteration<4;iteration++){const current=crossingSnapshot(),currentCrossings=current.count;if(0===currentCrossings)return;let bestEdge,bestPath,bestCrossings=currentCrossings,bestBends=Number.POSITIVE_INFINITY;for(const edge of current.edges){const currentEdgeBends=countOrthogonalBends(replacementPointsFor(edge),.001);for(const candidate of candidatePathsFor(edge)){const candidateHitsNode=pathHitsNode(edge,candidate),candidateHasSegmentConflict=!candidateHitsNode&&pathHasSegmentConflict(edge,candidate),candidateCrossings=crossingCountWithSingleReplacement(current,edge,candidate),candidateBends=countOrthogonalBends(candidate,.001);if(candidateHitsNode||candidateHasSegmentConflict)continue;(candidateCrossings<currentCrossings||candidateCrossings===currentCrossings&&candidateBends<currentEdgeBends)&&(candidateCrossings>bestCrossings||candidateCrossings===bestCrossings&&candidateBends>=bestBends||(bestEdge=edge,bestPath=candidate,bestCrossings=candidateCrossings,bestBends=candidateBends))}}if(bestEdge&&bestPath){bestEdge.points=bestPath;continue}const pairedReplacement=bestPairedReplacement(current);if(!pairedReplacement)return;for(const[edge,points]of pairedReplacement)edge.points=points}}__name(separateSharedRenderedTerminalLanes,"separateSharedRenderedTerminalLanes"),__name(collapseRedundantRectangularDoglegs,"collapseRedundantRectangularDoglegs"),__name(liftObstacleHuggingSameSideRails,"liftObstacleHuggingSameSideRails"),__name(liftTopLaneTitleBandsAboveRails,"liftTopLaneTitleBandsAboveRails"),__name(shiftLeftLaneTitleBandsLeftOfRails,"shiftLeftLaneTitleBandsLeftOfRails"),__name(swapDestinationTerminalTailsToReduceCrossings,"swapDestinationTerminalTailsToReduceCrossings"),__name(reassignCrossingExternalRailChannels,"reassignCrossingExternalRailChannels"),__name(shortcutRedundantOrthogonalJogs,"shortcutRedundantOrthogonalJogs"),__name(resolveRenderedOrthogonalCrossings,"resolveRenderedOrthogonalCrossings");function simplifyDetouredEdges(edges,nodes){const{nodeInfoById:nodeInfoById,realNodeRects:realNodeRects}=collectRealNodeBounds(nodes),sides=["top","bottom","left","right"],outsideTracks={top:Math.min(...realNodeRects.map(node=>node.rect.top))-20,bottom:Math.max(...realNodeRects.map(node=>node.rect.bottom))+20,left:Math.min(...realNodeRects.map(node=>node.rect.left))-20,right:Math.max(...realNodeRects.map(node=>node.rect.right))+20},buildOrthogonalPathCandidates=__name((src,srcSide,dst,dstSide)=>{const paths=[],base=buildOrthogonalPortPath(src,srcSide,dst,dstSide,20,.001);return base&&paths.push(base),srcSide===dstSide&&paths.push(buildSameSideTrackPath(src,srcSide,dst,outsideTracks[srcSide])),paths},"buildOrthogonalPathCandidates"),pathHitsNode=__name((pts,excludeIds)=>{for(let i=0;i<pts.length-1;i++){if(segmentHitsAnyRect(pts[i],pts[i+1],realNodeRects,excludeIds,1))return!0}return!1},"pathHitsNode"),pathConflictCount=__name((path,currentEdge,includeIncidentEdges=!1)=>{let conflicts=0;const pathSegments=orthogonalSegmentsForPoints(path,.001),currentStart=currentEdge.start,currentEnd=currentEdge.end;for(const other of edges){if(other===currentEdge||other.isLayoutOnly)continue;const otherStart=other.start,otherEnd=other.end;if(!includeIncidentEdges&&currentStart&&currentEnd&&(otherStart===currentStart||otherStart===currentEnd||otherEnd===currentStart||otherEnd===currentEnd))continue;const otherPts=other.points;if(otherPts&&!(otherPts.length<2))for(const pathSegment of pathSegments)for(const otherSegment of orthogonalSegmentsForPoints(otherPts,.001))(orthogonalSegmentsCross(pathSegment.a,pathSegment.b,otherSegment.a,otherSegment.b,.001,.001)||sameAxisSegmentOverlapLength(pathSegment,otherSegment,.001)>=8)&&conflicts++}return conflicts},"pathConflictCount"),nearestSideOfRect=__name((pt,info)=>{const dTop=Math.abs(pt.y-info.rect.top),dBottom=Math.abs(pt.y-info.rect.bottom),dLeft=Math.abs(pt.x-info.rect.left),dRight=Math.abs(pt.x-info.rect.right);let best="top",bestDist=dTop;return dBottom<bestDist&&(best="bottom",bestDist=dBottom),dLeft<bestDist&&(best="left",bestDist=dLeft),dRight<bestDist&&(best="right",bestDist=dRight),best},"nearestSideOfRect"),faceClaims=new Map,addFaceClaim=__name((nodeId,side,edgeId)=>{const claims=faceClaims.get(nodeId)??[];claims.push({side:side,edgeId:edgeId}),faceClaims.set(nodeId,claims)},"addFaceClaim");for(const e of edges){if(e.isLayoutOnly)continue;const pts=e.points??[];if(pts.length<1)continue;const eId=e.id??"",startId=e.start,endId=e.end;if(startId){const info=nodeInfoById.get(startId);info&&addFaceClaim(startId,nearestSideOfRect(pts[0],info),eId)}if(endId){const info=nodeInfoById.get(endId);info&&addFaceClaim(endId,nearestSideOfRect(pts[pts.length-1],info),eId)}}const faceIsClaimed=__name((nodeId,side,ignoreEdgeId)=>{var _a;return(null==(_a=faceClaims.get(nodeId))?void 0:_a.some(c=>c.edgeId!==ignoreEdgeId&&c.side===side))??!1},"faceIsClaimed");for(const edge of edges){if(edge.isLayoutOnly)continue;const pts=edge.points;if(!pts||pts.length<2)continue;const currentBends=countOrthogonalBends(pts,.001);if(currentBends<4)continue;const srcId=edge.start,dstId=edge.end;if(!srcId||!dstId)continue;const srcInfo=nodeInfoById.get(srcId),dstInfo=nodeInfoById.get(dstId);if(!srcInfo||!dstInfo)continue;const edgeId=edge.id??"",currentCrossingConflicts=pathConflictCount(pts,edge,!0),currentNonIncidentConflicts=pathConflictCount(pts,edge);let bestPath,bestCrossingConflicts=currentCrossingConflicts,bestBends=currentBends;for(const srcSide of sides){if(faceIsClaimed(srcId,srcSide,edgeId))continue;const srcPort=portForRectSide(srcInfo,srcSide);for(const dstSide of sides){if(faceIsClaimed(dstId,dstSide,edgeId))continue;const dstPort=portForRectSide(dstInfo,dstSide);for(const path of buildOrthogonalPathCandidates(srcPort,srcSide,dstPort,dstSide)){if(pathHitsNode(path,[srcId,dstId]))continue;const pathBends=countOrthogonalBends(path,.001);if(currentCrossingConflicts>0){const pathCrossingConflicts=pathConflictCount(path,edge,!0);if(pathCrossingConflicts>bestCrossingConflicts||pathCrossingConflicts===bestCrossingConflicts&&pathBends>=bestBends)continue;bestCrossingConflicts=pathCrossingConflicts,bestBends=pathBends,bestPath=path;continue}pathConflictCount(path,edge)>currentNonIncidentConflicts||pathBends<bestBends&&(bestBends=pathBends,bestPath=path)}}}if(bestPath){edge.points=bestPath;const refreshSrc=faceClaims.get(srcId);refreshSrc&&faceClaims.set(srcId,refreshSrc.filter(c=>c.edgeId!==edgeId));const refreshDst=faceClaims.get(dstId);refreshDst&&faceClaims.set(dstId,refreshDst.filter(c=>c.edgeId!==edgeId)),addFaceClaim(srcId,nearestSideOfRect(bestPath[0],srcInfo),edgeId),addFaceClaim(dstId,nearestSideOfRect(bestPath[bestPath.length-1],dstInfo),edgeId)}}}__name(simplifyDetouredEdges,"simplifyDetouredEdges");var EPS5=.001;function markerClearanceRectFor(pts,atStart){const terminalIndex=atStart?0:pts.length-1,step=atStart?1:-1,tip=pts[terminalIndex],inner=pts[terminalIndex+step];if(!tip||!inner)return;const dx=inner.x-tip.x,dy=inner.y-tip.y;if(!(Math.abs(dx)+Math.abs(dy)<EPS5)){if(Math.abs(dy)<=EPS5){const x2=tip.x+10*Math.sign(dx);return{left:Math.min(tip.x,x2),right:Math.max(tip.x,x2),top:tip.y-7,bottom:tip.y+7}}if(Math.abs(dx)<=EPS5){const y2=tip.y+10*Math.sign(dy);return{left:tip.x-7,right:tip.x+7,top:Math.min(tip.y,y2),bottom:Math.max(tip.y,y2)}}return{left:Math.min(tip.x,inner.x),right:Math.max(tip.x,inner.x),top:Math.min(tip.y,inner.y),bottom:Math.max(tip.y,inner.y)}}}function normalizeRect(rect){return{left:Math.min(rect.left,rect.right),right:Math.max(rect.left,rect.right),top:Math.min(rect.top,rect.bottom),bottom:Math.max(rect.top,rect.bottom)}}function labelOverlapsOwnMarker(rect,pts){const visiblePts=dedupeConsecutivePoints(pts);return[markerClearanceRectFor(visiblePts,!0),markerClearanceRectFor(visiblePts,!1)].some(marker=>marker&&rectsOverlap(rect,normalizeRect(marker)))}function anchorLabelsToPolyline(edges,nodeByIdMap){const allEdgeSegments=[];for(const other of edges){if(other.isLayoutOnly)continue;const pts=other.points;if(pts&&!(pts.length<2))for(let i=0;i<pts.length-1;i++)allEdgeSegments.push({edgeId:other.id,p1:pts[i],p2:pts[i+1]})}const foreignNodeRects=[],laneGroups=[];for(const n of nodeByIdMap.values()){const isGroup=n.isGroup,parentId=n.parentId;if(isGroup&&!parentId){const rect2=rectOfNodeBounds(n);rect2&&laneGroups.push({id:n.id,rect:rect2});continue}if(isGroup)continue;if(n.isEdgeLabel)continue;const rect=rectOfNodeBounds(n);rect&&foreignNodeRects.push({nodeId:n.id,rect:rect})}const labelOverlapsForeignNode=__name((labelId,rect)=>{const buffered=inflateRect(rect,3);for(const{nodeId:nodeId,rect:nr}of foreignNodeRects)if(nodeId!==labelId&&rectsOverlap(buffered,nr))return!0;return!1},"labelOverlapsForeignNode"),labelOverlapsForeignEdge=__name((edgeId,rect)=>{const buffered=inflateRect(rect,3);for(const s of allEdgeSegments)if(s.edgeId!==edgeId&&segmentBoundsOverlapRect(s.p1,s.p2,buffered))return!0;return!1},"labelOverlapsForeignEdge"),labelOverlapsAnything=__name((labelId,edgeId,rect)=>labelOverlapsForeignNode(labelId,rect)||labelOverlapsForeignEdge(edgeId,rect),"labelOverlapsAnything"),placedLabelRects=[],findContainingLane=__name(rect=>{for(const{id:id,rect:laneRect}of laneGroups)if(rectContainsRect(laneRect,rect))return id},"findContainingLane"),overlapsPlacedLabel=__name((labelId,rect)=>placedLabelRects.some(placed=>placed.labelId!==labelId&&rectsOverlap(rect,placed.rect)),"overlapsPlacedLabel");for(const edge of edges){if(edge.isLayoutOnly)continue;const labelId=edge.labelNodeId;if(!labelId)continue;const labelNode=nodeByIdMap.get(labelId);if(!labelNode)continue;const pts=edge.points;if(!pts||pts.length<2)continue;const lw=labelNode.width??0,lh=labelNode.height??0;if(lw<=0||lh<=0)continue;const segments=[];for(let i=0;i<pts.length-1;i++){const a=pts[i],b=pts[i+1],dx=Math.abs(a.x-b.x),dy=Math.abs(a.y-b.y);dx<EPS5&&dy<EPS5||(dx>=EPS5&&dy>=EPS5||segments.push({idx:i,length:dx+dy,orientation:dx>=EPS5?"horizontal":"vertical",midX:(a.x+b.x)/2,midY:(a.y+b.y)/2}))}if(0===segments.length)continue;const middleSegments=segments.length>=3?segments.filter(s=>s.idx>0&&s.idx<segments.length-1):segments,poolBase=middleSegments.length>0?middleSegments:segments,labelLongAxis=lw>=lh?"horizontal":"vertical",rankSegments=__name(pool=>[...pool].sort((a,b)=>{const aLongAxis=a.orientation===labelLongAxis;if(aLongAxis!==(b.orientation===labelLongAxis))return aLongAxis?-1:1;const aFits=a.length>=("horizontal"===a.orientation?lw:lh)+2;return aFits!==b.length>=("horizontal"===b.orientation?lw:lh)+2?aFits?-1:1:b.length-a.length}),"rankSegments"),firstVisibleSegment=segments[0],lastVisibleSegment=segments[segments.length-1],ALONG_SEGMENT_TS=[.5,.25,.75,.05,.95,.15,.85,.1,.9],anchorAtT=__name((seg,t)=>{const a=pts[seg.idx],b=pts[seg.idx+1];return{midX:a.x+(b.x-a.x)*t,midY:a.y+(b.y-a.y)*t}},"anchorAtT"),clamp=__name((value,min,max)=>Math.min(max,Math.max(min,value)),"clamp"),pointInsideRectInclusive=__name((point,rect)=>point.midX>=rect.left-EPS5&&point.midX<=rect.right+EPS5&&point.midY>=rect.top-EPS5&&point.midY<=rect.bottom+EPS5,"pointInsideRectInclusive"),placementForAnchor=__name(anchor=>{const centeredRect=rectFromCenterSize(anchor.midX,anchor.midY,lw,lh),centeredLane=findContainingLane(centeredRect);if(centeredLane)return{laneId:centeredLane,anchor:anchor,rect:centeredRect};const containingLane=laneGroups.find(({rect:rect})=>pointInsideRectInclusive(anchor,rect));if(!containingLane)return;const minX=containingLane.rect.left+lw/2+1,maxX=containingLane.rect.right-lw/2-1,minY=containingLane.rect.top+lh/2+1,maxY=containingLane.rect.bottom-lh/2-1;if(minX>maxX||minY>maxY)return;const clampedAnchor={midX:clamp(anchor.midX,minX,maxX),midY:clamp(anchor.midY,minY,maxY)},clampedRect=rectFromCenterSize(clampedAnchor.midX,clampedAnchor.midY,lw,lh);return pointInsideRectInclusive(anchor,clampedRect)?{laneId:containingLane.id,anchor:clampedAnchor,rect:clampedRect}:void 0},"placementForAnchor"),distanceAlongSegment=__name((seg,anchor,endpoint)=>"horizontal"===seg.orientation?Math.abs(anchor.midX-endpoint.x):Math.abs(anchor.midY-endpoint.y),"distanceAlongSegment"),labelClearsTerminalEndpoints=__name((seg,anchor)=>{const requiredDistance=("horizontal"===seg.orientation?lw/2:lh/2)+12;if(seg===firstVisibleSegment){const start=pts[seg.idx];if(distanceAlongSegment(seg,anchor,start)+EPS5<requiredDistance)return!1}if(seg===lastVisibleSegment){const end=pts[seg.idx+1];if(distanceAlongSegment(seg,anchor,end)+EPS5<requiredDistance)return!1}return!0},"labelClearsTerminalEndpoints"),tryPool=__name(pool=>{const rankedPool=rankSegments(pool);for(const seg of rankedPool)for(const t of ALONG_SEGMENT_TS){const anchor=anchorAtT(seg,t);if(!labelClearsTerminalEndpoints(seg,anchor))continue;const placement=placementForAnchor(anchor);if(placement&&(!labelOverlapsOwnMarker(placement.rect,pts)&&!overlapsPlacedLabel(labelId,placement.rect)&&!labelOverlapsAnything(labelId,edge.id,placement.rect)))return{laneId:placement.laneId,anchor:placement.anchor}}},"tryPool"),findLaneContainingFallback=__name((pool,requireEndpointClearance,allowForeignEdgeOverlap=!1)=>{const rankedPool=rankSegments(pool);for(const seg of rankedPool){const anchor={midX:seg.midX,midY:seg.midY};if(requireEndpointClearance&&!labelClearsTerminalEndpoints(seg,anchor))continue;const placement=placementForAnchor(anchor);if(placement&&!labelOverlapsOwnMarker(placement.rect,pts)&&!overlapsPlacedLabel(labelId,placement.rect)&&!labelOverlapsForeignNode(labelId,placement.rect)&&(allowForeignEdgeOverlap||!labelOverlapsForeignEdge(edge.id,placement.rect)))return{laneId:placement.laneId,anchor:placement.anchor}}},"findLaneContainingFallback"),chosen=tryPool(poolBase)??(poolBase.length<segments.length?tryPool(segments):void 0)??findLaneContainingFallback(segments,!0)??findLaneContainingFallback(segments,!1)??findLaneContainingFallback(segments,!1,!0);if(chosen){labelNode.x=chosen.anchor.midX,labelNode.y=chosen.anchor.midY,labelNode.parentId=chosen.laneId;const chosenRect=rectFromCenterSize(chosen.anchor.midX,chosen.anchor.midY,lw,lh),priorIdx=placedLabelRects.findIndex(placed=>placed.labelId===labelId);priorIdx>=0?placedLabelRects[priorIdx]={labelId:labelId,rect:chosenRect}:placedLabelRects.push({labelId:labelId,rect:chosenRect})}}}__name(markerClearanceRectFor,"markerClearanceRectFor"),__name(normalizeRect,"normalizeRect"),__name(labelOverlapsOwnMarker,"labelOverlapsOwnMarker"),__name(anchorLabelsToPolyline,"anchorLabelsToPolyline");function pairKey(a,b){return a<b?`${a}::${b}`:`${b}::${a}`}function straightenCollinearSiblingDetours(edges,nodes){const{nodeInfoById:nodeInfoById,realNodeRects:realNodeRects}=collectRealNodeBounds(nodes),labelDimById=new Map;for(const n of nodes){const id=n.id;n.isGroup||n.isEdgeLabel&&labelDimById.set(id,{w:n.width??0,h:n.height??0})}const labelClearanceFor=__name((thisEdge,thisSrcId,thisDstId,axis)=>{const targetPair=pairKey(thisSrcId,thisDstId);let maxHalf=0;const consider=__name(labelId=>{if(!labelId)return;const dim=labelDimById.get(labelId);if(!dim)return;const half="x"===axis?dim.w/2:dim.h/2;half>maxHalf&&(maxHalf=half)},"consider");consider(thisEdge.labelNodeId);for(const other of edges){if(other===thisEdge)continue;if(other.isLayoutOnly)continue;const oSrc=other.start,oDst=other.end;oSrc&&oDst&&(pairKey(oSrc,oDst)===targetPair&&consider(other.labelNodeId))}return maxHalf>0?maxHalf+3:0},"labelClearanceFor");for(const edge of edges){if(edge.isLayoutOnly)continue;if(!classifyThreeSegmentRoute(edge.points,1e-6))continue;const nodePair=getNodePairGeometry(edge,nodeInfoById,1e-6);if(!nodePair)continue;const{srcId:srcId,dstId:dstId,srcInfo:srcInfo,dstInfo:dstInfo,collinearX:collinearX,collinearY:collinearY}=nodePair;if(collinearX===collinearY)continue;let targetSrc,targetDst;if(collinearX){const dstBelow=dstInfo.cy>srcInfo.cy;targetSrc={x:srcInfo.cx,y:dstBelow?srcInfo.rect.bottom:srcInfo.rect.top},targetDst={x:dstInfo.cx,y:dstBelow?dstInfo.rect.top:dstInfo.rect.bottom}}else{const dstEast=dstInfo.cx>srcInfo.cx;targetSrc={x:dstEast?srcInfo.rect.right:srcInfo.rect.left,y:srcInfo.cy},targetDst={x:dstEast?dstInfo.rect.left:dstInfo.rect.right,y:dstInfo.cy}}if(segmentHitsAnyRect(targetSrc,targetDst,realNodeRects,[srcId,dstId],1))continue;const labelShift=labelClearanceFor(edge,srcId,dstId,collinearX?"x":"y"),effectiveShift=labelShift>4?labelShift:4,deltas=[0,effectiveShift,-effectiveShift];for(const delta of deltas){const shiftedSrc={...targetSrc},shiftedDst={...targetDst};if(collinearX){if(shiftedSrc.x+=delta,shiftedDst.x+=delta,shiftedSrc.x<=srcInfo.rect.left||shiftedSrc.x>=srcInfo.rect.right)continue;if(shiftedDst.x<=dstInfo.rect.left||shiftedDst.x>=dstInfo.rect.right)continue}else{if(shiftedSrc.y+=delta,shiftedDst.y+=delta,shiftedSrc.y<=srcInfo.rect.top||shiftedSrc.y>=srcInfo.rect.bottom)continue;if(shiftedDst.y<=dstInfo.rect.top||shiftedDst.y>=dstInfo.rect.bottom)continue}if(!segmentHitsAnyRect(shiftedSrc,shiftedDst,realNodeRects,[srcId,dstId],1)&&!segmentConflictsWithAnyEdge(shiftedSrc,shiftedDst,edges,edge,{epsilon:1e-6})){edge.points=[shiftedSrc,shiftedDst];break}}}}function nudgeSharedInteriorSubpaths(edges,nodeByIdMap){const{realNodeRects:realNodeRects,labelNodeRects:labelRects}=collectNodeRectEntries(nodeByIdMap.values()),segmentsFor2=__name((edge,points)=>orthogonalSegmentsForPoints(points,.001).map(segment=>({...segment,edge:edge,interior:segment.index>=1&&segment.index<=points.length-3})),"segmentsFor"),allSegments=__name(()=>{const result=[];for(const edge of edges){if(edge.isLayoutOnly)continue;const points=edge.points;!points||points.length<2||result.push(...segmentsFor2(edge,dedupeConsecutivePoints(points)))}return result},"allSegments"),hasCrowdedParallelTrack=__name((a,b)=>a.horizontal&&b.horizontal?overlapLength(a.a.x,a.b.x,b.a.x,b.b.x)>=8&&Math.abs(a.a.y-b.a.y)<7:!(!a.vertical||!b.vertical)&&(overlapLength(a.a.y,a.b.y,b.a.y,b.b.y)>=8&&Math.abs(a.a.x-b.a.x)<7),"hasCrowdedParallelTrack"),candidateIsSafe=__name((edge,candidate)=>{const sourceId=edge.start,targetId=edge.end,candidateSegments=segmentsFor2(edge,candidate);if(candidateSegments.length!==candidate.length-1)return!1;const endpointIds=[sourceId,targetId].filter(id=>Boolean(id)),ownLabelIds=edge.labelNodeId?[edge.labelNodeId]:[];for(const segment of candidateSegments){if(segmentHitsAnyRect(segment.a,segment.b,realNodeRects,endpointIds,-2))return!1;if(segmentHitsAnyRect(segment.a,segment.b,labelRects,ownLabelIds,-2))return!1}for(const other of edges){if(other===edge||other.isLayoutOnly)continue;const otherPoints=other.points;if(otherPoints&&!(otherPoints.length<2))for(const candidateSegment of candidateSegments)for(const otherSegment of segmentsFor2(other,dedupeConsecutivePoints(otherPoints))){if(hasCrowdedParallelTrack(candidateSegment,otherSegment))return!1;if(orthogonalSegmentsStrictlyCross(candidateSegment.a,candidateSegment.b,otherSegment.a,otherSegment.b,.001))return!1}}return!0},"candidateIsSafe"),shiftedCandidate=__name((segment,shift)=>{const points=dedupeConsecutivePoints(segment.edge.points??[]);if(points.length<4||segment.index>=points.length-1)return;const candidate=points.map(p=>({...p}));if(segment.horizontal)candidate[segment.index].y+=shift,candidate[segment.index+1].y+=shift;else{if(!segment.vertical)return;candidate[segment.index].x+=shift,candidate[segment.index+1].x+=shift}return segmentsFor2(segment.edge,candidate).length===candidate.length-1?candidate:void 0},"shiftedCandidate"),nodeCenter=__name((node,rect)=>({x:node.x??(rect.left+rect.right)/2,y:node.y??(rect.top+rect.bottom)/2}),"nodeCenter"),sourceDetourContextFor=__name(segment=>{const edge=segment.edge,points=dedupeConsecutivePoints(edge.points??[]);if(4!==points.length||1!==segment.index)return;const sourceNode=edge.start?nodeByIdMap.get(edge.start):void 0,targetNode=edge.end?nodeByIdMap.get(edge.end):void 0,sourceRect=sourceNode?rectOfNodeBounds(sourceNode):void 0,targetRect=targetNode?rectOfNodeBounds(targetNode):void 0,tail=points.slice(segment.index+2);return sourceNode&&targetNode&&sourceRect&&targetRect&&0!==tail.length?{sourceCenter:nodeCenter(sourceNode,sourceRect),targetCenter:nodeCenter(targetNode,targetRect),sourceRect:sourceRect,tail:tail}:void 0},"sourceDetourContextFor"),verticalSourceDetour=__name((segment,shift,sourceCenter,targetCenter,sourceRect,tail)=>{const targetBelow=targetCenter.y>=sourceCenter.y,sourcePortY=targetBelow?sourceRect.bottom:sourceRect.top,stubY=sourcePortY+(targetBelow?20:-20);if(targetBelow&&segment.b.y<=stubY+.001||!targetBelow&&segment.b.y>=stubY-.001)return;const railX=segment.a.x+shift;return dedupeConsecutivePoints([{x:sourceCenter.x,y:sourcePortY},{x:sourceCenter.x,y:stubY},{x:railX,y:stubY},{x:railX,y:segment.b.y},...tail],.001)},"verticalSourceDetour"),horizontalSourceDetour=__name((segment,shift,sourceCenter,targetCenter,sourceRect,tail)=>{const targetRight=targetCenter.x>=sourceCenter.x,sourcePortX=targetRight?sourceRect.right:sourceRect.left,stubX=sourcePortX+(targetRight?20:-20);if(targetRight&&segment.b.x<=stubX+.001||!targetRight&&segment.b.x>=stubX-.001)return;const railY=segment.a.y+shift;return dedupeConsecutivePoints([{x:sourcePortX,y:sourceCenter.y},{x:stubX,y:sourceCenter.y},{x:stubX,y:railY},{x:segment.b.x,y:railY},...tail],.001)},"horizontalSourceDetour"),sourceDetourCandidate=__name((segment,shift)=>{const context=sourceDetourContextFor(segment);if(context)return segment.vertical?verticalSourceDetour(segment,shift,context.sourceCenter,context.targetCenter,context.sourceRect,context.tail):segment.horizontal?horizontalSourceDetour(segment,shift,context.sourceCenter,context.targetCenter,context.sourceRect,context.tail):void 0},"sourceDetourCandidate"),shifts=[-7,7,-14,14,-21,21];for(let iteration=0;iteration<12;iteration++){const segments=allSegments();let fixed=!1;for(let i=0;i<segments.length&&!fixed;i++)for(let j=i+1;j<segments.length&&!fixed;j++){const first=segments[i],second=segments[j];if(first.edge===second.edge||!hasCrowdedParallelTrack(first,second))continue;const candidates=[first,second].filter(segment=>segment.interior);for(const segment of candidates){for(const shift of shifts){const direct=shiftedCandidate(segment,shift);if(direct&&candidateIsSafe(segment.edge,direct)){segment.edge.points=direct,fixed=!0;break}const detoured=sourceDetourCandidate(segment,shift);if(detoured&&candidateIsSafe(segment.edge,detoured)){segment.edge.points=detoured,fixed=!0;break}}if(fixed)break}}if(!fixed)return}}function segmentsIntersect(p1,p2,p3,p4){const d1x=p2.x-p1.x,d1y=p2.y-p1.y,d2x=p4.x-p3.x,d2y=p4.y-p3.y,cross=d1x*d2y-d1y*d2x;if(Math.abs(cross)<1e-10)return!1;const dx=p3.x-p1.x,dy=p3.y-p1.y,t=(dx*d2y-dy*d2x)/cross,u=(dx*d1y-dy*d1x)/cross;return t>.01&&t<.99&&u>.01&&u<.99}function validateSwimlanesLayout(layout){const nodes=layout.nodes??[],edges=layout.edges??[],issues=[];if(!edges.length||!nodes.length)return issues;const nodeRects=collectLayoutNodeRects(nodes),edgeSegments=[];for(const edge of edges){if(edge.isLayoutOnly)continue;const points=edge.points;if(!points||points.length<2)continue;const edgeStart=edge.start,edgeEnd=edge.end,ownLabelId=edge.labelNodeId,edgeId=edge.id??`${edgeStart}->${edgeEnd}`;for(const rect of nodeRects)if(rect.nodeId!==edgeStart&&rect.nodeId!==edgeEnd&&(!ownLabelId||rect.nodeId!==ownLabelId))for(let i=0;i<points.length-1;i++)if(segmentBoundsOverlapRect(points[i],points[i+1],rect,-1)){issues.push({type:"edge-node-overlap",edgeId:edgeId,targetId:rect.nodeId,detail:`segment ${i} passes through node "${rect.nodeId}"`});break}for(let i=0;i<points.length-1;i++)edgeSegments.push({edgeId:edgeId,start:edgeStart,end:edgeEnd,p1:points[i],p2:points[i+1]})}const crossingPairs=new Set;for(let i=0;i<edgeSegments.length;i++)for(let j=i+1;j<edgeSegments.length;j++){const a=edgeSegments[i],b=edgeSegments[j];if(a.edgeId!==b.edgeId&&(a.start!==b.start&&a.start!==b.end&&a.end!==b.start&&a.end!==b.end&&segmentsIntersect(a.p1,a.p2,b.p1,b.p2))){const pairKey2=a.edgeId<b.edgeId?`${a.edgeId}|${b.edgeId}`:`${b.edgeId}|${a.edgeId}`;crossingPairs.has(pairKey2)||(crossingPairs.add(pairKey2),issues.push({type:"edge-edge-crossing",edgeId:a.edgeId,targetId:b.edgeId,detail:`edges "${a.edgeId}" and "${b.edgeId}" cross`}))}}if(issues.length>0){const overlaps=issues.filter(i=>"edge-node-overlap"===i.type).length,crossings=issues.filter(i=>"edge-edge-crossing"===i.type).length;log.warn(`[SWIMLANE_VALIDATE] ${issues.length} issue(s) detected: ${overlaps} edge-node overlap(s), ${crossings} edge crossing(s)`);for(const issue of issues)log.warn(`[SWIMLANE_VALIDATE]   ${issue.type}: ${issue.detail}`)}return issues}function postProcessSwimlaneLayout(layout,direction){const nodes=layout.nodes??[],edges=layout.edges??[],contentNodes=nodes.filter(n=>!n.isGroup);if(("LR"===direction||"RL"===direction)&&contentNodes.length>0&&!applyLrDirectionTransform(layout,direction))return;if("BT"===direction&&contentNodes.length>0&&!applyBtDirectionTransform(layout))return;for(const edge of edges){if(edge.isLayoutOnly)continue;const pts=edge.points;!pts||pts.length<2||(edge.points=simplifyPolyline(orthogonalizePolyline(pts)))}simplifyDetouredEdges(edges,nodes),straightenCollinearSiblingDetours(edges,nodes),portSwapToLShape(edges,nodes);const nodeByIdMap=new Map;for(const n of nodes)nodeByIdMap.set(String(n.id),n);anchorLabelsToPolyline(edges,nodeByIdMap),clipEdgeEndpointsToNodeBoundaries(edges,nodeByIdMap),collapseShortTerminalStub(edges,nodeByIdMap),nudgeSharedInteriorSubpaths(edges,nodeByIdMap),separateSharedRenderedTerminalLanes(edges,nodeByIdMap),collapseRedundantRectangularDoglegs(edges,nodeByIdMap),liftObstacleHuggingSameSideRails(edges,nodeByIdMap),swapDestinationTerminalTailsToReduceCrossings(edges,nodeByIdMap);const finalizeRenderedEdges=__name(()=>{resolveRenderedOrthogonalCrossings(edges,nodeByIdMap),reassignCrossingExternalRailChannels(edges,nodeByIdMap),shortcutRedundantOrthogonalJogs(edges,nodeByIdMap),anchorLabelsToPolyline(edges,nodeByIdMap),prepareEdgeEndpointsForRenderer(edges,nodeByIdMap),liftObstacleHuggingSameSideRails(edges,nodeByIdMap),anchorLabelsToPolyline(edges,nodeByIdMap),prepareEdgeEndpointsForRenderer(edges,nodeByIdMap)},"finalizeRenderedEdges");finalizeRenderedEdges(),nudgeSharedInteriorSubpaths(edges,nodeByIdMap),finalizeRenderedEdges(),liftTopLaneTitleBandsAboveRails(edges,nodeByIdMap),shiftLeftLaneTitleBandsLeftOfRails(edges,nodeByIdMap),liftTopLaneTitleBandsAboveRails(edges,nodeByIdMap),shiftLeftLaneTitleBandsLeftOfRails(edges,nodeByIdMap)}function normalizeGraph(g){const nodeById=new Map(g.nodeById),seen=new Set,edges=[];for(const e of g.edges){if(!nodeById.has(e.src)||!nodeById.has(e.dst))continue;const key=`${e.id}:${e.src}->${e.dst}`;seen.has(key)||(seen.add(key),edges.push(e))}return{nodes:[...nodeById.keys()],edges:edges,layout:g.layout,nodeById:nodeById}}function incoming(g,v){return g.edges.filter(e=>e.dst===v)}function buildSuccessorMap(g){const succs=new Map;for(const v of g.nodes)succs.set(v,[]);for(const e of g.edges)succs.get(e.src).push(e.dst);return succs}function buildSortedSuccessorMap(g){const succs=buildSuccessorMap(g);for(const successors of succs.values())successors.sort((a,b)=>a.localeCompare(b));return succs}function buildInDegreeMap(g){const indeg=new Map;for(const v of g.nodes)indeg.set(v,0);for(const e of g.edges)indeg.set(e.dst,(indeg.get(e.dst)??0)+1);return indeg}function sortedZeroInDegreeNodes(indeg){return[...indeg.entries()].filter(([,degree])=>0===degree).map(([id])=>id).sort((a,b)=>a.localeCompare(b))}function buildPredecessorSuccessorMaps(g,includeEdge=()=>!0){const preds=new Map,succs=new Map;for(const v of g.nodes)preds.set(v,[]),succs.set(v,[]);for(const e of g.edges)includeEdge(e)&&(succs.get(e.src).push(e.dst),preds.get(e.dst).push(e.src));return{preds:preds,succs:succs}}function buildLayersFromRanks(g,order,rankOf,opts){var _a,_b;let maxRank=0;for(const v of g.nodes)(null==opts?void 0:opts.skipGroups)&&(null==(_a=g.nodeById.get(v))?void 0:_a.isGroup)||(maxRank=Math.max(maxRank,rankOf[v]??0));const layers=Array.from({length:maxRank+1},()=>[]);for(const v of order)(null==opts?void 0:opts.skipGroups)&&(null==(_b=g.nodeById.get(v))?void 0:_b.isGroup)||layers[Math.max(0,rankOf[v]??0)].push(v);return layers}function topoSortIfAcyclic(g){const indeg=buildInDegreeMap(g),queue=sortedZeroInDegreeNodes(indeg),order=[],adj=buildSortedSuccessorMap(g);for(;queue.length;){const u=queue.shift();order.push(u);for(const v of adj.get(u)??[])if(indeg.set(v,(indeg.get(v)??0)-1),0===(indeg.get(v)??0)){let i=0;for(;i<queue.length&&queue[i]<v;)i++;queue.splice(i,0,v)}}return order.length===g.nodes.length?order:null}function buildLayerIndex(layer){const m=new Map;let index=0;for(const id of layer)m.set(id,index),index++;return m}function countInversions(values){const tmp=new Array(values.length),count=__name((left,right)=>{if(right-left<=1)return 0;const mid=left+right>>1;let inversions=count(left,mid)+count(mid,right),i=left,j=mid,k=left;for(;i<mid||j<right;)j>=right||i<mid&&values[i]<=values[j]?tmp[k++]=values[i++]:(tmp[k++]=values[j++],inversions+=mid-i);for(let t=left;t<right;t++)values[t]=tmp[t];return inversions},"count");return count(0,values.length)}function removeCycles_DFS(g){const gn=normalizeGraph(g),adj=new Map;for(const v of gn.nodes)adj.set(v,[]);for(const e of gn.edges)adj.get(e.src).push(e);for(const arr of adj.values())arr.sort((a,b)=>a.dst===b.dst?a.id.localeCompare(b.id):a.dst.localeCompare(b.dst));const color=Object.create(null);for(const v of gn.nodes)color[v]=0;const reversed=[],dfs=__name(u=>{color[u]=1;for(const e of adj.get(u)??[]){const v=e.dst;0===color[v]?dfs(v):1===color[v]&&reversed.push(e)}color[u]=2},"dfs"),nodesSorted=[...gn.nodes].sort((a,b)=>a.localeCompare(b));for(const v of nodesSorted)0===color[v]&&dfs(v);const toReverse=new Set(reversed.map(e=>`${e.id}:${e.src}->${e.dst}`)),acycEdges=gn.edges.map(e=>toReverse.has(`${e.id}:${e.src}->${e.dst}`)?{id:e.id,src:e.dst,dst:e.src,weight:e.weight,ref:e.ref}:e);return{acyclic:{nodes:[...gn.nodes],edges:acycEdges,layout:gn.layout,nodeById:new Map(gn.nodeById)},reversed:reversed}}function buildTopLaneMap(g){const cache=new Map,resolve=__name(id=>{if(cache.has(id))return cache.get(id);const node=g.nodeById.get(id);if(!node)return cache.set(id,null),null;const parentId=node.parentId;if(!parentId)return cache.set(id,null),null;const lane=resolve(parentId)??parentId;return cache.set(id,lane),lane},"resolve");for(const id of g.nodes)resolve(id);return cache}function createTopLaneResolver(g){const topLaneMap=buildTopLaneMap(g);return id=>topLaneMap.get(id)??null}function buildTopLaneOrder(g){const lanes=[];for(const node of g.layout.nodes??[])node.isGroup&&!node.parentId&&lanes.push(node.id);return[...new Set(lanes)].reverse()}function resolveTopLaneOrder(g,preferredOrder){const sourceOrder=buildTopLaneOrder(g);if(!preferredOrder||0===preferredOrder.length)return sourceOrder;const sourceLaneIds=new Set(sourceOrder),seen=new Set,resolved=[];for(const laneId of preferredOrder)sourceLaneIds.has(laneId)&&!seen.has(laneId)&&(seen.add(laneId),resolved.push(laneId));for(const laneId of sourceOrder)seen.has(laneId)||resolved.push(laneId);return resolved}__name(pairKey,"pairKey"),__name(straightenCollinearSiblingDetours,"straightenCollinearSiblingDetours"),__name(nudgeSharedInteriorSubpaths,"nudgeSharedInteriorSubpaths"),__name(segmentsIntersect,"segmentsIntersect"),__name(validateSwimlanesLayout,"validateSwimlanesLayout"),__name(postProcessSwimlaneLayout,"postProcessSwimlaneLayout"),__name(normalizeGraph,"normalizeGraph"),__name(incoming,"incoming"),__name(buildSuccessorMap,"buildSuccessorMap"),__name(buildSortedSuccessorMap,"buildSortedSuccessorMap"),__name(buildInDegreeMap,"buildInDegreeMap"),__name(sortedZeroInDegreeNodes,"sortedZeroInDegreeNodes"),__name(buildPredecessorSuccessorMaps,"buildPredecessorSuccessorMaps"),__name(buildLayersFromRanks,"buildLayersFromRanks"),__name(topoSortIfAcyclic,"topoSortIfAcyclic"),__name(buildLayerIndex,"buildLayerIndex"),__name(countInversions,"countInversions"),__name(removeCycles_DFS,"removeCycles_DFS"),__name(buildTopLaneMap,"buildTopLaneMap"),__name(createTopLaneResolver,"createTopLaneResolver"),__name(buildTopLaneOrder,"buildTopLaneOrder"),__name(resolveTopLaneOrder,"resolveTopLaneOrder");var LAYERING_GRAVITY_ITERATIONS=8,LAYERING_MAX_CROSSING_OPTIMIZATION_PASSES=4,LAYERING_DEFAULT_COMPACT_SINGLE_INPUT=!0,COORDINATES_DEFAULT_LAYER_GAP=100,COORDINATES_DEFAULT_NODE_GAP=40;function buildDrivingTree(graph,opts){const g=normalizeGraph(graph),laneOf=(null==opts?void 0:opts.laneOf)??(()=>null),rankHint=null==opts?void 0:opts.rankHint,{preds:preds}=buildPredecessorSuccessorMaps(g);for(const arr of preds.values())arr.sort((a,b)=>a.localeCompare(b));const topoOrder=topoSortIfAcyclic(g)??[...g.nodes].sort((a,b)=>a.localeCompare(b)),topoIndex=new Map;for(const[idx,id]of topoOrder.entries())topoIndex.set(id,idx);const parent=new Map,children=new Map;for(const node of g.nodes)children.set(node,[]);for(const node of topoOrder){const candidates=(preds.get(node)??[]).filter(p=>parent.has(p));if(candidates.length>0){const chosen=chooseParent(node,candidates,{laneOf:laneOf,rankHint:rankHint,topoIndex:topoIndex});parent.set(node,chosen),children.get(chosen).push(node)}else parent.has(node)||parent.set(node,null)}for(const node of g.nodes)parent.has(node)||parent.set(node,null);const rootSet=new Set;for(const node of g.nodes)null===(parent.get(node)??null)&&rootSet.add(node);const roots=[...rootSet].sort((a,b)=>{const ta=topoIndex.get(a)??0,tb=topoIndex.get(b)??0;return ta===tb?a.localeCompare(b):ta-tb}),adjacency=buildAdjacency(g),adjacencyList=new Map;for(const[node,set]of adjacency.entries())adjacencyList.set(node,[...set].sort((a,b)=>a.localeCompare(b)));const componentOf=assignComponents(adjacencyList),blocks=computeBlocks(adjacencyList),nodeBlocks=new Map;for(const node of g.nodes)nodeBlocks.set(node,[]);for(const block of blocks)for(const node of block.nodes){const list=nodeBlocks.get(node);list?list.push(block.id):nodeBlocks.set(node,[block.id])}const preorder=[],postorder=[],seen=new Set,walk=__name(node=>{if(!seen.has(node)){seen.add(node),preorder.push(node);for(const child of children.get(node)??[])walk(child);postorder.push(node)}},"walk");for(const root of roots)walk(root);for(const node of topoOrder)walk(node);return{parent:parent,children:children,roots:roots,componentOf:componentOf,blocks:blocks,nodeBlocks:nodeBlocks,adjacency:adjacencyList,preorder:preorder,postorder:postorder,topologicalOrder:topoOrder}}function chooseParent(node,candidates,ctx){const laneNode=ctx.laneOf(node);return[...candidates].sort((a,b)=>{var _a,_b;const laneA=ctx.laneOf(a),laneB=ctx.laneOf(b),sameLaneA=null!=laneA&&laneA===laneNode;if(sameLaneA!==(null!=laneB&&laneB===laneNode))return sameLaneA?-1:1;const rankA=null==(_a=ctx.rankHint)?void 0:_a[a],rankB=null==(_b=ctx.rankHint)?void 0:_b[b];if(null!=rankA&&null!=rankB&&rankA!==rankB)return rankB-rankA;const idxA=ctx.topoIndex.get(a)??0,idxB=ctx.topoIndex.get(b)??0;return idxA!==idxB?idxA-idxB:a.localeCompare(b)})[0]}function buildAdjacency(g){const adjacency=new Map;for(const node of g.nodes)adjacency.set(node,new Set);for(const e of g.edges)adjacency.get(e.src).add(e.dst),adjacency.get(e.dst).add(e.src);return adjacency}function assignComponents(adjacency){const componentOf=new Map;let componentId=0;for(const node of adjacency.keys()){if(componentOf.has(node))continue;const stack=[node];for(;stack.length>0;){const cur=stack.pop();if(!componentOf.has(cur)){componentOf.set(cur,componentId);for(const next of adjacency.get(cur)??[])componentOf.has(next)||stack.push(next)}}componentId++}return componentOf}function computeBlocks(adjacency){const discovery=new Map,low=new Map,edgeStack=[],blocks=[];let time=0;const visit=__name((node,parent)=>{discovery.set(node,++time),low.set(node,time);for(const next of adjacency.get(node)??[])next!==parent&&(discovery.has(next)?(discovery.get(next)??0)<(discovery.get(node)??0)&&(edgeStack.push([node,next]),low.set(node,Math.min(low.get(node)??time,discovery.get(next)??time))):(edgeStack.push([node,next]),visit(next,node),low.set(node,Math.min(low.get(node)??time,low.get(next)??time)),(low.get(next)??0)>=(discovery.get(node)??0)&&blocks.push(popBlock(node,next,edgeStack,blocks.length))))},"visit");for(const node of adjacency.keys())discovery.has(node)||visit(node,null);return blocks}function popBlock(u,v,stack,id){const edges=[],nodes=new Set;for(;stack.length>0;){const edge=stack.pop();if(edges.push(edge),nodes.add(edge[0]),nodes.add(edge[1]),edge[0]===u&&edge[1]===v||edge[0]===v&&edge[1]===u)break}return{id:id,edges:edges,nodes:[...nodes]}}function computeSubtreeCrossCounts(g,rankOf,tree){const nodes=[...g.nodes],indexOf=new Map;for(const[i,node]of nodes.entries())indexOf.set(node,i);const n=nodes.length,parentIdx=new Array(n).fill(-1),depth=new Array(n).fill(0),queue=[],seen=new Set;for(const node of nodes){const parentId=tree.parent.get(node)??null,idx=indexOf.get(node);null!=idx&&(null==parentId&&(parentIdx[idx]=-1,depth[idx]=0,seen.has(node)||(seen.add(node),queue.push(node))))}for(;queue.length>0;){const current=queue.shift(),currentIdx=indexOf.get(current);if(null==currentIdx)continue;const childList=tree.children.get(current)??[];for(const child of childList){if(seen.has(child))continue;const childIdx=indexOf.get(child);null!=childIdx&&(parentIdx[childIdx]=currentIdx,depth[childIdx]=depth[currentIdx]+1,seen.add(child),queue.push(child))}}for(const node of nodes){if(seen.has(node))continue;const idx=indexOf.get(node);null!=idx&&(parentIdx[idx]=-1,depth[idx]=0,seen.add(node))}const maxLog=Math.max(1,Math.ceil(Math.log2(Math.max(1,n)))+1),up=Array.from({length:maxLog},()=>new Array(n).fill(-1));for(let i=0;i<n;i++)up[0][i]=parentIdx[i];for(let k=1;k<maxLog;k++)for(let i=0;i<n;i++){const prev=up[k-1][i];up[k][i]=-1===prev?-1:up[k-1][prev]}const lcaIndex=__name((aIdx,bIdx)=>{if(-1===aIdx||-1===bIdx)return-1;depth[aIdx]<depth[bIdx]&&([aIdx,bIdx]=[bIdx,aIdx]);const diff=depth[aIdx]-depth[bIdx];for(let k=0;k<maxLog;k++)if(diff>>k&1&&-1===(aIdx=up[k][aIdx]))return-1;if(aIdx===bIdx)return aIdx;for(let k=maxLog-1;k>=0;k--){const upA=up[k][aIdx],upB=up[k][bIdx];-1!==upA&&-1!==upB&&(upA!==upB&&(aIdx=upA,bIdx=upB))}return up[0][aIdx]},"lcaIndex"),ownCounts=Array.from({length:n},()=>new Map);for(const edge of g.edges){let src=edge.src,dst=edge.dst,ru=rankOf[src],rv=rankOf[dst];if(null==ru||null==rv)continue;if(ru>rv&&([src,dst]=[dst,src],[ru,rv]=[rv,ru]),null==ru||null==rv||ru===rv)continue;const upperIdx=indexOf.get(src),lowerIdx=indexOf.get(dst);if(null==upperIdx||null==lowerIdx)continue;const lca=lcaIndex(upperIdx,lowerIdx);if(-1===lca)continue;const bucket=ownCounts[lca];for(let layer=ru;layer<rv;layer++)bucket.set(layer,(bucket.get(layer)??0)+1)}const crossCounts=new Map,mergeInto=__name((target,source)=>{if(0!==source.size)for(const[layer,value]of source)target.set(layer,(target.get(layer)??0)+value)},"mergeInto"),visited=new Set,dfs=__name(node=>{const idx=indexOf.get(node);visited.add(node);const base=null==idx?void 0:ownCounts[idx],accumulator=base?new Map(base):new Map,childList=tree.children.get(node)??[];for(const child of childList){const childMap=dfs(child),parentLayer=rankOf[node];if(null!=parentLayer){let map=crossCounts.get(node);map||(map=new Map,crossCounts.set(node,map));let value=childMap.get(parentLayer)??0;const childLayer=rankOf[child];null!=childLayer&&childLayer>parentLayer&&(value+=1),map.set(child,value)}mergeInto(accumulator,childMap)}return accumulator},"dfs");for(const root of tree.roots)visited.has(root)||dfs(root);for(const node of nodes)visited.has(node)||dfs(node);return crossCounts}function annotateMinimumLayers(nodes,children,rankOf){const minLayer=new Map,annotate=__name(node=>{let minL=rankOf[node]??0;const childList=[...children.get(node)??[]];childList.sort(compareByRankThenId(rankOf));for(const child of childList){annotate(child);const childMin=minLayer.get(child);null!=childMin&&(minL=Math.min(minL,childMin))}minLayer.set(node,minL)},"annotate");for(const node of nodes)annotate(node);return minLayer}function compareByRankThenId(rankOf){return(a,b)=>{const ra=rankOf[a]??0,rb=rankOf[b]??0;return ra===rb?a.localeCompare(b):ra-rb}}function emitNodesInTreeOrder(roots,allNodes,rankOf,orderChildren){let maxRank=0;for(const node of allNodes){const r=rankOf[node]??0;r>maxRank&&(maxRank=r)}const layers=Array.from({length:maxRank+1},()=>[]),emitted=new Set,emit=__name(node=>{if(emitted.has(node))return;emitted.add(node);const layer=rankOf[node]??0;layers[layer]||(layers[layer]=[]),layers[layer].push(node);for(const child of orderChildren(node))emit(child)},"emit");for(const root of roots)emit(root);for(const node of allNodes)if(!emitted.has(node)){const layer=rankOf[node]??0;layers[layer]||(layers[layer]=[]),layers[layer].push(node),emitted.add(node)}return layers}function deduplicateLayers(layers){const result=[];for(const layer of layers){const seen=new Set,deduped=[];for(const id of layer)seen.has(id)||(seen.add(id),deduped.push(id));result.push(deduped)}return result}function createChildOrderer(children,rankOf,crossCounts,minLayer){return node=>{const raw=children.get(node)??[];if(0===raw.length)return[];const layer=rankOf[node]??0,future=[],present=[],crossMap=crossCounts.get(node);for(const child of raw){const minL=minLayer.get(child)??layer;minL>layer?future.push({child:child,min:minL}):present.push(child)}return future.sort((a,b)=>a.min===b.min?a.child.localeCompare(b.child):a.min-b.min),present.sort((a,b)=>{const ca=(null==crossMap?void 0:crossMap.get(a))??0,cb=(null==crossMap?void 0:crossMap.get(b))??0;if(ca!==cb)return ca-cb;const ma=minLayer.get(a)??layer,mb=minLayer.get(b)??layer;return ma!==mb?ma-mb:a.localeCompare(b)}),[...future.map(item=>item.child),...present]}}function buildMultitreeLayerOrder(g,rankOf,laneOf){const tree=buildDrivingTree(g,{rankHint:rankOf,laneOf:laneOf}),{children:children,roots:roots}=tree;for(const node of g.nodes)children.has(node)||children.set(node,[]);const crossCounts=computeSubtreeCrossCounts(g,rankOf,tree),rootsSorted=[...roots].sort(compareByRankThenId(rankOf)),orderChildren=createChildOrderer(children,rankOf,crossCounts,annotateMinimumLayers(rootsSorted,children,rankOf));let layers=emitNodesInTreeOrder(rootsSorted,g.nodes,rankOf,orderChildren);return layers=deduplicateLayers(layers),layers}function countCrossingsBetweenAdjacent(upper,lower,edges){const upperSet=new Set(upper),lowerSet=new Set(lower),li=buildLayerIndex(lower),vs=[];for(const e of edges)upperSet.has(e.src)&&lowerSet.has(e.dst)&&vs.push(li.get(e.dst));return countInversions(vs)}function totalCrossings(layers,edges,rankOf){const expanded=[];for(const e of edges){const ru=rankOf[e.src],rv=rankOf[e.dst];if(null==ru||null==rv||ru===rv)continue;let upper=e.src,lower=e.dst,rUpper=ru,rLower=rv;ru>rv&&(upper=e.dst,lower=e.src,rUpper=rv,rLower=ru);for(let L=rUpper;L<rLower;L++)expanded.push({id:`${e.id}@${L}`,src:upper,dst:lower,ref:e.ref})}let sum=0;for(let i=0;i+1<layers.length;i++)sum+=countCrossingsBetweenAdjacent(layers[i],layers[i+1],expanded);return sum}function optimizeRanksByCrossings(g,initialRank){const rankOf={...initialRank},{preds:preds}=buildPredecessorSuccessorMaps(g),laneOf=createTopLaneResolver(g);let best=totalCrossings(buildMultitreeLayerOrder(g,rankOf,laneOf),g.edges,rankOf);const maxPasses=LAYERING_MAX_CROSSING_OPTIMIZATION_PASSES;for(let pass=0;pass<maxPasses;pass++){let changed=!1;const nodesByRank=[...g.nodes].sort((a,b)=>(rankOf[b]??0)-(rankOf[a]??0));for(const v of nodesByRank){const r=rankOf[v]??0;if(0===r)continue;let lb=0;for(const u of preds.get(v)??[])lb=Math.max(lb,(rankOf[u]??0)+1);if(lb>=r)continue;const old=r;rankOf[v]=lb;const score=totalCrossings(buildMultitreeLayerOrder(g,rankOf,laneOf),g.edges,rankOf);score<best?(best=score,changed=!0):rankOf[v]=old}if(!changed)break}return rankOf}function adjustCrossLaneSources(g,rankOf){const topLaneOf=createTopLaneResolver(g),nodesByRank=[...g.nodes].sort((a,b)=>(rankOf[a]??0)-(rankOf[b]??0)||a.localeCompare(b));for(const v of nodesByRank){const laneV=topLaneOf(v);if(!laneV)continue;const outEdges=g.edges.filter(e=>e.src===v);if(0===outEdges.length)continue;let hasSameLaneSucc=!1,crossLaneCount=0;for(const e of outEdges){const laneDst=topLaneOf(e.dst);null==laneDst||laneDst===laneV?hasSameLaneSucc=!0:crossLaneCount++}if(0===crossLaneCount||hasSameLaneSucc)continue;let crossLaneIncoming=0,hasSameLanePred=!1;for(const e of g.edges){if(e.dst!==v)continue;const laneSrc=topLaneOf(e.src);laneSrc&&(laneSrc===laneV?hasSameLanePred=!0:crossLaneIncoming++)}if(crossLaneIncoming>0||!hasSameLanePred)continue;const current=rankOf[v]??0,target=current+crossLaneCount;let lb=0;for(const e of g.edges)e.dst===v&&(lb=Math.max(lb,(rankOf[e.src]??0)+1));const newRank=Math.max(current,lb,target);newRank!==current&&(rankOf[v]=newRank)}}function assignLayers_LongestPath(gAcyclic,opts){const g=normalizeGraph(gAcyclic),order=topoSortIfAcyclic(g)??[...g.nodes].sort(),compact=(null==opts?void 0:opts.compactSingleInput)??!1,topLaneOf=createTopLaneResolver(g);let rankOf=Object.create(null);for(const v of order){const incAll=incoming(g,v),inc=(null==opts?void 0:opts.ignoreCrossLaneEdges)?incAll.filter(e=>{const laneSrc=topLaneOf(e.src),laneDst=topLaneOf(v);return!laneSrc||!laneDst||laneSrc===laneDst}):incAll;if(0===inc.length)rankOf[v]=0;else if(compact&&1===inc.length){const u=inc[0].src,laneU=topLaneOf(u),laneV=topLaneOf(v);rankOf[v]=laneU!==laneV?rankOf[u]??0:(rankOf[u]??0)+1}else{let mx=-1/0;for(const e of inc)mx=Math.max(mx,(rankOf[e.src]??0)+1);rankOf[v]=mx===-1/0?0:mx}}(null==opts?void 0:opts.optimizeRanksByCrossings)&&(rankOf=optimizeRanksByCrossings(g,rankOf)),(null==opts?void 0:opts.ignoreCrossLaneEdges)&&adjustCrossLaneSources(g,rankOf);return{layers:buildMultitreeLayerOrder(g,rankOf,topLaneOf),rankOf:rankOf,dummy:new Set}}function assignLayers_Gravity(gAcyclic,opts){const g=normalizeGraph(gAcyclic),rankOf={...assignLayers_LongestPath(g,{compactSingleInput:null==opts?void 0:opts.compactSingleInput,ignoreCrossLaneEdges:null==opts?void 0:opts.ignoreCrossLaneEdges,optimizeRanksByCrossings:null==opts?void 0:opts.optimizeRanksByCrossings}).rankOf},topLaneOf=createTopLaneResolver(g),{preds:preds,succs:succs}=buildPredecessorSuccessorMaps(g,e=>{if(null==opts?void 0:opts.ignoreCrossLaneEdges){const laneSrc=topLaneOf(e.src),laneDst=topLaneOf(e.dst);if(laneSrc&&laneDst&&laneSrc!==laneDst)return!1}return!0}),order=topoSortIfAcyclic(g)??[...g.nodes],revOrder=[...order].reverse(),clampFeasible=__name((v,desired)=>{let lb=0;for(const u of preds.get(v)??[])lb=Math.max(lb,(rankOf[u]??0)+1);let ub=Number.POSITIVE_INFINITY;const s=succs.get(v)??[];return s.length>0&&(ub=Math.min(...s.map(w=>(rankOf[w]??0)-1))),Number.isFinite(ub)||(ub=Math.max(lb,desired)),Math.min(Math.max(desired,lb),ub)},"clampFeasible"),iters=LAYERING_GRAVITY_ITERATIONS,relaxOrder=__name(nodeOrder=>{let changed=!1;for(const v of nodeOrder){const ps=preds.get(v)??[],ss=succs.get(v)??[];if(0===ps.length&&0===ss.length)continue;const predAvg=ps.length>0?ps.reduce((a,u)=>a+(rankOf[u]??0)+1,0)/ps.length:rankOf[v]??0,succAvg=ss.length>0?ss.reduce((a,w)=>a+(rankOf[w]??0)-1,0)/ss.length:rankOf[v]??0,desired=Math.round((predAvg+succAvg)/2),clamped=clampFeasible(v,desired);clamped!==rankOf[v]&&(rankOf[v]=clamped,changed=!0)}return changed},"relaxOrder");for(let it=0;it<iters;it++){const forwardChanged=relaxOrder(order),backwardChanged=relaxOrder(revOrder);if(!forwardChanged&&!backwardChanged)break}for(const v of order){let lb=0;for(const u of preds.get(v)??[])lb=Math.max(lb,(rankOf[u]??0)+1);(rankOf[v]??0)<lb&&(rankOf[v]=lb)}for(const v of revOrder){const s=succs.get(v)??[];if(s.length>0){const ub=Math.min(...s.map(w=>(rankOf[w]??0)-1));(rankOf[v]??0)>ub&&(rankOf[v]=ub)}}return{layers:buildLayersFromRanks(g,order,rankOf),rankOf:rankOf,dummy:new Set}}function topoSortByGenerationIfAcyclic(g){const indeg=buildInDegreeMap(g),adj=buildSortedSuccessorMap(g);let frontier=sortedZeroInDegreeNodes(indeg);const order=[];for(;frontier.length>0;){const nextFrontier=[];for(const u of frontier){order.push(u);for(const v of adj.get(u)??[])indeg.set(v,(indeg.get(v)??0)-1),0===(indeg.get(v)??0)&&nextFrontier.push(v)}frontier=nextFrontier.sort((a,b)=>a.localeCompare(b))}return order.length===g.nodes.length?order:null}function assignLayers_LaneAwareCompact(gAcyclic,opts){const g=normalizeGraph(gAcyclic),order="LR"===(null==opts?void 0:opts.direction)?topoSortByGenerationIfAcyclic(g)??[...g.nodes].sort():topoSortIfAcyclic(g)??[...g.nodes].sort(),topLaneOf=createTopLaneResolver(g),laneOf=__name(id=>topLaneOf(id)??id,"laneOf"),rankOf=Object.create(null),nextFree=new Map,edgeWeight=__name((u,v)=>(null==opts?void 0:opts.ignoreCrossLaneEdges)??!0?laneOf(u)===laneOf(v)?1:0:1,"edgeWeight");for(const v of order){const node=g.nodeById.get(v);if(null==node?void 0:node.isGroup)continue;const preds=incoming(g,v);let base=0;if(preds.length>0)for(const e of preds){const u=e.src,ru=rankOf[u]??0;base=Math.max(base,ru+edgeWeight(u,v))}const lane=laneOf(v),nf=nextFree.get(lane)??0,L=Math.max(base,nf);rankOf[v]=L,nextFree.set(lane,L+1)}return{layers:buildLayersFromRanks(g,order,rankOf,{skipGroups:!0}),rankOf:rankOf,dummy:new Set}}function makeProperLayering(layering,gAcyclic){const g=normalizeGraph(gAcyclic),{rankOf:rankOf}=layering,layers=layering.layers.map(l=>[...l]),dummy=new Set(layering.dummy?[...layering.dummy]:[]);let dummySeq=0;const nodeById=new Map(g.nodeById),addDummyAt=__name(L=>{const id="placeholder-"+dummySeq++,dn={id:id,isGroup:!1,isDummy:!0,width:0,height:0};for(nodeById.set(id,dn),dummy.add(id);layers.length<=L;)layers.push([]);return layers[L].push(id),rankOf[id]=L,id},"addDummyAt"),edgesSorted=[...g.edges].sort((a,b)=>a.id===b.id?a.src===b.src?a.dst.localeCompare(b.dst):a.src.localeCompare(b.src):a.id.localeCompare(b.id)),newEdges=[];for(const e of edgesSorted){const rU=rankOf[e.src]??0,rV=rankOf[e.dst]??0;if(rV-rU<=1){newEdges.push(e);continue}let prev=e.src;for(let L=rU+1,k=0;L<rV;L++,k++){const d=addDummyAt(L);newEdges.push({id:`${e.id}#${k}`,src:prev,dst:d,weight:e.weight,ref:e.ref}),prev=d}const lastIndex=rV-rU-2;newEdges.push({id:`${e.id}#${Math.max(lastIndex+1,0)}`,src:prev,dst:e.dst,weight:e.weight,ref:e.ref})}const graphWithDummies={nodes:[...g.nodes,...[...dummy].filter(id=>!g.nodes.includes(id))],edges:newEdges,layout:g.layout,nodeById:nodeById};return{layering:{layers:layers,rankOf:rankOf,dummy:dummy},graphWithDummies:graphWithDummies}}function median(values){const n=values.length;if(0===n)return Number.POSITIVE_INFINITY;const a=[...values].sort((x,y)=>x-y);return n%2==1?a[(n-1)/2]:.5*(a[n/2-1]+a[n/2])}function barycenter(values){if(0===values.length)return Number.POSITIVE_INFINITY;return values.reduce((acc,v)=>acc+v,0)/values.length}function neighborPositionsFor(targetNodes,fixedIndex,edges,direction){const neighborPositions=new Map;for(const v of targetNodes)neighborPositions.set(v,[]);for(const e of edges)"down"===direction?fixedIndex.has(e.src)&&neighborPositions.has(e.dst)&&neighborPositions.get(e.dst).push(fixedIndex.get(e.src)):fixedIndex.has(e.dst)&&neighborPositions.has(e.src)&&neighborPositions.get(e.src).push(fixedIndex.get(e.dst));return neighborPositions}function currentOrderTieBreak(a,b,currentLayerIndex){const ia=currentLayerIndex.get(a)??0,ib=currentLayerIndex.get(b)??0;return ia!==ib?ia-ib:a.localeCompare(b)}function countCrossingsBetweenAdjacent2(upper,lower,edges){const upperSet=new Set(upper),lowerSet=new Set(lower),upperIndex=buildLayerIndex(upper),lowerIndex=buildLayerIndex(lower),pairs=[];for(const e of edges)upperSet.has(e.src)&&lowerSet.has(e.dst)&&pairs.push({u:upperIndex.get(e.src),v:lowerIndex.get(e.dst)});pairs.sort((a,b)=>a.u===b.u?a.v-b.v:a.u-b.u);return countInversions(pairs.map(p=>p.v))}function sortByHeuristic(nodes,neighborPositions,currentLayerIndex){return[...nodes].sort((a,b)=>{const sa=median(neighborPositions.get(a)??[]),sb=median(neighborPositions.get(b)??[]);return sa===sb?currentOrderTieBreak(a,b,currentLayerIndex):isFinite(sa)?isFinite(sb)?sa-sb:-1:1})}function reorderLayer(fixedLayer,targetLayer,edges,direction,topLaneOf,laneOrder){const fixedIndex=buildLayerIndex(fixedLayer),currIndex=buildLayerIndex(targetLayer),neighborPositions=neighborPositionsFor(targetLayer,fixedIndex,edges,direction);if(!topLaneOf||!laneOrder||0===laneOrder.length)return sortByHeuristic(targetLayer,neighborPositions,currIndex);const byLane=new Map;for(const id of targetLayer){const lane=topLaneOf(id),arr=byLane.get(lane)??[];arr.push(id),byLane.set(lane,arr)}const result=[];for(const lane of laneOrder){const nodesInLane=byLane.get(lane);if(!nodesInLane||0===nodesInLane.length)continue;const sorted=sortByHeuristic(nodesInLane,neighborPositions,currIndex);result.push(...sorted)}const nullNodes=byLane.get(null);if(nullNodes&&nullNodes.length>0){const sorted=sortByHeuristic(nullNodes,neighborPositions,currIndex);for(const nid of sorted){const bc=barycenter(neighborPositions.get(nid)??[]);let bestIdx=result.length;if(isFinite(bc))for(const[i,rid]of result.entries()){if(bc<barycenter(neighborPositions.get(rid)??[])){bestIdx=i;break}}result.splice(bestIdx,0,nid)}}return result}function transposeImprove(upper,current,edges,next,topLaneOf){const best=[...current],upperSet=new Set(upper),layerSet=new Set(current),nextSet=next?new Set(next):null,edgesIn=edges.filter(e=>upperSet.has(e.src)&&layerSet.has(e.dst)),edgesOut=nextSet?edges.filter(e=>layerSet.has(e.src)&&nextSet.has(e.dst)):void 0,crossingScore=__name(order=>{let score=countCrossingsBetweenAdjacent2(upper,order,edgesIn);return edgesOut&&next&&(score+=countCrossingsBetweenAdjacent2(order,next,edgesOut)),score},"crossingScore"),laneOf=topLaneOf?new Map:null;if(topLaneOf&&laneOf)for(const id of current)laneOf.set(id,topLaneOf(id));let improved=!0,bestScore=crossingScore(best);for(;improved;){improved=!1;for(let i=0;i+1<best.length;i++){if(laneOf){if(laneOf.get(best[i])!==laneOf.get(best[i+1]))continue}const prev=bestScore;[best[i],best[i+1]]=[best[i+1],best[i]];const nextScore=crossingScore(best);nextScore<prev?(bestScore=nextScore,improved=!0):[best[i],best[i+1]]=[best[i+1],best[i]]}}return best}function orderLayers(layering,gWithDummies,opts){const layers=layering.layers.map(l=>[...l]),edges=gWithDummies.edges,topLaneOf=createTopLaneResolver(gWithDummies),laneOrder=resolveTopLaneOrder(gWithDummies,null==opts?void 0:opts.laneOrder);for(let s=0;s<3;s++){for(let i=1;i<layers.length;i++)layers[i]=reorderLayer(layers[i-1],layers[i],edges,"down",topLaneOf,laneOrder),layers[i]=transposeImprove(layers[i-1],layers[i],edges,layers[i+1],topLaneOf);for(let i=layers.length-2;i>=0;i--)layers[i]=reorderLayer(layers[i+1],layers[i],edges,"up",topLaneOf,laneOrder),layers[i]=transposeImprove(layers[i+1],layers[i],edges,layers[i-1],topLaneOf)}return{layers:layers}}function assignCoordinates(ordered,gWithDummies,opts){const layerGap=(null==opts?void 0:opts.layerGap)??COORDINATES_DEFAULT_LAYER_GAP,nodeGap=(null==opts?void 0:opts.nodeGap)??COORDINATES_DEFAULT_NODE_GAP,laneGap=(null==opts?void 0:opts.laneGap)??2*nodeGap,direction=(null==opts?void 0:opts.direction)??"TB",isHorizontal="LR"===direction||"RL"===direction,layers=ordered.layers,x=Object.create(null),y=Object.create(null),getNode=__name(id=>gWithDummies.nodeById.get(id),"getNode"),getWidth=__name(id=>{var _a;return(null==(_a=getNode(id))?void 0:_a.width)??0},"getWidth"),getHeight=__name(id=>{var _a;return(null==(_a=getNode(id))?void 0:_a.height)??0},"getHeight"),topLaneOf=createTopLaneResolver(gWithDummies),laneOrderGlobal=resolveTopLaneOrder(gWithDummies,null==opts?void 0:opts.laneOrder),layerHeights=layers.map(layer=>layer.reduce((m,v)=>Math.max(m,getHeight(v)),0)),extraLayerGaps=[];if(isHorizontal)for(let i=0;i+1<layers.length;i++){const thisLayerMaxWidth=layers[i].reduce((m,v)=>Math.max(m,getWidth(v)),0),nextLayerMaxWidth=layers[i+1].reduce((m,v)=>Math.max(m,getWidth(v)),0),normalSpacing=layerHeights[i]/2+layerHeights[i+1]/2,requiredSpacing=(thisLayerMaxWidth+nextLayerMaxWidth)/2,extraNeeded=Math.max(0,requiredSpacing-normalSpacing-layerGap);extraLayerGaps.push(extraNeeded)}const lanesUsedSet=new Set;for(const layer of layers)for(const id of layer)lanesUsedSet.add(topLaneOf(id));const hasNullLane=lanesUsedSet.has(null),lanesUsed=laneOrderGlobal.filter(L=>lanesUsedSet.has(L)),laneOrderColumns=[...hasNullLane?[null]:[],...lanesUsed],laneWidth=Object.create(null);for(const L of lanesUsed)laneWidth[L]=0;hasNullLane&&(laneWidth.null=0);for(const layer of layers){const perLane=Object.create(null),nullIds=[];for(const id of layer){const L=topLaneOf(id);null===L?nullIds.push(id):(perLane[L]||(perLane[L]=[])).push(id)}for(const[L,ids]of Object.entries(perLane)){const total=ids.reduce((s,id)=>s+getWidth(id),0)+nodeGap*Math.max(0,ids.length-1);laneWidth[L]=Math.max(laneWidth[L]??0,total)}if(hasNullLane&&nullIds.length){const totalNull=nullIds.reduce((s,id)=>s+getWidth(id),0)+nodeGap*Math.max(0,nullIds.length-1);laneWidth.null=Math.max(laneWidth.null??0,totalNull)}}const centerX=new Map;{const widths=laneOrderColumns.map(L=>(null===L?laneWidth.null:laneWidth[L])??0);let cursor=-(widths.reduce((a,b)=>a+b,0)+laneGap*Math.max(0,laneOrderColumns.length-1))/2;for(let i=0;i<laneOrderColumns.length;i++){const L=laneOrderColumns[i],w=widths[i]??0,cx=cursor+w/2;centerX.set(L,cx),cursor+=w,i<laneOrderColumns.length-1&&(cursor+=laneGap)}}let yOffset=0;for(const[li,layer]of layers.entries()){const layerH=layerHeights[li]??0,byLane=new Map;for(const id of layer){const laneId=topLaneOf(id),arr=byLane.get(laneId)??[];arr.push(id),byLane.set(laneId,arr)}for(const L of laneOrderColumns){const nodesInLane=byLane.get(L)??[];if(0===nodesInLane.length)continue;const cx=centerX.get(L);if(1===nodesInLane.length){const id=nodesInLane[0];x[id]=cx,y[id]=yOffset+layerH/2}else{const widths=nodesInLane.map(id=>getWidth(id));let start=cx-(widths.reduce((a,b)=>a+b,0)+nodeGap*(nodesInLane.length-1))/2;for(const[i,id]of nodesInLane.entries()){const w=widths[i];x[id]=start+w/2,y[id]=yOffset+layerH/2,start+=w+nodeGap}}}yOffset+=layerH+layerGap+(extraLayerGaps[li]??0)}const byRef=new Map;for(const e of gWithDummies.edges){const rid=e.ref.id;byRef.has(rid)||byRef.set(rid,[]),byRef.get(rid).push(e)}for(const[,chainEdges]of byRef){if(0===chainEdges.length)continue;const ref=chainEdges[0].ref,src=ref.start,dst=ref.end;if(null==src||null==dst)continue;const midX=Math.round(((x[src]??0)+(x[dst]??0))/2),involved=new Set;for(const e of chainEdges)involved.add(e.src),involved.add(e.dst);for(const vid of involved){if(vid===src||vid===dst)continue;const node=gWithDummies.nodeById.get(vid);(null==node?void 0:node.isDummy)&&(x[vid]=midX)}}return{x:x,y:y}}__name(buildDrivingTree,"buildDrivingTree"),__name(chooseParent,"chooseParent"),__name(buildAdjacency,"buildAdjacency"),__name(assignComponents,"assignComponents"),__name(computeBlocks,"computeBlocks"),__name(popBlock,"popBlock"),__name(computeSubtreeCrossCounts,"computeSubtreeCrossCounts"),__name(annotateMinimumLayers,"annotateMinimumLayers"),__name(compareByRankThenId,"compareByRankThenId"),__name(emitNodesInTreeOrder,"emitNodesInTreeOrder"),__name(deduplicateLayers,"deduplicateLayers"),__name(createChildOrderer,"createChildOrderer"),__name(buildMultitreeLayerOrder,"buildMultitreeLayerOrder"),__name(countCrossingsBetweenAdjacent,"countCrossingsBetweenAdjacent"),__name(totalCrossings,"totalCrossings"),__name(optimizeRanksByCrossings,"optimizeRanksByCrossings"),__name(adjustCrossLaneSources,"adjustCrossLaneSources"),__name(assignLayers_LongestPath,"assignLayers_LongestPath"),__name(assignLayers_Gravity,"assignLayers_Gravity"),__name(topoSortByGenerationIfAcyclic,"topoSortByGenerationIfAcyclic"),__name(assignLayers_LaneAwareCompact,"assignLayers_LaneAwareCompact"),__name(makeProperLayering,"makeProperLayering"),__name(median,"median"),__name(barycenter,"barycenter"),__name(neighborPositionsFor,"neighborPositionsFor"),__name(currentOrderTieBreak,"currentOrderTieBreak"),__name(countCrossingsBetweenAdjacent2,"countCrossingsBetweenAdjacent"),__name(sortByHeuristic,"sortByHeuristic"),__name(reorderLayer,"reorderLayer"),__name(transposeImprove,"transposeImprove"),__name(orderLayers,"orderLayers"),__name(assignCoordinates,"assignCoordinates");function hashString(input){let hash=2166136261;for(let i=0;i<input.length;i++)hash^=input.charCodeAt(i),hash=Math.imul(hash,16777619);return hash>>>0}function mulberry32(seed){let state=seed>>>0;return()=>{state+=1831565813;let t=state;return t=Math.imul(t^t>>>15,1|t),t^=t+Math.imul(t^t>>>7,61|t),((t^t>>>14)>>>0)/4294967296}}function deterministicShuffle(order,seed){const shuffled=[...order],random=mulberry32(seed);for(let i=shuffled.length-1;i>0;i--){const j=Math.floor(random()*(i+1));[shuffled[i],shuffled[j]]=[shuffled[j],shuffled[i]]}return shuffled}function sourceDistance(order,sourceIndex){let distance=0;for(const[index,laneId]of order.entries())distance+=Math.abs(index-(sourceIndex.get(laneId)??index));return distance}function laneArrangementCost(order,weights){const position=new Map;for(const[index,laneId]of order.entries())position.set(laneId,index);let cost=0;for(const{a:a,b:b,weight:weight}of weights){const ai=position.get(a),bi=position.get(b);null!=ai&&null!=bi&&(cost+=weight*Math.abs(ai-bi))}return cost}function buildWeightedLaneEdges(g){const sourceOrder=buildTopLaneOrder(g);if(sourceOrder.length<2)return[];const sourceIndex=new Map(sourceOrder.map((laneId,index)=>[laneId,index])),topLaneOf=createTopLaneResolver(g),weights=new Map;for(const edge of g.layout.edges??[]){if(edge.isLayoutOnly)continue;const src="string"==typeof edge.start?edge.start:void 0,dst="string"==typeof edge.end?edge.end:void 0;if(!(src&&dst&&g.nodeById.has(src)&&g.nodeById.has(dst)))continue;const laneA=topLaneOf(src),laneB=topLaneOf(dst);if(!laneA||!laneB||laneA===laneB)continue;const ia=sourceIndex.get(laneA),ib=sourceIndex.get(laneB);if(null==ia||null==ib)continue;const[a,b]=ia<=ib?[laneA,laneB]:[laneB,laneA],key=`${a}\0${b}`,existing=weights.get(key);existing?existing.weight++:weights.set(key,{a:a,b:b,weight:1})}return[...weights.values()]}function greedySwitch(startOrder,weights,sourceIndex){const order=[...startOrder];let cost=laneArrangementCost(order,weights),changed=!0,sweeps=0;const maxSweeps=Math.max(1,order.length);for(;changed&&sweeps<maxSweeps;){changed=!1,sweeps++;for(let i=0;i+1<order.length;i++){[order[i],order[i+1]]=[order[i+1],order[i]];const nextCost=laneArrangementCost(order,weights);nextCost<cost?(cost=nextCost,changed=!0):[order[i],order[i+1]]=[order[i+1],order[i]]}}return{order:order,cost:cost,sourceDistance:sourceDistance(order,sourceIndex)}}function isBetterCandidate(candidate,best){return candidate.cost!==best.cost?candidate.cost<best.cost:candidate.sourceDistance<best.sourceDistance}function seedForRestart(sourceOrder,weights,restartIndex){const weightSignature=[...weights].sort((a,b)=>a.a===b.a?a.b.localeCompare(b.b):a.a.localeCompare(b.a)).map(({a:a,b:b,weight:weight})=>`${a}:${b}:${weight}`).join("|");return hashString(`${sourceOrder.join("|")}#${weightSignature}#${restartIndex}`)}function optimizeTopLaneOrder(g,opts={}){const sourceOrder=buildTopLaneOrder(g);if(sourceOrder.length<2)return sourceOrder;const weights=buildWeightedLaneEdges(g);if(0===weights.length)return sourceOrder;const sourceIndex=new Map(sourceOrder.map((laneId,index)=>[laneId,index]));let best=greedySwitch(sourceOrder,weights,sourceIndex);const restarts=Math.max(0,opts.restarts??8);for(let i=0;i<restarts;i++){const candidate=greedySwitch(deterministicShuffle(sourceOrder,seedForRestart(sourceOrder,weights,i)),weights,sourceIndex);isBetterCandidate(candidate,best)&&(best=candidate)}return best.order}function sugiyamaLayout(g,opts){const ignoreCrossLaneEdges=(null==opts?void 0:opts.ignoreCrossLaneEdges)??!0,optimizeRanksByCrossings2=(null==opts?void 0:opts.optimizeRanksByCrossings)??!0,g0=normalizeGraph(g),laneOrder=(null==opts?void 0:opts.automaticLaneOrdering)?optimizeTopLaneOrder(g0,{restarts:8}):void 0,cycleRes=removeCycles_DFS(g0),gAcyclic=cycleRes.acyclic,layering=ignoreCrossLaneEdges?assignLayers_LaneAwareCompact(gAcyclic,{compactSingleInput:(null==opts?void 0:opts.compactSingleInput)??LAYERING_DEFAULT_COMPACT_SINGLE_INPUT,ignoreCrossLaneEdges:!0,direction:null==opts?void 0:opts.direction}):assignLayers_Gravity(gAcyclic,{compactSingleInput:(null==opts?void 0:opts.compactSingleInput)??LAYERING_DEFAULT_COMPACT_SINGLE_INPUT,ignoreCrossLaneEdges:!1,optimizeRanksByCrossings:optimizeRanksByCrossings2}),{layering:properLayering,graphWithDummies:graphWithDummies}=makeProperLayering(layering,gAcyclic),ordered=orderLayers(properLayering,graphWithDummies,{laneOrder:laneOrder}),coordinates=assignCoordinates(ordered,graphWithDummies,{layerGap:null==opts?void 0:opts.layerGap,nodeGap:null==opts?void 0:opts.nodeGap,direction:null==opts?void 0:opts.direction,laneOrder:laneOrder});return{acyclic:gAcyclic,reversed:cycleRes.reversed,layering:properLayering,ordered:ordered,coordinates:coordinates}}__name(hashString,"hashString"),__name(mulberry32,"mulberry32"),__name(deterministicShuffle,"deterministicShuffle"),__name(sourceDistance,"sourceDistance"),__name(laneArrangementCost,"laneArrangementCost"),__name(buildWeightedLaneEdges,"buildWeightedLaneEdges"),__name(greedySwitch,"greedySwitch"),__name(isBetterCandidate,"isBetterCandidate"),__name(seedForRestart,"seedForRestart"),__name(optimizeTopLaneOrder,"optimizeTopLaneOrder"),__name(sugiyamaLayout,"sugiyamaLayout");var EPS7=1e-6;function chooseOrthogonalSide(node,target,fallback){const cx=node.x??0,cy=node.y??0,dx=target.x-cx,dy=target.y-cy,absDx=Math.abs(dx),absDy=Math.abs(dy);if(absDx<EPS7&&absDy<EPS7)return fallback;return absDy>EPS7&&3*absDy>=absDx?dy>0?"bottom":"top":absDx>EPS7?dx>0?"right":"left":fallback}function sharedLineEndpointCoord(line,nextLine){return Math.abs(line.to-nextLine.from)<EPS7||Math.abs(line.to-nextLine.to)<EPS7?line.to:line.from}function pointOnLine(line,along){return"vertical"===line.orient?{x:line.coord,y:along}:{x:along,y:line.coord}}function routeEdgesOrthogonal(data,direction){var _a,_b,_c,_d;const nodes=data.nodes??[],originalEdges=data.edges??[],edges=[];for(const oe of originalEdges)oe.isLayoutOnly||edges.push({...oe,__originalEdge:oe});const nodeById=new Map,laneByNodeId=new Map,pipes=[],isLR="LR"===direction;for(const n of nodes)nodeById.set(n.id,n);const topLevelGroups=nodes.filter(n=>n.isGroup&&!n.parentId);for(const group of topLevelGroups){const lane={id:group.id},assignLane=__name(n=>{laneByNodeId.set(n.id,lane),nodes.filter(child=>child.parentId===n.id).forEach(assignLane)},"assignLane");assignLane(group)}const obstacles=nodes.filter(n=>!n.isGroup&&!n.isEdgeLabel).map(n=>{const w=n.width??10,h=n.height??10,x=n.x??0,y=n.y??0;return{nodeId:n.id,minX:x-w/2-8,maxX:x+w/2+8,minY:y-h/2-8,maxY:y+h/2+8,visualXHalfExtent:isLR?h/2+8:w/2+8}}),getOrAddPipe=__name((orientation,coord,spanMin,spanMax)=>{let pipe=pipes.find(p=>p.orientation===orientation&&Math.abs(p.coord-coord)<1);return pipe||(pipe={id:`pipe-${orientation}-${coord.toFixed(0)}`,orientation:orientation,coord:coord,spanMin:spanMin,spanMax:spanMax,tracks:[]},pipes.push(pipe)),pipe.spanMin=Math.min(pipe.spanMin,spanMin),pipe.spanMax=Math.max(pipe.spanMax,spanMax),pipe},"getOrAddPipe"),portForSide=__name((node,side)=>{const w=node.width??10,h=node.height??10,cx=node.x??0,cy=node.y??0;switch(side){case"top":return{x:cx,y:cy-h/2};case"bottom":return{x:cx,y:cy+h/2};case"left":return{x:cx-w/2,y:cy};case"right":return{x:cx+w/2,y:cy}}},"portForSide"),getOrthogonalPort=__name((node,target,isSource)=>portForSide(node,chooseOrthogonalSide(node,target,isSource?"bottom":"top")),"getOrthogonalPort"),allRoutedSegments=[],edgeSegmentIndices=[],straightIntraLaneEdges=new Set,crossingPenalty=__name((edgeIdx,from,to)=>{if(0===allRoutedSegments.length)return 0;const isHorizontal=Math.abs(from.y-to.y)<EPS7,isVertical=Math.abs(from.x-to.x)<EPS7;if(!isHorizontal&&!isVertical)return 0;let penalties=0;if(isHorizontal){const y=from.y,minX=Math.min(from.x,to.x)-EPS7,maxX=Math.max(from.x,to.x)+EPS7;if(maxX<=minX)return 0;for(const seg of allRoutedSegments)seg.edgeIndex!==edgeIdx&&"vertical"===seg.orientation&&(seg.pipe.coord<minX||seg.pipe.coord>maxX||seg.from-EPS7<=y&&seg.to+EPS7>=y&&(penalties+=1e3))}else if(isVertical){const x=from.x,minY=Math.min(from.y,to.y)-EPS7,maxY=Math.max(from.y,to.y)+EPS7;if(maxY<=minY)return 0;for(const seg of allRoutedSegments)seg.edgeIndex!==edgeIdx&&"horizontal"===seg.orientation&&(seg.pipe.coord<minY||seg.pipe.coord>maxY||seg.from-EPS7<=x&&seg.to+EPS7>=x&&(penalties+=1e3))}return penalties},"crossingPenalty"),routingOrder=edges.map((edge,idx)=>{if(!edge.start||!edge.end)return{idx:idx,crossLane:0,dx:0,dy:0};const srcNode=nodeById.get(edge.start),dstNode=nodeById.get(edge.end),srcLane=laneByNodeId.get(edge.start),dstLane=laneByNodeId.get(edge.end);return{idx:idx,crossLane:srcLane&&dstLane&&srcLane.id!==dstLane.id?1:0,dx:srcNode&&dstNode?Math.abs((dstNode.x??0)-(srcNode.x??0)):0,dy:srcNode&&dstNode?Math.abs((dstNode.y??0)-(srcNode.y??0)):0}}).sort((a,b)=>{if(a.crossLane!==b.crossLane)return b.crossLane-a.crossLane;const aDist=a.dx+a.dy,bDist=b.dx+b.dy;return Math.abs(aDist-bDist)>1?aDist-bDist:a.idx-b.idx}).map(entry=>entry.idx),isSegmentBlocked=__name((p1,p2,excludeStart,excludeEnd)=>{const segMinX=Math.min(p1.x,p2.x),segMaxX=Math.max(p1.x,p2.x),segMinY=Math.min(p1.y,p2.y),segMaxY=Math.max(p1.y,p2.y);return!!obstacles.find(obs=>(!excludeStart||obs.nodeId!==excludeStart)&&((!excludeEnd||obs.nodeId!==excludeEnd)&&(Math.abs(p1.x-p2.x)>EPS7?obs.minY<p1.y&&obs.maxY>p1.y&&obs.maxX>segMinX&&obs.minX<segMaxX:obs.minX<p1.x&&obs.maxX>p1.x&&obs.maxY>segMinY&&obs.minY<segMaxY)))},"isSegmentBlocked"),portGroups=new Map,incidentEdgeTotals=new Map;for(const edge of edges)edge.start&&edge.end&&edge.start!==edge.end&&(incidentEdgeTotals.set(edge.start,(incidentEdgeTotals.get(edge.start)??0)+1),incidentEdgeTotals.set(edge.end,(incidentEdgeTotals.get(edge.end)??0)+1));const determineSide=__name((node,target)=>chooseOrthogonalSide(node,target,"bottom"),"determineSide"),sideInfoByIdx=new Map;for(const[i,e]of edges.entries()){if(!e.start||!e.end||e.start===e.end)continue;if(e.points&&e.points.length>0)continue;const src=nodeById.get(e.start),dst=nodeById.get(e.end);if(!src||!dst)continue;const dx=(dst.x??0)-(src.x??0),dy=(dst.y??0)-(src.y??0);sideInfoByIdx.set(i,{edgeIdx:i,srcId:e.start,dstId:e.end,srcSide:determineSide(src,{x:dst.x??0,y:dst.y??0}),dstSide:determineSide(dst,{x:src.x??0,y:src.y??0}),absDx:Math.abs(dx),absDy:Math.abs(dy),dxSign:Math.sign(dx),dySign:Math.sign(dy)})}const preferenceStrength=__name(info=>"top"===info.srcSide||"bottom"===info.srcSide?0===info.absDx?1/0:info.absDy/info.absDx:0===info.absDy?1/0:info.absDx/info.absDy,"preferenceStrength"),secondarySide=__name(info=>"top"===info.srcSide||"bottom"===info.srcSide?info.dxSign>=0?"right":"left":info.dySign>=0?"bottom":"top","secondarySide"),sourceSideGroups=new Map;for(const info of sideInfoByIdx.values()){const key=`${info.srcId}:${info.srcSide}`;sourceSideGroups.has(key)||sourceSideGroups.set(key,[]),sourceSideGroups.get(key).push(info)}const sideLoad=new Map,loadKey=__name((nodeId,side)=>`${nodeId}:${side}`,"loadKey");for(const info of sideInfoByIdx.values())sideLoad.set(loadKey(info.srcId,info.srcSide),(sideLoad.get(loadKey(info.srcId,info.srcSide))??0)+1),sideLoad.set(loadKey(info.dstId,info.dstSide),(sideLoad.get(loadKey(info.dstId,info.dstSide))??0)+1);for(const group of sourceSideGroups.values())if(!(group.length<2)){group.sort((a,b)=>{const sa=preferenceStrength(a),sb=preferenceStrength(b);return Math.abs(sa-sb)>1e-9?sb-sa:a.edgeIdx-b.edgeIdx});for(let g=1;g<group.length;g++){const info=group[g],secondary=secondarySide(info),primaryLoad=sideLoad.get(loadKey(info.srcId,info.srcSide))??0,secondaryLoad=sideLoad.get(loadKey(info.srcId,secondary))??0;secondaryLoad>=primaryLoad||(sideLoad.set(loadKey(info.srcId,info.srcSide),primaryLoad-1),sideLoad.set(loadKey(info.srcId,secondary),secondaryLoad+1),info.srcSide=secondary)}}const isDiamondNode=__name(node=>{const shape=null==node?void 0:node.shape;return"question"===shape||"diamond"===shape},"isDiamondNode"),inSidesByNode=new Map;for(const info of sideInfoByIdx.values())inSidesByNode.has(info.dstId)||inSidesByNode.set(info.dstId,new Set),inSidesByNode.get(info.dstId).add(info.dstSide);for(const info of sideInfoByIdx.values()){if(!isDiamondNode(nodeById.get(info.srcId)))continue;const inSides=inSidesByNode.get(info.srcId);if(!(null==inSides?void 0:inSides.has(info.srcSide)))continue;const secondary=secondarySide(info);if(inSides.has(secondary)||(sideLoad.get(loadKey(info.srcId,secondary))??0)>0)continue;const primaryLoad=sideLoad.get(loadKey(info.srcId,info.srcSide))??0;sideLoad.set(loadKey(info.srcId,info.srcSide),Math.max(0,primaryLoad-1)),sideLoad.set(loadKey(info.srcId,secondary),1),info.srcSide=secondary}for(const info of sideInfoByIdx.values()){const{edgeIdx:i,srcId:srcId,dstId:dstId,srcSide:srcSide,dstSide:dstSide}=info,src=nodeById.get(srcId),dst=nodeById.get(dstId),srcKey=`${srcId}:${srcSide}:src`,dstCoord="top"===srcSide||"bottom"===srcSide?dst.x??0:dst.y??0;portGroups.has(srcKey)||portGroups.set(srcKey,[]),portGroups.get(srcKey).push({edgeIdx:i,oppositeCoord:dstCoord});const dstKey=`${dstId}:${dstSide}:dst`,srcCoord="top"===dstSide||"bottom"===dstSide?src.x??0:src.y??0;portGroups.has(dstKey)||portGroups.set(dstKey,[]),portGroups.get(dstKey).push({edgeIdx:i,oppositeCoord:srcCoord})}const portOffsets=new Map;for(const[key,group]of portGroups){if(group.length<2)continue;group.sort((a,b)=>a.oppositeCoord-b.oppositeCoord);const parts=key.split(":"),nodeId=parts.slice(0,-2).join(":"),side=parts[parts.length-2],role=parts[parts.length-1],node=nodeById.get(nodeId);if(!node)continue;const sideLength="left"===side||"right"===side?node.height??10:node.width??10,shape=node.shape,effectiveLength="question"===shape||"diamond"===shape?.3*sideLength:sideLength,MAX_PORT_SPACING=20,spacing=Math.min(MAX_PORT_SPACING,Math.max(8,effectiveLength/(group.length+1))),startOffset=-(spacing*(group.length-1))/2;for(const[j,element]of group.entries()){const offset=startOffset+j*spacing,offsetKey=`${element.edgeIdx}:${role}`;portOffsets.set(offsetKey,offset)}}const edgeHasLabelNode=__name(edgeIdx=>{var _a2;return Boolean(null==(_a2=edges[edgeIdx])?void 0:_a2.labelNodeId)},"edgeHasLabelNode"),faceHasLabelNode=__name((nodeId,side)=>!!nodeId&&((portGroups.get(`${nodeId}:${side}:src`)??[]).some(({edgeIdx:edgeIdx})=>edgeHasLabelNode(edgeIdx))||(portGroups.get(`${nodeId}:${side}:dst`)??[]).some(({edgeIdx:edgeIdx})=>edgeHasLabelNode(edgeIdx))),"faceHasLabelNode"),applyPortOffset=__name((basePort,side,offset)=>"top"===side||"bottom"===side?{x:basePort.x+offset,y:basePort.y}:{x:basePort.x,y:basePort.y+offset},"applyPortOffset"),portsForEdge=__name((edgeIndex,src,dst)=>{const sideInfo=sideInfoByIdx.get(edgeIndex),srcTarget={x:dst.x??0,y:dst.y??0},dstTarget={x:src.x??0,y:src.y??0},srcSide=(null==sideInfo?void 0:sideInfo.srcSide)??determineSide(src,srcTarget),dstSide=(null==sideInfo?void 0:sideInfo.dstSide)??determineSide(dst,dstTarget);let pSrcPort=sideInfo?portForSide(src,sideInfo.srcSide):getOrthogonalPort(src,srcTarget,!0),pDstPort=sideInfo?portForSide(dst,sideInfo.dstSide):getOrthogonalPort(dst,dstTarget,!1);const srcOffset=portOffsets.get(`${edgeIndex}:src`),dstOffset=portOffsets.get(`${edgeIndex}:dst`);return void 0!==srcOffset&&(pSrcPort=applyPortOffset(pSrcPort,srcSide,srcOffset)),void 0!==dstOffset&&(pDstPort=applyPortOffset(pDstPort,dstSide,dstOffset)),{pSrcPort:pSrcPort,pDstPort:pDstPort,srcSide:srcSide,dstSide:dstSide}},"portsForEdge");for(const i of routingOrder){const e=edges[i];if(edgeSegmentIndices[i]=[],!e.start||!e.end)continue;if(e.points&&e.points.length>0)continue;if(e.start===e.end)continue;const src=nodeById.get(e.start),dst=nodeById.get(e.end);if(!src||!dst)continue;const{pSrcPort:pSrcPort,pDstPort:pDstPort,srcSide:srcPortSide,dstSide:dstPortSide}=portsForEdge(i,src,dst),pSrcAnchor={...pSrcPort},pDstAnchor={...pDstPort},srcPortIsVertical="top"===srcPortSide||"bottom"===srcPortSide,dstPortIsVertical="top"===dstPortSide||"bottom"===dstPortSide;if(srcPortIsVertical){const isBottom=pSrcPort.y>(src.y??0);pSrcAnchor.y=isBottom?pSrcPort.y+20:pSrcPort.y-20}else{const isRight=pSrcPort.x>(src.x??0);pSrcAnchor.x=isRight?pSrcPort.x+20:pSrcPort.x-20}if(dstPortIsVertical){const isBottom=pDstPort.y>(dst.y??0);pDstAnchor.y=isBottom?pDstPort.y+20:pDstPort.y-20}else{const isRight=pDstPort.x>(dst.x??0);pDstAnchor.x=isRight?pDstPort.x+20:pDstPort.x-20}const isPointInObstacle=__name((pt,excludeNodeIds)=>{for(const obs of obstacles)if(!excludeNodeIds.includes(obs.nodeId)&&pt.x>obs.minX&&pt.x<obs.maxX&&pt.y>obs.minY&&pt.y<obs.maxY)return{inside:!0,obstacle:obs};return{inside:!1}},"isPointInObstacle"),obstacleDetour=__name((port,node,opposite,obs,portIsVertical)=>{if(portIsVertical){const leavesPositiveSide2=port.y>(node.y??0);return{x:(opposite.x??0)>=port.x?obs.maxX+15:obs.minX-15,y:leavesPositiveSide2?obs.maxY+15:obs.minY-15,leavesPositiveSide:leavesPositiveSide2}}const leavesPositiveSide=port.x>(node.x??0),goDown=(opposite.y??0)>=port.y;return{x:leavesPositiveSide?obs.maxX+15:obs.minX-15,y:goDown?obs.maxY+15:obs.minY-15,leavesPositiveSide:leavesPositiveSide}},"obstacleDetour");let srcHandleWaypoints=[];const endpointIds=[e.start,e.end],srcCheck=isPointInObstacle(pSrcAnchor,endpointIds);if(srcCheck.inside&&srcCheck.obstacle){const obs=srcCheck.obstacle;if(srcPortIsVertical){const detour=obstacleDetour(pSrcPort,src,dst,obs,!0);pSrcAnchor.x=detour.x,pSrcAnchor.y=detour.y;const gapY=detour.leavesPositiveSide?Math.min(obs.minY-2,pSrcPort.y+20):Math.max(obs.maxY+2,pSrcPort.y-20);srcHandleWaypoints=[{x:pSrcPort.x,y:gapY},{x:detour.x,y:gapY},{x:detour.x,y:detour.y}]}else{const detour=obstacleDetour(pSrcPort,src,dst,obs,!1),gapX=detour.leavesPositiveSide?Math.min(obs.minX-2,pSrcPort.x+20):Math.max(obs.maxX+2,pSrcPort.x-20);pSrcAnchor.x=detour.x,pSrcAnchor.y=detour.y,srcHandleWaypoints=[{x:gapX,y:pSrcPort.y},{x:gapX,y:detour.y},{x:detour.x,y:detour.y}]}}let dstHandleWaypoints=[];const dstCheck=isPointInObstacle(pDstAnchor,endpointIds);if(dstCheck.inside&&dstCheck.obstacle){const obs=dstCheck.obstacle;if(dstPortIsVertical){const detour=obstacleDetour(pDstPort,dst,src,obs,!0);pDstAnchor.x=detour.x,pDstAnchor.y=detour.y,dstHandleWaypoints=[{x:detour.x,y:detour.y},{x:pDstPort.x,y:detour.y}]}else{const detour=obstacleDetour(pDstPort,dst,src,obs,!1);pDstAnchor.x=detour.x,pDstAnchor.y=detour.y,dstHandleWaypoints=[{x:detour.x,y:detour.y},{x:detour.x,y:pDstPort.y}]}}if(0===srcHandleWaypoints.length&&0===dstHandleWaypoints.length){const hpMargin=15,anchorsSameX=Math.abs(pSrcAnchor.x-pDstAnchor.x)<hpMargin,anchorsSameY=Math.abs(pSrcAnchor.y-pDstAnchor.y)<hpMargin,hasPortOffset=void 0!==portOffsets.get(`${i}:src`)||void 0!==portOffsets.get(`${i}:dst`),srcFaceTotal=((null==(_a=portGroups.get(`${e.start??""}:${srcPortSide}:src`))?void 0:_a.length)??0)+((null==(_b=portGroups.get(`${e.start??""}:${srcPortSide}:dst`))?void 0:_b.length)??0),dstFaceTotal=((null==(_c=portGroups.get(`${e.end??""}:${dstPortSide}:src`))?void 0:_c.length)??0)+((null==(_d=portGroups.get(`${e.end??""}:${dstPortSide}:dst`))?void 0:_d.length)??0),faceContested=srcFaceTotal>1||dstFaceTotal>1,srcIncidentTotal=incidentEdgeTotals.get(e.start??"")??0,dstIncidentTotal=incidentEdgeTotals.get(e.end??"")??0,contestedFaceHasLabel=srcFaceTotal>1&&faceHasLabelNode(e.start,srcPortSide)||dstFaceTotal>1&&faceHasLabelNode(e.end,dstPortSide);if((anchorsSameX||anchorsSameY)&&!hasPortOffset&&(!faceContested||faceContested&&!contestedFaceHasLabel&&(srcFaceTotal<=1||srcIncidentTotal<=2)&&(dstFaceTotal<=1||dstIncidentTotal<=2))){if(!isSegmentBlocked(pSrcPort,pDstPort,e.start,e.end)){e.points=[{...pSrcPort},{...pSrcAnchor},{...pDstAnchor},{...pDstPort}],straightIntraLaneEdges.add(i);const fastPathOrientation=anchorsSameY?"horizontal":"vertical",fastPathCoord=anchorsSameY?pSrcPort.y:pSrcPort.x,fastPathFrom=anchorsSameY?Math.min(pSrcPort.x,pDstPort.x):Math.min(pSrcPort.y,pDstPort.y),fastPathTo=anchorsSameY?Math.max(pSrcPort.x,pDstPort.x):Math.max(pSrcPort.y,pDstPort.y),fastPathPipe={id:`fast-path-${fastPathOrientation}-${fastPathCoord.toFixed(0)}-${i}`,orientation:fastPathOrientation,coord:fastPathCoord,spanMin:fastPathFrom,spanMax:fastPathTo,tracks:[]};allRoutedSegments.push({edgeIndex:i,segmentIndex:0,orientation:fastPathOrientation,pipe:fastPathPipe,trackIndex:0,from:fastPathFrom,to:fastPathTo});continue}}}const srcPipe=getOrAddPipe("vertical",pSrcAnchor.x,pSrcAnchor.y,pSrcAnchor.y);pSrcAnchor.x=srcPipe.coord;const dstPipe=getOrAddPipe("vertical",pDstAnchor.x,pDstAnchor.y,pDstAnchor.y);pDstAnchor.x=dstPipe.coord;let bbMinX=Math.min(pSrcAnchor.x,pDstAnchor.x)-50,bbMaxX=Math.max(pSrcAnchor.x,pDstAnchor.x)+50,bbMinY=Math.min(pSrcAnchor.y,pDstAnchor.y)-50,bbMaxY=Math.max(pSrcAnchor.y,pDstAnchor.y)+50;for(const obs of obstacles){const pathMinX=Math.min(pSrcAnchor.x,pDstAnchor.x),pathMaxX=Math.max(pSrcAnchor.x,pDstAnchor.x),pathMinY=Math.min(pSrcAnchor.y,pDstAnchor.y),pathMaxY=Math.max(pSrcAnchor.y,pDstAnchor.y);obs.minX<pathMaxX&&obs.maxX>pathMinX&&obs.minY<pathMaxY&&obs.maxY>pathMinY&&(bbMinX=Math.min(bbMinX,obs.minX-25),bbMaxX=Math.max(bbMaxX,obs.maxX+25),bbMinY=Math.min(bbMinY,obs.minY-25),bbMaxY=Math.max(bbMaxY,obs.maxY+25))}for(const obs of obstacles){if(obs.maxX<bbMinX||obs.minX>bbMaxX||obs.maxY<bbMinY||obs.minY>bbMaxY)continue;const hMargin=15;getOrAddPipe("horizontal",obs.minY-hMargin,bbMinX,bbMaxX),getOrAddPipe("horizontal",obs.maxY+hMargin,bbMinX,bbMaxX);const vMargin=15;getOrAddPipe("vertical",obs.minX-vMargin,bbMinY,bbMaxY),getOrAddPipe("vertical",obs.maxX+vMargin,bbMinY,bbMaxY)}getOrAddPipe("horizontal",pSrcAnchor.y,bbMinX,bbMaxX),getOrAddPipe("horizontal",pDstAnchor.y,bbMinX,bbMaxX);const hPipes=pipes.filter(p=>"horizontal"===p.orientation&&p.coord>=bbMinY&&p.coord<=bbMaxY),vPipes=pipes.filter(p=>"vertical"===p.orientation&&p.coord>=bbMinX&&p.coord<=bbMaxX),getKey=__name((x,y)=>`${x.toFixed(1)},${y.toFixed(1)}`,"getKey"),startKey=getKey(pSrcAnchor.x,pSrcAnchor.y),endKey=getKey(pDstAnchor.x,pDstAnchor.y),gScore=new Map,cameFrom=new Map,arrivalDir=new Map,openSet=new Set,openList=[];gScore.set(startKey,0),arrivalDir.set(startKey,"n"),openList.push({key:startKey,f:Math.hypot(pDstAnchor.x-pSrcAnchor.x,pDstAnchor.y-pSrcAnchor.y),pt:pSrcAnchor}),openSet.add(startKey);let foundPath=[];const checkSegmentBlocked=__name((p1,p2)=>isSegmentBlocked(p1,p2,e.start,e.end),"checkSegmentBlocked"),cornerHV={x:pDstAnchor.x,y:pSrcAnchor.y},seg1HV_blocked=checkSegmentBlocked(pSrcAnchor,cornerHV),seg2HV_blocked=checkSegmentBlocked(cornerHV,pDstAnchor),pathHV_blocked=seg1HV_blocked||seg2HV_blocked,cornerVH={x:pSrcAnchor.x,y:pDstAnchor.y},seg1VH_blocked=checkSegmentBlocked(pSrcAnchor,cornerVH),seg2VH_blocked=checkSegmentBlocked(cornerVH,pDstAnchor);if(pathHV_blocked?seg1VH_blocked||seg2VH_blocked||(foundPath=Math.abs(pSrcAnchor.x-pDstAnchor.x)<EPS7?[pSrcAnchor,pDstAnchor]:[pSrcAnchor,cornerVH,pDstAnchor]):foundPath=Math.abs(pSrcAnchor.y-pDstAnchor.y)<EPS7||Math.abs(pSrcAnchor.x-pDstAnchor.x)<EPS7?[pSrcAnchor,pDstAnchor]:[pSrcAnchor,cornerHV,pDstAnchor],0===foundPath.length)for(;openList.length>0;){openList.sort((a,b)=>a.f-b.f);const current=openList.shift();if(openSet.delete(current.key),current.key===endKey){let currKey=endKey,currPt=pDstAnchor;for(foundPath=[currPt];cameFrom.has(currKey);){const prev=cameFrom.get(currKey);foundPath.unshift(prev),currPt=prev,currKey=getKey(prev.x,prev.y)}break}const cx=current.pt.x,cy=current.pt.y,sortedVPipes=vPipes.sort((a,b)=>a.coord-b.coord),vIdx=sortedVPipes.findIndex(p=>Math.abs(p.coord-cx)<1),hPipesSorted=hPipes.sort((a,b)=>a.coord-b.coord),hIdx=hPipesSorted.findIndex(p=>Math.abs(p.coord-cy)<1),neighbors=[];vIdx>0&&neighbors.push({x:sortedVPipes[vIdx-1].coord,y:cy}),vIdx>=0&&vIdx<sortedVPipes.length-1&&neighbors.push({x:sortedVPipes[vIdx+1].coord,y:cy}),hIdx>0&&neighbors.push({x:cx,y:hPipesSorted[hIdx-1].coord}),hIdx>=0&&hIdx<hPipesSorted.length-1&&neighbors.push({x:cx,y:hPipesSorted[hIdx+1].coord});for(const neighbor of neighbors){const minX=Math.min(cx,neighbor.x),maxX=Math.max(cx,neighbor.x),minY=Math.min(cy,neighbor.y),maxY=Math.max(cy,neighbor.y);if(obstacles.some(obs=>obs.nodeId!==e.start&&obs.nodeId!==e.end&&(minX!==maxX?obs.minY<cy&&obs.maxY>cy&&obs.maxX>minX&&obs.minX<maxX:obs.minX<cx&&obs.maxX>cx&&obs.maxY>minY&&obs.minY<maxY)))continue;const nKey=getKey(neighbor.x,neighbor.y),dist=Math.abs(neighbor.x-cx)+Math.abs(neighbor.y-cy),penalty=crossingPenalty(i,current.pt,neighbor);let dirPenalty=0;const destDx=pDstAnchor.x-pSrcAnchor.x,destDy=pDstAnchor.y-pSrcAnchor.y,moveDx=neighbor.x-cx,moveDy=neighbor.y-cy;(destDy>10&&moveDy<-5||destDy<-10&&moveDy>5)&&(dirPenalty=100*Math.abs(moveDy)),(destDx>10&&moveDx<-5||destDx<-10&&moveDx>5)&&(dirPenalty+=50*Math.abs(moveDx));let bendPenalty=0;const currentDir=arrivalDir.get(current.key)??"n",moveDir=Math.abs(moveDx)>EPS7?"h":"v";"n"!==currentDir&&currentDir!==moveDir&&(bendPenalty=50);const stepCost=dist+penalty+dirPenalty+bendPenalty,tentativeG=(gScore.get(current.key)??1/0)+stepCost,h=Math.abs(pDstAnchor.x-neighbor.x)+Math.abs(pDstAnchor.y-neighbor.y);if(tentativeG<(gScore.get(nKey)??1/0))if(cameFrom.set(nKey,current.pt),gScore.set(nKey,tentativeG),arrivalDir.set(nKey,moveDir),openSet.has(nKey)){const idx=openList.findIndex(x=>x.key===nKey);-1!==idx&&(openList[idx].f=tentativeG+h)}else openList.push({key:nKey,f:tentativeG+h,pt:neighbor}),openSet.add(nKey)}}if(0===foundPath.length&&(foundPath=[pSrcAnchor,{x:pSrcAnchor.x,y:pDstAnchor.y},pDstAnchor]),foundPath.length>4){const start=foundPath[0],end=foundPath[foundPath.length-1];let minX=Math.min(start.x,end.x),maxX=Math.max(start.x,end.x),minY=Math.min(start.y,end.y),maxY=Math.max(start.y,end.y);for(const pt of foundPath)minX=Math.min(minX,pt.x),maxX=Math.max(maxX,pt.x),minY=Math.min(minY,pt.y),maxY=Math.max(maxY,pt.y);const wentRight=maxX>Math.max(start.x,end.x),wentLeft=minX<Math.min(start.x,end.x);if(isLR){const margin=15;if(wentRight){const pathX=Math.max(start.x,end.x),pathMinY=Math.min(start.y,end.y),pathMaxY=Math.max(start.y,end.y),detourObstacles=obstacles.filter(obs=>obs.minX<pathX&&obs.maxX>pathX&&obs.minY<pathMaxY&&obs.maxY>pathMinY);if(detourObstacles.length>0){let visualMaxX=Math.max(start.x,end.x);for(const obs of detourObstacles){const obsCenterX=(obs.minX+obs.maxX)/2;if(void 0===obs.visualXHalfExtent||isNaN(obs.visualXHalfExtent))continue;const visualRight=obsCenterX+obs.visualXHalfExtent+margin;visualMaxX=Math.max(visualMaxX,visualRight)}isNaN(visualMaxX)||(maxX=visualMaxX)}}if(wentLeft){const detourObstacles=obstacles.filter(obs=>obs.minX<Math.min(start.x,end.x)+margin&&obs.minY<Math.max(start.y,end.y)&&obs.maxY>Math.min(start.y,end.y));if(detourObstacles.length>0){let visualMinX=Math.min(start.x,end.x);for(const obs of detourObstacles){const visualLeft=(obs.minX+obs.maxX)/2-obs.visualXHalfExtent-margin;visualMinX=Math.min(visualMinX,visualLeft)}minX=visualMinX}}}const findBestReturnY=__name(detourX=>{const goingDown=end.y>start.y,relevantObs=obstacles.filter(obs=>{const obsInXRange=Math.min(start.x,end.x)<obs.maxX&&Math.max(start.x,end.x)>obs.minX,obsInYRange=Math.min(start.y,end.y)<obs.maxY&&Math.max(start.y,end.y)>obs.minY;return obsInXRange&&obsInYRange});let filteredObs=relevantObs;if(isLR&&relevantObs.length>0){const obsAtDetourX=relevantObs.filter(obs=>obs.minX<detourX&&obs.maxX>detourX);obsAtDetourX.length>0&&(filteredObs=obsAtDetourX)}if(0===filteredObs.length)return end.y;if(goingDown){const bestY=Math.max(...filteredObs.map(obs=>obs.maxY))+15;if(bestY<end.y-EPS7)return bestY}else{const bestY=Math.min(...filteredObs.map(obs=>obs.minY))-15;if(bestY>end.y+EPS7)return bestY}return end.y},"findBestReturnY"),trySimplifyWithDetourX=__name(detourX=>{const bestY=findBestReturnY(detourX),corner1={x:detourX,y:start.y},corner2={x:detourX,y:bestY},corner3={x:end.x,y:bestY},seg1Blocked=checkSegmentBlocked(start,corner1),seg2Blocked=checkSegmentBlocked(corner1,corner2),seg3Blocked=checkSegmentBlocked(corner2,corner3),seg4Blocked=bestY!==end.y&&checkSegmentBlocked(corner3,end);return seg1Blocked||seg2Blocked||seg3Blocked||seg4Blocked?null:Math.abs(bestY-end.y)<EPS7?[start,corner1,corner2,end]:[start,corner1,corner2,corner3,end]},"trySimplifyWithDetourX"),simplified2=wentRight&&!wentLeft?trySimplifyWithDetourX(maxX):wentLeft&&!wentRight?trySimplifyWithDetourX(minX):null;simplified2&&(foundPath=simplified2)}const fullPoints=[pSrcPort,...srcHandleWaypoints,...foundPath,...dstHandleWaypoints.reverse(),pDstPort];if(fullPoints.length>=3){const C=fullPoints[fullPoints.length-1],B=fullPoints[fullPoints.length-2],A=fullPoints[fullPoints.length-3],isHoriz=Math.abs(A.y-B.y)<EPS7&&Math.abs(B.y-C.y)<EPS7,isVert=Math.abs(A.x-B.x)<EPS7&&Math.abs(B.x-C.x)<EPS7;if(isHoriz){const signAB=Math.sign(B.x-A.x),signAC=Math.sign(C.x-A.x);0!==signAB&&signAB===signAC&&Math.abs(B.x-A.x)>Math.abs(C.x-A.x)&&fullPoints.splice(-2,1)}else if(isVert){const signAB=Math.sign(B.y-A.y),signAC=Math.sign(C.y-A.y);0!==signAB&&signAB===signAC&&Math.abs(B.y-A.y)>Math.abs(C.y-A.y)&&fullPoints.splice(-2,1)}}const simplified=[fullPoints[0]];for(let k=1;k<fullPoints.length-1;k++){if(1===k){simplified.push(fullPoints[k]);continue}const prev=simplified[simplified.length-1],curr=fullPoints[k],next=fullPoints[k+1];if(Math.abs(prev.y-curr.y)<EPS7&&Math.abs(curr.y-next.y)<EPS7){if(curr.x>prev.x!==next.x>curr.x){simplified.push(curr);continue}continue}if(Math.abs(prev.x-curr.x)<EPS7&&Math.abs(curr.x-next.x)<EPS7){if(curr.y>prev.y!==next.y>curr.y){simplified.push(curr);continue}continue}simplified.push(curr)}simplified.push(fullPoints[fullPoints.length-1]);for(let k=0;k<simplified.length-1;k++){const p1=simplified[k],p2=simplified[k+1],orientation=Math.abs(p1.x-p2.x)<EPS7?"vertical":"horizontal",coord="vertical"===orientation?p1.x:p1.y,from="vertical"===orientation?Math.min(p1.y,p2.y):Math.min(p1.x,p2.x),to="vertical"===orientation?Math.max(p1.y,p2.y):Math.max(p1.x,p2.x),pipe=getOrAddPipe(orientation,coord,from,to),rSeg={edgeIndex:i,segmentIndex:k,orientation:orientation,pipe:pipe,trackIndex:0,from:from,to:to};allRoutedSegments.push(rSeg),edgeSegmentIndices[i].push(allRoutedSegments.length-1),pipe.tracks[0]||(pipe.tracks[0]={index:0,coord:pipe.coord,segments:[]}),pipe.tracks[0].segments.push({edgeIndex:i,segmentIndex:k,from:from,to:to})}}const segmentsOverlap=__name((s1,s2)=>s1.from<s2.to&&s2.from<s1.to,"segmentsOverlap"),trySwapSegmentsAcrossTracks=__name((s1,s2,t1,t2)=>{const canS1GoT2=!t2.segments.some(r=>(r.edgeIndex!==s2.edgeIndex||r.segmentIndex!==s2.segmentIndex)&&segmentsOverlap(r,s1)),canS2GoT1=!t1.segments.some(r=>(r.edgeIndex!==s1.edgeIndex||r.segmentIndex!==s1.segmentIndex)&&segmentsOverlap(r,s2));return!(!canS1GoT2||!canS2GoT1)&&(s1.trackIndex=t2.index,s2.trackIndex=t1.index,t1.segments=[...t1.segments.filter(r=>r.edgeIndex!==s1.edgeIndex||r.segmentIndex!==s1.segmentIndex),{edgeIndex:s2.edgeIndex,segmentIndex:s2.segmentIndex,from:s2.from,to:s2.to}],t2.segments=[...t2.segments.filter(r=>r.edgeIndex!==s2.edgeIndex||r.segmentIndex!==s2.segmentIndex),{edgeIndex:s1.edgeIndex,segmentIndex:s1.segmentIndex,from:s1.from,to:s1.to}],!0)},"trySwapSegmentsAcrossTracks"),createNewTrack=__name(pipe=>{const idx=pipe.tracks.length;return pipe.tracks[idx]={index:idx,coord:pipe.coord,segments:[]},idx},"createNewTrack"),moveSegmentToTrack=__name((seg,trackIdx)=>{const oldTrack=seg.pipe.tracks[seg.trackIndex];oldTrack.segments=oldTrack.segments.filter(r=>r.edgeIndex!==seg.edgeIndex||r.segmentIndex!==seg.segmentIndex),seg.trackIndex=trackIdx;seg.pipe.tracks[trackIdx].segments.push({edgeIndex:seg.edgeIndex,segmentIndex:seg.segmentIndex,from:seg.from,to:seg.to})},"moveSegmentToTrack"),moveSegmentChainToTrack=__name((seg,trackIdx)=>{const indices=edgeSegmentIndices[seg.edgeIndex];for(const idx of indices){const s=allRoutedSegments[idx];s.pipe===seg.pipe&&moveSegmentToTrack(s,trackIdx)}},"moveSegmentChainToTrack"),getAdjacentSegmentsAlongEdge=__name(seg=>{const indices=edgeSegmentIndices[seg.edgeIndex],idxInList=indices.indexOf(allRoutedSegments.indexOf(seg)),adj=[];return idxInList>0&&adj.push(allRoutedSegments[indices[idxInList-1]]),idxInList<indices.length-1&&adj.push(allRoutedSegments[indices[idxInList+1]]),adj},"getAdjacentSegmentsAlongEdge"),haveAnyCrossing=__name((segA,segB)=>{if(segA.orientation===segB.orientation)return!1;const h="horizontal"===segA.orientation?segA:segB,v="horizontal"===segA.orientation?segB:segA;return v.pipe.coord>h.from&&v.pipe.coord<h.to&&h.pipe.coord>v.from&&h.pipe.coord<v.to},"haveAnyCrossing"),findAvailableTrack=__name((pipe,seg)=>{for(const track of pipe.tracks){if(!track.segments.some(r=>(r.edgeIndex!==seg.edgeIndex||r.segmentIndex!==seg.segmentIndex)&&segmentsOverlap(r,seg)))return track.index}return-1},"findAvailableTrack"),segmentsConflict=__name((s1,s2)=>{if(s1.trackIndex===s2.trackIndex)return segmentsOverlap(s1,s2);const adj1=getAdjacentSegmentsAlongEdge(s1),adj2=getAdjacentSegmentsAlongEdge(s2);return adj1.some(a1=>adj2.some(a2=>haveAnyCrossing(a1,a2)))},"segmentsConflict"),resolveTrackConflict=__name((s1,s2,move)=>{if(trySwapSegmentsAcrossTracks(s1,s2,s1.pipe.tracks[s1.trackIndex],s2.pipe.tracks[s2.trackIndex]))return;const avail=findAvailableTrack(s1.pipe,s2);move(s2,-1!==avail?avail:createNewTrack(s1.pipe))},"resolveTrackConflict"),resolveHandleConflicts=__name(handles=>{let crossings=0;for(let i=0;i<handles.length;i++)for(let j=i+1;j<handles.length;j++){const h1=handles[i],h2=handles[j];h1.pipe===h2.pipe&&(segmentsConflict(h1,h2)&&(crossings++,resolveTrackConflict(h1,h2,moveSegmentChainToTrack)))}return crossings},"resolveHandleConflicts"),destInfoCache=new Map,getDestInfo=__name(edgeIdx=>{if(destInfoCache.has(edgeIdx))return destInfoCache.get(edgeIdx);const indices=edgeSegmentIndices[edgeIdx];if(0===indices.length){const info2={dest:0,deviation:0,base:0,delta:0};return destInfoCache.set(edgeIdx,info2),info2}const base=allRoutedSegments[indices[0]].pipe.coord;let dest=base;for(let idx=1;idx<indices.length;idx++){const seg=allRoutedSegments[indices[idx]];if("horizontal"===seg.orientation){const candidateA=seg.from,candidateB=seg.to;dest=Math.abs(candidateA-base)>Math.abs(candidateB-base)?candidateA:candidateB;break}}const info={dest:dest,deviation:Math.abs(dest-base),base:base,delta:dest-base};return destInfoCache.set(edgeIdx,info),info},"getDestInfo"),fixSourceHandleCrossings=__name(()=>{let crossings=0;const edgesBySource=new Map;for(const[i,e]of edges.entries())0!==edgeSegmentIndices[i].length&&e.start&&(edgesBySource.has(e.start)||edgesBySource.set(e.start,[]),edgesBySource.get(e.start).push(i));const getEdgeDistance=__name(edgeIdx=>{const edge=edges[edgeIdx];if(!edge.start||!edge.end)return 0;const srcNode=nodeById.get(edge.start),dstNode=nodeById.get(edge.end);if(!srcNode||!dstNode)return 0;const dx=(dstNode.x??0)-(srcNode.x??0),dy=(dstNode.y??0)-(srcNode.y??0);return Math.abs(dx)+Math.abs(dy)},"getEdgeDistance");for(const grp of edgesBySource.values()){grp.sort((a,b)=>{const infoA=getDestInfo(a),infoB=getDestInfo(b);if(Math.abs(infoA.deviation-infoB.deviation)>1)return infoA.deviation-infoB.deviation;if(Math.abs(infoA.dest-infoB.dest)>1)return infoA.dest-infoB.dest;const distA=getEdgeDistance(a),distB=getEdgeDistance(b);if(Math.abs(distA-distB)>1)return distB-distA;const lenA=edgeSegmentIndices[a].length,lenB=edgeSegmentIndices[b].length;if(lenA!==lenB)return lenA-lenB;if(1===lenA){const idxA=edgeSegmentIndices[a][0],idxB=edgeSegmentIndices[b][0];if(allRoutedSegments[idxA]&&allRoutedSegments[idxB]){const segA=allRoutedSegments[idxA],segB=allRoutedSegments[idxB],distA2=Math.abs(segA.to-segA.from),distB2=Math.abs(segB.to-segB.from);if(Math.abs(distA2-distB2)>1)return distA2-distB2}}return 0});const handles=grp.map(ei=>allRoutedSegments[edgeSegmentIndices[ei][0]]);crossings+=resolveHandleConflicts(handles)}return crossings},"fixSourceHandleCrossings"),fixTargetHandleCrossings=__name(()=>{let crossings=0;const edgesByTarget=new Map;for(const[i,e]of edges.entries()){0!==edgeSegmentIndices[i].length&&(e.end&&(edgesByTarget.has(e.end)||edgesByTarget.set(e.end,[]),edgesByTarget.get(e.end).push(i)))}for(const grp of edgesByTarget.values()){grp.sort((a,b)=>{const getDist=__name(edgeIdx=>{const indices=edgeSegmentIndices[edgeIdx];if(indices.length<2)return 0;const prev=allRoutedSegments[indices[indices.length-2]];return Math.abs(prev.to-prev.from)},"getDist"),scoreA=getDist(a),scoreB=getDist(b);return Math.abs(scoreA-scoreB)>.1?scoreA-scoreB:a-b});const handles=grp.map(ei=>allRoutedSegments[edgeSegmentIndices[ei][edgeSegmentIndices[ei].length-1]]);crossings+=resolveHandleConflicts(handles)}return crossings},"fixTargetHandleCrossings"),fixPipeCrossings=__name(()=>{let crossings=0;for(const pipe of pipes){const pipeSegments=[];for(const t of pipe.tracks)for(const ref of t.segments){const idx=edgeSegmentIndices[ref.edgeIndex].find(ix=>allRoutedSegments[ix].segmentIndex===ref.segmentIndex);void 0!==idx&&pipeSegments.push(allRoutedSegments[idx])}pipeSegments.sort((a,b)=>a.edgeIndex-b.edgeIndex||a.segmentIndex-b.segmentIndex);for(let i=0;i<pipeSegments.length;i++)for(let j=i+1;j<pipeSegments.length;j++){const s1=pipeSegments[i],s2=pipeSegments[j];segmentsConflict(s1,s2)&&(crossings++,resolveTrackConflict(s1,s2,moveSegmentToTrack))}}return crossings},"fixPipeCrossings");let iterations=0;for(;iterations<10;){let changed=0;if(changed+=fixSourceHandleCrossings(),changed+=fixTargetHandleCrossings(),changed+=fixPipeCrossings(),0===changed)break;iterations++}const segmentCoords=new Map;for(const pipe of pipes){const segments=[];pipe.tracks.forEach(t=>{t.segments.forEach(s=>{segments.push({edgeIndex:s.edgeIndex,segmentIndex:s.segmentIndex,trackIndex:t.index,from:s.from,to:s.to})})}),segments.sort((a,b)=>a.from-b.from);const clusters=[];if(segments.length>0){let currentCluster=[segments[0]],clusterEnd=segments[0].to;for(let k=1;k<segments.length;k++){const s=segments[k];s.from<clusterEnd?(currentCluster.push(s),clusterEnd=Math.max(clusterEnd,s.to)):(clusters.push(currentCluster),currentCluster=[s],clusterEnd=s.to)}clusters.push(currentCluster)}for(const cluster of clusters){const usedTracks=new Set;cluster.forEach(s=>usedTracks.add(s.trackIndex));const trackScores=new Map;cluster.forEach(s=>{const info=getDestInfo(s.edgeIndex);trackScores.set(s.trackIndex,(trackScores.get(s.trackIndex)??0)+info.delta)});const leftTracks=[...usedTracks].filter(t=>(trackScores.get(t)??0)<-1),rightTracks=[...usedTracks].filter(t=>(trackScores.get(t)??0)>1),neutralTracks=[...usedTracks].filter(t=>Math.abs(trackScores.get(t)??0)<=1);leftTracks.sort((a,b)=>(trackScores.get(b)??0)-(trackScores.get(a)??0)),rightTracks.sort((a,b)=>(trackScores.get(a)??0)-(trackScores.get(b)??0));const assignCoord=__name((trackIndex,coord)=>{cluster.filter(s=>s.trackIndex===trackIndex).forEach(s=>{const effectiveCoord=straightIntraLaneEdges.has(s.edgeIndex)?pipe.coord:coord;segmentCoords.set(`${s.edgeIndex}-${s.segmentIndex}`,effectiveCoord)})},"assignCoord");let leftCount=0;for(const trackIndex of leftTracks)leftCount++,assignCoord(trackIndex,pipe.coord-10*leftCount);if(0===neutralTracks.length&&usedTracks.size>0){const bestTrack=[...usedTracks].sort((a,b)=>Math.abs(trackScores.get(a)??0)-Math.abs(trackScores.get(b)??0))[0],leftIdx=leftTracks.indexOf(bestTrack);-1!==leftIdx&&leftTracks.splice(leftIdx,1);const rightIdx=rightTracks.indexOf(bestTrack);-1!==rightIdx&&rightTracks.splice(rightIdx,1),neutralTracks.push(bestTrack)}let neutralAssigned=0;for(const trackIndex of neutralTracks){if(0===neutralAssigned)assignCoord(trackIndex,pipe.coord);else{const dir=neutralAssigned%2==1?1:-1,magnitude=Math.ceil(neutralAssigned/2);assignCoord(trackIndex,pipe.coord+dir*magnitude*10*.5)}neutralAssigned++}let rightCount=0;for(const trackIndex of rightTracks)rightCount++,assignCoord(trackIndex,pipe.coord+10*rightCount)}}for(const[i,e]of edges.entries()){const indices=edgeSegmentIndices[i]??[];if(0===indices.length)continue;const newPoints=[],src=nodeById.get(e.start),dst=nodeById.get(e.end),{pSrcPort:pSrcPort,pDstPort:pDstPort}=portsForEdge(i,src,dst),lines=indices.map(idx=>{const s=allRoutedSegments[idx],coord=segmentCoords.get(`${s.edgeIndex}-${s.segmentIndex}`)??s.pipe.coord;return{orient:s.orientation,coord:coord,from:s.from,to:s.to}});newPoints.push(pSrcPort);for(let k=0;k<lines.length;k++){const line=lines[k],prevPt=newPoints[newPoints.length-1],prevAlong="vertical"===line.orient?prevPt.y:prevPt.x,prevTrackCoord="vertical"===line.orient?prevPt.x:prevPt.y,nextLine=lines[k+1],hasNextLine=k<lines.length-1;if(Math.abs(prevTrackCoord-line.coord)>EPS7&&newPoints.push(pointOnLine(line,prevAlong)),hasNextLine&&nextLine.orient===line.orient)if(Math.abs(line.coord-nextLine.coord)>EPS7){const junction="vertical"===line.orient?(prevAlong+nextLine.from)/2:sharedLineEndpointCoord(line,nextLine);newPoints.push(pointOnLine(line,junction),pointOnLine(nextLine,junction))}else 0!==k&&k!==lines.length-2||newPoints.push(pointOnLine(line,sharedLineEndpointCoord(line,nextLine)));else if(hasNextLine)newPoints.push(pointOnLine(line,nextLine.coord));else{const endAlong=Math.abs(line.from-prevAlong)<Math.abs(line.to-prevAlong)?line.to:line.from;newPoints.push(pointOnLine(line,endAlong))}}const last=newPoints[newPoints.length-1];(Math.abs(last.x-pDstPort.x)>EPS7||Math.abs(last.y-pDstPort.y)>EPS7)&&newPoints.push(pDstPort);const filtered=[];newPoints.length>0&&filtered.push(newPoints[0]);for(let k=1;k<newPoints.length;k++){const p=newPoints[k],prev=filtered[filtered.length-1];(Math.abs(p.x-prev.x)>EPS7||Math.abs(p.y-prev.y)>EPS7)&&filtered.push(p)}e.points=filtered}for(const re of edges){const orig=re.__originalEdge;orig&&re.points&&(orig.points=re.points)}data.edges=(data.edges??[]).filter(e=>!e.isLayoutOnly);const nodeBoundaryClamp=__name((p,node)=>{const cx=node.x??0,cy=node.y??0,w=node.width??0,h=node.height??0;if(w<=0||h<=0)return p;const left=cx-w/2,right=cx+w/2,top=cy-h/2,bottom=cy+h/2;if(p.x<left||p.x>right||p.y<top||p.y>bottom)return p;const dLeft=p.x-left,dRight=right-p.x,dTop=p.y-top,dBottom=bottom-p.y,minD=Math.min(dLeft,dRight,dTop,dBottom);return minD===dLeft?{x:left,y:p.y}:minD===dRight?{x:right,y:p.y}:minD===dTop?{x:p.x,y:top}:{x:p.x,y:bottom}},"nodeBoundaryClamp");for(const edge of data.edges){const pts=edge.points;if(!pts||pts.length<2)continue;const srcId=edge.start,dstId=edge.end,src=srcId?nodeById.get(srcId):void 0,dst=dstId?nodeById.get(dstId):void 0;src&&(pts[0]=nodeBoundaryClamp(pts[0],src)),dst&&(pts[pts.length-1]=nodeBoundaryClamp(pts[pts.length-1],dst))}return data}function getSwimlaneDirection(data4Layout){return data4Layout.direction??"TB"}function runSwimlaneLayoutCore(data4Layout){var _a,_b,_c,_d,_e;const g=toGraphView(data4Layout),nodeGap=(null==(_a=data4Layout.config.flowchart)?void 0:_a.nodeSpacing)??40,layerGap=(null==(_b=data4Layout.config.flowchart)?void 0:_b.rankSpacing)??100,ignoreCrossLaneEdges=(null==(_c=data4Layout.config.swimlane)?void 0:_c.ignoreCrossLaneEdges)??!0,optimizeRanksByCrossings2=(null==(_d=data4Layout.config.swimlane)?void 0:_d.optimizeRanksByCrossings)??!0,automaticLaneOrdering=(null==(_e=data4Layout.config.swimlane)?void 0:_e.automaticLaneOrdering)??!1,direction=getSwimlaneDirection(data4Layout),{ordered:ordered,coordinates:coordinates}=sugiyamaLayout(g,{nodeGap:nodeGap,layerGap:layerGap,ignoreCrossLaneEdges:ignoreCrossLaneEdges,optimizeRanksByCrossings:optimizeRanksByCrossings2,automaticLaneOrdering:automaticLaneOrdering,direction:direction});writeBackToLayoutData(g,ordered,coordinates,{nodeGap:nodeGap,layerGap:layerGap});for(const edge of data4Layout.edges??[])delete edge.points;routeEdgesOrthogonal(data4Layout,direction);for(const edge of data4Layout.edges??[])edge.curve&&"basis"!==edge.curve||(edge.curve="rounded");return postProcessSwimlaneLayout(data4Layout,direction),validateSwimlanesLayout(data4Layout),direction}async function render(data4Layout,svg){const element=svg.select("g");markers_default(element,data4Layout.markers,data4Layout.type,data4Layout.diagramId),clear2(),clear(),clear$1(),clear$2(),prepareLayoutForSwimlanes(data4Layout);const transformedData=createEdgeLabelNodes(data4Layout);data4Layout.nodes=transformedData.nodes,data4Layout.edges=transformedData.edges;const{groups:groups}=await createGraphWithElements(element,data4Layout);runSwimlaneLayoutCore(data4Layout),await adjustLayout(data4Layout,groups)}__name(chooseOrthogonalSide,"chooseOrthogonalSide"),__name(sharedLineEndpointCoord,"sharedLineEndpointCoord"),__name(pointOnLine,"pointOnLine"),__name(routeEdgesOrthogonal,"routeEdgesOrthogonal"),__name(getSwimlaneDirection,"getSwimlaneDirection"),__name(runSwimlaneLayoutCore,"runSwimlaneLayoutCore"),__name(render,"render");export{render};

package/dist/assets/swimlanesDiagram-G3AALYLV-C19viY0G.js

@@ -0,0 +1 @@
+import{c as createFlowDiagram,s as styles_default}from"./flowDiagram-23GEKE2U-CEQPYHrk.js";import{_ as __name}from"./mermaid.core-Cy9iVxov.js";import"./vendor-antd-Bzi1WuBb.js";import"./chunk-5VM5RSS4-DFhufY9o.js";import"./chunk-XXDRQBXY-BPj05P7g.js";import"./chunk-VR4S4FIN-Bomuor1h.js";import"./chunk-32BRIVSS-VNg3Ylzs.js";import"./vendor-markdown-BN3QLsBu.js";import"./channel-BrN6yx0e.js";import"./vendor-mdxeditor-4PbKH6K7.js";import"./vendor-codemirror-CKTrJd47.js";var diagram=createFlowDiagram({defaultLayout:"swimlane",styles:__name(options=>`${styles_default(options)}\n  .swimlane.cluster rect {\n    stroke: ${options.clusterBorder} !important;\n  }\n  [data-look="neo"].cluster rect {\n    filter: none;\n  }\n`,"getStyles")});export{diagram};

package/dist/assets/tcl-CQhJd1WY.js

@@ -0,0 +1 @@
+function parseWords(str){for(var obj={},words=str.split(" "),i=0;i<words.length;++i)obj[words[i]]=!0;return obj}var keywords=parseWords("Tcl safe after append array auto_execok auto_import auto_load auto_mkindex auto_mkindex_old auto_qualify auto_reset bgerror binary break catch cd close concat continue dde eof encoding error eval exec exit expr fblocked fconfigure fcopy file fileevent filename filename flush for foreach format gets glob global history http if incr info interp join lappend lindex linsert list llength load lrange lreplace lsearch lset lsort memory msgcat namespace open package parray pid pkg::create pkg_mkIndex proc puts pwd re_syntax read regex regexp registry regsub rename resource return scan seek set socket source split string subst switch tcl_endOfWord tcl_findLibrary tcl_startOfNextWord tcl_wordBreakAfter tcl_startOfPreviousWord tcl_wordBreakBefore tcltest tclvars tell time trace unknown unset update uplevel upvar variable vwait"),functions=parseWords("if elseif else and not or eq ne in ni for foreach while switch"),isOperatorChar=/[+\-*&%=<>!?^\/\|]/;function chain(stream,state,f){return state.tokenize=f,f(stream,state)}function tokenBase(stream,state){var beforeParams=state.beforeParams;state.beforeParams=!1;var quote,ch=stream.next();if('"'!=ch&&"'"!=ch||!state.inParams){if(/[\[\]{}\(\),;\.]/.test(ch))return"("==ch&&beforeParams?state.inParams=!0:")"==ch&&(state.inParams=!1),null;if(/\d/.test(ch))return stream.eatWhile(/[\w\.]/),"number";if("#"==ch)return stream.eat("*")?chain(stream,state,tokenComment):"#"==ch&&stream.match(/ *\[ *\[/)?chain(stream,state,tokenUnparsed):(stream.skipToEnd(),"comment");if('"'==ch)return stream.skipTo(/"/),"comment";if("$"==ch)return stream.eatWhile(/[$_a-z0-9A-Z\.{:]/),stream.eatWhile(/}/),state.beforeParams=!0,"builtin";if(isOperatorChar.test(ch))return stream.eatWhile(isOperatorChar),"comment";stream.eatWhile(/[\w\$_{}\xa1-\uffff]/);var word=stream.current().toLowerCase();return keywords&&keywords.propertyIsEnumerable(word)?"keyword":functions&&functions.propertyIsEnumerable(word)?(state.beforeParams=!0,"keyword"):null}return chain(stream,state,(quote=ch,function(stream,state){for(var next,escaped=!1,end=!1;null!=(next=stream.next());){if(next==quote&&!escaped){end=!0;break}escaped=!escaped&&"\\"==next}return end&&(state.tokenize=tokenBase),"string"}))}function tokenComment(stream,state){for(var ch,maybeEnd=!1;ch=stream.next();){if("#"==ch&&maybeEnd){state.tokenize=tokenBase;break}maybeEnd="*"==ch}return"comment"}function tokenUnparsed(stream,state){for(var ch,maybeEnd=0;ch=stream.next();){if("#"==ch&&2==maybeEnd){state.tokenize=tokenBase;break}"]"==ch?maybeEnd++:" "!=ch&&(maybeEnd=0)}return"meta"}const tcl={name:"tcl",startState:function(){return{tokenize:tokenBase,beforeParams:!1,inParams:!1}},token:function(stream,state){return stream.eatSpace()?null:state.tokenize(stream,state)},languageData:{commentTokens:{line:"#"}}};export{tcl};

package/dist/assets/textile-D9XqfVtL.js

@@ -0,0 +1 @@
+var TOKEN_STYLES={addition:"inserted",attributes:"propertyName",bold:"strong",cite:"keyword",code:"monospace",definitionList:"list",deletion:"deleted",div:"punctuation",em:"emphasis",footnote:"variable",footCite:"qualifier",header:"heading",html:"comment",image:"atom",italic:"emphasis",link:"link",linkDefinition:"link",list1:"list",list2:"list.special",list3:"list",notextile:"string.special",pre:"operator",p:"content",quote:"bracket",span:"quote",specialChar:"character",strong:"strong",sub:"content.special",sup:"content.special",table:"variableName.special",tableHeading:"operator"};function handlePhraseModifier(stream,state,ch){if("_"===ch)return stream.eat("_")?togglePhraseModifier(stream,state,"italic",/__/,2):togglePhraseModifier(stream,state,"em",/_/,1);if("*"===ch)return stream.eat("*")?togglePhraseModifier(stream,state,"bold",/\*\*/,2):togglePhraseModifier(stream,state,"strong",/\*/,1);if("["===ch)return stream.match(/\d+\]/)&&(state.footCite=!0),tokenStyles(state);if("("===ch&&stream.match(/^(r|tm|c)\)/))return TOKEN_STYLES.specialChar;if("<"===ch&&stream.match(/(\w+)[^>]+>[^<]+<\/\1>/))return TOKEN_STYLES.html;if("?"===ch&&stream.eat("?"))return togglePhraseModifier(stream,state,"cite",/\?\?/,2);if("="===ch&&stream.eat("="))return togglePhraseModifier(stream,state,"notextile",/==/,2);if("-"===ch&&!stream.eat("-"))return togglePhraseModifier(stream,state,"deletion",/-/,1);if("+"===ch)return togglePhraseModifier(stream,state,"addition",/\+/,1);if("~"===ch)return togglePhraseModifier(stream,state,"sub",/~/,1);if("^"===ch)return togglePhraseModifier(stream,state,"sup",/\^/,1);if("%"===ch)return togglePhraseModifier(stream,state,"span",/%/,1);if("@"===ch)return togglePhraseModifier(stream,state,"code",/@/,1);if("!"===ch){var type=togglePhraseModifier(stream,state,"image",/(?:\([^\)]+\))?!/,1);return stream.match(/^:\S+/),type}return tokenStyles(state)}function togglePhraseModifier(stream,state,phraseModifier,closeRE,openSize){var charBefore=stream.pos>openSize?stream.string.charAt(stream.pos-openSize-1):null,charAfter=stream.peek();if(state[phraseModifier]){if((!charAfter||/\W/.test(charAfter))&&charBefore&&/\S/.test(charBefore)){var type=tokenStyles(state);return state[phraseModifier]=!1,type}}else(!charBefore||/\W/.test(charBefore))&&charAfter&&/\S/.test(charAfter)&&stream.match(new RegExp("^.*\\S"+closeRE.source+"(?:\\W|$)"),!1)&&(state[phraseModifier]=!0,state.mode=Modes.attributes);return tokenStyles(state)}function tokenStyles(state){var disabled=textileDisabled(state);if(disabled)return disabled;var styles=[];return state.layoutType&&styles.push(TOKEN_STYLES[state.layoutType]),styles=styles.concat(function(state){for(var styles=[],i=1;i<arguments.length;++i)state[arguments[i]]&&styles.push(TOKEN_STYLES[arguments[i]]);return styles}(state,"addition","bold","cite","code","deletion","em","footCite","image","italic","link","span","strong","sub","sup","table","tableHeading")),"header"===state.layoutType&&styles.push(TOKEN_STYLES.header+"-"+state.header),styles.length?styles.join(" "):null}function textileDisabled(state){var type=state.layoutType;switch(type){case"notextile":case"code":case"pre":return TOKEN_STYLES[type];default:return state.notextile?TOKEN_STYLES.notextile+(type?" "+TOKEN_STYLES[type]:""):null}}var REs={cache:{},single:{bc:"bc",bq:"bq",definitionList:/- .*?:=+/,definitionListEnd:/.*=:\s*$/,div:"div",drawTable:/\|.*\|/,foot:/fn\d+/,header:/h[1-6]/,html:/\s*<(?:\/)?(\w+)(?:[^>]+)?>(?:[^<]+<\/\1>)?/,link:/[^"]+":\S/,linkDefinition:/\[[^\s\]]+\]\S+/,list:/(?:#+|\*+)/,notextile:"notextile",para:"p",pre:"pre",table:"table",tableCellAttributes:/[\/\\]\d+/,tableHeading:/\|_\./,tableText:/[^"_\*\[\(\?\+~\^%@|-]+/,text:/[^!"_=\*\[\(<\?\+~\^%@-]+/},attributes:{align:/(?:<>|<|>|=)/,selector:/\([^\(][^\)]+\)/,lang:/\[[^\[\]]+\]/,pad:/(?:\(+|\)+){1,2}/,css:/\{[^\}]+\}/},createRe:function(name){switch(name){case"drawTable":return REs.makeRe("^",REs.single.drawTable,"$");case"html":return REs.makeRe("^",REs.single.html,"(?:",REs.single.html,")*","$");case"linkDefinition":return REs.makeRe("^",REs.single.linkDefinition,"$");case"listLayout":return REs.makeRe("^",REs.single.list,RE("allAttributes"),"*\\s+");case"tableCellAttributes":return REs.makeRe("^",REs.choiceRe(REs.single.tableCellAttributes,RE("allAttributes")),"+\\.");case"type":return REs.makeRe("^",RE("allTypes"));case"typeLayout":return REs.makeRe("^",RE("allTypes"),RE("allAttributes"),"*\\.\\.?","(\\s+|$)");case"attributes":return REs.makeRe("^",RE("allAttributes"),"+");case"allTypes":return REs.choiceRe(REs.single.div,REs.single.foot,REs.single.header,REs.single.bc,REs.single.bq,REs.single.notextile,REs.single.pre,REs.single.table,REs.single.para);case"allAttributes":return REs.choiceRe(REs.attributes.selector,REs.attributes.css,REs.attributes.lang,REs.attributes.align,REs.attributes.pad);default:return REs.makeRe("^",REs.single[name])}},makeRe:function(){for(var pattern="",i=0;i<arguments.length;++i){var arg=arguments[i];pattern+="string"==typeof arg?arg:arg.source}return new RegExp(pattern)},choiceRe:function(){for(var parts=[arguments[0]],i=1;i<arguments.length;++i)parts[2*i-1]="|",parts[2*i]=arguments[i];return parts.unshift("(?:"),parts.push(")"),REs.makeRe.apply(null,parts)}};function RE(name){return REs.cache[name]||(REs.cache[name]=REs.createRe(name))}var Modes={newLayout:function(stream,state){return stream.match(RE("typeLayout"),!1)?(state.spanningLayout=!1,(state.mode=Modes.blockType)(stream,state)):(textileDisabled(state)||(stream.match(RE("listLayout"),!1)?newMode=Modes.list:stream.match(RE("drawTable"),!1)?newMode=Modes.table:stream.match(RE("linkDefinition"),!1)?newMode=Modes.linkDefinition:stream.match(RE("definitionList"))?newMode=Modes.definitionList:stream.match(RE("html"),!1)&&(newMode=Modes.html)),(state.mode=newMode||Modes.text)(stream,state));var newMode},blockType:function(stream,state){var match,type;return state.layoutType=null,(match=stream.match(RE("type")))?((match=(type=match[0]).match(RE("header")))?(state.layoutType="header",state.header=parseInt(match[0][1])):type.match(RE("bq"))?state.layoutType="quote":type.match(RE("bc"))?state.layoutType="code":type.match(RE("foot"))?state.layoutType="footnote":type.match(RE("notextile"))?state.layoutType="notextile":type.match(RE("pre"))?state.layoutType="pre":type.match(RE("div"))?state.layoutType="div":type.match(RE("table"))&&(state.layoutType="table"),state.mode=Modes.attributes,tokenStyles(state)):(state.mode=Modes.text)(stream,state)},text:function(stream,state){if(stream.match(RE("text")))return tokenStyles(state);var ch=stream.next();return'"'===ch?(state.mode=Modes.link)(stream,state):handlePhraseModifier(stream,state,ch)},attributes:function(stream,state){return state.mode=Modes.layoutLength,stream.match(RE("attributes"))?TOKEN_STYLES.attributes:tokenStyles(state)},layoutLength:function(stream,state){return stream.eat(".")&&stream.eat(".")&&(state.spanningLayout=!0),state.mode=Modes.text,tokenStyles(state)},list:function(stream,state){var match=stream.match(RE("list"));state.listDepth=match[0].length;var listMod=(state.listDepth-1)%3;return state.layoutType=listMod?1===listMod?"list2":"list3":"list1",state.mode=Modes.attributes,tokenStyles(state)},link:function(stream,state){return state.mode=Modes.text,stream.match(RE("link"))?(stream.match(/\S+/),TOKEN_STYLES.link):tokenStyles(state)},linkDefinition:function(stream){return stream.skipToEnd(),TOKEN_STYLES.linkDefinition},definitionList:function(stream,state){return stream.match(RE("definitionList")),state.layoutType="definitionList",stream.match(/\s*$/)?state.spanningLayout=!0:state.mode=Modes.attributes,tokenStyles(state)},html:function(stream){return stream.skipToEnd(),TOKEN_STYLES.html},table:function(stream,state){return state.layoutType="table",(state.mode=Modes.tableCell)(stream,state)},tableCell:function(stream,state){return stream.match(RE("tableHeading"))?state.tableHeading=!0:stream.eat("|"),state.mode=Modes.tableCellAttributes,tokenStyles(state)},tableCellAttributes:function(stream,state){return state.mode=Modes.tableText,stream.match(RE("tableCellAttributes"))?TOKEN_STYLES.attributes:tokenStyles(state)},tableText:function(stream,state){return stream.match(RE("tableText"))?tokenStyles(state):"|"===stream.peek()?(state.mode=Modes.tableCell,tokenStyles(state)):handlePhraseModifier(stream,state,stream.next())}};const textile={name:"textile",startState:function(){return{mode:Modes.newLayout}},token:function(stream,state){return stream.sol()&&function(stream,state){state.mode=Modes.newLayout,state.tableHeading=!1,"definitionList"===state.layoutType&&state.spanningLayout&&stream.match(RE("definitionListEnd"),!1)&&(state.spanningLayout=!1)}(stream,state),state.mode(stream,state)},blankLine:function(state){var spanningLayout=state.spanningLayout,type=state.layoutType;for(var key in state)state.hasOwnProperty(key)&&delete state[key];state.mode=Modes.newLayout,spanningLayout&&(state.layoutType=type,state.spanningLayout=!0)}};export{textile};

package/dist/assets/tiddlywiki-DfOYgVky.js

@@ -0,0 +1 @@
+var textwords={},keywords={allTags:!0,closeAll:!0,list:!0,newJournal:!0,newTiddler:!0,permaview:!0,saveChanges:!0,search:!0,slider:!0,tabs:!0,tag:!0,tagging:!0,tags:!0,tiddler:!0,timeline:!0,today:!0,version:!0,option:!0,with:!0,filter:!0},isSpaceName=/[\w_\-]/i,reHR=/^\-\-\-\-+$/,reWikiCommentStart=/^\/\*\*\*$/,reWikiCommentStop=/^\*\*\*\/$/,reBlockQuote=/^<<<$/,reJsCodeStart=/^\/\/\{\{\{$/,reJsCodeStop=/^\/\/\}\}\}$/,reXmlCodeStart=/^<!--\{\{\{-->$/,reXmlCodeStop=/^<!--\}\}\}-->$/,reCodeBlockStart=/^\{\{\{$/,reCodeBlockStop=/^\}\}\}$/,reUntilCodeStop=/.*?\}\}\}/;function chain(stream,state,f){return state.tokenize=f,f(stream,state)}function tokenBase(stream,state){var sol=stream.sol(),ch=stream.peek();if(state.block=!1,sol&&/[<\/\*{}\-]/.test(ch)){if(stream.match(reCodeBlockStart))return state.block=!0,chain(stream,state,twTokenCode);if(stream.match(reBlockQuote))return"quote";if(stream.match(reWikiCommentStart)||stream.match(reWikiCommentStop))return"comment";if(stream.match(reJsCodeStart)||stream.match(reJsCodeStop)||stream.match(reXmlCodeStart)||stream.match(reXmlCodeStop))return"comment";if(stream.match(reHR))return"contentSeparator"}if(stream.next(),sol&&/[\/\*!#;:>|]/.test(ch)){if("!"==ch)return stream.skipToEnd(),"header";if("*"==ch)return stream.eatWhile("*"),"comment";if("#"==ch)return stream.eatWhile("#"),"comment";if(";"==ch)return stream.eatWhile(";"),"comment";if(":"==ch)return stream.eatWhile(":"),"comment";if(">"==ch)return stream.eatWhile(">"),"quote";if("|"==ch)return"header"}if("{"==ch&&stream.match("{{"))return chain(stream,state,twTokenCode);if(/[hf]/i.test(ch)&&/[ti]/i.test(stream.peek())&&stream.match(/\b(ttps?|tp|ile):\/\/[\-A-Z0-9+&@#\/%?=~_|$!:,.;]*[A-Z0-9+&@#\/%=~_|$]/i))return"link";if('"'==ch)return"string";if("~"==ch)return"brace";if(/[\[\]]/.test(ch)&&stream.match(ch))return"brace";if("@"==ch)return stream.eatWhile(isSpaceName),"link";if(/\d/.test(ch))return stream.eatWhile(/\d/),"number";if("/"==ch){if(stream.eat("%"))return chain(stream,state,twTokenComment);if(stream.eat("/"))return chain(stream,state,twTokenEm)}if("_"==ch&&stream.eat("_"))return chain(stream,state,twTokenUnderline);if("-"==ch&&stream.eat("-")){if(" "!=stream.peek())return chain(stream,state,twTokenStrike);if(" "==stream.peek())return"brace"}return"'"==ch&&stream.eat("'")?chain(stream,state,twTokenStrong):"<"==ch&&stream.eat("<")?chain(stream,state,twTokenMacro):(stream.eatWhile(/[\w\$_]/),textwords.propertyIsEnumerable(stream.current())?"keyword":null)}function twTokenComment(stream,state){for(var ch,maybeEnd=!1;ch=stream.next();){if("/"==ch&&maybeEnd){state.tokenize=tokenBase;break}maybeEnd="%"==ch}return"comment"}function twTokenStrong(stream,state){for(var ch,maybeEnd=!1;ch=stream.next();){if("'"==ch&&maybeEnd){state.tokenize=tokenBase;break}maybeEnd="'"==ch}return"strong"}function twTokenCode(stream,state){var sb=state.block;return sb&&stream.current()?"comment":!sb&&stream.match(reUntilCodeStop)||sb&&stream.sol()&&stream.match(reCodeBlockStop)?(state.tokenize=tokenBase,"comment"):(stream.next(),"comment")}function twTokenEm(stream,state){for(var ch,maybeEnd=!1;ch=stream.next();){if("/"==ch&&maybeEnd){state.tokenize=tokenBase;break}maybeEnd="/"==ch}return"emphasis"}function twTokenUnderline(stream,state){for(var ch,maybeEnd=!1;ch=stream.next();){if("_"==ch&&maybeEnd){state.tokenize=tokenBase;break}maybeEnd="_"==ch}return"link"}function twTokenStrike(stream,state){for(var ch,maybeEnd=!1;ch=stream.next();){if("-"==ch&&maybeEnd){state.tokenize=tokenBase;break}maybeEnd="-"==ch}return"deleted"}function twTokenMacro(stream,state){if("<<"==stream.current())return"meta";var ch=stream.next();return ch?">"==ch&&">"==stream.peek()?(stream.next(),state.tokenize=tokenBase,"meta"):(stream.eatWhile(/[\w\$_]/),keywords.propertyIsEnumerable(stream.current())?"keyword":null):(state.tokenize=tokenBase,null)}const tiddlyWiki={name:"tiddlywiki",startState:function(){return{tokenize:tokenBase}},token:function(stream,state){return stream.eatSpace()?null:state.tokenize(stream,state)}};export{tiddlyWiki};