@knowvah/dot-engine 2.10.2 → 2.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (344) hide show
  1. package/dist/gvc/context.d.ts.map +1 -1
  2. package/dist/gvc/emit-xdot.d.ts.map +1 -1
  3. package/dist/gvc/layout-reset.d.ts +38 -1
  4. package/dist/gvc/layout-reset.d.ts.map +1 -1
  5. package/dist/index.js +1191 -423
  6. package/dist/index.js.map +4 -4
  7. package/dist/layout/circo/circular.d.ts.map +1 -1
  8. package/dist/layout/circo/index.d.ts.map +1 -1
  9. package/dist/layout/dot/edge-route-helpers.d.ts +6 -1
  10. package/dist/layout/dot/edge-route-helpers.d.ts.map +1 -1
  11. package/dist/layout/dot/edge-route-rank.d.ts +4 -1
  12. package/dist/layout/dot/edge-route-rank.d.ts.map +1 -1
  13. package/dist/layout/dot/index.d.ts.map +1 -1
  14. package/dist/layout/dot/init.d.ts +0 -10
  15. package/dist/layout/dot/init.d.ts.map +1 -1
  16. package/dist/layout/fdp/cluster-edges.d.ts +11 -0
  17. package/dist/layout/fdp/cluster-edges.d.ts.map +1 -1
  18. package/dist/layout/fdp/init.d.ts.map +1 -1
  19. package/dist/layout/neato/closest.d.ts +20 -0
  20. package/dist/layout/neato/closest.d.ts.map +1 -0
  21. package/dist/layout/neato/constrained-majorization.d.ts +13 -0
  22. package/dist/layout/neato/constrained-majorization.d.ts.map +1 -1
  23. package/dist/layout/neato/embed-graph.d.ts +20 -0
  24. package/dist/layout/neato/embed-graph.d.ts.map +1 -0
  25. package/dist/layout/neato/fdp-adjust.d.ts.map +1 -1
  26. package/dist/layout/neato/index.d.ts.map +1 -1
  27. package/dist/layout/neato/init-dim.d.ts +54 -0
  28. package/dist/layout/neato/init-dim.d.ts.map +1 -0
  29. package/dist/layout/neato/init.d.ts +1 -11
  30. package/dist/layout/neato/init.d.ts.map +1 -1
  31. package/dist/layout/neato/kk.d.ts +4 -2
  32. package/dist/layout/neato/kk.d.ts.map +1 -1
  33. package/dist/layout/neato/matrix-ops-dense.d.ts +34 -0
  34. package/dist/layout/neato/matrix-ops-dense.d.ts.map +1 -0
  35. package/dist/layout/neato/pca.d.ts +14 -0
  36. package/dist/layout/neato/pca.d.ts.map +1 -0
  37. package/dist/layout/neato/sgd.d.ts +2 -3
  38. package/dist/layout/neato/sgd.d.ts.map +1 -1
  39. package/dist/layout/neato/start.d.ts +5 -5
  40. package/dist/layout/neato/start.d.ts.map +1 -1
  41. package/dist/layout/neato/stress-kernel.d.ts +10 -2
  42. package/dist/layout/neato/stress-kernel.d.ts.map +1 -1
  43. package/dist/layout/neato/stress-subspace.d.ts +39 -0
  44. package/dist/layout/neato/stress-subspace.d.ts.map +1 -0
  45. package/dist/layout/neato/vpsc-adjust.d.ts.map +1 -1
  46. package/dist/layout/osage/index.d.ts +1 -4
  47. package/dist/layout/osage/index.d.ts.map +1 -1
  48. package/dist/layout/pack/ccomps.d.ts +4 -2
  49. package/dist/layout/pack/ccomps.d.ts.map +1 -1
  50. package/dist/layout/patchwork/index.d.ts.map +1 -1
  51. package/dist/layout/sfdp/index.d.ts.map +1 -1
  52. package/dist/layout/sfdp/init.d.ts +6 -7
  53. package/dist/layout/sfdp/init.d.ts.map +1 -1
  54. package/dist/layout/twopi/circle.d.ts.map +1 -1
  55. package/dist/layout/twopi/index.d.ts.map +1 -1
  56. package/dist/layout/twopi/init.d.ts.map +1 -1
  57. package/dist/render/dot/attrs.d.ts +7 -0
  58. package/dist/render/dot/attrs.d.ts.map +1 -1
  59. package/dist/render.js +1574 -806
  60. package/dist/render.js.map +4 -4
  61. package/package.json +4 -4
  62. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.1 +20 -0
  63. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.2 +20 -0
  64. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.3 +20 -0
  65. package/src/gvc/__fixtures__/rerender/abom-shift-pack.gv +1 -0
  66. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.1 +22 -0
  67. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.2 +22 -0
  68. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.3 +22 -0
  69. package/src/gvc/__fixtures__/rerender/abom-shift-parity.gv +1 -0
  70. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.1 +13 -0
  71. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.2 +13 -0
  72. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.3 +13 -0
  73. package/src/gvc/__fixtures__/rerender/abom-shift.gv +1 -0
  74. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.1 +10 -0
  75. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.2 +11 -0
  76. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.gv +9 -0
  77. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.1 +40 -0
  78. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.2 +40 -0
  79. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.1 +15 -0
  80. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.2 +17 -0
  81. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.1 +40 -0
  82. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.2 +15 -0
  83. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.1 +40 -0
  84. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.2 +99 -0
  85. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.1 +489 -0
  86. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.2 +503 -0
  87. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.1 +40 -0
  88. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.2 +109 -0
  89. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.1 +69 -0
  90. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.2 +70 -0
  91. package/src/gvc/__fixtures__/rerender/cluster-edges.gv +15 -0
  92. package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.1 +104 -0
  93. package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.2 +104 -0
  94. package/src/gvc/__fixtures__/rerender/fdp-1581.gv +26 -0
  95. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.1 +34 -0
  96. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.2 +34 -0
  97. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.3 +34 -0
  98. package/src/gvc/__fixtures__/rerender/flat-rev-stale.gv +33 -0
  99. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.1 +181 -0
  100. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.2 +218 -0
  101. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.3 +255 -0
  102. package/src/gvc/__fixtures__/rerender/regen.sh +25 -0
  103. package/src/gvc/context.ts +7 -2
  104. package/src/gvc/emit-xdot.ts +37 -7
  105. package/src/gvc/layout-reset.ts +68 -2
  106. package/src/layout/circo/circular.ts +3 -1
  107. package/src/layout/circo/index.ts +1 -3
  108. package/src/layout/dot/edge-route-helpers.ts +8 -2
  109. package/src/layout/dot/edge-route-rank.ts +20 -2
  110. package/src/layout/dot/index.ts +17 -2
  111. package/src/layout/dot/init.ts +11 -49
  112. package/src/layout/dot/splines-flat.ts +12 -12
  113. package/src/layout/fdp/cluster-edges.ts +0 -0
  114. package/src/layout/fdp/init.ts +2 -17
  115. package/src/layout/neato/__fixtures__/dim/circuit-dim3.dot +33 -0
  116. package/src/layout/neato/__fixtures__/dim/circuit-dim3.gv +12 -0
  117. package/src/layout/neato/__fixtures__/dim/circuit-dim3.stderr +0 -0
  118. package/src/layout/neato/__fixtures__/dim/circuit-dim3.xdot +54 -0
  119. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.dot +32 -0
  120. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.gv +11 -0
  121. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.stderr +0 -0
  122. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.xdot +53 -0
  123. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.dot +32 -0
  124. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.gv +11 -0
  125. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.stderr +0 -0
  126. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.xdot +53 -0
  127. package/src/layout/neato/__fixtures__/dim/dim3.dot +31 -0
  128. package/src/layout/neato/__fixtures__/dim/dim3.gv +10 -0
  129. package/src/layout/neato/__fixtures__/dim/dim3.stderr +0 -0
  130. package/src/layout/neato/__fixtures__/dim/dim3.xdot +52 -0
  131. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.dot +32 -0
  132. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.gv +11 -0
  133. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.stderr +0 -0
  134. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.xdot +53 -0
  135. package/src/layout/neato/__fixtures__/dim/dimen3.dot +31 -0
  136. package/src/layout/neato/__fixtures__/dim/dimen3.gv +10 -0
  137. package/src/layout/neato/__fixtures__/dim/dimen3.stderr +0 -0
  138. package/src/layout/neato/__fixtures__/dim/dimen3.xdot +52 -0
  139. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.dot +267 -0
  140. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.gv +84 -0
  141. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.stderr +0 -0
  142. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.xdot +468 -0
  143. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.dot +267 -0
  144. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.gv +84 -0
  145. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.stderr +0 -0
  146. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.xdot +468 -0
  147. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.dot +268 -0
  148. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.gv +85 -0
  149. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.stderr +0 -0
  150. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.xdot +469 -0
  151. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.dot +484 -0
  152. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.gv +151 -0
  153. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.stderr +0 -0
  154. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.xdot +852 -0
  155. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.dot +34 -0
  156. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.gv +13 -0
  157. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.stderr +0 -0
  158. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.xdot +55 -0
  159. package/src/layout/neato/__fixtures__/dim/hier-dim3.dot +33 -0
  160. package/src/layout/neato/__fixtures__/dim/hier-dim3.gv +12 -0
  161. package/src/layout/neato/__fixtures__/dim/hier-dim3.stderr +0 -0
  162. package/src/layout/neato/__fixtures__/dim/hier-dim3.xdot +54 -0
  163. package/src/layout/neato/__fixtures__/dim/hier-dim4.dot +33 -0
  164. package/src/layout/neato/__fixtures__/dim/hier-dim4.gv +12 -0
  165. package/src/layout/neato/__fixtures__/dim/hier-dim4.stderr +0 -0
  166. package/src/layout/neato/__fixtures__/dim/hier-dim4.xdot +54 -0
  167. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.dot +32 -0
  168. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.gv +11 -0
  169. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.stderr +0 -0
  170. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.xdot +53 -0
  171. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.dot +34 -0
  172. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.gv +13 -0
  173. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.stderr +0 -0
  174. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.xdot +55 -0
  175. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.dot +37 -0
  176. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.gv +12 -0
  177. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.stderr +0 -0
  178. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.xdot +58 -0
  179. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.dot +141 -0
  180. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.gv +48 -0
  181. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.stderr +1 -0
  182. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.xdot +233 -0
  183. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.dot +21 -0
  184. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.gv +8 -0
  185. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.stderr +1 -0
  186. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.xdot +33 -0
  187. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.dot +23 -0
  188. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.gv +10 -0
  189. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.stderr +1 -0
  190. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.xdot +35 -0
  191. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.dot +23 -0
  192. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.gv +10 -0
  193. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.stderr +1 -0
  194. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.xdot +35 -0
  195. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.dot +26 -0
  196. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.gv +7 -0
  197. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.stderr +0 -0
  198. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.xdot +44 -0
  199. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.dot +28 -0
  200. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.gv +9 -0
  201. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.stderr +0 -0
  202. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.xdot +46 -0
  203. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.dot +48 -0
  204. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.gv +15 -0
  205. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.stderr +0 -0
  206. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.xdot +79 -0
  207. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.dot +56 -0
  208. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.gv +17 -0
  209. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.stderr +0 -0
  210. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.xdot +94 -0
  211. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.dot +47 -0
  212. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.gv +14 -0
  213. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.stderr +0 -0
  214. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.xdot +78 -0
  215. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.dot +34 -0
  216. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.gv +13 -0
  217. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.stderr +0 -0
  218. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.xdot +55 -0
  219. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.dot +34 -0
  220. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.gv +13 -0
  221. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.stderr +0 -0
  222. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.xdot +55 -0
  223. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.dot +34 -0
  224. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.gv +13 -0
  225. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.stderr +0 -0
  226. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.xdot +55 -0
  227. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.dot +15 -0
  228. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.gv +6 -0
  229. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.stderr +0 -0
  230. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.xdot +22 -0
  231. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.dot +33 -0
  232. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.gv +12 -0
  233. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.stderr +0 -0
  234. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.xdot +54 -0
  235. package/src/layout/neato/__fixtures__/dim/kk-dim3.dot +33 -0
  236. package/src/layout/neato/__fixtures__/dim/kk-dim3.gv +12 -0
  237. package/src/layout/neato/__fixtures__/dim/kk-dim3.stderr +0 -0
  238. package/src/layout/neato/__fixtures__/dim/kk-dim3.xdot +54 -0
  239. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.dot +33 -0
  240. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.gv +12 -0
  241. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.stderr +0 -0
  242. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.xdot +54 -0
  243. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.dot +39 -0
  244. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.gv +15 -0
  245. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.stderr +0 -0
  246. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.xdot +60 -0
  247. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.dot +33 -0
  248. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.gv +12 -0
  249. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.stderr +0 -0
  250. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.xdot +54 -0
  251. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.dot +33 -0
  252. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.gv +12 -0
  253. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.stderr +0 -0
  254. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.xdot +54 -0
  255. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.dot +33 -0
  256. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.gv +12 -0
  257. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.stderr +0 -0
  258. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.xdot +54 -0
  259. package/src/layout/neato/__fixtures__/dim/pack-dim3.dot +47 -0
  260. package/src/layout/neato/__fixtures__/dim/pack-dim3.gv +14 -0
  261. package/src/layout/neato/__fixtures__/dim/pack-dim3.stderr +0 -0
  262. package/src/layout/neato/__fixtures__/dim/pack-dim3.xdot +78 -0
  263. package/src/layout/neato/__fixtures__/dim/pins-dim3.dot +38 -0
  264. package/src/layout/neato/__fixtures__/dim/pins-dim3.gv +14 -0
  265. package/src/layout/neato/__fixtures__/dim/pins-dim3.stderr +0 -0
  266. package/src/layout/neato/__fixtures__/dim/pins-dim3.xdot +59 -0
  267. package/src/layout/neato/__fixtures__/dim/regen.sh +24 -0
  268. package/src/layout/neato/__fixtures__/dim/regular-dim3.dot +33 -0
  269. package/src/layout/neato/__fixtures__/dim/regular-dim3.gv +12 -0
  270. package/src/layout/neato/__fixtures__/dim/regular-dim3.stderr +0 -0
  271. package/src/layout/neato/__fixtures__/dim/regular-dim3.xdot +54 -0
  272. package/src/layout/neato/__fixtures__/dim/sgd-dim3.dot +33 -0
  273. package/src/layout/neato/__fixtures__/dim/sgd-dim3.gv +12 -0
  274. package/src/layout/neato/__fixtures__/dim/sgd-dim3.stderr +0 -0
  275. package/src/layout/neato/__fixtures__/dim/sgd-dim3.xdot +54 -0
  276. package/src/layout/neato/__fixtures__/dim/smart-units.json +16 -0
  277. package/src/layout/neato/__fixtures__/dim/subset-dim3.dot +33 -0
  278. package/src/layout/neato/__fixtures__/dim/subset-dim3.gv +12 -0
  279. package/src/layout/neato/__fixtures__/dim/subset-dim3.stderr +0 -0
  280. package/src/layout/neato/__fixtures__/dim/subset-dim3.xdot +54 -0
  281. package/src/layout/neato/closest.ts +206 -0
  282. package/src/layout/neato/constrained-majorization.ts +4 -23
  283. package/src/layout/neato/embed-graph.ts +81 -0
  284. package/src/layout/neato/fdp-adjust.ts +22 -8
  285. package/src/layout/neato/index.ts +26 -17
  286. package/src/layout/neato/init-dim.ts +165 -0
  287. package/src/layout/neato/init.ts +10 -38
  288. package/src/layout/neato/kk.ts +47 -41
  289. package/src/layout/neato/matrix-ops-dense.ts +232 -0
  290. package/src/layout/neato/pca.ts +60 -0
  291. package/src/layout/neato/sgd.ts +11 -4
  292. package/src/layout/neato/start.ts +8 -5
  293. package/src/layout/neato/stress-kernel.ts +65 -5
  294. package/src/layout/neato/stress-subspace.ts +371 -0
  295. package/src/layout/neato/vpsc-adjust.ts +3 -1
  296. package/src/layout/osage/index.ts +3 -22
  297. package/src/layout/pack/__fixtures__/cc-reuse/circo.dot +23 -0
  298. package/src/layout/pack/__fixtures__/cc-reuse/circo.gv +1 -0
  299. package/src/layout/pack/__fixtures__/cc-reuse/circo.stderr +0 -0
  300. package/src/layout/pack/__fixtures__/cc-reuse/circo.xdot +38 -0
  301. package/src/layout/pack/__fixtures__/cc-reuse/neato.dot +23 -0
  302. package/src/layout/pack/__fixtures__/cc-reuse/neato.gv +1 -0
  303. package/src/layout/pack/__fixtures__/cc-reuse/neato.stderr +0 -0
  304. package/src/layout/pack/__fixtures__/cc-reuse/neato.xdot +38 -0
  305. package/src/layout/pack/__fixtures__/cc-reuse/osage.dot +23 -0
  306. package/src/layout/pack/__fixtures__/cc-reuse/osage.gv +1 -0
  307. package/src/layout/pack/__fixtures__/cc-reuse/osage.stderr +0 -0
  308. package/src/layout/pack/__fixtures__/cc-reuse/osage.xdot +38 -0
  309. package/src/layout/pack/__fixtures__/cc-reuse/regen.sh +24 -0
  310. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.dot +21 -0
  311. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.gv +1 -0
  312. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.stderr +0 -0
  313. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.xdot +36 -0
  314. package/src/layout/pack/__fixtures__/cc-reuse/twopi.dot +21 -0
  315. package/src/layout/pack/__fixtures__/cc-reuse/twopi.gv +1 -0
  316. package/src/layout/pack/__fixtures__/cc-reuse/twopi.stderr +1 -0
  317. package/src/layout/pack/__fixtures__/cc-reuse/twopi.xdot +36 -0
  318. package/src/layout/pack/ccomps.ts +34 -6
  319. package/src/layout/patchwork/index.ts +1 -3
  320. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.dot +32 -0
  321. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.gv +11 -0
  322. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.stderr +0 -0
  323. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.xdot +53 -0
  324. package/src/layout/sfdp/__fixtures__/dim/dim3.dot +31 -0
  325. package/src/layout/sfdp/__fixtures__/dim/dim3.gv +10 -0
  326. package/src/layout/sfdp/__fixtures__/dim/dim3.stderr +0 -0
  327. package/src/layout/sfdp/__fixtures__/dim/dim3.xdot +52 -0
  328. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.dot +32 -0
  329. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.gv +11 -0
  330. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.stderr +0 -0
  331. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.xdot +53 -0
  332. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.dot +33 -0
  333. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.gv +12 -0
  334. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.stderr +0 -0
  335. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.xdot +54 -0
  336. package/src/layout/sfdp/__fixtures__/dim/regen.sh +24 -0
  337. package/src/layout/sfdp/index.ts +15 -10
  338. package/src/layout/sfdp/init.ts +27 -14
  339. package/src/layout/twopi/circle.ts +5 -1
  340. package/src/layout/twopi/index.ts +3 -0
  341. package/src/layout/twopi/init.ts +1 -3
  342. package/src/render/dot/agwrite.ts +2 -2
  343. package/src/render/dot/attrs.ts +16 -0
  344. package/src/render/dot/write-back.ts +2 -2
package/dist/index.js CHANGED
@@ -4195,8 +4195,8 @@ var StmtProcessor = class _StmtProcessor {
4195
4195
  * @see lib/cgraph/edge.c:agedge:274-275 (`if (e == NULL && agisundirected(g))`)
4196
4196
  */
4197
4197
  static strictKey(tail, head, undirected) {
4198
- const swap3 = undirected && head.id < tail.id;
4199
- return swap3 ? `${head.id}\0${tail.id}` : `${tail.id}\0${head.id}`;
4198
+ const swap4 = undirected && head.id < tail.id;
4199
+ return swap4 ? `${head.id}\0${tail.id}` : `${tail.id}\0${head.id}`;
4200
4200
  }
4201
4201
  /**
4202
4202
  * Apply the DOT-syntax `:port:compass` endpoints to an edge's attrs.
@@ -5575,12 +5575,184 @@ var P_LPROMOTER = {
5575
5575
  vertices: null
5576
5576
  };
5577
5577
 
5578
+ // src/layout/fdp/cluster-edges.ts
5579
+ function fillMap(g, map) {
5580
+ const n = g.info.n_cluster ?? 0;
5581
+ for (let c = 0; c < n; c++) {
5582
+ const cl = g.info.clust[c];
5583
+ const s = cl.name;
5584
+ if (!map.has(s)) map.set(s, cl);
5585
+ fillMap(cl, map);
5586
+ }
5587
+ }
5588
+ function mkClustMap(g) {
5589
+ const map = /* @__PURE__ */ new Map();
5590
+ fillMap(g, map);
5591
+ return map;
5592
+ }
5593
+ function mapc(cmap, n) {
5594
+ if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
5595
+ return null;
5596
+ }
5597
+ function edgeKey(t, h) {
5598
+ return `${t.name}\0${h.name}`;
5599
+ }
5600
+ function mapEdge(map, t, h) {
5601
+ return map.get(edgeKey(t, h));
5602
+ }
5603
+ function insertEdge(map, t, h, ce) {
5604
+ map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
5605
+ map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
5606
+ }
5607
+ function clustNode(n, cg, root, delSet, idx) {
5608
+ const name = `__${idx.v}:${cg.name}`;
5609
+ const cn = agnode(root, name, true);
5610
+ cn.info.clustnode = true;
5611
+ agsubnode(cg, cn, true);
5612
+ delSet.add(n);
5613
+ cn.attrs.set("label", "");
5614
+ cn.attrs.set("style", "invis");
5615
+ cn.attrs.set("shape", "box");
5616
+ return cn;
5617
+ }
5618
+ function nextEdgeSeq(root) {
5619
+ let max = 0;
5620
+ for (const e of root.edges) max = Math.max(max, e.graphSeq);
5621
+ return max + 1;
5622
+ }
5623
+ function cloneEdge(root, e, ct, ch) {
5624
+ const ce = new Edge(ct, ch, "");
5625
+ for (const [k, v] of e.attrs) ce.attrs.set(k, v);
5626
+ ce.info.compound = 1;
5627
+ ce.graphSeq = nextEdgeSeq(root);
5628
+ root.edges.push(ce);
5629
+ return ce;
5630
+ }
5631
+ function checkCompound(e, root, cmap, map, delSet, idx) {
5632
+ const t = e.tail;
5633
+ const h = e.head;
5634
+ if (h.info.clustnode) return 0;
5635
+ const tg = mapc(cmap, t);
5636
+ const hg = mapc(cmap, h);
5637
+ if (!tg && !hg) return 0;
5638
+ if (tg === hg) return 0;
5639
+ const ip = mapEdge(map, t, h);
5640
+ if (ip) {
5641
+ cloneEdge(root, e, ip.t, ip.h);
5642
+ return 1;
5643
+ }
5644
+ let cn;
5645
+ let ce;
5646
+ if (hg) {
5647
+ if (tg) {
5648
+ if (agContains(hg, tg) || agContains(tg, hg)) return 0;
5649
+ cn = clustNode(t, tg, root, delSet, idx);
5650
+ const cn1 = clustNode(h, hg, root, delSet, idx);
5651
+ ce = cloneEdge(root, e, cn, cn1);
5652
+ insertEdge(map, t, h, ce);
5653
+ } else {
5654
+ if (agContainsNode(hg, t)) return 0;
5655
+ cn = clustNode(h, hg, root, delSet, idx);
5656
+ ce = cloneEdge(root, e, t, cn);
5657
+ insertEdge(map, t, h, ce);
5658
+ }
5659
+ } else {
5660
+ if (agContainsNode(tg, h)) return 0;
5661
+ cn = clustNode(t, tg, root, delSet, idx);
5662
+ ce = cloneEdge(root, e, cn, h);
5663
+ insertEdge(map, t, h, ce);
5664
+ }
5665
+ return 1;
5666
+ }
5667
+ function agContains(a, b) {
5668
+ for (let g = b; g !== null; g = g.parent) {
5669
+ if (g === a) return true;
5670
+ }
5671
+ return false;
5672
+ }
5673
+ function agContainsNode(cg, n) {
5674
+ return cg.nodes.has(n.name);
5675
+ }
5676
+ function deleteNodeAndEdges(root, n) {
5677
+ const purge = (gr) => {
5678
+ if (gr.edges.length > 0) {
5679
+ gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
5680
+ }
5681
+ gr.nodes.delete(n.name);
5682
+ for (const sg of gr.subgraphs.values()) purge(sg);
5683
+ };
5684
+ purge(root);
5685
+ }
5686
+ function processClusterEdges(g) {
5687
+ const root = g.root;
5688
+ const cmap = mkClustMap(g);
5689
+ if (cmap.size === 0) return;
5690
+ const map = /* @__PURE__ */ new Map();
5691
+ const delSet = /* @__PURE__ */ new Set();
5692
+ const idx = { v: 0 };
5693
+ let numClEdges = 0;
5694
+ for (const n of [...g.nodes.values()]) {
5695
+ if (n.info.clustnode) continue;
5696
+ for (const e of n.outEdges(g)) {
5697
+ numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
5698
+ }
5699
+ }
5700
+ for (const n of delSet) deleteNodeAndEdges(root, n);
5701
+ if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
5702
+ }
5703
+ function mapN(n, delSet) {
5704
+ if (!n.info.clustnode) return n;
5705
+ delSet.add(n);
5706
+ const name = n.name.slice(n.name.indexOf(":") + 1);
5707
+ const existing = agnode(n.root, name, false);
5708
+ if (existing !== null) return existing;
5709
+ const nn = agnode(n.root, name, true);
5710
+ nn.info.clustnode = true;
5711
+ return nn;
5712
+ }
5713
+ function undoCompound(root, e, delSet) {
5714
+ const ntail = mapN(e.tail, delSet);
5715
+ const nhead = mapN(e.head, delSet);
5716
+ const ce = cloneEdge(root, e, ntail, nhead);
5717
+ ce.info.spl = e.info.spl;
5718
+ e.info.spl = void 0;
5719
+ ce.info.label = e.info.label;
5720
+ e.info.label = void 0;
5721
+ ce.info.xlabel = e.info.xlabel;
5722
+ e.info.xlabel = void 0;
5723
+ ce.info.head_label = e.info.head_label;
5724
+ e.info.head_label = void 0;
5725
+ ce.info.tail_label = e.info.tail_label;
5726
+ e.info.tail_label = void 0;
5727
+ }
5728
+ function undoClusterEdges(g) {
5729
+ if (!g.info.n_cluster_edges) return;
5730
+ const root = g.root;
5731
+ const delSet = /* @__PURE__ */ new Set();
5732
+ const edgelist = [];
5733
+ for (const n of g.nodes.values()) {
5734
+ for (const e of n.outEdges(g)) {
5735
+ if (e.info.compound && isProxyEdge(e)) edgelist.push(e);
5736
+ }
5737
+ }
5738
+ for (const e of edgelist) undoCompound(root, e, delSet);
5739
+ for (const n of delSet) deleteNodeAndEdges(root, n);
5740
+ }
5741
+ function isProxyEdge(e) {
5742
+ return e.tail.info.clustnode && e.tail.name.includes(":") || e.head.info.clustnode && e.head.name.includes(":");
5743
+ }
5744
+
5578
5745
  // src/gvc/layout-reset.ts
5579
5746
  function layoutWasFreed(g) {
5580
5747
  return g.info?.laidOut === true && g.info.cleanup === void 0;
5581
5748
  }
5749
+ function undoRenderedClusterEdges(g) {
5750
+ if (g.info?.n_cluster_edges && g.attrs.get("bb")?.includes(",")) undoClusterEdges(g);
5751
+ }
5582
5752
  function resetGraphRecords(g) {
5753
+ const clusterEdges = g.info.n_cluster_edges;
5583
5754
  g.info = makeGraphInfo();
5755
+ if (clusterEdges !== void 0) g.info.n_cluster_edges = clusterEdges;
5584
5756
  for (const subg of g.subgraphs.values()) resetGraphRecords(subg);
5585
5757
  }
5586
5758
  function resetLayoutRecords(g) {
@@ -5588,6 +5760,21 @@ function resetLayoutRecords(g) {
5588
5760
  for (const e of g.edges) e.info = makeEdgeInfo(makePort(), makePort());
5589
5761
  resetGraphRecords(g);
5590
5762
  }
5763
+ function resetFreedLayouts(g) {
5764
+ const visit = (h) => {
5765
+ if (layoutWasFreed(h)) resetLayoutRecords(h);
5766
+ else for (const subg of h.subgraphs.values()) visit(subg);
5767
+ };
5768
+ visit(g.root);
5769
+ }
5770
+ function bindDotRoot(g) {
5771
+ const droot = g === g.root ? void 0 : g;
5772
+ const visit = (h) => {
5773
+ h.info.dotroot = droot;
5774
+ for (const subg of h.subgraphs.values()) visit(subg);
5775
+ };
5776
+ visit(g);
5777
+ }
5591
5778
 
5592
5779
  // src/xdot/types.ts
5593
5780
  var XDOT_PARSE_ERROR = 1;
@@ -6257,7 +6444,12 @@ var GvcContext = class {
6257
6444
  }
6258
6445
  engine = override2;
6259
6446
  }
6260
- if (layoutWasFreed(g)) resetLayoutRecords(g);
6447
+ undoRenderedClusterEdges(g);
6448
+ if (g.root) {
6449
+ resetFreedLayouts(g);
6450
+ bindDotRoot(g);
6451
+ g.root.info.gvc = this;
6452
+ }
6261
6453
  if (g.info) g.info.gvc = this;
6262
6454
  initXdot(g);
6263
6455
  engine.layout(g);
@@ -22611,13 +22803,13 @@ function dfsNode(Xg, v, frames) {
22611
22803
  frames.push({ v, edges: v.outEdges(Xg).slice(), i: 0 });
22612
22804
  }
22613
22805
  function dfsStep2(Xg, frames) {
22614
- const fr10 = frames[frames.length - 1];
22615
- if (fr10.i < fr10.edges.length) {
22616
- const e = fr10.edges[fr10.i++];
22806
+ const fr12 = frames[frames.length - 1];
22807
+ if (fr12.i < fr12.edges.length) {
22808
+ const e = fr12.edges[fr12.i++];
22617
22809
  if (e.head.info.onstack) reverseEdge2(Xg, e);
22618
22810
  else if (!e.head.info.mark) dfsNode(Xg, e.head, frames);
22619
22811
  } else {
22620
- fr10.v.info.onstack = 0;
22812
+ fr12.v.info.onstack = 0;
22621
22813
  frames.pop();
22622
22814
  }
22623
22815
  }
@@ -22806,7 +22998,7 @@ function newMatrix(rows, cols) {
22806
22998
  function dotRoot(g) {
22807
22999
  return g.info.dotroot ?? g.root;
22808
23000
  }
22809
- function agContainsNode(g, n) {
23001
+ function agContainsNode2(g, n) {
22810
23002
  return g.nodes.get(n.name) === n;
22811
23003
  }
22812
23004
  function agContainsEdge(g, e) {
@@ -22819,7 +23011,7 @@ function rankSet(rank3, i, n) {
22819
23011
  rank3.v[(rank3.vStart ?? 0) + i] = n;
22820
23012
  }
22821
23013
  function isNormalNodeOf(g, v) {
22822
- return v.info.node_type === NORMAL && agContainsNode(g, v);
23014
+ return v.info.node_type === NORMAL && agContainsNode2(g, v);
22823
23015
  }
22824
23016
  function isVnodeOfEdgeOf(g, v) {
22825
23017
  if (v.info.node_type !== VIRTUAL) return false;
@@ -23255,7 +23447,7 @@ function flatSearchNormal(g, v, e, M2, hascl) {
23255
23447
  }
23256
23448
  function flatSearchEdge(g, v, e, M2, hascl) {
23257
23449
  if (!M2) return false;
23258
- if (hascl && !(agContainsNode(g, e.tail) && agContainsNode(g, e.head))) return false;
23450
+ if (hascl && !(agContainsNode2(g, e.tail) && agContainsNode2(g, e.head))) return false;
23259
23451
  if ((e.info.weight !== void 0 ? e.info.weight : 0) === 0) return false;
23260
23452
  if (e.head.info.onstack) return flatSearchOstack(g, v, e, M2);
23261
23453
  flatSearchNormal(g, v, e, M2, hascl);
@@ -27158,11 +27350,11 @@ function initSubgraphRankdir(g) {
27158
27350
  var CL_CROSS = 1e3;
27159
27351
  function dotInitNode(n) {
27160
27352
  n.info.UF_size = 1;
27161
- if (!n.info.in) n.info.in = { list: [], size: 0 };
27162
- if (!n.info.out) n.info.out = { list: [], size: 0 };
27163
- if (!n.info.flat_in) n.info.flat_in = { list: [], size: 0 };
27164
- if (!n.info.flat_out) n.info.flat_out = { list: [], size: 0 };
27165
- if (!n.info.other) n.info.other = { list: [], size: 0 };
27353
+ n.info.in = { list: [], size: 0 };
27354
+ n.info.out = { list: [], size: 0 };
27355
+ n.info.flat_in = { list: [], size: 0 };
27356
+ n.info.flat_out = { list: [], size: 0 };
27357
+ n.info.other = { list: [], size: 0 };
27166
27358
  if (n.info.lw === void 0) n.info.lw = 27;
27167
27359
  if (n.info.rw === void 0) n.info.rw = 27;
27168
27360
  if (n.info.ht === void 0) n.info.ht = 36;
@@ -27189,7 +27381,7 @@ function applyNonconstraintZero(e) {
27189
27381
  }
27190
27382
  function dotInitEdge(e) {
27191
27383
  initEdgeConstraint(e);
27192
- e.info.weight = e.attrs.has("weight") ? lateInt(e.attrs.get("weight"), 1, 0) : e.info.weight ?? 1;
27384
+ e.info.weight = lateInt(e.attrs.get("weight"), 1, 0);
27193
27385
  e.info.count = 1;
27194
27386
  e.info.xpenalty = 1;
27195
27387
  applyGroupPenalty(e);
@@ -27219,7 +27411,6 @@ function clearFastGraphLists(n) {
27219
27411
  function dotInitNodeEdge(g) {
27220
27412
  for (const n of nodesInSeq(g)) {
27221
27413
  commonInitNode(n, g);
27222
- clearFastGraphLists(n);
27223
27414
  dotInitNode(n);
27224
27415
  }
27225
27416
  const measurer = g.root.info.gvc?.textMeasurer;
@@ -27239,24 +27430,7 @@ function removeFill(g) {
27239
27430
  }
27240
27431
  agdelsubg(g.root, sg);
27241
27432
  }
27242
- function gvCleanupEdgeLabels(e) {
27243
- e.info.label = void 0;
27244
- e.info.xlabel = void 0;
27245
- e.info.head_label = void 0;
27246
- e.info.tail_label = void 0;
27247
- }
27248
- function gvCleanupNodeLabels(n) {
27249
- n.info.label = void 0;
27250
- n.info.xlabel = void 0;
27251
- }
27252
- function dotCleanupGraph(g) {
27253
- for (const subg of g.subgraphs.values()) dotCleanupGraph(subg);
27254
- if (g !== g.root) g.info.label = void 0;
27255
- }
27256
27433
  function dotCleanup(g) {
27257
- for (const e of g.edges) gvCleanupEdgeLabels(e);
27258
- for (const n2 of g.nodes.values()) gvCleanupNodeLabels(n2);
27259
- dotCleanupGraph(g);
27260
27434
  let n = g.info.nlist;
27261
27435
  while (n !== void 0) {
27262
27436
  const next = n.info.next;
@@ -29704,12 +29878,22 @@ function setGradientFill(obj, color) {
29704
29878
  obj.fill = 2 /* Linear */;
29705
29879
  }
29706
29880
  }
29881
+ var PEN_OF_STYLE = /* @__PURE__ */ new Map([
29882
+ ["solid", 3 /* Solid */],
29883
+ ["dashed", 1 /* Dashed */],
29884
+ ["dotted", 2 /* Dotted */],
29885
+ ["invis", 0 /* None */],
29886
+ ["invisible", 0 /* None */]
29887
+ ]);
29707
29888
  function setStyle(obj, tokens) {
29708
29889
  gvrenderSetStyle(tokens);
29709
29890
  obj.rawStyle = [...tokens];
29710
- const flags = parseStyleFlags(tokens.join(","));
29711
- obj.pen = resolvePenType(flags);
29712
- obj.penWidth = resolvePenWidth(flags, void 0);
29891
+ for (const token of tokens) {
29892
+ const pen = PEN_OF_STYLE.get(styleName(token));
29893
+ if (pen !== void 0) obj.pen = pen;
29894
+ const flags = parseStyleFlags(token);
29895
+ if (flags.bold || flags.setLineWidth !== null) obj.penWidth = resolvePenWidth(flags, void 0);
29896
+ }
29713
29897
  }
29714
29898
  function devicePoints(pts, job) {
29715
29899
  return pts.map((p) => transformPoint({ x: p.x, y: p.y }, job));
@@ -29776,11 +29960,14 @@ function emitXdot(g, renderer, job) {
29776
29960
  for (const op of xd.ops) {
29777
29961
  styled ||= op.kind === "style";
29778
29962
  if (op.kind === "text") continue;
29779
- if (!inClip && isDrawing(op)) continue;
29963
+ if (isDrawing(op) && !drawsNow(obj, inClip)) continue;
29780
29964
  if (!drawOp(op, renderer, job)) stateOp(op, obj, warned2);
29781
29965
  }
29782
29966
  if (styled) setStyle(obj, DEFAULT_LINE_STYLE2);
29783
29967
  }
29968
+ function drawsNow(obj, inClip) {
29969
+ return inClip && obj.pen !== 0 /* None */;
29970
+ }
29784
29971
  function isDrawing(op) {
29785
29972
  return op.kind.endsWith("ellipse") || op.kind.endsWith("polygon") || op.kind.endsWith("bezier") || op.kind === "polyline";
29786
29973
  }
@@ -30742,8 +30929,8 @@ function vnodeNotRelatedTo(g, v) {
30742
30929
  let e = v.info.save_out?.list[0];
30743
30930
  while (e?.info.to_orig) e = e.info.to_orig;
30744
30931
  if (!e) return false;
30745
- if (agContainsNode(g, e.tail)) return false;
30746
- if (agContainsNode(g, e.head)) return false;
30932
+ if (agContainsNode2(g, e.tail)) return false;
30933
+ if (agContainsNode2(g, e.head)) return false;
30747
30934
  return true;
30748
30935
  }
30749
30936
  function keepoutLeft(root, g, r, margin) {
@@ -33274,7 +33461,10 @@ function staleBezierCount(e) {
33274
33461
  return staleBeziersByEdge.get(e) ?? 0;
33275
33462
  }
33276
33463
  function staleAdjacent(e) {
33277
- return staleBezierCount(e) > 0 && (e.info.adjacent ?? 0) !== 0;
33464
+ let rep = e;
33465
+ while (rep.info.to_virt !== void 0 && rep.info.to_virt !== rep) rep = rep.info.to_virt;
33466
+ const samePair = rep.tail === e.tail && rep.head === e.head || rep.tail === e.head && rep.head === e.tail;
33467
+ return staleBezierCount(e) > 0 && ((samePair ? rep : e).info.adjacent ?? 0) !== 0;
33278
33468
  }
33279
33469
  function swapStaleBeziers(g) {
33280
33470
  for (const e of g.edges) {
@@ -33284,8 +33474,13 @@ function swapStaleBeziers(g) {
33284
33474
  const old = spl.list.splice(0, stale).reverse();
33285
33475
  for (const bz of old) swapBezier(bz);
33286
33476
  spl.list.push(...old);
33477
+ fillEdgeArrowSlots(e, old);
33287
33478
  }
33288
33479
  }
33480
+ function fillEdgeArrowSlots(e, old) {
33481
+ e.info.tailArrowOps ??= old.find((bz) => bz.sflag !== 0)?.sArrowOps;
33482
+ e.info.headArrowOps ??= old.find((bz) => bz.eflag !== 0)?.eArrowOps;
33483
+ }
33289
33484
  function rankEdgeInfoOf(g, tailNode, headNode) {
33290
33485
  const rankTable = g.info.rank;
33291
33486
  if (rankTable === void 0) return void 0;
@@ -34992,7 +35187,7 @@ function cloneNode(g, orign) {
34992
35187
  }
34993
35188
  return n;
34994
35189
  }
34995
- function cloneEdge(g, tn, hn, orig) {
35190
+ function cloneEdge2(g, tn, hn, orig) {
34996
35191
  const e = new Edge(tn, hn, orig.name);
34997
35192
  e.info.tail_port = { ...makePort(), ...orig.info.tail_port };
34998
35193
  e.info.head_port = { ...makePort(), ...orig.info.head_port };
@@ -36583,7 +36778,7 @@ function mapArrowOps(ops) {
36583
36778
  return m;
36584
36779
  });
36585
36780
  }
36586
- function mapEdge(e) {
36781
+ function mapEdge2(e) {
36587
36782
  const spl = e.info.spl;
36588
36783
  if (spl === void 0) return;
36589
36784
  mapSpl(spl);
@@ -36646,7 +36841,7 @@ function translateDrawing(g) {
36646
36841
  }
36647
36842
  continue;
36648
36843
  }
36649
- mapEdge(e);
36844
+ mapEdge2(e);
36650
36845
  }
36651
36846
  }
36652
36847
  translateBb(g, g.info.rankdir & 3);
@@ -36785,7 +36980,7 @@ function isPortless(e) {
36785
36980
  return !e.info.tail_port.defined && !e.info.head_port.defined;
36786
36981
  }
36787
36982
  function cloneFlatEdge(auxg, tn, auxt, auxh, orig) {
36788
- return orig.tail === tn ? cloneEdge(auxg, auxt, auxh, orig) : cloneEdge(auxg, auxh, auxt, orig);
36983
+ return orig.tail === tn ? cloneEdge2(auxg, auxt, auxh, orig) : cloneEdge2(auxg, auxh, auxt, orig);
36789
36984
  }
36790
36985
  function flatLeadPair(edges) {
36791
36986
  const t = edges[0].tail, h = edges[0].head;
@@ -36810,7 +37005,7 @@ function buildFlatAux(g, edges, cnt) {
36810
37005
  hvye = new Edge(auxt, auxh, "");
36811
37006
  auxg.edges.push(hvye);
36812
37007
  }
36813
- hvye.info.weight = 1e4;
37008
+ hvye.attrs.set("weight", "10000");
36814
37009
  return { auxg, auxt, auxh, alg };
36815
37010
  }
36816
37011
  function blocksAdjacency(vn) {
@@ -36838,8 +37033,9 @@ function repositionFlatAux(g, edges, aux) {
36838
37033
  else n.info.coord = { x: n.info.coord.x, y: midx };
36839
37034
  }
36840
37035
  }
37036
+ var transformArrowOps = (ops, del, flip) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
36841
37037
  function copyFlatArrow(orig, auxe, del, flip) {
36842
- const xf = (ops) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
37038
+ const xf = (ops) => transformArrowOps(ops, del, flip);
36843
37039
  const eflag = auxe.info.spl?.list[0]?.eflag;
36844
37040
  const head = auxe.info.headArrowOps ?? (eflag ? auxe.info.tailArrowOps : void 0);
36845
37041
  if (head !== void 0) orig.info.headArrowOps = xf(head);
@@ -36864,6 +37060,8 @@ function copyOneFlatSpline(orig, auxe, del, flip, g) {
36864
37060
  bz.eflag = auxbz.eflag;
36865
37061
  bz.sp = transformf(auxbz.sp, del, flip);
36866
37062
  bz.ep = transformf(auxbz.ep, del, flip);
37063
+ if (auxbz.sArrowOps) bz.sArrowOps = transformArrowOps(auxbz.sArrowOps, del, flip);
37064
+ if (auxbz.eArrowOps) bz.eArrowOps = transformArrowOps(auxbz.eArrowOps, del, flip);
36867
37065
  for (let j = 0; j < sz; j++) bz.list[j] = transformf(auxbz.list[j], del, flip);
36868
37066
  const bb = g.info.bb;
36869
37067
  if (bb !== void 0) {
@@ -37515,11 +37713,8 @@ function makeBezierRecord(bezierPts, arrowTip) {
37515
37713
  ep: arrowTip
37516
37714
  };
37517
37715
  }
37518
- function makeSplineRecord(bz) {
37519
- return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
37520
- }
37521
37716
  function installEdgeSpline(e, bezierPts, arrowTip) {
37522
- e.info.spl = makeSplineRecord(makeBezierRecord(bezierPts, arrowTip));
37717
+ Object.assign(newSpline(e, bezierPts.length), makeBezierRecord(bezierPts, arrowTip));
37523
37718
  const bb = e.tail.root.info.bb;
37524
37719
  if (bb != null) {
37525
37720
  for (let i = 0; i + 3 < bezierPts.length; i += 3) {
@@ -38616,7 +38811,7 @@ function makeGraph(n) {
38616
38811
  }
38617
38812
  return { nvs: n, vertices };
38618
38813
  }
38619
- function insertEdge(g, v1, v2) {
38814
+ function insertEdge2(g, v1, v2) {
38620
38815
  if (!edgeExists(g, v1, v2)) {
38621
38816
  g.vertices[v1].adjList.push(v2);
38622
38817
  }
@@ -39543,7 +39738,7 @@ function speFlip(isVert, commCoordMatchesP1, lDirMatchesTarget) {
39543
39738
  }
39544
39739
  function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
39545
39740
  let chan = seg1.isVert ? chanSearch(mp.vchans, seg1.commCoord, seg1.p) : chanSearch(mp.hchans, seg1.commCoord, seg1.p);
39546
- insertEdge(chan.G, seg1.indNo, seg2.indNo);
39741
+ insertEdge2(chan.G, seg1.indNo, seg2.indNo);
39547
39742
  for (let x = 1; x <= hops; x++) {
39548
39743
  const prev1 = nextSeg(seg1, dir1);
39549
39744
  const prev2 = nextSeg(seg2, dir2);
@@ -39553,8 +39748,8 @@ function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
39553
39748
  const target = seg1.isVert ? 2 /* B_LEFT */ : 1 /* B_UP */;
39554
39749
  const flip = speFlip(seg1.isVert, commCoordMatchesP1, lDir === target);
39555
39750
  const edgeSeen = edgeExists(chan.G, seg1.indNo, seg2.indNo);
39556
- if (edgeSeen === flip) insertEdge(nchan.G, prev2.indNo, prev1.indNo);
39557
- else insertEdge(nchan.G, prev1.indNo, prev2.indNo);
39751
+ if (edgeSeen === flip) insertEdge2(nchan.G, prev2.indNo, prev1.indNo);
39752
+ else insertEdge2(nchan.G, prev1.indNo, prev2.indNo);
39558
39753
  chan = nchan;
39559
39754
  seg1 = prev1;
39560
39755
  seg2 = prev2;
@@ -39841,8 +40036,8 @@ function addEdgesInG(cp) {
39841
40036
  for (let y = x + 1; y < size; y++) {
39842
40037
  const cmp = segCmp(cp.segList[x], cp.segList[y]);
39843
40038
  if (cmp === -2) return -1;
39844
- if (cmp > 0) insertEdge(G, x, y);
39845
- else if (cmp === -1) insertEdge(G, y, x);
40039
+ if (cmp > 0) insertEdge2(G, x, y);
40040
+ else if (cmp === -1) insertEdge2(G, y, x);
39846
40041
  }
39847
40042
  }
39848
40043
  return 0;
@@ -40797,7 +40992,7 @@ function fillClustMap(g, map) {
40797
40992
  fillClustMap(cl, map);
40798
40993
  }
40799
40994
  }
40800
- function mkClustMap(g) {
40995
+ function mkClustMap2(g) {
40801
40996
  const map = /* @__PURE__ */ new Map();
40802
40997
  fillClustMap(g, map);
40803
40998
  return map;
@@ -40952,7 +41147,7 @@ function makeCompoundEdge(e, clustMap) {
40952
41147
  if (tailClipped && bez.sflag) restashArrow(e, bez.sp, bez.list[0], true);
40953
41148
  }
40954
41149
  function dotCompoundEdges(g) {
40955
- const clustMap = mkClustMap(g);
41150
+ const clustMap = mkClustMap2(g);
40956
41151
  for (const e of g.edges) makeCompoundEdge(e, clustMap);
40957
41152
  }
40958
41153
 
@@ -41516,20 +41711,33 @@ function copyParentAttrs(parent2, sg) {
41516
41711
  for (const [k, v] of parent2.attrs) sg.attrs.set(k, v);
41517
41712
  return sg;
41518
41713
  }
41714
+ function componentSubgraph(g, nodes, name, reuse) {
41715
+ const existing = reuse ? g.subgraphs.get(name) : void 0;
41716
+ if (existing === void 0) return copyParentAttrs(g, buildSubgraph(g, nodes, name));
41717
+ const members = /* @__PURE__ */ new Set([...existing.nodes.values(), ...nodes]);
41718
+ existing.nodes.clear();
41719
+ for (const n of [...members].sort((a, b) => a.id - b.id)) existing.nodes.set(n.name, n);
41720
+ const ns = new Set(nodes);
41721
+ const have = new Set(existing.edges);
41722
+ for (const e of g.edges) {
41723
+ if (ns.has(e.tail) && ns.has(e.head) && !have.has(e)) existing.edges.push(e);
41724
+ }
41725
+ return existing;
41726
+ }
41519
41727
  function isLegal(p) {
41520
41728
  return /^[A-Za-z0-9_]*$/.test(p);
41521
41729
  }
41522
41730
  function setPrefix(pfx) {
41523
41731
  return pfx == null || !isLegal(pfx) ? "_cc_" : pfx;
41524
41732
  }
41525
- function ccomps(g, pfx) {
41733
+ function ccomps(g, pfx, reuse = true) {
41526
41734
  const visited = /* @__PURE__ */ new Set();
41527
41735
  const result = [];
41528
41736
  let idx = 0;
41529
41737
  for (const n of g.nodes.values()) {
41530
41738
  if (visited.has(n.name)) continue;
41531
41739
  const comp = dfsCollect(g, n, visited);
41532
- result.push(copyParentAttrs(g, buildSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`)));
41740
+ result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, reuse));
41533
41741
  }
41534
41742
  return result;
41535
41743
  }
@@ -41545,12 +41753,12 @@ function pccomps(g, pfx) {
41545
41753
  pinned = true;
41546
41754
  }
41547
41755
  if (pinnedNodes.length > 0) {
41548
- result.push(copyParentAttrs(g, buildSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`)));
41756
+ result.push(componentSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`, true));
41549
41757
  }
41550
41758
  for (const n of g.nodes.values()) {
41551
41759
  if (visited.has(n.name)) continue;
41552
41760
  const comp = dfsCollect(g, n, visited);
41553
- result.push(copyParentAttrs(g, buildSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`)));
41761
+ result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, true));
41554
41762
  }
41555
41763
  return { graphs: result, pinned };
41556
41764
  }
@@ -42003,8 +42211,15 @@ function setEdgeTypeFromAttr(g, defaultValue) {
42003
42211
  else et = edgeTypeFromString(s, defaultValue);
42004
42212
  setEdgeType(g, et);
42005
42213
  }
42214
+ function resetAbomShift(g) {
42215
+ const shift = g.info.abomShift ?? 0;
42216
+ if (shift !== 0) {
42217
+ for (const n of g.nodes.values()) n.info.rank = (n.info.rank ?? 0) - shift;
42218
+ }
42219
+ g.info.abomShift = 0;
42220
+ }
42006
42221
  function dotPhaseInit(g) {
42007
- for (const e of g.edges) e.info.weight = void 0;
42222
+ resetAbomShift(g);
42008
42223
  dotGraphInit(g);
42009
42224
  setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
42010
42225
  setAspect(g);
@@ -42085,6 +42300,7 @@ function doDot(g) {
42085
42300
  } else if (ratioIsNone(g)) {
42086
42301
  pinfo.doSplines = true;
42087
42302
  layoutAndPack(g, comps, pinfo, origOf);
42303
+ for (const comp of comps) resetAbomShift(comp);
42088
42304
  } else {
42089
42305
  dotLayoutPipeline(g);
42090
42306
  }
@@ -42812,6 +43028,109 @@ function buildMask(max) {
42812
43028
  return mask >>> 0;
42813
43029
  }
42814
43030
 
43031
+ // src/common/utils-inputscale.ts
43032
+ var POINTS_PER_INCH4 = 72;
43033
+ function getInputscale(g) {
43034
+ const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
43035
+ return d === 0 ? POINTS_PER_INCH4 : d;
43036
+ }
43037
+ function inputscaleDivisor(g) {
43038
+ const sc = getInputscale(g);
43039
+ return sc > 0 ? sc : 1;
43040
+ }
43041
+
43042
+ // src/layout/neato/init-dim.ts
43043
+ var DFLT_DIM = 2;
43044
+ var MAXDIM = 10;
43045
+ var POINTS_PER_INCH5 = 72;
43046
+ var NUM = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
43047
+ var POS3 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
43048
+ var POS2 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
43049
+ var Z_NUM = new RegExp(`^\\s*${NUM}`);
43050
+ function neatoInitGraphDim(g) {
43051
+ const root = g.root;
43052
+ const outdim = lateInt(root.attrs.get("dimen"), DFLT_DIM, 2);
43053
+ const ndim = Math.min(lateInt(root.attrs.get("dim"), outdim, 2), MAXDIM);
43054
+ root.info.ndim = ndim;
43055
+ root.info.odim = Math.min(outdim, ndim);
43056
+ return ndim;
43057
+ }
43058
+ function ndimOf(g) {
43059
+ return g.root.info.ndim ?? DFLT_DIM;
43060
+ }
43061
+ function jitterD(np, nG, n, ndim) {
43062
+ const pos = np.info.pos;
43063
+ if (pos === void 0) return;
43064
+ for (let k = n; k < ndim; k++) pos[k] = nG * drand48();
43065
+ }
43066
+ function jitter3d(np, nG, ndim) {
43067
+ jitterD(np, nG, 2, ndim);
43068
+ }
43069
+ function nodeAttrDeclared(g, name) {
43070
+ if (g.nodeDefaults.has(name)) return true;
43071
+ for (const n of g.nodes.values()) if (n.attrs.has(name)) return true;
43072
+ for (const sub of g.subgraphs.values()) if (nodeAttrDeclared(sub, name)) return true;
43073
+ return false;
43074
+ }
43075
+ function zDeclared(g) {
43076
+ return nodeAttrDeclared(g.root, "z");
43077
+ }
43078
+ function zValue(np) {
43079
+ return np.attrs.get("z") ?? np.nodeDefaultsSnapshot?.get("z") ?? "";
43080
+ }
43081
+ function scalePos(pvec, ndim, div) {
43082
+ for (let i = 0; i < ndim; i++) pvec[i] = pvec[i] / div;
43083
+ }
43084
+ function userPos3(np, m, nG, ndim) {
43085
+ const pvec = np.info.pos;
43086
+ pvec[0] = Number(m[1]);
43087
+ pvec[1] = Number(m[2]);
43088
+ pvec[2] = Number(m[3]);
43089
+ scalePos(pvec, ndim, inputscaleDivisor(np.root));
43090
+ if (ndim > 3) jitterD(np, nG, 3, ndim);
43091
+ }
43092
+ function userPos2(np, m, nG, ndim) {
43093
+ const pvec = np.info.pos;
43094
+ const div = inputscaleDivisor(np.root);
43095
+ pvec[0] = Number(m[1]);
43096
+ pvec[1] = Number(m[2]);
43097
+ scalePos(pvec, ndim, div);
43098
+ if (ndim <= 2) return;
43099
+ const zm = zDeclared(np.root) ? Z_NUM.exec(zValue(np)) : null;
43100
+ if (zm === null) {
43101
+ jitter3d(np, nG, ndim);
43102
+ return;
43103
+ }
43104
+ pvec[2] = Number(zm[1]) / div;
43105
+ jitterD(np, nG, 3, ndim);
43106
+ }
43107
+ function ensurePos(n, ndim) {
43108
+ if (n.info.pos === void 0 || n.info.pos.length < ndim) n.info.pos = new Array(ndim).fill(0);
43109
+ }
43110
+ function pinRequested(n, c) {
43111
+ const pin = n.attrs.get("pin");
43112
+ return c === "!" || pin !== void 0 && mapbool(pin);
43113
+ }
43114
+ function userPos(n, ndim = DFLT_DIM, nG = n.root.nodes.size) {
43115
+ const p = n.attrs.get("pos");
43116
+ if (p === void 0 || p.length === 0) return false;
43117
+ const m3 = ndim >= 3 ? POS3.exec(p) : null;
43118
+ const m = m3 ?? POS2.exec(p);
43119
+ if (m === null) return false;
43120
+ n.info.posSet = true;
43121
+ ensurePos(n, ndim);
43122
+ if (m3 !== null) userPos3(n, m3, nG, ndim);
43123
+ else userPos2(n, m, nG, ndim);
43124
+ if (pinRequested(n, m[m.length - 1])) n.info.pinned = true;
43125
+ return true;
43126
+ }
43127
+ function addZ(g) {
43128
+ if (ndimOf(g) < 3 || !zDeclared(g)) return;
43129
+ for (const n of g.nodes.values()) {
43130
+ ownAttrs(n).set("z", (POINTS_PER_INCH5 * (n.info.pos?.[2] ?? 0)).toFixed(6));
43131
+ }
43132
+ }
43133
+
42815
43134
  // src/layout/neato/start.ts
42816
43135
  var INIT_SELF = 0;
42817
43136
  var INIT_REGULAR = 1;
@@ -42850,6 +43169,7 @@ function parseStart(p, dflt) {
42850
43169
  return { init, seed };
42851
43170
  }
42852
43171
  function initRegular(g, nG) {
43172
+ const ndim = ndimOf(g);
42853
43173
  let a = 0;
42854
43174
  const da = 2 * Math.PI / nG;
42855
43175
  for (const np of g.nodes.values()) {
@@ -42857,6 +43177,7 @@ function initRegular(g, nG) {
42857
43177
  np.info.posSet = true;
42858
43178
  np.info.pinned = false;
42859
43179
  a += da;
43180
+ if (ndim > 2) jitter3d(np, nG, ndim);
42860
43181
  }
42861
43182
  }
42862
43183
  function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
@@ -43026,12 +43347,17 @@ function fisheryatesShuffle(terms, state3) {
43026
43347
  function hasPos(np) {
43027
43348
  return np.info.posSet === true || np.info.pinned === true;
43028
43349
  }
43350
+ function randompos(np, nG, ndim) {
43351
+ np.info.pos = [nG * drand48(), nG * drand48()];
43352
+ if (ndim > 2) jitter3d(np, nG, ndim);
43353
+ }
43029
43354
  function initialPositions(g, nG = g.nodes.size) {
43030
43355
  if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) return;
43031
43356
  checkStart(g, nG, INIT_RANDOM);
43357
+ const ndim = ndimOf(g);
43032
43358
  for (const np of g.nodes.values()) {
43033
43359
  if (hasPos(np)) continue;
43034
- np.info.pos = [drand48(), drand48()];
43360
+ randompos(np, 1, ndim);
43035
43361
  }
43036
43362
  }
43037
43363
  function computeSchedule(terms, maxIter, epsilon = SGD_EPSILON) {
@@ -43939,7 +44265,6 @@ function mdsModel2(dist5, n, edges) {
43939
44265
  }
43940
44266
 
43941
44267
  // src/layout/neato/kk.ts
43942
- var NDIM = 2;
43943
44268
  var DEFAULT_DAMPING = 0.99;
43944
44269
  var EPSILON_PER_NODE = 1e-4;
43945
44270
  var ITERATIONS_PER_NODE = 100;
@@ -44000,13 +44325,15 @@ function scanGraphMode(g, maxIter) {
44000
44325
  const damp = g.root.attrs.get("Damping");
44001
44326
  const { total, lens } = setEdgeLens(g, nodes);
44002
44327
  const ini = initialDist(g, total, epsilon);
44328
+ const ndim = ndimOf(g);
44003
44329
  const st = {
44004
44330
  n,
44331
+ ndim,
44005
44332
  nodes,
44006
44333
  dist: new Float64Array(n * n).fill(ini),
44007
44334
  spring: new Float64Array(n * n).fill(1),
44008
- sumT: new Float64Array(n * NDIM).fill(1),
44009
- t: new Float64Array(n * n * NDIM),
44335
+ sumT: new Float64Array(n * ndim).fill(1),
44336
+ t: new Float64Array(n * n * ndim),
44010
44337
  damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
44011
44338
  epsilon,
44012
44339
  maxIter,
@@ -44014,9 +44341,10 @@ function scanGraphMode(g, maxIter) {
44014
44341
  };
44015
44342
  return { st, adj: neighbours(g, nodes, lens), ini, lens };
44016
44343
  }
44017
- function randompos(np) {
44344
+ function randompos2(np, ndim) {
44018
44345
  np.info.pos[0] = drand48();
44019
44346
  np.info.pos[1] = drand48();
44347
+ if (ndim > 2) jitter3d(np, 1, ndim);
44020
44348
  }
44021
44349
  function initialPositions2(g, st) {
44022
44350
  const init = checkStart(g, st.n, INIT_RANDOM);
@@ -44024,12 +44352,12 @@ function initialPositions2(g, st) {
44024
44352
  if (init === INIT_SELF) warnStartSelfOnce();
44025
44353
  for (const np of st.nodes) {
44026
44354
  if (np.info.posSet === true || np.info.pinned === true) continue;
44027
- randompos(np);
44355
+ randompos2(np, st.ndim);
44028
44356
  }
44029
44357
  }
44030
- function distvec(p0, p1, del) {
44358
+ function distvec(p0, p1, del, ndim) {
44031
44359
  let dist5 = 0;
44032
- for (let k = 0; k < NDIM; k++) {
44360
+ for (let k = 0; k < ndim; k++) {
44033
44361
  del[k] = p0[k] - p1[k];
44034
44362
  dist5 = fma(del[k], del[k], dist5);
44035
44363
  }
@@ -44047,14 +44375,15 @@ function springFactors(g) {
44047
44375
  return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
44048
44376
  }
44049
44377
  function fillRow(st, i, del) {
44378
+ const { ndim } = st;
44050
44379
  const vi = st.nodes[i];
44051
44380
  for (let j = 0; j < st.n; j++) {
44052
44381
  if (i === j) continue;
44053
- const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
44054
- for (let k = 0; k < NDIM; k++) {
44382
+ const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
44383
+ for (let k = 0; k < ndim; k++) {
44055
44384
  const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
44056
- st.t[(i * st.n + j) * NDIM + k] = v;
44057
- st.sumT[i * NDIM + k] += v;
44385
+ st.t[(i * st.n + j) * ndim + k] = v;
44386
+ st.sumT[i * ndim + k] += v;
44058
44387
  }
44059
44388
  }
44060
44389
  }
@@ -44071,61 +44400,62 @@ function diffeqModel(g, st) {
44071
44400
  }
44072
44401
  }
44073
44402
  st.sumT.fill(0);
44074
- const del = new Float64Array(NDIM);
44403
+ const del = new Float64Array(st.ndim);
44075
44404
  for (let i = 0; i < n; i++) fillRow(st, i, del);
44076
44405
  }
44077
44406
  function updateArrays(st, i) {
44078
- const { n } = st;
44079
- const del = new Float64Array(NDIM);
44407
+ const { n, ndim } = st;
44408
+ const del = new Float64Array(ndim);
44080
44409
  const vi = st.nodes[i];
44081
- for (let k = 0; k < NDIM; k++) st.sumT[i * NDIM + k] = 0;
44410
+ for (let k = 0; k < ndim; k++) st.sumT[i * ndim + k] = 0;
44082
44411
  for (let j = 0; j < n; j++) {
44083
44412
  if (i === j) continue;
44084
- const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
44085
- for (let k = 0; k < NDIM; k++) {
44413
+ const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
44414
+ for (let k = 0; k < ndim; k++) {
44086
44415
  const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
44087
- st.t[(i * n + j) * NDIM + k] = tij;
44088
- st.sumT[i * NDIM + k] += tij;
44089
- const old = st.t[(j * n + i) * NDIM + k];
44090
- st.t[(j * n + i) * NDIM + k] = -tij;
44091
- st.sumT[j * NDIM + k] += -tij - old;
44416
+ st.t[(i * n + j) * ndim + k] = tij;
44417
+ st.sumT[i * ndim + k] += tij;
44418
+ const old = st.t[(j * n + i) * ndim + k];
44419
+ st.t[(j * n + i) * ndim + k] = -tij;
44420
+ st.sumT[j * ndim + k] += -tij - old;
44092
44421
  }
44093
44422
  }
44094
44423
  }
44095
44424
  function d2e(st, m, M2) {
44096
- const { n } = st;
44425
+ const { n, ndim } = st;
44097
44426
  const vn = st.nodes[m];
44098
- const t = new Float64Array(NDIM);
44427
+ const t = new Float64Array(ndim);
44099
44428
  M2.fill(0);
44100
44429
  for (let i = 0; i < n; i++) {
44101
44430
  if (m === i) continue;
44102
44431
  const vi = st.nodes[i];
44103
44432
  let sq = 0;
44104
- for (let k = 0; k < NDIM; k++) {
44433
+ for (let k = 0; k < ndim; k++) {
44105
44434
  t[k] = vn.info.pos[k] - vi.info.pos[k];
44106
44435
  sq = fma(t[k], t[k], sq);
44107
44436
  }
44108
44437
  const scale = 1 / Math.pow(sq, 1.5);
44109
44438
  const K = st.spring[m * n + i];
44110
44439
  const D = st.dist[m * n + i];
44111
- for (let k = 0; k < NDIM; k++) {
44112
- for (let l = 0; l < k; l++) M2[l * NDIM + k] = fma(K * D * t[k] * t[l], scale, M2[l * NDIM + k]);
44440
+ for (let k = 0; k < ndim; k++) {
44441
+ for (let l = 0; l < k; l++) M2[l * ndim + k] = fma(K * D * t[k] * t[l], scale, M2[l * ndim + k]);
44113
44442
  const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
44114
- M2[k * NDIM + k] = fma(K, inner, M2[k * NDIM + k]);
44443
+ M2[k * ndim + k] = fma(K, inner, M2[k * ndim + k]);
44115
44444
  }
44116
44445
  }
44117
- for (let k = 1; k < NDIM; k++) {
44118
- for (let l = 0; l < k; l++) M2[k * NDIM + l] = M2[l * NDIM + k];
44446
+ for (let k = 1; k < ndim; k++) {
44447
+ for (let l = 0; l < k; l++) M2[k * ndim + l] = M2[l * ndim + k];
44119
44448
  }
44120
44449
  }
44121
44450
  function chooseNode(st) {
44122
44451
  if (st.move >= st.maxIter) return -1;
44452
+ const { ndim } = st;
44123
44453
  let max = 0;
44124
44454
  let choice = -1;
44125
44455
  for (let i = 0; i < st.n; i++) {
44126
44456
  if (st.nodes[i].info.pinned === true) continue;
44127
44457
  let m = 0;
44128
- for (let k = 0; k < NDIM; k++) m = fma(st.sumT[i * NDIM + k], st.sumT[i * NDIM + k], m);
44458
+ for (let k = 0; k < ndim; k++) m = fma(st.sumT[i * ndim + k], st.sumT[i * ndim + k], m);
44129
44459
  if (m > max) {
44130
44460
  choice = i;
44131
44461
  max = m;
@@ -44134,14 +44464,15 @@ function chooseNode(st) {
44134
44464
  return max < st.epsilon * st.epsilon ? -1 : choice;
44135
44465
  }
44136
44466
  function moveNode(st, m) {
44137
- const a = new Float64Array(NDIM * NDIM);
44138
- const b = new Float64Array(NDIM);
44139
- const c = new Float64Array(NDIM);
44467
+ const { ndim } = st;
44468
+ const a = new Float64Array(ndim * ndim);
44469
+ const b = new Float64Array(ndim);
44470
+ const c = new Float64Array(ndim);
44140
44471
  d2e(st, m, a);
44141
- for (let i = 0; i < NDIM; i++) c[i] = -st.sumT[m * NDIM + i];
44142
- solve(a, b, c, NDIM);
44472
+ for (let i = 0; i < ndim; i++) c[i] = -st.sumT[m * ndim + i];
44473
+ solve(a, b, c, ndim);
44143
44474
  const pos = st.nodes[m].info.pos;
44144
- for (let i = 0; i < NDIM; i++) {
44475
+ for (let i = 0; i < ndim; i++) {
44145
44476
  b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
44146
44477
  pos[i] += b[i];
44147
44478
  }
@@ -44595,8 +44926,567 @@ function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
44595
44926
  return 0;
44596
44927
  }
44597
44928
 
44598
- // src/layout/neato/stress-kernel.ts
44929
+ // src/layout/neato/embed-graph.ts
44930
+ function saveWeights(graph, n) {
44931
+ return graph[0].ewgts.length === 0 ? null : graph.slice(0, n).map((v) => v.ewgts);
44932
+ }
44933
+ function pivotDistances(node, graph, n, reweightGraph, dist5) {
44934
+ if (reweightGraph) ngdijkstra(node, graph, n, dist5);
44935
+ else bfs(node, graph, n, dist5);
44936
+ }
44937
+ function embedGraph(graph, n, dim, reweightGraph) {
44938
+ const dist5 = new Int32Array(n);
44939
+ const oldWeights = saveWeights(graph, n);
44940
+ const coords = Array.from({ length: dim }, () => new Int32Array(n));
44941
+ if (reweightGraph) computeNewWeights(graph, n);
44942
+ let node = crand() % n;
44943
+ pivotDistances(node, graph, n, reweightGraph, coords[0]);
44944
+ let maxDist = 0;
44945
+ for (let i = 0; i < n; i++) {
44946
+ dist5[i] = coords[0][i];
44947
+ if (dist5[i] > maxDist) {
44948
+ node = i;
44949
+ maxDist = dist5[i];
44950
+ }
44951
+ }
44952
+ for (let i = 1; i < dim; i++) {
44953
+ pivotDistances(node, graph, n, reweightGraph, coords[i]);
44954
+ maxDist = 0;
44955
+ for (let j = 0; j < n; j++) {
44956
+ dist5[j] = Math.min(dist5[j], coords[i][j]);
44957
+ if (dist5[j] > maxDist) {
44958
+ node = j;
44959
+ maxDist = dist5[j];
44960
+ }
44961
+ }
44962
+ }
44963
+ if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
44964
+ return coords;
44965
+ }
44966
+ function centerCoordinate(coords, n, dim) {
44967
+ for (let i = 0; i < dim; i++) {
44968
+ let sum = 0;
44969
+ for (let j = 0; j < n; j++) sum += coords[i][j];
44970
+ const avg = Math.trunc(sum / n);
44971
+ for (let j = 0; j < n; j++) coords[i][j] = coords[i][j] - avg;
44972
+ }
44973
+ }
44974
+
44975
+ // src/layout/neato/matrix-ops-dense.ts
44599
44976
  var fr5 = Math.fround;
44977
+ var P_ITERATION_THRESHOLD = 1e-3;
44978
+ var POWER_LENGTH_FLOOR2 = 1e-10;
44979
+ var GUESS_RANGE = 100;
44980
+ var BLOCK_ROW = 8;
44981
+ function rightMultWithVectorD(matrix, dim1, dim2, vector, result) {
44982
+ const blocked = dim2 - dim2 % BLOCK_ROW;
44983
+ for (let i = 0; i < dim1; i++) {
44984
+ const row = matrix[i];
44985
+ let res = 0;
44986
+ let j = 0;
44987
+ for (; j < blocked; j++) res += row[j] * vector[j];
44988
+ for (; j < dim2; j++) res = fma(row[j], vector[j], res);
44989
+ result[i] = res;
44990
+ }
44991
+ }
44992
+ function rightMultWithVectorTranspose(matrix, dim1, dim2, vector, result) {
44993
+ for (let i = 0; i < dim1; i++) {
44994
+ let res = 0;
44995
+ for (let j = 0; j < dim2; j++) res = fma(matrix[j][i], vector[j], res);
44996
+ result[i] = res;
44997
+ }
44998
+ }
44999
+ function multDenseMat(A3, B2, dim1, dim2, dim3) {
45000
+ const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim3));
45001
+ for (let i = 0; i < dim1; i++) {
45002
+ for (let j = 0; j < dim3; j++) {
45003
+ let sum = 0;
45004
+ for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
45005
+ C6[i][j] = sum;
45006
+ }
45007
+ }
45008
+ return C6;
45009
+ }
45010
+ function multDenseMatD(A3, B2, dim1, dim2, dim3) {
45011
+ const C6 = Array.from({ length: dim1 }, () => new Float64Array(dim3));
45012
+ for (let i = 0; i < dim1; i++) {
45013
+ for (let j = 0; j < dim3; j++) {
45014
+ let sum = 0;
45015
+ for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
45016
+ C6[i][j] = sum;
45017
+ }
45018
+ }
45019
+ return C6;
45020
+ }
45021
+ function multSparseDenseMatTranspose(A3, B2, dim1, dim2) {
45022
+ const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim2));
45023
+ for (let i = 0; i < dim1; i++) {
45024
+ const { edges, ewgts, nedges } = A3[i];
45025
+ for (let j = 0; j < dim2; j++) {
45026
+ let sum = 0;
45027
+ for (let k = 0; k < nedges; k++) sum = fma(fr5(ewgts[k]), B2[j][edges[k]], sum);
45028
+ C6[i][j] = sum;
45029
+ }
45030
+ }
45031
+ return C6;
45032
+ }
45033
+ function orthogonalize(st, i, vec) {
45034
+ for (let j = 0; j < i; j++) {
45035
+ const alpha = -innerProduct(st.n, st.eigs[j], vec, BLOCK_ROW);
45036
+ scadd(vec, st.n - 1, alpha, st.eigs[j]);
45037
+ }
45038
+ }
45039
+ function guess(st, i) {
45040
+ const curr = st.eigs[i];
45041
+ for (let j = 0; j < st.n; j++) curr[j] = crand() % GUESS_RANGE;
45042
+ orthogonalize(st, i, curr);
45043
+ return norm(curr, st.n - 1, BLOCK_NONE);
45044
+ }
45045
+ function iterate(st, i) {
45046
+ const { n, mat, tmpVec, lastVec } = st;
45047
+ const curr = st.eigs[i];
45048
+ let angle;
45049
+ let len;
45050
+ st.iteration = 0;
45051
+ do {
45052
+ st.iteration++;
45053
+ copyVector(n, curr, lastVec);
45054
+ rightMultWithVectorD(mat, n, n, curr, tmpVec);
45055
+ copyVector(n, tmpVec, curr);
45056
+ orthogonalize(st, i, curr);
45057
+ len = norm(curr, n - 1, BLOCK_NONE);
45058
+ if (len < POWER_LENGTH_FLOOR2 || st.iteration > st.maxIterations) return null;
45059
+ vectorsScalarMult(n, curr, 1 / len, curr);
45060
+ angle = innerProduct(n, curr, lastVec, BLOCK_ROW);
45061
+ } while (Math.abs(angle) < st.tol);
45062
+ return angle * len;
45063
+ }
45064
+ function fillNullSpace(st, from, neigs) {
45065
+ for (let i = from; i < neigs; i++) {
45066
+ const len = guess(st, i);
45067
+ vectorsScalarMult(st.n, st.eigs[i], 1 / len, st.eigs[i]);
45068
+ st.evals[i] = 0;
45069
+ }
45070
+ }
45071
+ function sortByEval(st, neigs) {
45072
+ const { n, eigs, evals, tmpVec } = st;
45073
+ for (let i = 0; i < neigs - 1; i++) {
45074
+ let largestIndex = i;
45075
+ let largestEval = evals[largestIndex];
45076
+ for (let j = i + 1; j < neigs; j++) {
45077
+ if (largestEval < evals[j]) {
45078
+ largestIndex = j;
45079
+ largestEval = evals[largestIndex];
45080
+ }
45081
+ }
45082
+ if (largestIndex !== i) {
45083
+ copyVector(n, eigs[i], tmpVec);
45084
+ copyVector(n, eigs[largestIndex], eigs[i]);
45085
+ copyVector(n, tmpVec, eigs[largestIndex]);
45086
+ evals[largestIndex] = evals[i];
45087
+ evals[i] = largestEval;
45088
+ }
45089
+ }
45090
+ }
45091
+ function powerIteration(mat, n, neigsIn, eigs) {
45092
+ const neigs = neigsIn >= n ? n : neigsIn;
45093
+ const st = {
45094
+ mat,
45095
+ n,
45096
+ eigs,
45097
+ evals: new Float64Array(neigs),
45098
+ tmpVec: new Float64Array(n),
45099
+ lastVec: new Float64Array(n),
45100
+ maxIterations: 30 * n,
45101
+ tol: 1 - P_ITERATION_THRESHOLD,
45102
+ iteration: 0
45103
+ };
45104
+ let i = 0;
45105
+ for (; i < neigs; i++) {
45106
+ let len = guess(st, i);
45107
+ while (len < POWER_LENGTH_FLOOR2) len = guess(st, i);
45108
+ vectorsScalarMult(n, eigs[i], 1 / len, eigs[i]);
45109
+ const rayleigh = iterate(st, i);
45110
+ if (rayleigh === null) break;
45111
+ st.evals[i] = rayleigh;
45112
+ }
45113
+ fillNullSpace(st, i, neigs);
45114
+ sortByEval(st, neigs);
45115
+ return st.iteration <= st.maxIterations;
45116
+ }
45117
+
45118
+ // src/layout/neato/closest.ts
45119
+ function greaterPriority2(h, i, j) {
45120
+ const a = h.data[i].dist;
45121
+ const b = h.data[j].dist;
45122
+ return a < b || a === b && crand() % 2 !== 0;
45123
+ }
45124
+ function swap3(h, i, j) {
45125
+ const t = h.data[i];
45126
+ h.data[i] = h.data[j];
45127
+ h.data[j] = t;
45128
+ }
45129
+ function heapify2(h, start) {
45130
+ let i = start;
45131
+ for (; ; ) {
45132
+ const l = 2 * i;
45133
+ const r = 2 * i + 1;
45134
+ let largest = l < h.heapSize && greaterPriority2(h, l, i) ? l : i;
45135
+ if (r < h.heapSize && greaterPriority2(h, r, largest)) largest = r;
45136
+ if (largest === i) break;
45137
+ swap3(h, largest, i);
45138
+ i = largest;
45139
+ }
45140
+ }
45141
+ function initHeap2(place, ordering, n) {
45142
+ const h = { data: [], heapSize: n - 1 };
45143
+ for (let i = 0; i < n - 1; i++) {
45144
+ const left2 = ordering[i];
45145
+ const right2 = ordering[i + 1];
45146
+ h.data.push({ left: left2, right: right2, dist: place[right2] - place[left2] });
45147
+ }
45148
+ for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapify2(h, j);
45149
+ return h;
45150
+ }
45151
+ function extractMax2(h) {
45152
+ if (h.heapSize === 0) return null;
45153
+ const max = h.data[0];
45154
+ h.data[0] = h.data[h.heapSize - 1];
45155
+ h.heapSize--;
45156
+ heapify2(h, 0);
45157
+ return max;
45158
+ }
45159
+ function insert(h, edge) {
45160
+ let i = h.heapSize;
45161
+ h.heapSize++;
45162
+ h.data[i] = edge;
45163
+ while (i > 0 && greaterPriority2(h, i, Math.trunc(i / 2))) {
45164
+ swap3(h, i, Math.trunc(i / 2));
45165
+ i = Math.trunc(i / 2);
45166
+ }
45167
+ }
45168
+ function insertDescendants(s, pair) {
45169
+ const { place, ordering, invOrdering, left: left2, right: right2, heap } = s;
45170
+ const leftIndex = invOrdering[pair.left];
45171
+ const rightIndex = invOrdering[pair.right];
45172
+ if (leftIndex > 0) {
45173
+ const neighbor2 = ordering[leftIndex - 1];
45174
+ if (invOrdering[right2[neighbor2]] < rightIndex) {
45175
+ insert(heap, { left: neighbor2, right: pair.right, dist: place[pair.right] - place[neighbor2] });
45176
+ right2[neighbor2] = pair.right;
45177
+ left2[pair.right] = neighbor2;
45178
+ }
45179
+ }
45180
+ if (rightIndex < s.n - 1) {
45181
+ const neighbor2 = ordering[rightIndex + 1];
45182
+ if (invOrdering[left2[neighbor2]] > leftIndex) {
45183
+ insert(heap, { left: pair.left, right: neighbor2, dist: place[neighbor2] - place[pair.left] });
45184
+ left2[neighbor2] = pair.left;
45185
+ right2[pair.left] = neighbor2;
45186
+ }
45187
+ }
45188
+ }
45189
+ function orderByPlace(place, n) {
45190
+ const ordering = Array.from({ length: n }, (_, i) => i);
45191
+ return gvQsort(ordering, (x, y) => {
45192
+ if (place[x] < place[y]) return -1;
45193
+ if (place[x] > place[y]) return 1;
45194
+ return 0;
45195
+ });
45196
+ }
45197
+ function findClosestPairs(place, n, numPairs) {
45198
+ const ordering = orderByPlace(place, n);
45199
+ const invOrdering = new Int32Array(n);
45200
+ for (let i = 0; i < n; i++) invOrdering[ordering[i]] = i;
45201
+ const left2 = new Int32Array(n);
45202
+ const right2 = new Int32Array(n);
45203
+ const heap = initHeap2(place, ordering, n);
45204
+ for (let i = 1; i < n; i++) left2[ordering[i]] = ordering[i - 1];
45205
+ for (let i = 0; i < n - 1; i++) right2[ordering[i]] = ordering[i + 1];
45206
+ const scan = { place, n, ordering, invOrdering, left: left2, right: right2, heap };
45207
+ const stack = [];
45208
+ for (let i = 0; i < numPairs; i++) {
45209
+ const pair = extractMax2(heap);
45210
+ if (pair === null) break;
45211
+ stack.push(pair);
45212
+ insertDescendants(scan, pair);
45213
+ }
45214
+ return stack;
45215
+ }
45216
+ function addEdge2(graph, u, v) {
45217
+ const gu = graph[u];
45218
+ const gv = graph[v];
45219
+ if (gu.edges.includes(v)) return;
45220
+ gu.edges.push(v);
45221
+ gu.ewgts.push(1);
45222
+ gu.nedges++;
45223
+ gv.edges.push(u);
45224
+ gv.ewgts.push(1);
45225
+ gv.nedges++;
45226
+ gu.ewgts[0]--;
45227
+ gv.ewgts[0]--;
45228
+ }
45229
+ function constructGraph(n, edgesStack) {
45230
+ const graph = Array.from({ length: n }, (_, i) => ({ nedges: 1, edges: [i], ewgts: [0] }));
45231
+ for (let top = edgesStack.length - 1; top >= 0; top--) {
45232
+ addEdge2(graph, edgesStack[top].left, edgesStack[top].right);
45233
+ }
45234
+ return graph;
45235
+ }
45236
+ function closestPairs2Graph(place, n, numPairs) {
45237
+ return constructGraph(n, findClosestPairs(place, n, numPairs));
45238
+ }
45239
+
45240
+ // src/layout/neato/pca.ts
45241
+ var NUM_PAIRS = 4;
45242
+ function pcaAlloc(coords, dim, n, newCoords, newDim) {
45243
+ const eigs = Array.from({ length: newDim }, () => new Float64Array(dim));
45244
+ const DD = Array.from({ length: dim }, () => new Float64Array(dim));
45245
+ for (let i = 0; i < dim; i++) {
45246
+ for (let j = 0; j <= i; j++) {
45247
+ let sum = 0;
45248
+ for (let k = 0; k < n; k++) sum += Math.imul(coords[i][k], coords[j][k]);
45249
+ DD[i][j] = DD[j][i] = sum;
45250
+ }
45251
+ }
45252
+ powerIteration(DD, dim, newDim, eigs);
45253
+ for (let j = 0; j < newDim; j++) {
45254
+ for (let i = 0; i < n; i++) {
45255
+ let sum = 0;
45256
+ for (let k = 0; k < dim; k++) sum = fma(coords[k][i], eigs[j][k], sum);
45257
+ newCoords[j][i] = sum;
45258
+ }
45259
+ }
45260
+ }
45261
+ function iterativePCA1D(coords, dim, n, newDirection) {
45262
+ const laplacian = closestPairs2Graph(coords[0], n, NUM_PAIRS * n);
45263
+ const mat1 = multSparseDenseMatTranspose(laplacian, coords, n, dim);
45264
+ const mat = multDenseMatD(coords, mat1, dim, n, dim);
45265
+ return powerIteration(mat, dim, 1, [newDirection]);
45266
+ }
45267
+
45268
+ // src/layout/neato/stress-subspace.ts
45269
+ var fr6 = Math.fround;
45270
+ var STRESS_PCA_DIM = 50;
45271
+ var MIN_EMBEDDING_PIVOTS = 50;
45272
+ var ZERO_DISTANCE = 1e-30;
45273
+ var STRESS_GUARD = 1e-10;
45274
+ function distanceKD(coords, dim, i, j) {
45275
+ let sum = 0;
45276
+ for (let k = 0; k < dim; k++) {
45277
+ const d = coords[k][i] - coords[k][j];
45278
+ sum = fma(d, d, sum);
45279
+ }
45280
+ return Math.sqrt(sum);
45281
+ }
45282
+ function computeStress1(coords, distances, dim, n, exp) {
45283
+ let sum = 0;
45284
+ for (let i = 0; i < n; i++) {
45285
+ const row = distances[i];
45286
+ for (let j = 0; j < row.nedges; j++) {
45287
+ const node = row.edges[j];
45288
+ if (node <= i) continue;
45289
+ const dist5 = distanceKD(coords, dim, i, node);
45290
+ const Dij = row.edist[j];
45291
+ sum += exp === 2 ? (Dij - dist5) * (Dij - dist5) / (Dij * Dij) : (Dij - dist5) * (Dij - dist5) / Dij;
45292
+ }
45293
+ }
45294
+ return sum;
45295
+ }
45296
+ function nextPivot(dist5, Di, n, from) {
45297
+ let node = from;
45298
+ let maxDist = 0;
45299
+ for (let j = 0; j < n; j++) {
45300
+ dist5[j] = Math.min(dist5[j], Di[j]);
45301
+ if (dist5[j] > maxDist || dist5[j] === maxDist && crand() % (j + 1) === 0) {
45302
+ node = j;
45303
+ maxDist = dist5[j];
45304
+ }
45305
+ }
45306
+ return node;
45307
+ }
45308
+ function selectPivots(graph, n, numCenters, reweightGraph) {
45309
+ const centerIndex = new Int32Array(n).fill(-1);
45310
+ const invCenterIndex = new Int32Array(numCenters);
45311
+ const Dij = Array.from({ length: numCenters }, () => new Int32Array(n));
45312
+ const dist5 = new Int32Array(n);
45313
+ let node = crand() % n;
45314
+ centerIndex[node] = 0;
45315
+ invCenterIndex[0] = node;
45316
+ pivotDistances(node, graph, n, reweightGraph, Dij[0]);
45317
+ let maxDist = 0;
45318
+ for (let i = 0; i < n; i++) {
45319
+ dist5[i] = Dij[0][i];
45320
+ if (dist5[i] > maxDist) {
45321
+ node = i;
45322
+ maxDist = dist5[i];
45323
+ }
45324
+ }
45325
+ for (let i = 1; i < numCenters; i++) {
45326
+ centerIndex[node] = i;
45327
+ invCenterIndex[i] = node;
45328
+ pivotDistances(node, graph, n, reweightGraph, Dij[i]);
45329
+ node = nextPivot(dist5, Dij[i], n, node);
45330
+ }
45331
+ return { centerIndex, invCenterIndex, Dij };
45332
+ }
45333
+ function pivotRow(i, n, Di) {
45334
+ const edges = new Int32Array(n - 1);
45335
+ const edist = new Int32Array(n - 1);
45336
+ for (let j = 0; j < i; j++) {
45337
+ edges[j] = j;
45338
+ edist[j] = Di[j];
45339
+ }
45340
+ for (let j = i + 1; j < n; j++) {
45341
+ edges[j - 1] = j;
45342
+ edist[j - 1] = Di[j];
45343
+ }
45344
+ return { nedges: n - 1, edges, edist };
45345
+ }
45346
+ function nonPivotRow(i, numCenters, p) {
45347
+ const edges = new Int32Array(numCenters);
45348
+ const edist = new Int32Array(numCenters);
45349
+ for (let j = 0; j < numCenters; j++) {
45350
+ edges[j] = p.invCenterIndex[j];
45351
+ edist[j] = p.Dij[j][i];
45352
+ }
45353
+ return { nedges: numCenters, edges, edist };
45354
+ }
45355
+ function buildDistances(n, numCenters, p) {
45356
+ const distances = [];
45357
+ for (let i = 0; i < n; i++) {
45358
+ const index = p.centerIndex[i];
45359
+ distances.push(index >= 0 ? pivotRow(i, n, p.Dij[index]) : nonPivotRow(i, numCenters, p));
45360
+ }
45361
+ return distances;
45362
+ }
45363
+ function buildSparseLaplacian(distances, n, exp) {
45364
+ const lap = [];
45365
+ for (let i = 0; i < n; i++) {
45366
+ const row = distances[i];
45367
+ const edges = [i];
45368
+ const ewgts = [0];
45369
+ let degree = 0;
45370
+ for (let j = 0; j < row.nedges; j++) {
45371
+ const d = fr6(row.edist[j]);
45372
+ const w = exp === 2 ? fr6(-1 / fr6(d * d)) : fr6(-1 / d);
45373
+ edges.push(row.edges[j]);
45374
+ ewgts.push(w);
45375
+ degree -= w;
45376
+ }
45377
+ ewgts[0] = fr6(degree);
45378
+ lap.push({ nedges: row.nedges + 1, edges, ewgts });
45379
+ }
45380
+ return lap;
45381
+ }
45382
+ function initialDirections(subspace, subspaceDim, n, dim) {
45383
+ const storage = new Float64Array(dim * subspaceDim);
45384
+ const directions = Array.from({ length: dim }, (_, k) => storage.subarray(k * subspaceDim, (k + 1) * subspaceDim));
45385
+ if (dim !== 2) {
45386
+ for (let k = 0; k < dim; k++) storage[k * subspaceDim + k] = 1;
45387
+ return directions;
45388
+ }
45389
+ directions[0][0] = 1;
45390
+ if (!iterativePCA1D(subspace, subspaceDim, n, directions[1])) {
45391
+ directions[1].fill(0);
45392
+ directions[1][1] = 1;
45393
+ }
45394
+ return directions;
45395
+ }
45396
+ function computeB(st, k) {
45397
+ const { n, dim, coords, distances, lap, b } = st;
45398
+ const ck = coords[k];
45399
+ for (let i = 0; i < n; i++) {
45400
+ let degree = 0;
45401
+ let bi = 0;
45402
+ const { edges, ewgts, nedges } = lap[i];
45403
+ const edist = distances[i].edist;
45404
+ for (let j = 1; j < nedges; j++) {
45405
+ const node = edges[j];
45406
+ const distIj = distanceKD(coords, dim, i, node);
45407
+ if (distIj > ZERO_DISTANCE) {
45408
+ const Lij = fr6(-ewgts[j] * fr6(edist[j - 1])) / distIj;
45409
+ degree -= Lij;
45410
+ bi = fma(Lij, ck[node], bi);
45411
+ }
45412
+ }
45413
+ b[i] = fma(degree, ck[i], bi);
45414
+ }
45415
+ }
45416
+ function optimizeAxes(st) {
45417
+ const { n, dim, subspaceDim, subspace, matrix, directions, coords, b, bRestricted } = st;
45418
+ for (let k = 0; k < dim; k++) {
45419
+ computeB(st, k);
45420
+ rightMultWithVectorD(subspace, subspaceDim, n, b, bRestricted);
45421
+ const rc = conjugateGradientF(matrix, directions[k], bRestricted, subspaceDim, {
45422
+ tol: TOLERANCE_CG,
45423
+ maxIterations: subspaceDim,
45424
+ ortho1: false
45425
+ });
45426
+ if (rc !== 0) return true;
45427
+ rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
45428
+ }
45429
+ return false;
45430
+ }
45431
+ function optimizeLayout(st, o) {
45432
+ let oldStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
45433
+ let converged = false;
45434
+ let iterations = 0;
45435
+ for (; iterations < o.nIterations && !converged; iterations++) {
45436
+ if (optimizeAxes(st)) return -1;
45437
+ if (iterations % 2 === 0) {
45438
+ const newStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
45439
+ converged = Math.abs(newStress - oldStress) / (newStress + STRESS_GUARD) < o.epsilon;
45440
+ oldStress = newStress;
45441
+ }
45442
+ }
45443
+ return iterations;
45444
+ }
45445
+ function computeSubspace(graph, n, subspaceDim, reweightGraph) {
45446
+ const subspace = Array.from({ length: subspaceDim }, () => new Float64Array(n));
45447
+ const numCentersLocal = Math.min(n, Math.max(2 * subspaceDim, MIN_EMBEDDING_PIVOTS));
45448
+ const fullCoords = embedGraph(graph, n, numCentersLocal, reweightGraph);
45449
+ centerCoordinate(fullCoords, n, numCentersLocal);
45450
+ pcaAlloc(fullCoords, numCentersLocal, n, subspace, subspaceDim);
45451
+ return subspace;
45452
+ }
45453
+ function sparseStressSubspaceMajorizationKD(graph, n, coords, o) {
45454
+ const { dim, exp, reweightGraph, numCenters } = o;
45455
+ const subspaceDim = Math.min(STRESS_PCA_DIM, n);
45456
+ const subspace = computeSubspace(graph, n, subspaceDim, reweightGraph);
45457
+ const oldWeights = saveWeights(graph, n);
45458
+ if (reweightGraph) computeNewWeights(graph, n);
45459
+ const pivots = selectPivots(graph, n, numCenters, reweightGraph);
45460
+ const distances = buildDistances(n, numCenters, pivots);
45461
+ const lap = buildSparseLaplacian(distances, n, exp);
45462
+ const directions = initialDirections(subspace, subspaceDim, n, dim);
45463
+ for (let k = 0; k < dim; k++) {
45464
+ rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
45465
+ }
45466
+ const tmpMat = multSparseDenseMatTranspose(lap, subspace, n, subspaceDim);
45467
+ const matrix = multDenseMat(subspace, tmpMat, subspaceDim, n, subspaceDim);
45468
+ const iterations = optimizeLayout({
45469
+ n,
45470
+ dim,
45471
+ subspaceDim,
45472
+ subspace,
45473
+ distances,
45474
+ lap,
45475
+ matrix,
45476
+ directions,
45477
+ coords,
45478
+ b: new Float64Array(n),
45479
+ bRestricted: new Float64Array(subspaceDim)
45480
+ }, o);
45481
+ if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
45482
+ return iterations;
45483
+ }
45484
+
45485
+ // src/layout/neato/stress-kernel.ts
45486
+ var fr7 = Math.fround;
45487
+ var SMART_SUBSPACE_ITERATIONS = 50;
45488
+ var NUM_PIVOTS_STRESS = 40;
45489
+ var SMART_NOISE = 1e-6;
44600
45490
  function computeApspPacked2(graph, n) {
44601
45491
  const Dij = new Float32Array(n * (n + 1) / 2);
44602
45492
  const Di = new Int32Array(n);
@@ -44620,6 +45510,7 @@ function initLayout(n, dim, coords, nodes) {
44620
45510
  if (hasPos2(np)) {
44621
45511
  coords[0][i] = np.info.pos?.[0] ?? 0;
44622
45512
  coords[1][i] = np.info.pos?.[1] ?? 0;
45513
+ for (let d = 2; d < dim; d++) coords[d][i] = np.info.pos?.[d] ?? 0;
44623
45514
  if (isFixed(np)) pinned = true;
44624
45515
  } else {
44625
45516
  coords[0][i] = drand48();
@@ -44669,7 +45560,7 @@ function buildLap1(lap1, lap2, coords, shape) {
44669
45560
  for (let k = 0; k < dim; k++) {
44670
45561
  const ck = coords[k];
44671
45562
  for (let x = 0; x < len; x++) {
44672
- const tmp = fr5(ck[i] + fr5(-1 * ck[i + 1 + x]));
45563
+ const tmp = fr7(ck[i] + fr7(-1 * ck[i + 1 + x]));
44673
45564
  distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]);
44674
45565
  }
44675
45566
  }
@@ -44682,7 +45573,7 @@ function buildLap1(lap1, lap2, coords, shape) {
44682
45573
  let degree = 0;
44683
45574
  if (exp === 2) {
44684
45575
  for (let j = 0; j < len; j++, count++) {
44685
- const val2 = lap1[count] = fr5(lap1[count] * distAccumulator[j]);
45576
+ const val2 = lap1[count] = fr7(lap1[count] * distAccumulator[j]);
44686
45577
  degree += val2;
44687
45578
  degrees[i + j + 1] = degrees[i + j + 1] - val2;
44688
45579
  }
@@ -44727,19 +45618,50 @@ function solveAxis(st, k, havePinned, nodes) {
44727
45618
  }
44728
45619
  return 0;
44729
45620
  }
45621
+ function smartLayout(smart, n, dCoords, o) {
45622
+ const { dim } = o;
45623
+ const iterations = sparseStressSubspaceMajorizationKD(smart.graph, n, dCoords, {
45624
+ dim,
45625
+ exp: o.opts & OPT_EXP_FLAG,
45626
+ reweightGraph: smart.reweightGraph,
45627
+ nIterations: SMART_SUBSPACE_ITERATIONS,
45628
+ numCenters: NUM_PIVOTS_STRESS,
45629
+ epsilon: o.epsilon
45630
+ });
45631
+ if (iterations < 0) return -1;
45632
+ for (let i = 0; i < dim; i++) {
45633
+ const c = dCoords[i];
45634
+ let max = 1;
45635
+ for (let j = 0; j < n; j++) {
45636
+ if (Math.abs(c[j]) > max) max = Math.abs(c[j]);
45637
+ }
45638
+ for (let j = 0; j < n; j++) c[j] = c[j] / max;
45639
+ for (let j = 0; j < n; j++) c[j] = fma(drand48() - 0.5, SMART_NOISE, c[j]);
45640
+ orthog1(n, c);
45641
+ }
45642
+ return 0;
45643
+ }
45644
+ function initialLayout(n, dCoords, nodes, o) {
45645
+ if (o.smart !== void 0 && (o.opts & OPT_SMART_INIT) !== 0 && n > 1) {
45646
+ return smartLayout(o.smart, n, dCoords, o);
45647
+ }
45648
+ return initLayout(n, o.dim, dCoords, nodes) ? 1 : 0;
45649
+ }
44730
45650
  function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
44731
45651
  const { dim, maxi } = o;
44732
45652
  const exp = o.opts & OPT_EXP_FLAG;
44733
45653
  if (maxi < 0) return 0;
44734
- const havePinned = initLayout(n, dim, dCoords, nodes);
45654
+ const layout2 = initialLayout(n, dCoords, nodes, o);
45655
+ if (layout2 < 0) return -1;
45656
+ const havePinned = layout2 === 1;
44735
45657
  if (n === 1 || maxi === 0) return 0;
44736
45658
  const coords = [];
44737
45659
  for (let i = 0; i < dim; i++) {
44738
45660
  const c = new Float32Array(n);
44739
- for (let j = 0; j < n; j++) c[j] = fr5(dCoords[i][j]);
45661
+ for (let j = 0; j < n; j++) c[j] = fr7(dCoords[i][j]);
44740
45662
  coords.push(c);
44741
45663
  }
44742
- const constantTerm = fr5(n * (n - 1) / 2);
45664
+ const constantTerm = fr7(n * (n - 1) / 2);
44743
45665
  const lap2 = Dij;
44744
45666
  buildLap2(lap2, n, exp);
44745
45667
  const lapLength = n * (n + 1) / 2;
@@ -44761,7 +45683,6 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
44761
45683
  for (; iterations < maxi && !converged; iterations++) {
44762
45684
  buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
44763
45685
  const newStress = computeStress(st);
44764
- if (typeof process !== "undefined" && process.env["STRESS_DEBUG"] && iterations % 5 === 0) console.error(newStress.toFixed(3));
44765
45686
  const change = Math.abs(oldStress - newStress);
44766
45687
  converged = change / oldStress < o.epsilon || newStress < o.epsilon;
44767
45688
  oldStress = newStress;
@@ -44879,7 +45800,7 @@ function stressModelDij(graph, n, model) {
44879
45800
  }
44880
45801
 
44881
45802
  // src/layout/neato/constrained-majorization.ts
44882
- var fr6 = Math.fround;
45803
+ var fr8 = Math.fround;
44883
45804
  var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
44884
45805
  var LEVELS_SEP_TOL = 0.1;
44885
45806
  var ABS_TOL = 0.01;
@@ -44888,18 +45809,15 @@ var FLT_MAX3 = 34028234663852886e22;
44888
45809
  var DBL_MAX = Number.MAX_VALUE;
44889
45810
  var MIN_LEVELS = 1;
44890
45811
  var Y_AXIS = 1;
44891
- function unsupported2(what) {
44892
- throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
44893
- }
44894
45812
  function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
44895
45813
  if (o.maxi < 0) return 0;
44896
45814
  const Dij = stressModelDij(graph, n, o.model);
44897
- if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
44898
45815
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
44899
45816
  dim: o.dim,
44900
45817
  opts: o.opts,
44901
45818
  maxi: o.maxi,
44902
- epsilon: o.epsilon
45819
+ epsilon: o.epsilon,
45820
+ smart: { graph, reweightGraph: o.model === MODEL_SUBSET2 }
44903
45821
  });
44904
45822
  }
44905
45823
  function hasDirectionality(graph, n) {
@@ -44947,14 +45865,6 @@ function plainInitLayers(graph, n, dCoords, nodes, dim) {
44947
45865
  const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, null);
44948
45866
  return h === null ? -1 : h;
44949
45867
  }
44950
- function distanceKD(coords, dim, i, j) {
44951
- let sum = 0;
44952
- for (let k = 0; k < dim; k++) {
44953
- const d = coords[k][i] - coords[k][j];
44954
- sum = fma(d, d, sum);
44955
- }
44956
- return Math.sqrt(sum);
44957
- }
44958
45868
  function scaleDownLayout(dCoords, n, dim) {
44959
45869
  let max = 1;
44960
45870
  for (let i = 0; i < dim; i++) {
@@ -44977,7 +45887,7 @@ function scaleDistances(Dij, dCoords, n, dim) {
44977
45887
  sum2 += distanceKD(dCoords, dim, i, j) / Dij[count];
44978
45888
  }
44979
45889
  }
44980
- const scaleRatio = fr6(sum2 / sum1);
45890
+ const scaleRatio = fr8(sum2 / sum1);
44981
45891
  for (let i = 0; i < length; i++) Dij[i] = Dij[i] * scaleRatio;
44982
45892
  }
44983
45893
  function centerLayout(dCoords, n, dim) {
@@ -45033,7 +45943,7 @@ function buildLap12(st) {
45033
45943
  count++;
45034
45944
  let degree = 0;
45035
45945
  for (let j = 0; j < len; j++, count++) {
45036
- const val2 = fr6(lap1[count] * distAccumulator[j]);
45946
+ const val2 = fr8(lap1[count] * distAccumulator[j]);
45037
45947
  lap1[count] = val2;
45038
45948
  degree += val2;
45039
45949
  degrees[i + j + 1] -= val2;
@@ -46586,8 +47496,8 @@ function genYConstraints(rects, vs) {
46586
47496
  }
46587
47497
 
46588
47498
  // src/layout/neato/quad-prog-vpsc-overlap.ts
46589
- var fr7 = Math.fround;
46590
- var X_GROWTH = fr7(1.0001);
47499
+ var fr9 = Math.fround;
47500
+ var X_GROWTH = fr9(1.0001);
46591
47501
  var BOUNDARY_WIDTH = 1e-4;
46592
47502
  var TMP_CLUSTER_VAR_ID = 123;
46593
47503
  function copyBox(b) {
@@ -46733,7 +47643,7 @@ function generateNonoverlapConstraints(e, a) {
46733
47643
  n -= 2 * a.opt.clusters.nclusters;
46734
47644
  }
46735
47645
  if (a.k === 0) {
46736
- nsizeScale = fr7(nsizeScale * X_GROWTH);
47646
+ nsizeScale = fr9(nsizeScale * X_GROWTH);
46737
47647
  }
46738
47648
  const bb = nodeBoxes(n, nsizeScale, a);
46739
47649
  let csol;
@@ -46796,15 +47706,15 @@ function getNumDigcolaConstraints(levels, numLevels) {
46796
47706
  }
46797
47707
 
46798
47708
  // src/layout/neato/quad-prog-vpsc.ts
46799
- var fr8 = Math.fround;
47709
+ var fr10 = Math.fround;
46800
47710
  var QUAD_PROG_TOL = 1e-4;
46801
47711
  var DUMMY_WEIGHT = 1e-6;
46802
47712
  var VECTOR_BLOCK = 4;
46803
47713
  function rowReduce(row, factor, v, n, acc) {
46804
47714
  const blocked = n - n % VECTOR_BLOCK;
46805
47715
  let j = 0;
46806
- for (; j < blocked; j++) acc = fr8(acc + fr8(fr8(factor * row[j]) * v[j]));
46807
- for (; j < n; j++) acc = fmaf(fr8(factor * row[j]), v[j], acc);
47716
+ for (; j < blocked; j++) acc = fr10(acc + fr10(fr10(factor * row[j]) * v[j]));
47717
+ for (; j < n; j++) acc = fmaf(fr10(factor * row[j]), v[j], acc);
46808
47718
  return acc;
46809
47719
  }
46810
47720
  function project(e, place, n) {
@@ -46822,7 +47732,7 @@ function descentStep(e, b, place, n) {
46822
47732
  const oldPlace = e.fArray2;
46823
47733
  for (let i = 0; i < n; i++) {
46824
47734
  oldPlace[i] = place[i];
46825
- g[i] = rowReduce(A3[i], -2, place, n, fr8(2 * b[i]));
47735
+ g[i] = rowReduce(A3[i], -2, place, n, fr10(2 * b[i]));
46826
47736
  }
46827
47737
  let numerator = 0;
46828
47738
  let denominator = 0;
@@ -46831,7 +47741,7 @@ function descentStep(e, b, place, n) {
46831
47741
  const r = rowReduce(A3[i], 2, g, n, 0);
46832
47742
  denominator = fmaf(-r, g[i], denominator);
46833
47743
  }
46834
- return denominator !== 0 ? -fr8(numerator / denominator) : -1;
47744
+ return denominator !== 0 ? -fr10(numerator / denominator) : -1;
46835
47745
  }
46836
47746
  function lineSearchBeta(e, place, n) {
46837
47747
  const A3 = e.A;
@@ -46839,7 +47749,7 @@ function lineSearchBeta(e, place, n) {
46839
47749
  const oldPlace = e.fArray2;
46840
47750
  const d = e.fArray3;
46841
47751
  for (let i = 0; i < n; i++) {
46842
- d[i] = fr8(place[i] - oldPlace[i]);
47752
+ d[i] = fr10(place[i] - oldPlace[i]);
46843
47753
  }
46844
47754
  let numerator = 0;
46845
47755
  let denominator = 0;
@@ -46848,7 +47758,7 @@ function lineSearchBeta(e, place, n) {
46848
47758
  const r = rowReduce(A3[i], 2, d, n, 0);
46849
47759
  denominator = fmaf(r, d[i], denominator);
46850
47760
  }
46851
- if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return fr8(numerator / denominator);
47761
+ if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return fr10(numerator / denominator);
46852
47762
  return 1;
46853
47763
  }
46854
47764
  function applyBeta(e, place, n, beta) {
@@ -46859,7 +47769,7 @@ function applyBeta(e, place, n, beta) {
46859
47769
  if (beta > 0 && beta < 1) {
46860
47770
  place[i] = fmaf(beta, d[i], oldPlace[i]);
46861
47771
  }
46862
- test = fr8(test + fr8(Math.abs(place[i] - oldPlace[i])));
47772
+ test = fr10(test + fr10(Math.abs(place[i] - oldPlace[i])));
46863
47773
  }
46864
47774
  return test;
46865
47775
  }
@@ -47005,11 +47915,11 @@ function deleteCMajEnvVPSC(e) {
47005
47915
  }
47006
47916
 
47007
47917
  // src/layout/neato/stress-cola.ts
47008
- var fr9 = Math.fround;
47918
+ var fr11 = Math.fround;
47009
47919
  var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
47010
47920
  var FLT_MAX4 = 34028234663852886e22;
47011
- var CLUSTER_WEIGHT_FLOOR = fr9(0.01);
47012
- var STRESS_GUARD = 1e-10;
47921
+ var CLUSTER_WEIGHT_FLOOR = fr11(0.01);
47922
+ var STRESS_GUARD2 = 1e-10;
47013
47923
  var NSIZE_SCALE_STEP = 0.1;
47014
47924
  var NSIZE_SCALE_LIMIT = 0.999;
47015
47925
  var NSIZE_SCALE_ACTIVE = 1e-3;
@@ -47020,7 +47930,7 @@ function maxEdgeLength(graph, n) {
47020
47930
  let maxEdgeLen = 0;
47021
47931
  for (let i = 0; i < n; i++) {
47022
47932
  for (let j = 1; j < graph[i].nedges; j++) {
47023
- maxEdgeLen = fr9(Math.max(graph[i].ewgts[j], maxEdgeLen));
47933
+ maxEdgeLen = fr11(Math.max(graph[i].ewgts[j], maxEdgeLen));
47024
47934
  }
47025
47935
  }
47026
47936
  return maxEdgeLen;
@@ -47072,8 +47982,8 @@ function clusterLaplacian(lap2, n, nclusters, maxEdgeLen) {
47072
47982
  if (i < n && j < n - i) {
47073
47983
  v = lap2[c0++];
47074
47984
  } else if (j === 1 && i % 2 === 1) {
47075
- v = fr9(maxEdgeLen * maxEdgeLen);
47076
- if (v > CLUSTER_WEIGHT_FLOOR) v = fr9(1 / v);
47985
+ v = fr11(maxEdgeLen * maxEdgeLen);
47986
+ if (v > CLUSTER_WEIGHT_FLOOR) v = fr11(1 / v);
47077
47987
  } else {
47078
47988
  v = 0;
47079
47989
  }
@@ -47131,7 +48041,7 @@ function colaState(Dij, origN, dCoords, o, maxEdgeLen) {
47131
48041
  degrees,
47132
48042
  coords: floatCoords(dCoords, o.dim, n, origN),
47133
48043
  /* compute constant term in stress sum which is \sum_{i<j} w_{ij}d_{ij}^2 */
47134
- constantTerm: fr9(n * (n - 1) / 2),
48044
+ constantTerm: fr11(n * (n - 1) / 2),
47135
48045
  b: Array.from({ length: o.dim }, () => new Float32Array(n)),
47136
48046
  tmpCoords: new Float32Array(n),
47137
48047
  distAccumulator: new Float32Array(n)
@@ -47163,7 +48073,7 @@ function buildLap13(st) {
47163
48073
  count++;
47164
48074
  let degree = 0;
47165
48075
  for (let j = 0; j < len; j++, count++) {
47166
- const val2 = lap1[count] = fr9(lap1[count] * st.distAccumulator[j]);
48076
+ const val2 = lap1[count] = fr11(lap1[count] * st.distAccumulator[j]);
47167
48077
  degree += val2;
47168
48078
  degrees[i + j + 1] = degrees[i + j + 1] - val2;
47169
48079
  }
@@ -47198,7 +48108,7 @@ var overlapDue = (opt, nsizeScale) => opt.noverlap === NOVERLAP_CONSTRAINTS && n
47198
48108
  function solveHorizontal(st, e, nsizeScale, opt) {
47199
48109
  if (overlapDue(opt, nsizeScale)) {
47200
48110
  generateNonoverlapConstraints(e, {
47201
- nsizeScale: fr9(nsizeScale),
48111
+ nsizeScale: fr11(nsizeScale),
47202
48112
  coords: st.coords,
47203
48113
  k: 0,
47204
48114
  transitiveClosure: nsizeScale >= TRANSITIVE_CLOSURE_SCALE,
@@ -47217,7 +48127,7 @@ function solveHorizontal(st, e, nsizeScale, opt) {
47217
48127
  }
47218
48128
  function solveVertical(st, e, nsizeScale, opt) {
47219
48129
  if (overlapDue(opt, nsizeScale)) {
47220
- generateNonoverlapConstraints(e, { nsizeScale: fr9(nsizeScale), coords: st.coords, k: 1, transitiveClosure: false, opt });
48130
+ generateNonoverlapConstraints(e, { nsizeScale: fr11(nsizeScale), coords: st.coords, k: 1, transitiveClosure: false, opt });
47221
48131
  }
47222
48132
  if (e.m > 0) {
47223
48133
  if (constrainedMajorizationVpsc(e, st.b[1], st.coords[1], LOCAL_CONSTR_MAJOR_ITERATIONS2) < 0) return -1;
@@ -47226,13 +48136,13 @@ function solveVertical(st, e, nsizeScale, opt) {
47226
48136
  }
47227
48137
  return 0;
47228
48138
  }
47229
- function iterate(st, envs, o, observe) {
48139
+ function iterate2(st, envs, o, observe) {
47230
48140
  const s = { iterations: 0, converged: false, oldStress: Number.MAX_VALUE, nsizeScale: 0 };
47231
48141
  for (; s.iterations < o.maxi && !s.converged; s.iterations++) {
47232
48142
  buildLap13(st);
47233
48143
  const newStress = computeStress2(st);
47234
48144
  observe?.(newStress);
47235
- s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress + STRESS_GUARD) < o.epsilon;
48145
+ s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress + STRESS_GUARD2) < o.epsilon;
47236
48146
  s.oldStress = newStress;
47237
48147
  scaleUpNodes(s, o.maxi, o.opt);
47238
48148
  if (solveHorizontal(st, envs.hor, s.nsizeScale, o.opt) < 0) return -1;
@@ -47246,7 +48156,7 @@ function optimize(st, graph, o, observe) {
47246
48156
  const vrt = initCMajVPSC(st.n, st.lap2, graph, o.opt, o.opt.diredges);
47247
48157
  if (vrt === null) return -1;
47248
48158
  st.lap1 = new Float32Array(st.lapLength);
47249
- const iterations = iterate(st, { hor, vrt }, o, observe);
48159
+ const iterations = iterate2(st, { hor, vrt }, o, observe);
47250
48160
  if (iterations < 0) return iterations;
47251
48161
  deleteCMajEnvVPSC(hor);
47252
48162
  deleteCMajEnvVPSC(vrt);
@@ -47351,7 +48261,7 @@ function realEdges(de) {
47351
48261
  function isNewEdge(de) {
47352
48262
  return de.info.alg === void 0;
47353
48263
  }
47354
- function addEdge2(de, e) {
48264
+ function addEdge3(de, e) {
47355
48265
  const el = de.info.alg;
47356
48266
  if (el === void 0) {
47357
48267
  de.info.alg = [e];
@@ -47899,10 +48809,10 @@ var Cdt = class {
47899
48809
  }
47900
48810
  /** gts_point_locate (guess=NULL): closest_face + barycenter walk. */
47901
48811
  pointLocate(x, y) {
47902
- const guess = this.closestFace(x, y);
47903
- if (guess === null) return null;
47904
- const [bx, by] = this.barycenter(guess);
47905
- return this.pointLocateWalk(bx, by, x, y, guess);
48812
+ const guess2 = this.closestFace(x, y);
48813
+ if (guess2 === null) return null;
48814
+ const [bx, by] = this.barycenter(guess2);
48815
+ return this.pointLocateWalk(bx, by, x, y, guess2);
47906
48816
  }
47907
48817
  // -------------------------------------------------------------------
47908
48818
  // Delaunay insertion (cdt.c: swap_if_in_circle, add_vertex_to_face)
@@ -51779,10 +52689,19 @@ var SMOOTHING_NONE = 0;
51779
52689
  var INT_MAX2 = 2147483647;
51780
52690
  var ELSCHEME_PENALTY2 = 2;
51781
52691
  var EDGE_LABEL_NODE_PREFIX = "|edgelabel|";
52692
+ function sfdpInitDim(g) {
52693
+ const root = g.root;
52694
+ const outdim = lateInt(aggetGraph(g, "dimen"), DFLT_DIM, 2);
52695
+ const ndim = Math.min(lateInt(aggetGraph(g, "dim"), outdim, 2), MAXDIM);
52696
+ root.info.ndim = ndim;
52697
+ root.info.odim = Math.min(outdim, ndim);
52698
+ return ndim;
52699
+ }
51782
52700
  function sfdpInitGraph(g) {
51783
52701
  setEdgeTypeFromAttr(g, EDGETYPE_LINE);
52702
+ const ndim = sfdpInitDim(g);
51784
52703
  commonInitNodeEdge(g);
51785
- for (const n of g.nodes.values()) neatoInitNode(n);
52704
+ for (const n of g.nodes.values()) neatoInitNode(n, ndim);
51786
52705
  const measurer = layoutMeasurer(g);
51787
52706
  if (measurer !== void 0) {
51788
52707
  for (const n of g.nodes.values()) {
@@ -51899,12 +52818,12 @@ function makeMatrix(g) {
51899
52818
  MATRIX_TYPE_REAL
51900
52819
  );
51901
52820
  }
51902
- function getSizes(g, pad) {
51903
- const sizes = new Array(2 * g.nodes.size).fill(0);
52821
+ function getSizes(g, pad, ndim = DFLT_DIM) {
52822
+ const sizes = new Array(ndim * g.nodes.size).fill(0);
51904
52823
  for (const n of g.nodes.values()) {
51905
52824
  const i = n.info.id;
51906
- sizes[i * 2] = (n.info.width ?? 0) * 0.5 + pad.x;
51907
- sizes[i * 2 + 1] = (n.info.height ?? 0) * 0.5 + pad.y;
52825
+ sizes[i * ndim] = (n.info.width ?? 0) * 0.5 + pad.x;
52826
+ sizes[i * ndim + 1] = (n.info.height ?? 0) * 0.5 + pad.y;
51908
52827
  }
51909
52828
  return sizes;
51910
52829
  }
@@ -51928,8 +52847,6 @@ function getPos(g, dim) {
51928
52847
  return pos;
51929
52848
  }
51930
52849
  function sfdpCleanup(g) {
51931
- for (const e of g.edges) gvCleanupEdgeLabels(e);
51932
- for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
51933
52850
  for (const n of g.nodes.values()) {
51934
52851
  n.info.pos = void 0;
51935
52852
  n.info.id = void 0;
@@ -52838,7 +53755,7 @@ var AM_PORTHOYX = 12;
52838
53755
  var SCALE = 10;
52839
53756
  var SCALE2 = SCALE / 2;
52840
53757
  var INT_MAX3 = 2147483647;
52841
- var POINTS_PER_INCH4 = 72;
53758
+ var POINTS_PER_INCH6 = 72;
52842
53759
  function cmpitem(a, b) {
52843
53760
  if (a < b) return -1;
52844
53761
  if (a > b) return 1;
@@ -53066,18 +53983,18 @@ function overlaps(p) {
53066
53983
  return false;
53067
53984
  }
53068
53985
  function initItem(n, margin) {
53069
- const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH4);
53070
- const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH4);
53986
+ const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH6);
53987
+ const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH6);
53071
53988
  const width2 = n.info.width ?? 0;
53072
53989
  const height2 = n.info.height ?? 0;
53073
53990
  let w2;
53074
53991
  let h2;
53075
53992
  if (margin.doAdd) {
53076
- w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH4) + margin.x));
53077
- h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH4) + margin.y));
53993
+ w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH6) + margin.x));
53994
+ h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH6) + margin.y));
53078
53995
  } else {
53079
- w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH4);
53080
- h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH4);
53996
+ w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH6);
53997
+ h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH6);
53081
53998
  }
53082
53999
  return {
53083
54000
  val: 0,
@@ -53112,8 +54029,8 @@ function cAdjust(g, mode) {
53112
54029
  if (!overlaps(nlist)) return 0;
53113
54030
  runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO));
53114
54031
  for (const p of nlist) {
53115
- const x = p.pos.x / POINTS_PER_INCH4 / SCALE;
53116
- const y = p.pos.y / POINTS_PER_INCH4 / SCALE;
54032
+ const x = p.pos.x / POINTS_PER_INCH6 / SCALE;
54033
+ const y = p.pos.y / POINTS_PER_INCH6 / SCALE;
53117
54034
  if (p.np.info.pos) {
53118
54035
  p.np.info.pos[0] = x;
53119
54036
  p.np.info.pos[1] = y;
@@ -53128,10 +54045,10 @@ function cAdjust(g, mode) {
53128
54045
  var POLY_BOX = 1;
53129
54046
  var POLY_CIRCLE = 2;
53130
54047
  var DFLT_SAMPLE2 = 20;
53131
- var POINTS_PER_INCH5 = 72;
54048
+ var POINTS_PER_INCH7 = 72;
53132
54049
  var MIN_SAMPLES = 3;
53133
54050
  function ps2inch2(a) {
53134
- return a / POINTS_PER_INCH5;
54051
+ return a / POINTS_PER_INCH7;
53135
54052
  }
53136
54053
  function isBoxKind(p) {
53137
54054
  return (p.kind & POLY_BOX) !== 0;
@@ -53424,7 +54341,7 @@ function polyOverlap(p, pp, q, qp) {
53424
54341
  // src/layout/neato/adjust-info.ts
53425
54342
  var DEFAULT_VORO_MARGIN = 0.05;
53426
54343
  var INCR = 0.05;
53427
- var POINTS_PER_INCH6 = 72;
54344
+ var POINTS_PER_INCH8 = 72;
53428
54345
  function newInfoState() {
53429
54346
  return {
53430
54347
  nodeInfo: [],
@@ -53479,8 +54396,8 @@ function chkBoundBox(st, graph) {
53479
54396
  function makeInfo(st, graph) {
53480
54397
  const pmargin = { ...sepFactor(graph) };
53481
54398
  if (pmargin.doAdd) {
53482
- pmargin.x /= POINTS_PER_INCH6;
53483
- pmargin.y /= POINTS_PER_INCH6;
54399
+ pmargin.x /= POINTS_PER_INCH8;
54400
+ pmargin.y /= POINTS_PER_INCH8;
53484
54401
  }
53485
54402
  const polyf = pmargin.doAdd ? makeAddPoly : makePoly;
53486
54403
  const info = [];
@@ -53614,7 +54531,7 @@ function sAdjustGraph(g) {
53614
54531
  }
53615
54532
 
53616
54533
  // src/layout/neato/vpsc-adjust.ts
53617
- var POINTS_PER_INCH7 = 72;
54534
+ var POINTS_PER_INCH9 = 72;
53618
54535
  function noClusters() {
53619
54536
  return {
53620
54537
  nvars: 0,
@@ -53640,21 +54557,30 @@ function vpscAdjust(g) {
53640
54557
  noverlap: 2,
53641
54558
  clusters: noClusters(),
53642
54559
  gap: {
53643
- x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH7),
53644
- y: 2 * ((margin.doAdd ? margin.y : DFLT_MARGIN) / POINTS_PER_INCH7)
54560
+ x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH9),
54561
+ y: 2 * ((margin.doAdd ? margin.y : DFLT_MARGIN) / POINTS_PER_INCH9)
53645
54562
  },
53646
54563
  nsize: nodes.map((n) => ({ x: n.info.width, y: n.info.height }))
53647
54564
  };
53648
54565
  removeoverlaps(nodes.length, coords, opt);
53649
54566
  nodes.forEach((n, j) => {
53650
- n.info.pos = [coords[0][j], coords[1][j]];
54567
+ n.info.pos[0] = coords[0][j];
54568
+ n.info.pos[1] = coords[1][j];
53651
54569
  });
53652
54570
  return 0;
53653
54571
  }
53654
54572
 
53655
54573
  // src/layout/neato/fdp-adjust.ts
53656
54574
  var DFLT_MARGIN2 = 4;
53657
- var NDIM2 = 2;
54575
+ function sizesByNdim(sizes2, ndim) {
54576
+ if (ndim === 2) return sizes2;
54577
+ const sizes = new Array(sizes2.length / 2 * ndim).fill(0);
54578
+ for (let i = 0; i < sizes2.length / 2; i++) {
54579
+ sizes[i * ndim] = sizes2[i * 2];
54580
+ sizes[i * ndim + 1] = sizes2[i * 2 + 1];
54581
+ }
54582
+ return sizes;
54583
+ }
53658
54584
  function mapBoolDflt(p, defaultValue) {
53659
54585
  if (p === void 0 || p === "") return defaultValue;
53660
54586
  const s = p.toLowerCase();
@@ -53696,14 +54622,14 @@ function overlapPrismTries(flag) {
53696
54622
  }
53697
54623
  function fdpAdjust(g, ntry) {
53698
54624
  const A0 = makeMatrix(g);
53699
- const pos = new Array(NDIM2 * g.nodes.size).fill(0);
54625
+ const ndim = ndimOf(g);
54626
+ const pos = new Array(ndim * g.nodes.size).fill(0);
53700
54627
  const sep = sepFactor(g);
53701
54628
  const pad = sep.doAdd ? { x: sep.x / 72, y: sep.y / 72 } : { x: DFLT_MARGIN2 / 72, y: DFLT_MARGIN2 / 72 };
53702
- const sizes = getSizes(g, pad);
54629
+ const sizes = sizesByNdim(getSizes(g, pad), ndim);
53703
54630
  for (const n of g.nodes.values()) {
53704
54631
  const i = n.info.id;
53705
- pos[i * NDIM2] = n.info.pos?.[0] ?? 0;
53706
- pos[i * NDIM2 + 1] = n.info.pos?.[1] ?? 0;
54632
+ for (let k = 0; k < ndim; k++) pos[i * ndim + k] = n.info.pos?.[k] ?? 0;
53707
54633
  }
53708
54634
  const A3 = !smIsSymmetric(A0, false) || A0.type !== MATRIX_TYPE_REAL ? smGetRealAdjacencySymmetrized(A0) : smRemoveDiagonal(A0);
53709
54635
  const scaling = lateDouble(
@@ -53715,12 +54641,11 @@ function fdpAdjust(g, ntry) {
53715
54641
  g.attrs.get("overlap_shrink") ?? g.root.attrs.get("overlap_shrink"),
53716
54642
  true
53717
54643
  );
53718
- removeOverlapPrism(NDIM2, A3, pos, sizes, ntry, scaling, doShrinking);
54644
+ removeOverlapPrism(ndim, A3, pos, sizes, ntry, scaling, doShrinking);
53719
54645
  for (const n of g.nodes.values()) {
53720
54646
  const i = n.info.id;
53721
54647
  if (!n.info.pos) n.info.pos = [0, 0];
53722
- n.info.pos[0] = pos[i * NDIM2];
53723
- n.info.pos[1] = pos[i * NDIM2 + 1];
54648
+ for (let k = 0; k < ndim; k++) n.info.pos[k] = pos[i * ndim + k];
53724
54649
  }
53725
54650
  }
53726
54651
  var AM_NONE = 0;
@@ -53814,9 +54739,9 @@ function graphAdjustMode(g) {
53814
54739
  }
53815
54740
 
53816
54741
  // src/layout/neato/ipsep-opts.ts
53817
- var POINTS_PER_INCH8 = 72;
54742
+ var POINTS_PER_INCH10 = 72;
53818
54743
  var HIER_PREFIX = "hier";
53819
- var ps2inch3 = (points2) => points2 / POINTS_PER_INCH8;
54744
+ var ps2inch3 = (points2) => points2 / POINTS_PER_INCH10;
53820
54745
  var zeroBox = () => ({ ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } });
53821
54746
  function memberIndices(subg, nodes) {
53822
54747
  const members = nodesInSeq(subg);
@@ -53895,19 +54820,8 @@ function ipsepOptions(mg, g, nodes, am) {
53895
54820
  return { diredges, edgeGap, noverlap, gap, nsize, clusters };
53896
54821
  }
53897
54822
 
53898
- // src/common/utils-inputscale.ts
53899
- var POINTS_PER_INCH9 = 72;
53900
- function getInputscale(g) {
53901
- const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
53902
- return d === 0 ? POINTS_PER_INCH9 : d;
53903
- }
53904
- function inputscaleDivisor(g) {
53905
- const sc = getInputscale(g);
53906
- return sc > 0 ? sc : 1;
53907
- }
53908
-
53909
54823
  // src/layout/neato/set-aspect.ts
53910
- var POINTS_PER_INCH10 = 72;
54824
+ var POINTS_PER_INCH11 = 72;
53911
54825
  function neatoRatioKind(g) {
53912
54826
  const p = g.attrs.get("ratio");
53913
54827
  if (p === void 0) return null;
@@ -53955,8 +54869,8 @@ function neatoTranslate(g) {
53955
54869
  const bb = g.info.bb;
53956
54870
  if (!bb) return;
53957
54871
  const ll = bb.ll;
53958
- const ox = ll.x / POINTS_PER_INCH10;
53959
- const oy = ll.y / POINTS_PER_INCH10;
54872
+ const ox = ll.x / POINTS_PER_INCH11;
54873
+ const oy = ll.y / POINTS_PER_INCH11;
53960
54874
  for (const n of g.nodes.values()) {
53961
54875
  if (!n.info.pos) n.info.pos = [0, 0];
53962
54876
  n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
@@ -54041,8 +54955,7 @@ var MODEL_SHORTPATH2 = 0;
54041
54955
  var MODEL_CIRCUIT2 = 1;
54042
54956
  var MODEL_SUBSET2 = 2;
54043
54957
  var MODEL_MDS2 = 3;
54044
- var DFLT_DIM = 2;
54045
- var POINTS_PER_INCH11 = 72;
54958
+ var POINTS_PER_INCH12 = 72;
54046
54959
  function neatoInitNode(n, dim = DFLT_DIM) {
54047
54960
  if (!n.info.pos || n.info.pos.length < dim) {
54048
54961
  const pos = [];
@@ -54054,19 +54967,6 @@ function neatoInitNode(n, dim = DFLT_DIM) {
54054
54967
  if (!n.info.width && !plainShaped) n.info.width = 0.75;
54055
54968
  if (!n.info.height && !plainShaped) n.info.height = 0.5;
54056
54969
  }
54057
- function userPos(n) {
54058
- const p = n.attrs.get("pos");
54059
- if (p === void 0 || p.length === 0) return false;
54060
- const num2 = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
54061
- const m = new RegExp(`^\\s*${num2}\\s*,\\s*${num2}(.?)`).exec(p);
54062
- if (m === null) return false;
54063
- const div = inputscaleDivisor(n.root);
54064
- n.info.pos = [Number(m[1]) / div, Number(m[2]) / div];
54065
- n.info.posSet = true;
54066
- const pin = n.attrs.get("pin");
54067
- if (m[3] === "!" || pin !== void 0 && mapbool(pin)) n.info.pinned = true;
54068
- return true;
54069
- }
54070
54970
  function assignNodeIds2(g) {
54071
54971
  const nodeList = [];
54072
54972
  let idx = 0;
@@ -54086,10 +54986,11 @@ function solveStress(c, vtx, dCoords, nodeList) {
54086
54986
  const { g, mode, model, opts } = c;
54087
54987
  const n = nodeList.length;
54088
54988
  const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
54989
+ const dim = ndimOf(g);
54089
54990
  const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
54090
54991
  if (mode === MODE_HIER) {
54091
54992
  return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
54092
- dim: DFLT_DIM,
54993
+ dim,
54093
54994
  opts,
54094
54995
  model,
54095
54996
  maxi,
@@ -54100,7 +55001,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
54100
55001
  if (mode === MODE_IPSEP) {
54101
55002
  const opt = ipsepOptions(g.root, g, nodeList, c.am);
54102
55003
  return stressMajorizationCola(vtx, n, dCoords, nodeList, {
54103
- dim: DFLT_DIM,
55004
+ dim,
54104
55005
  model,
54105
55006
  maxi,
54106
55007
  epsilon,
@@ -54109,7 +55010,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
54109
55010
  }
54110
55011
  const Dij = stressModelDij(vtx, n, model);
54111
55012
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
54112
- dim: DFLT_DIM,
55013
+ dim,
54113
55014
  opts,
54114
55015
  maxi,
54115
55016
  epsilon
@@ -54124,13 +55025,14 @@ function runMajorization(g, mode, model, am) {
54124
55025
  const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
54125
55026
  const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
54126
55027
  const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
54127
- const dCoords = [new Float64Array(n), new Float64Array(n)];
55028
+ const ndim = ndimOf(g);
55029
+ const dCoords = Array.from({ length: ndim }, () => new Float64Array(n));
54128
55030
  if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
54129
55031
  agerr("prev", "layout aborted");
54130
55032
  return;
54131
55033
  }
54132
55034
  for (let i = 0; i < n; i++) {
54133
- nodeList[i].info.pos = [dCoords[0][i], dCoords[1][i]];
55035
+ nodeList[i].info.pos = dCoords.map((c) => c[i]);
54134
55036
  }
54135
55037
  }
54136
55038
  var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
@@ -54153,14 +55055,12 @@ function neatoSetAspect(g) {
54153
55055
  const pos = n.info.pos;
54154
55056
  if (!pos) continue;
54155
55057
  n.info.coord = {
54156
- x: (pos[0] ?? 0) * POINTS_PER_INCH11,
54157
- y: (pos[1] ?? 0) * POINTS_PER_INCH11
55058
+ x: (pos[0] ?? 0) * POINTS_PER_INCH12,
55059
+ y: (pos[1] ?? 0) * POINTS_PER_INCH12
54158
55060
  };
54159
55061
  }
54160
55062
  }
54161
55063
  function neatoCleanup(g) {
54162
- for (const e of g.edges) gvCleanupEdgeLabels(e);
54163
- for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
54164
55064
  for (const [, n] of g.nodes) {
54165
55065
  n.info.pos = void 0;
54166
55066
  n.info.pinned = void 0;
@@ -54172,7 +55072,7 @@ function neatoCleanup(g) {
54172
55072
  }
54173
55073
 
54174
55074
  // src/layout/twopi/init.ts
54175
- var POINTS_PER_INCH12 = 72;
55075
+ var POINTS_PER_INCH13 = 72;
54176
55076
  function makeRdata(INF) {
54177
55077
  return {
54178
55078
  kind: "twopi",
@@ -54224,8 +55124,8 @@ function finaliseCoords(g) {
54224
55124
  const pos = n.info.pos;
54225
55125
  if (!pos) continue;
54226
55126
  n.info.coord = {
54227
- x: (pos[0] ?? 0) * POINTS_PER_INCH12,
54228
- y: (pos[1] ?? 0) * POINTS_PER_INCH12
55127
+ x: (pos[0] ?? 0) * POINTS_PER_INCH13,
55128
+ y: (pos[1] ?? 0) * POINTS_PER_INCH13
54229
55129
  };
54230
55130
  }
54231
55131
  }
@@ -54240,8 +55140,6 @@ function twopiFreeAlg(g) {
54240
55140
  }
54241
55141
  function twopiCleanup(g) {
54242
55142
  if (g.nodes.size === 0) return;
54243
- for (const e of g.edges) gvCleanupEdgeLabels(e);
54244
- for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
54245
55143
  g.info.neato_nlist = void 0;
54246
55144
  }
54247
55145
 
@@ -54463,7 +55361,10 @@ function circleLayout(sg, center) {
54463
55361
  if (center === null) center = findCenterNode(sg);
54464
55362
  if (center === null) return null;
54465
55363
  const maxN = setParentNodes(sg, center);
54466
- if (maxN === Number.MAX_SAFE_INTEGER) return center;
55364
+ if (maxN === Number.MAX_SAFE_INTEGER) {
55365
+ agerrorf("twopi: use of weight=0 creates disconnected component.");
55366
+ return center;
55367
+ }
54467
55368
  setSubtreeSize(sg);
54468
55369
  setSubtreeSpans(sg, center);
54469
55370
  setPositions(sg, center);
@@ -54554,18 +55455,21 @@ function parseModel(g) {
54554
55455
  function maybeRemoveOverlap(g, am) {
54555
55456
  removeOverlapWith(g, am);
54556
55457
  }
54557
- function neatoLayout(g) {
54558
- graphInit(g, false);
54559
- setEdgeTypeFromAttr(g, EDGETYPE_LINE);
54560
- commonInitNodeEdge(g);
55458
+ function neatoInitNodeEdge(g, ndim) {
54561
55459
  for (const [, n] of g.nodes) {
54562
- neatoInitNode(n);
54563
- userPos(n);
55460
+ neatoInitNode(n, ndim);
55461
+ userPos(n, ndim, g.nodes.size);
54564
55462
  }
54565
55463
  const measurer = layoutMeasurer(g);
54566
55464
  if (measurer !== void 0) {
54567
55465
  for (const e of g.edges) initEdgeLabels(e, g, measurer);
54568
55466
  }
55467
+ }
55468
+ function neatoLayout(g) {
55469
+ graphInit(g, false);
55470
+ setEdgeTypeFromAttr(g, EDGETYPE_LINE);
55471
+ commonInitNodeEdge(g);
55472
+ neatoInitNodeEdge(g, neatoInitGraphDim(g));
54569
55473
  const mode = parseMode(g);
54570
55474
  const am = graphAdjustMode(g);
54571
55475
  const model = parseModel(g);
@@ -54577,6 +55481,7 @@ function neatoLayout(g) {
54577
55481
  maybeRemoveOverlap(g, am);
54578
55482
  splineEdgesShifted(g);
54579
55483
  }
55484
+ addZ(g);
54580
55485
  addClusters(g);
54581
55486
  g.info.bb = computeSubgraphBB(g, 0);
54582
55487
  placeGraphLabel(g);
@@ -54768,127 +55673,6 @@ function initParams(g, xpms) {
54768
55673
  return ret;
54769
55674
  }
54770
55675
 
54771
- // src/layout/fdp/cluster-edges.ts
54772
- function fillMap(g, map) {
54773
- const n = g.info.n_cluster ?? 0;
54774
- for (let c = 0; c < n; c++) {
54775
- const cl = g.info.clust[c];
54776
- const s = cl.name;
54777
- if (!map.has(s)) map.set(s, cl);
54778
- fillMap(cl, map);
54779
- }
54780
- }
54781
- function mkClustMap2(g) {
54782
- const map = /* @__PURE__ */ new Map();
54783
- fillMap(g, map);
54784
- return map;
54785
- }
54786
- function mapc(cmap, n) {
54787
- if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
54788
- return null;
54789
- }
54790
- function edgeKey(t, h) {
54791
- return `${t.name}\0${h.name}`;
54792
- }
54793
- function mapEdge2(map, t, h) {
54794
- return map.get(edgeKey(t, h));
54795
- }
54796
- function insertEdge2(map, t, h, ce) {
54797
- map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
54798
- map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
54799
- }
54800
- function clustNode(n, cg, root, delSet, idx) {
54801
- const name = `__${idx.v}:${cg.name}`;
54802
- const cn = agnode(root, name, true);
54803
- cn.info.clustnode = true;
54804
- agsubnode(cg, cn, true);
54805
- delSet.add(n);
54806
- cn.attrs.set("label", "");
54807
- cn.attrs.set("style", "invis");
54808
- cn.attrs.set("shape", "box");
54809
- return cn;
54810
- }
54811
- function cloneEdge2(root, e, ct, ch) {
54812
- const ce = new Edge(ct, ch, "");
54813
- for (const [k, v] of e.attrs) ce.attrs.set(k, v);
54814
- ce.info.compound = 1;
54815
- root.edges.push(ce);
54816
- ce.graphSeq = root.edges.length;
54817
- return ce;
54818
- }
54819
- function checkCompound(e, root, cmap, map, delSet, idx) {
54820
- const t = e.tail;
54821
- const h = e.head;
54822
- if (h.info.clustnode) return 0;
54823
- const tg = mapc(cmap, t);
54824
- const hg = mapc(cmap, h);
54825
- if (!tg && !hg) return 0;
54826
- if (tg === hg) return 0;
54827
- const ip = mapEdge2(map, t, h);
54828
- if (ip) {
54829
- cloneEdge2(root, e, ip.t, ip.h);
54830
- return 1;
54831
- }
54832
- let cn;
54833
- let ce;
54834
- if (hg) {
54835
- if (tg) {
54836
- if (agContains(hg, tg) || agContains(tg, hg)) return 0;
54837
- cn = clustNode(t, tg, root, delSet, idx);
54838
- const cn1 = clustNode(h, hg, root, delSet, idx);
54839
- ce = cloneEdge2(root, e, cn, cn1);
54840
- insertEdge2(map, t, h, ce);
54841
- } else {
54842
- if (agContainsNode2(hg, t)) return 0;
54843
- cn = clustNode(h, hg, root, delSet, idx);
54844
- ce = cloneEdge2(root, e, t, cn);
54845
- insertEdge2(map, t, h, ce);
54846
- }
54847
- } else {
54848
- if (agContainsNode2(tg, h)) return 0;
54849
- cn = clustNode(t, tg, root, delSet, idx);
54850
- ce = cloneEdge2(root, e, cn, h);
54851
- insertEdge2(map, t, h, ce);
54852
- }
54853
- return 1;
54854
- }
54855
- function agContains(a, b) {
54856
- for (let g = b; g !== null; g = g.parent) {
54857
- if (g === a) return true;
54858
- }
54859
- return false;
54860
- }
54861
- function agContainsNode2(cg, n) {
54862
- return cg.nodes.has(n.name);
54863
- }
54864
- function deleteNodeAndEdges(root, n) {
54865
- const purge = (gr) => {
54866
- if (gr.edges.length > 0) {
54867
- gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
54868
- }
54869
- gr.nodes.delete(n.name);
54870
- for (const sg of gr.subgraphs.values()) purge(sg);
54871
- };
54872
- purge(root);
54873
- }
54874
- function processClusterEdges(g) {
54875
- const root = g.root;
54876
- const cmap = mkClustMap2(g);
54877
- if (cmap.size === 0) return;
54878
- const map = /* @__PURE__ */ new Map();
54879
- const delSet = /* @__PURE__ */ new Set();
54880
- const idx = { v: 0 };
54881
- let numClEdges = 0;
54882
- for (const n of [...g.nodes.values()]) {
54883
- if (n.info.clustnode) continue;
54884
- for (const e of n.outEdges(g)) {
54885
- numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
54886
- }
54887
- }
54888
- for (const n of delSet) deleteNodeAndEdges(root, n);
54889
- if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
54890
- }
54891
-
54892
55676
  // src/layout/fdp/init.ts
54893
55677
  function initialPositions3(g) {
54894
55678
  const div = inputscaleDivisor(g);
@@ -54934,18 +55718,7 @@ function fdpInitNodeEdge(g) {
54934
55718
  }
54935
55719
  initialPositions3(g);
54936
55720
  }
54937
- function fdpCleanupSubgs(g) {
54938
- const nClust = g.info.n_cluster ?? 0;
54939
- for (let i = 1; i <= nClust; i++) {
54940
- const subg = g.info.clust[i - 1];
54941
- subg.info.label = void 0;
54942
- fdpCleanupSubgs(subg);
54943
- }
54944
- }
54945
55721
  function fdpCleanup(g) {
54946
- for (const e of g.edges) gvCleanupEdgeLabels(e);
54947
- for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
54948
- fdpCleanupSubgs(g);
54949
55722
  for (const n of g.nodes.values()) {
54950
55723
  n.info.alg = void 0;
54951
55724
  n.info.pos = void 0;
@@ -55757,7 +56530,7 @@ function deriveEdges(g, dg, byPair) {
55757
56530
  dndata(hd).deg++;
55758
56531
  dndata(tl).deg++;
55759
56532
  }
55760
- addEdge2(de, e);
56533
+ addEdge3(de, e);
55761
56534
  }
55762
56535
  }
55763
56536
  }
@@ -55779,7 +56552,7 @@ function derivePort(g, dg, byPair, port, m) {
55779
56552
  const de = deriveEdge(dg, byPair, m, dn);
55780
56553
  de.info.dist = port.e.info.dist;
55781
56554
  de.info.factor = port.e.info.factor;
55782
- addEdge2(de, port.e);
56555
+ addEdge3(de, port.e);
55783
56556
  dndata(dn).wdeg++;
55784
56557
  dndata(m).wdeg++;
55785
56558
  dndata(dn).deg++;
@@ -55889,7 +56662,7 @@ function expandCluster2(n, cg) {
55889
56662
  }
55890
56663
 
55891
56664
  // src/layout/fdp/layout.ts
55892
- var POINTS_PER_INCH13 = 72;
56665
+ var POINTS_PER_INCH14 = 72;
55893
56666
  var DEFAULT_NODEWIDTH_PTS = 54;
55894
56667
  var DEFAULT_NODEHEIGHT_PTS = 36;
55895
56668
  function initInfo(g) {
@@ -55984,7 +56757,7 @@ function shiftComponents(cc, pts, pt) {
55984
56757
  } else {
55985
56758
  p = pt;
55986
56759
  }
55987
- const del = { x: p.x / POINTS_PER_INCH13, y: p.y / POINTS_PER_INCH13 };
56760
+ const del = { x: p.x / POINTS_PER_INCH14, y: p.y / POINTS_PER_INCH14 };
55988
56761
  for (const n of cc[i].nodes.values()) {
55989
56762
  n.info.pos[0] += del.x;
55990
56763
  n.info.pos[1] += del.y;
@@ -56000,8 +56773,8 @@ function finalCC(g, cc, pts, rg, infop) {
56000
56773
  const pt = applyMarginAndBorder(rg, bb, margin);
56001
56774
  if (cc.length > 0) shiftComponents(cc, pts, pt);
56002
56775
  gdata(g).bb = {
56003
- ll: { x: bb.ll.x / POINTS_PER_INCH13, y: bb.ll.y / POINTS_PER_INCH13 },
56004
- ur: { x: bb.ur.x / POINTS_PER_INCH13, y: bb.ur.y / POINTS_PER_INCH13 }
56776
+ ll: { x: bb.ll.x / POINTS_PER_INCH14, y: bb.ll.y / POINTS_PER_INCH14 },
56777
+ ur: { x: bb.ur.x / POINTS_PER_INCH14, y: bb.ur.y / POINTS_PER_INCH14 }
56005
56778
  };
56006
56779
  }
56007
56780
  function applyMarginAndBorder(rg, bb, margin) {
@@ -56047,8 +56820,8 @@ function translateOwnNodes(g, bb) {
56047
56820
  function setBB(g) {
56048
56821
  const bb = gdata(g).bb;
56049
56822
  g.info.bb = {
56050
- ll: { x: POINTS_PER_INCH13 * bb.ll.x, y: POINTS_PER_INCH13 * bb.ll.y },
56051
- ur: { x: POINTS_PER_INCH13 * bb.ur.x, y: POINTS_PER_INCH13 * bb.ur.y }
56823
+ ll: { x: POINTS_PER_INCH14 * bb.ll.x, y: POINTS_PER_INCH14 * bb.ll.y },
56824
+ ur: { x: POINTS_PER_INCH14 * bb.ur.x, y: POINTS_PER_INCH14 * bb.ur.y }
56052
56825
  };
56053
56826
  const nClusters = g.info.n_cluster ?? 0;
56054
56827
  for (let i = 0; i < nClusters; i++) {
@@ -56063,8 +56836,8 @@ function setClustNodes(root) {
56063
56836
  const bb = gdata(p).bb;
56064
56837
  const w = bb.ur.x - bb.ll.x;
56065
56838
  const h = bb.ur.y - bb.ll.y;
56066
- const w2 = POINTS_PER_INCH13 * (w / 2);
56067
- const h2 = POINTS_PER_INCH13 * (h / 2);
56839
+ const w2 = POINTS_PER_INCH14 * (w / 2);
56840
+ const h2 = POINTS_PER_INCH14 * (h / 2);
56068
56841
  n.info.pos[0] = w / 2;
56069
56842
  n.info.pos[1] = h / 2;
56070
56843
  n.info.width = w;
@@ -56073,7 +56846,7 @@ function setClustNodes(root) {
56073
56846
  n.info.outline_width = w + penwidth;
56074
56847
  n.info.outline_height = h + penwidth;
56075
56848
  n.info.lw = n.info.rw = w2;
56076
- n.info.ht = POINTS_PER_INCH13 * h;
56849
+ n.info.ht = POINTS_PER_INCH14 * h;
56077
56850
  const poly = n.info.shape_info;
56078
56851
  if (poly && poly.vertices) {
56079
56852
  poly.vertices[0] = { x: w2, y: h2 };
@@ -56086,8 +56859,8 @@ function setClustNodes(root) {
56086
56859
  function syncCoordFromPos(cg) {
56087
56860
  for (const n of cg.nodes.values()) {
56088
56861
  n.info.coord = {
56089
- x: POINTS_PER_INCH13 * n.info.pos[0],
56090
- y: POINTS_PER_INCH13 * n.info.pos[1]
56862
+ x: POINTS_PER_INCH14 * n.info.pos[0],
56863
+ y: POINTS_PER_INCH14 * n.info.pos[1]
56091
56864
  };
56092
56865
  }
56093
56866
  }
@@ -56099,8 +56872,8 @@ function expandComponentClusters(cg, infop, counter) {
56099
56872
  if (r !== 0) return r;
56100
56873
  n.info.width = gdata(sg).bb.ur.x;
56101
56874
  n.info.height = gdata(sg).bb.ur.y;
56102
- const ptx = POINTS_PER_INCH13 * gdata(sg).bb.ur.x;
56103
- const pty = POINTS_PER_INCH13 * gdata(sg).bb.ur.y;
56875
+ const ptx = POINTS_PER_INCH14 * gdata(sg).bb.ur.x;
56876
+ const pty = POINTS_PER_INCH14 * gdata(sg).bb.ur.y;
56104
56877
  n.info.rw = n.info.lw = ptx / 2;
56105
56878
  n.info.ht = pty;
56106
56879
  } else if (isPort(n)) {
@@ -56664,15 +57437,15 @@ function multilevelSpringElectricalEmbedding(dim, A0, ctrl, labelSizes, x) {
56664
57437
  }
56665
57438
 
56666
57439
  // src/layout/sfdp/index.ts
56667
- var DIM = 2;
56668
57440
  function sfdpLayoutComponent(g, ctrl, pad) {
57441
+ const ndim = ndimOf(g);
56669
57442
  const A3 = makeMatrix(g);
56670
- const sizes = ctrl.overlap >= 0 ? getSizes(g, pad) : null;
56671
- const pos = getPos(g, DIM);
56672
- multilevelSpringElectricalEmbedding(DIM, A3, ctrl, sizes, pos);
57443
+ const sizes = ctrl.overlap >= 0 ? getSizes(g, pad, ndim) : null;
57444
+ const pos = getPos(g, ndim);
57445
+ multilevelSpringElectricalEmbedding(ndim, A3, ctrl, sizes, pos);
56673
57446
  for (const n of g.nodes.values()) {
56674
57447
  const i = n.info.id;
56675
- n.info.pos = [pos[i * DIM], pos[i * DIM + 1]];
57448
+ n.info.pos = pos.slice(i * ndim, (i + 1) * ndim);
56676
57449
  }
56677
57450
  }
56678
57451
  function resolveControl(g) {
@@ -56683,7 +57456,8 @@ function resolveControl(g) {
56683
57456
  const flag = overlap5 === void 0 ? "prism0" : overlap5;
56684
57457
  warnUnrecognizedOverlap(flag);
56685
57458
  const ntry = overlapPrismTries(flag);
56686
- if (ntry !== null) {
57459
+ const doAdjust = ndimOf(g) === 2;
57460
+ if (ntry !== null && doAdjust) {
56687
57461
  ctrl.overlap = ntry;
56688
57462
  ctrl.initialScaling = lateDouble(
56689
57463
  g.root.attrs.get("overlap_scaling"),
@@ -56698,7 +57472,7 @@ function resolveControl(g) {
56698
57472
  return { ctrl, pad, doAdjust: false };
56699
57473
  }
56700
57474
  ctrl.overlap = -1;
56701
- return { ctrl, pad, doAdjust: true };
57475
+ return { ctrl, pad, doAdjust };
56702
57476
  }
56703
57477
  function layoutComponents3(g, comps, ctrl, pad, doAdjust) {
56704
57478
  const pinfo = {
@@ -56746,6 +57520,7 @@ function sfdpLayout(g) {
56746
57520
  } else {
56747
57521
  layoutComponents3(g, comps, ctrl, pad, doAdjust);
56748
57522
  }
57523
+ for (const c of comps) agdelsubg(g, c);
56749
57524
  }
56750
57525
  postprocess(g, singleComponent);
56751
57526
  }
@@ -57659,7 +58434,7 @@ function buildDerivedEdges(g, dg) {
57659
58434
  return edges;
57660
58435
  }
57661
58436
  function derivedComponents(g, dg, allEdges3) {
57662
- const comps = ccomps(g);
58437
+ const comps = ccomps(g, null, false);
57663
58438
  return comps.map((sg, i) => {
57664
58439
  const nodes = [];
57665
58440
  for (const n of sg.nodes.values()) {
@@ -57765,8 +58540,6 @@ function circoLayoutFull(g) {
57765
58540
  }
57766
58541
  function circoCleanup(g) {
57767
58542
  if (g.nodes.size === 0) return;
57768
- for (const e of g.edges) gvCleanupEdgeLabels(e);
57769
- for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
57770
58543
  g.info.alg = void 0;
57771
58544
  g.info.neato_nlist = void 0;
57772
58545
  }
@@ -57795,6 +58568,7 @@ function twopiLayout(g) {
57795
58568
  } else {
57796
58569
  layoutMulti(g, comps, globalRoot, buildPackInfo(g));
57797
58570
  }
58571
+ for (const c of comps) agdelsubg(g, c);
57798
58572
  normalizeGraphBB(g);
57799
58573
  placeGraphLabel(g);
57800
58574
  gvPostprocess(g);
@@ -58052,23 +58826,10 @@ function osageLayout(g) {
58052
58826
  placeGraphLabel(g);
58053
58827
  gvPostprocess(g);
58054
58828
  }
58055
- function cleanupGraphs(g) {
58056
- const nClust = g.info.n_cluster ?? 0;
58057
- for (let i = 1; i <= nClust; i++) {
58058
- const subg = g.info.clust[i - 1];
58059
- subg.info.label = void 0;
58060
- cleanupGraphs(subg);
58061
- }
58062
- g.info.clust = void 0;
58063
- g.info.n_cluster = void 0;
58064
- }
58065
58829
  function osageCleanup(g) {
58066
- for (const e of g.edges) gvCleanupEdgeLabels(e);
58067
- for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
58068
58830
  for (const n of g.nodes.values()) {
58069
58831
  if (n.info.alg?.kind === "osage") n.info.alg = void 0;
58070
58832
  }
58071
- cleanupGraphs(g);
58072
58833
  }
58073
58834
  var OSAGE_LAYOUT_ENGINE = {
58074
58835
  type: "osage",
@@ -58416,8 +59177,6 @@ function patchworkEngineLayout(g) {
58416
59177
  }
58417
59178
  function patchworkEngineCleanup(g) {
58418
59179
  if (g.nodes.size === 0) return;
58419
- for (const e of g.edges) gvCleanupEdgeLabels(e);
58420
- for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
58421
59180
  g.info.clust = void 0;
58422
59181
  g.info.n_cluster = void 0;
58423
59182
  for (const n of g.nodes.values()) {
@@ -58622,8 +59381,8 @@ var forfunc = (cur, total, init) => (1 - cur / total) * init / 2;
58622
59381
  var revfunc = (cur, total, init) => cur / total * init / 2;
58623
59382
  var nonefunc = (_cur, _total, init) => init / 2;
58624
59383
  var bothfunc = (cur, total, init) => {
58625
- const fr10 = cur / total;
58626
- return fr10 <= 0.5 ? fr10 * init : (1 - fr10) * init;
59384
+ const fr12 = cur / total;
59385
+ return fr12 <= 0.5 ? fr12 * init : (1 - fr12) * init;
58627
59386
  };
58628
59387
  function taperfun(dir, directed) {
58629
59388
  if (dir === "forward") return forfunc;
@@ -59485,6 +60244,15 @@ function trimFixed3(v) {
59485
60244
  function edgeAttrsAttached(e) {
59486
60245
  return e.info.edge_type !== IGNORED && e.info.spl != null;
59487
60246
  }
60247
+ function nodePosRaw(n) {
60248
+ const c = n.info.coord;
60249
+ let raw = gfmt5(c.x) + "," + gfmt5(c.y);
60250
+ const odim = n.root.info.odim ?? 2;
60251
+ for (let k = 2; odim >= 3 && k < odim; k++) {
60252
+ raw += "," + gfmt5(POINTS_PER_INCH * (n.info.pos?.[k] ?? 0));
60253
+ }
60254
+ return raw;
60255
+ }
59488
60256
  function appendRecordRects(n, f, out) {
59489
60257
  const c = n.info.coord;
59490
60258
  if (f.n_flds === 0) {
@@ -59956,7 +60724,7 @@ var DotWriterBase = class {
59956
60724
  nodeAttrs(n, scope) {
59957
60725
  const info = n.info;
59958
60726
  const defs = effectiveNodeDefaults2(scope);
59959
- const posRaw = gfmt5(info.coord.x) + "," + gfmt5(info.coord.y);
60727
+ const posRaw = nodePosRaw(n);
59960
60728
  const widthRaw = gfmt5((info.lw + info.rw) / 72);
59961
60729
  const heightRaw = gfmt5(info.ht / 72);
59962
60730
  const parts = [
@@ -60208,13 +60976,13 @@ var EdgeDrawBase = class extends DotWriterBase {
60208
60976
  };
60209
60977
 
60210
60978
  // src/render/dot/write-back.ts
60211
- var POINTS_PER_INCH14 = 72;
60979
+ var POINTS_PER_INCH15 = 72;
60212
60980
  function attachNode(n) {
60213
60981
  const attrs = ownAttrs(n);
60214
60982
  const info = n.info;
60215
- attrs.set("pos", gfmt5(info.coord.x) + "," + gfmt5(info.coord.y));
60216
- attrs.set("height", gfmt5(info.ht / POINTS_PER_INCH14));
60217
- attrs.set("width", gfmt5((info.lw + info.rw) / POINTS_PER_INCH14));
60983
+ attrs.set("pos", nodePosRaw(n));
60984
+ attrs.set("height", gfmt5(info.ht / POINTS_PER_INCH15));
60985
+ attrs.set("width", gfmt5((info.lw + info.rw) / POINTS_PER_INCH15));
60218
60986
  const xlabel = info.xlabel;
60219
60987
  if (xlabel?.set) attrs.set("xlp", lpStr(xlabel.pos));
60220
60988
  if (info.shape?.name === "record") {
@@ -60244,8 +61012,8 @@ function recAttachBb(g) {
60244
61012
  const label = g.info.label;
60245
61013
  if (label && label.text.length > 0) {
60246
61014
  g.attrs.set("lp", lpStr(label.pos));
60247
- g.attrs.set("lwidth", gfmt2(label.dimen.x / POINTS_PER_INCH14));
60248
- g.attrs.set("lheight", gfmt2(label.dimen.y / POINTS_PER_INCH14));
61015
+ g.attrs.set("lwidth", gfmt2(label.dimen.x / POINTS_PER_INCH15));
61016
+ g.attrs.set("lheight", gfmt2(label.dimen.y / POINTS_PER_INCH15));
60249
61017
  }
60250
61018
  for (const sg of clustersOf(g)) recAttachBb(sg);
60251
61019
  }
@@ -61319,7 +62087,7 @@ function insertEdge3(g, root, edge) {
61319
62087
  cur.edges.push(edge);
61320
62088
  }
61321
62089
  }
61322
- function addEdge3(g, tail, head, name) {
62090
+ function addEdge4(g, tail, head, name) {
61323
62091
  requireObject("g", g);
61324
62092
  requireObject("tail", tail);
61325
62093
  requireObject("head", head);
@@ -61456,7 +62224,7 @@ var GraphBuilder = class _GraphBuilder {
61456
62224
  requireAttrs("attrs", attrs);
61457
62225
  const tailNode = resolveNode2(this._graph, tail);
61458
62226
  const headNode = resolveNode2(this._graph, head);
61459
- const edge = addEdge3(this._graph, tailNode, headNode);
62227
+ const edge = addEdge4(this._graph, tailNode, headNode);
61460
62228
  applyAttrs2(edge.attrs, attrs);
61461
62229
  return new EdgeHandle(edge);
61462
62230
  }
@@ -62106,7 +62874,7 @@ export {
62106
62874
  LutTextMeasurer,
62107
62875
  ParseError,
62108
62876
  RenderError,
62109
- addEdge3 as addEdge,
62877
+ addEdge4 as addEdge,
62110
62878
  createGraph,
62111
62879
  getDrawOps,
62112
62880
  getLayout,