@knowvah/dot-engine 2.10.3 → 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 (332) 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 -372
  6. package/dist/index.js.map +4 -4
  7. package/dist/layout/circo/circular.d.ts.map +1 -1
  8. package/dist/layout/dot/edge-route-helpers.d.ts +6 -1
  9. package/dist/layout/dot/edge-route-helpers.d.ts.map +1 -1
  10. package/dist/layout/dot/edge-route-rank.d.ts +4 -1
  11. package/dist/layout/dot/edge-route-rank.d.ts.map +1 -1
  12. package/dist/layout/dot/index.d.ts.map +1 -1
  13. package/dist/layout/dot/init.d.ts.map +1 -1
  14. package/dist/layout/fdp/cluster-edges.d.ts +11 -0
  15. package/dist/layout/fdp/cluster-edges.d.ts.map +1 -1
  16. package/dist/layout/neato/closest.d.ts +20 -0
  17. package/dist/layout/neato/closest.d.ts.map +1 -0
  18. package/dist/layout/neato/constrained-majorization.d.ts +13 -0
  19. package/dist/layout/neato/constrained-majorization.d.ts.map +1 -1
  20. package/dist/layout/neato/embed-graph.d.ts +20 -0
  21. package/dist/layout/neato/embed-graph.d.ts.map +1 -0
  22. package/dist/layout/neato/fdp-adjust.d.ts.map +1 -1
  23. package/dist/layout/neato/index.d.ts.map +1 -1
  24. package/dist/layout/neato/init-dim.d.ts +54 -0
  25. package/dist/layout/neato/init-dim.d.ts.map +1 -0
  26. package/dist/layout/neato/init.d.ts +1 -11
  27. package/dist/layout/neato/init.d.ts.map +1 -1
  28. package/dist/layout/neato/kk.d.ts +4 -2
  29. package/dist/layout/neato/kk.d.ts.map +1 -1
  30. package/dist/layout/neato/matrix-ops-dense.d.ts +34 -0
  31. package/dist/layout/neato/matrix-ops-dense.d.ts.map +1 -0
  32. package/dist/layout/neato/pca.d.ts +14 -0
  33. package/dist/layout/neato/pca.d.ts.map +1 -0
  34. package/dist/layout/neato/sgd.d.ts +2 -3
  35. package/dist/layout/neato/sgd.d.ts.map +1 -1
  36. package/dist/layout/neato/start.d.ts +5 -5
  37. package/dist/layout/neato/start.d.ts.map +1 -1
  38. package/dist/layout/neato/stress-kernel.d.ts +10 -2
  39. package/dist/layout/neato/stress-kernel.d.ts.map +1 -1
  40. package/dist/layout/neato/stress-subspace.d.ts +39 -0
  41. package/dist/layout/neato/stress-subspace.d.ts.map +1 -0
  42. package/dist/layout/neato/vpsc-adjust.d.ts.map +1 -1
  43. package/dist/layout/pack/ccomps.d.ts +4 -2
  44. package/dist/layout/pack/ccomps.d.ts.map +1 -1
  45. package/dist/layout/sfdp/index.d.ts.map +1 -1
  46. package/dist/layout/sfdp/init.d.ts +6 -7
  47. package/dist/layout/sfdp/init.d.ts.map +1 -1
  48. package/dist/layout/twopi/circle.d.ts.map +1 -1
  49. package/dist/layout/twopi/index.d.ts.map +1 -1
  50. package/dist/render/dot/attrs.d.ts +7 -0
  51. package/dist/render/dot/attrs.d.ts.map +1 -1
  52. package/dist/render.js +1574 -755
  53. package/dist/render.js.map +4 -4
  54. package/package.json +4 -4
  55. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.1 +20 -0
  56. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.2 +20 -0
  57. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.3 +20 -0
  58. package/src/gvc/__fixtures__/rerender/abom-shift-pack.gv +1 -0
  59. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.1 +22 -0
  60. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.2 +22 -0
  61. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.3 +22 -0
  62. package/src/gvc/__fixtures__/rerender/abom-shift-parity.gv +1 -0
  63. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.1 +13 -0
  64. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.2 +13 -0
  65. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.3 +13 -0
  66. package/src/gvc/__fixtures__/rerender/abom-shift.gv +1 -0
  67. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.1 +10 -0
  68. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.2 +11 -0
  69. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.gv +9 -0
  70. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.1 +40 -0
  71. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.2 +40 -0
  72. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.1 +15 -0
  73. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.2 +17 -0
  74. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.1 +40 -0
  75. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.2 +15 -0
  76. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.1 +40 -0
  77. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.2 +99 -0
  78. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.1 +489 -0
  79. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.2 +503 -0
  80. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.1 +40 -0
  81. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.2 +109 -0
  82. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.1 +69 -0
  83. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.2 +70 -0
  84. package/src/gvc/__fixtures__/rerender/cluster-edges.gv +15 -0
  85. package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.1 +104 -0
  86. package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.2 +104 -0
  87. package/src/gvc/__fixtures__/rerender/fdp-1581.gv +26 -0
  88. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.1 +34 -0
  89. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.2 +34 -0
  90. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.3 +34 -0
  91. package/src/gvc/__fixtures__/rerender/flat-rev-stale.gv +33 -0
  92. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.1 +181 -0
  93. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.2 +218 -0
  94. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.3 +255 -0
  95. package/src/gvc/__fixtures__/rerender/regen.sh +25 -0
  96. package/src/gvc/context.ts +7 -2
  97. package/src/gvc/emit-xdot.ts +37 -7
  98. package/src/gvc/layout-reset.ts +59 -1
  99. package/src/layout/circo/circular.ts +3 -1
  100. package/src/layout/dot/edge-route-helpers.ts +8 -2
  101. package/src/layout/dot/edge-route-rank.ts +20 -2
  102. package/src/layout/dot/index.ts +17 -2
  103. package/src/layout/dot/init.ts +9 -17
  104. package/src/layout/dot/splines-flat.ts +12 -12
  105. package/src/layout/fdp/cluster-edges.ts +0 -0
  106. package/src/layout/neato/__fixtures__/dim/circuit-dim3.dot +33 -0
  107. package/src/layout/neato/__fixtures__/dim/circuit-dim3.gv +12 -0
  108. package/src/layout/neato/__fixtures__/dim/circuit-dim3.stderr +0 -0
  109. package/src/layout/neato/__fixtures__/dim/circuit-dim3.xdot +54 -0
  110. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.dot +32 -0
  111. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.gv +11 -0
  112. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.stderr +0 -0
  113. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.xdot +53 -0
  114. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.dot +32 -0
  115. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.gv +11 -0
  116. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.stderr +0 -0
  117. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.xdot +53 -0
  118. package/src/layout/neato/__fixtures__/dim/dim3.dot +31 -0
  119. package/src/layout/neato/__fixtures__/dim/dim3.gv +10 -0
  120. package/src/layout/neato/__fixtures__/dim/dim3.stderr +0 -0
  121. package/src/layout/neato/__fixtures__/dim/dim3.xdot +52 -0
  122. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.dot +32 -0
  123. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.gv +11 -0
  124. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.stderr +0 -0
  125. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.xdot +53 -0
  126. package/src/layout/neato/__fixtures__/dim/dimen3.dot +31 -0
  127. package/src/layout/neato/__fixtures__/dim/dimen3.gv +10 -0
  128. package/src/layout/neato/__fixtures__/dim/dimen3.stderr +0 -0
  129. package/src/layout/neato/__fixtures__/dim/dimen3.xdot +52 -0
  130. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.dot +267 -0
  131. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.gv +84 -0
  132. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.stderr +0 -0
  133. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.xdot +468 -0
  134. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.dot +267 -0
  135. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.gv +84 -0
  136. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.stderr +0 -0
  137. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.xdot +468 -0
  138. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.dot +268 -0
  139. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.gv +85 -0
  140. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.stderr +0 -0
  141. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.xdot +469 -0
  142. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.dot +484 -0
  143. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.gv +151 -0
  144. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.stderr +0 -0
  145. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.xdot +852 -0
  146. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.dot +34 -0
  147. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.gv +13 -0
  148. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.stderr +0 -0
  149. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.xdot +55 -0
  150. package/src/layout/neato/__fixtures__/dim/hier-dim3.dot +33 -0
  151. package/src/layout/neato/__fixtures__/dim/hier-dim3.gv +12 -0
  152. package/src/layout/neato/__fixtures__/dim/hier-dim3.stderr +0 -0
  153. package/src/layout/neato/__fixtures__/dim/hier-dim3.xdot +54 -0
  154. package/src/layout/neato/__fixtures__/dim/hier-dim4.dot +33 -0
  155. package/src/layout/neato/__fixtures__/dim/hier-dim4.gv +12 -0
  156. package/src/layout/neato/__fixtures__/dim/hier-dim4.stderr +0 -0
  157. package/src/layout/neato/__fixtures__/dim/hier-dim4.xdot +54 -0
  158. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.dot +32 -0
  159. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.gv +11 -0
  160. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.stderr +0 -0
  161. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.xdot +53 -0
  162. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.dot +34 -0
  163. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.gv +13 -0
  164. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.stderr +0 -0
  165. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.xdot +55 -0
  166. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.dot +37 -0
  167. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.gv +12 -0
  168. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.stderr +0 -0
  169. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.xdot +58 -0
  170. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.dot +141 -0
  171. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.gv +48 -0
  172. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.stderr +1 -0
  173. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.xdot +233 -0
  174. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.dot +21 -0
  175. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.gv +8 -0
  176. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.stderr +1 -0
  177. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.xdot +33 -0
  178. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.dot +23 -0
  179. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.gv +10 -0
  180. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.stderr +1 -0
  181. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.xdot +35 -0
  182. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.dot +23 -0
  183. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.gv +10 -0
  184. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.stderr +1 -0
  185. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.xdot +35 -0
  186. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.dot +26 -0
  187. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.gv +7 -0
  188. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.stderr +0 -0
  189. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.xdot +44 -0
  190. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.dot +28 -0
  191. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.gv +9 -0
  192. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.stderr +0 -0
  193. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.xdot +46 -0
  194. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.dot +48 -0
  195. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.gv +15 -0
  196. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.stderr +0 -0
  197. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.xdot +79 -0
  198. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.dot +56 -0
  199. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.gv +17 -0
  200. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.stderr +0 -0
  201. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.xdot +94 -0
  202. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.dot +47 -0
  203. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.gv +14 -0
  204. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.stderr +0 -0
  205. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.xdot +78 -0
  206. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.dot +34 -0
  207. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.gv +13 -0
  208. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.stderr +0 -0
  209. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.xdot +55 -0
  210. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.dot +34 -0
  211. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.gv +13 -0
  212. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.stderr +0 -0
  213. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.xdot +55 -0
  214. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.dot +34 -0
  215. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.gv +13 -0
  216. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.stderr +0 -0
  217. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.xdot +55 -0
  218. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.dot +15 -0
  219. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.gv +6 -0
  220. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.stderr +0 -0
  221. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.xdot +22 -0
  222. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.dot +33 -0
  223. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.gv +12 -0
  224. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.stderr +0 -0
  225. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.xdot +54 -0
  226. package/src/layout/neato/__fixtures__/dim/kk-dim3.dot +33 -0
  227. package/src/layout/neato/__fixtures__/dim/kk-dim3.gv +12 -0
  228. package/src/layout/neato/__fixtures__/dim/kk-dim3.stderr +0 -0
  229. package/src/layout/neato/__fixtures__/dim/kk-dim3.xdot +54 -0
  230. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.dot +33 -0
  231. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.gv +12 -0
  232. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.stderr +0 -0
  233. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.xdot +54 -0
  234. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.dot +39 -0
  235. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.gv +15 -0
  236. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.stderr +0 -0
  237. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.xdot +60 -0
  238. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.dot +33 -0
  239. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.gv +12 -0
  240. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.stderr +0 -0
  241. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.xdot +54 -0
  242. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.dot +33 -0
  243. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.gv +12 -0
  244. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.stderr +0 -0
  245. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.xdot +54 -0
  246. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.dot +33 -0
  247. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.gv +12 -0
  248. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.stderr +0 -0
  249. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.xdot +54 -0
  250. package/src/layout/neato/__fixtures__/dim/pack-dim3.dot +47 -0
  251. package/src/layout/neato/__fixtures__/dim/pack-dim3.gv +14 -0
  252. package/src/layout/neato/__fixtures__/dim/pack-dim3.stderr +0 -0
  253. package/src/layout/neato/__fixtures__/dim/pack-dim3.xdot +78 -0
  254. package/src/layout/neato/__fixtures__/dim/pins-dim3.dot +38 -0
  255. package/src/layout/neato/__fixtures__/dim/pins-dim3.gv +14 -0
  256. package/src/layout/neato/__fixtures__/dim/pins-dim3.stderr +0 -0
  257. package/src/layout/neato/__fixtures__/dim/pins-dim3.xdot +59 -0
  258. package/src/layout/neato/__fixtures__/dim/regen.sh +24 -0
  259. package/src/layout/neato/__fixtures__/dim/regular-dim3.dot +33 -0
  260. package/src/layout/neato/__fixtures__/dim/regular-dim3.gv +12 -0
  261. package/src/layout/neato/__fixtures__/dim/regular-dim3.stderr +0 -0
  262. package/src/layout/neato/__fixtures__/dim/regular-dim3.xdot +54 -0
  263. package/src/layout/neato/__fixtures__/dim/sgd-dim3.dot +33 -0
  264. package/src/layout/neato/__fixtures__/dim/sgd-dim3.gv +12 -0
  265. package/src/layout/neato/__fixtures__/dim/sgd-dim3.stderr +0 -0
  266. package/src/layout/neato/__fixtures__/dim/sgd-dim3.xdot +54 -0
  267. package/src/layout/neato/__fixtures__/dim/smart-units.json +16 -0
  268. package/src/layout/neato/__fixtures__/dim/subset-dim3.dot +33 -0
  269. package/src/layout/neato/__fixtures__/dim/subset-dim3.gv +12 -0
  270. package/src/layout/neato/__fixtures__/dim/subset-dim3.stderr +0 -0
  271. package/src/layout/neato/__fixtures__/dim/subset-dim3.xdot +54 -0
  272. package/src/layout/neato/closest.ts +206 -0
  273. package/src/layout/neato/constrained-majorization.ts +4 -23
  274. package/src/layout/neato/embed-graph.ts +81 -0
  275. package/src/layout/neato/fdp-adjust.ts +22 -8
  276. package/src/layout/neato/index.ts +26 -17
  277. package/src/layout/neato/init-dim.ts +165 -0
  278. package/src/layout/neato/init.ts +9 -35
  279. package/src/layout/neato/kk.ts +47 -41
  280. package/src/layout/neato/matrix-ops-dense.ts +232 -0
  281. package/src/layout/neato/pca.ts +60 -0
  282. package/src/layout/neato/sgd.ts +11 -4
  283. package/src/layout/neato/start.ts +8 -5
  284. package/src/layout/neato/stress-kernel.ts +65 -5
  285. package/src/layout/neato/stress-subspace.ts +371 -0
  286. package/src/layout/neato/vpsc-adjust.ts +3 -1
  287. package/src/layout/pack/__fixtures__/cc-reuse/circo.dot +23 -0
  288. package/src/layout/pack/__fixtures__/cc-reuse/circo.gv +1 -0
  289. package/src/layout/pack/__fixtures__/cc-reuse/circo.stderr +0 -0
  290. package/src/layout/pack/__fixtures__/cc-reuse/circo.xdot +38 -0
  291. package/src/layout/pack/__fixtures__/cc-reuse/neato.dot +23 -0
  292. package/src/layout/pack/__fixtures__/cc-reuse/neato.gv +1 -0
  293. package/src/layout/pack/__fixtures__/cc-reuse/neato.stderr +0 -0
  294. package/src/layout/pack/__fixtures__/cc-reuse/neato.xdot +38 -0
  295. package/src/layout/pack/__fixtures__/cc-reuse/osage.dot +23 -0
  296. package/src/layout/pack/__fixtures__/cc-reuse/osage.gv +1 -0
  297. package/src/layout/pack/__fixtures__/cc-reuse/osage.stderr +0 -0
  298. package/src/layout/pack/__fixtures__/cc-reuse/osage.xdot +38 -0
  299. package/src/layout/pack/__fixtures__/cc-reuse/regen.sh +24 -0
  300. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.dot +21 -0
  301. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.gv +1 -0
  302. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.stderr +0 -0
  303. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.xdot +36 -0
  304. package/src/layout/pack/__fixtures__/cc-reuse/twopi.dot +21 -0
  305. package/src/layout/pack/__fixtures__/cc-reuse/twopi.gv +1 -0
  306. package/src/layout/pack/__fixtures__/cc-reuse/twopi.stderr +1 -0
  307. package/src/layout/pack/__fixtures__/cc-reuse/twopi.xdot +36 -0
  308. package/src/layout/pack/ccomps.ts +34 -6
  309. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.dot +32 -0
  310. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.gv +11 -0
  311. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.stderr +0 -0
  312. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.xdot +53 -0
  313. package/src/layout/sfdp/__fixtures__/dim/dim3.dot +31 -0
  314. package/src/layout/sfdp/__fixtures__/dim/dim3.gv +10 -0
  315. package/src/layout/sfdp/__fixtures__/dim/dim3.stderr +0 -0
  316. package/src/layout/sfdp/__fixtures__/dim/dim3.xdot +52 -0
  317. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.dot +32 -0
  318. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.gv +11 -0
  319. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.stderr +0 -0
  320. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.xdot +53 -0
  321. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.dot +33 -0
  322. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.gv +12 -0
  323. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.stderr +0 -0
  324. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.xdot +54 -0
  325. package/src/layout/sfdp/__fixtures__/dim/regen.sh +24 -0
  326. package/src/layout/sfdp/index.ts +15 -10
  327. package/src/layout/sfdp/init.ts +26 -11
  328. package/src/layout/twopi/circle.ts +5 -1
  329. package/src/layout/twopi/index.ts +3 -0
  330. package/src/render/dot/agwrite.ts +2 -2
  331. package/src/render/dot/attrs.ts +16 -0
  332. 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;
@@ -29687,12 +29878,22 @@ function setGradientFill(obj, color) {
29687
29878
  obj.fill = 2 /* Linear */;
29688
29879
  }
29689
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
+ ]);
29690
29888
  function setStyle(obj, tokens) {
29691
29889
  gvrenderSetStyle(tokens);
29692
29890
  obj.rawStyle = [...tokens];
29693
- const flags = parseStyleFlags(tokens.join(","));
29694
- obj.pen = resolvePenType(flags);
29695
- 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
+ }
29696
29897
  }
29697
29898
  function devicePoints(pts, job) {
29698
29899
  return pts.map((p) => transformPoint({ x: p.x, y: p.y }, job));
@@ -29759,11 +29960,14 @@ function emitXdot(g, renderer, job) {
29759
29960
  for (const op of xd.ops) {
29760
29961
  styled ||= op.kind === "style";
29761
29962
  if (op.kind === "text") continue;
29762
- if (!inClip && isDrawing(op)) continue;
29963
+ if (isDrawing(op) && !drawsNow(obj, inClip)) continue;
29763
29964
  if (!drawOp(op, renderer, job)) stateOp(op, obj, warned2);
29764
29965
  }
29765
29966
  if (styled) setStyle(obj, DEFAULT_LINE_STYLE2);
29766
29967
  }
29968
+ function drawsNow(obj, inClip) {
29969
+ return inClip && obj.pen !== 0 /* None */;
29970
+ }
29767
29971
  function isDrawing(op) {
29768
29972
  return op.kind.endsWith("ellipse") || op.kind.endsWith("polygon") || op.kind.endsWith("bezier") || op.kind === "polyline";
29769
29973
  }
@@ -30725,8 +30929,8 @@ function vnodeNotRelatedTo(g, v) {
30725
30929
  let e = v.info.save_out?.list[0];
30726
30930
  while (e?.info.to_orig) e = e.info.to_orig;
30727
30931
  if (!e) return false;
30728
- if (agContainsNode(g, e.tail)) return false;
30729
- if (agContainsNode(g, e.head)) return false;
30932
+ if (agContainsNode2(g, e.tail)) return false;
30933
+ if (agContainsNode2(g, e.head)) return false;
30730
30934
  return true;
30731
30935
  }
30732
30936
  function keepoutLeft(root, g, r, margin) {
@@ -33257,7 +33461,10 @@ function staleBezierCount(e) {
33257
33461
  return staleBeziersByEdge.get(e) ?? 0;
33258
33462
  }
33259
33463
  function staleAdjacent(e) {
33260
- 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;
33261
33468
  }
33262
33469
  function swapStaleBeziers(g) {
33263
33470
  for (const e of g.edges) {
@@ -33267,8 +33474,13 @@ function swapStaleBeziers(g) {
33267
33474
  const old = spl.list.splice(0, stale).reverse();
33268
33475
  for (const bz of old) swapBezier(bz);
33269
33476
  spl.list.push(...old);
33477
+ fillEdgeArrowSlots(e, old);
33270
33478
  }
33271
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
+ }
33272
33484
  function rankEdgeInfoOf(g, tailNode, headNode) {
33273
33485
  const rankTable = g.info.rank;
33274
33486
  if (rankTable === void 0) return void 0;
@@ -34975,7 +35187,7 @@ function cloneNode(g, orign) {
34975
35187
  }
34976
35188
  return n;
34977
35189
  }
34978
- function cloneEdge(g, tn, hn, orig) {
35190
+ function cloneEdge2(g, tn, hn, orig) {
34979
35191
  const e = new Edge(tn, hn, orig.name);
34980
35192
  e.info.tail_port = { ...makePort(), ...orig.info.tail_port };
34981
35193
  e.info.head_port = { ...makePort(), ...orig.info.head_port };
@@ -36566,7 +36778,7 @@ function mapArrowOps(ops) {
36566
36778
  return m;
36567
36779
  });
36568
36780
  }
36569
- function mapEdge(e) {
36781
+ function mapEdge2(e) {
36570
36782
  const spl = e.info.spl;
36571
36783
  if (spl === void 0) return;
36572
36784
  mapSpl(spl);
@@ -36629,7 +36841,7 @@ function translateDrawing(g) {
36629
36841
  }
36630
36842
  continue;
36631
36843
  }
36632
- mapEdge(e);
36844
+ mapEdge2(e);
36633
36845
  }
36634
36846
  }
36635
36847
  translateBb(g, g.info.rankdir & 3);
@@ -36768,7 +36980,7 @@ function isPortless(e) {
36768
36980
  return !e.info.tail_port.defined && !e.info.head_port.defined;
36769
36981
  }
36770
36982
  function cloneFlatEdge(auxg, tn, auxt, auxh, orig) {
36771
- 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);
36772
36984
  }
36773
36985
  function flatLeadPair(edges) {
36774
36986
  const t = edges[0].tail, h = edges[0].head;
@@ -36793,7 +37005,7 @@ function buildFlatAux(g, edges, cnt) {
36793
37005
  hvye = new Edge(auxt, auxh, "");
36794
37006
  auxg.edges.push(hvye);
36795
37007
  }
36796
- hvye.info.weight = 1e4;
37008
+ hvye.attrs.set("weight", "10000");
36797
37009
  return { auxg, auxt, auxh, alg };
36798
37010
  }
36799
37011
  function blocksAdjacency(vn) {
@@ -36821,8 +37033,9 @@ function repositionFlatAux(g, edges, aux) {
36821
37033
  else n.info.coord = { x: n.info.coord.x, y: midx };
36822
37034
  }
36823
37035
  }
37036
+ var transformArrowOps = (ops, del, flip) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
36824
37037
  function copyFlatArrow(orig, auxe, del, flip) {
36825
- const xf = (ops) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
37038
+ const xf = (ops) => transformArrowOps(ops, del, flip);
36826
37039
  const eflag = auxe.info.spl?.list[0]?.eflag;
36827
37040
  const head = auxe.info.headArrowOps ?? (eflag ? auxe.info.tailArrowOps : void 0);
36828
37041
  if (head !== void 0) orig.info.headArrowOps = xf(head);
@@ -36847,6 +37060,8 @@ function copyOneFlatSpline(orig, auxe, del, flip, g) {
36847
37060
  bz.eflag = auxbz.eflag;
36848
37061
  bz.sp = transformf(auxbz.sp, del, flip);
36849
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);
36850
37065
  for (let j = 0; j < sz; j++) bz.list[j] = transformf(auxbz.list[j], del, flip);
36851
37066
  const bb = g.info.bb;
36852
37067
  if (bb !== void 0) {
@@ -37498,11 +37713,8 @@ function makeBezierRecord(bezierPts, arrowTip) {
37498
37713
  ep: arrowTip
37499
37714
  };
37500
37715
  }
37501
- function makeSplineRecord(bz) {
37502
- return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
37503
- }
37504
37716
  function installEdgeSpline(e, bezierPts, arrowTip) {
37505
- e.info.spl = makeSplineRecord(makeBezierRecord(bezierPts, arrowTip));
37717
+ Object.assign(newSpline(e, bezierPts.length), makeBezierRecord(bezierPts, arrowTip));
37506
37718
  const bb = e.tail.root.info.bb;
37507
37719
  if (bb != null) {
37508
37720
  for (let i = 0; i + 3 < bezierPts.length; i += 3) {
@@ -38599,7 +38811,7 @@ function makeGraph(n) {
38599
38811
  }
38600
38812
  return { nvs: n, vertices };
38601
38813
  }
38602
- function insertEdge(g, v1, v2) {
38814
+ function insertEdge2(g, v1, v2) {
38603
38815
  if (!edgeExists(g, v1, v2)) {
38604
38816
  g.vertices[v1].adjList.push(v2);
38605
38817
  }
@@ -39526,7 +39738,7 @@ function speFlip(isVert, commCoordMatchesP1, lDirMatchesTarget) {
39526
39738
  }
39527
39739
  function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
39528
39740
  let chan = seg1.isVert ? chanSearch(mp.vchans, seg1.commCoord, seg1.p) : chanSearch(mp.hchans, seg1.commCoord, seg1.p);
39529
- insertEdge(chan.G, seg1.indNo, seg2.indNo);
39741
+ insertEdge2(chan.G, seg1.indNo, seg2.indNo);
39530
39742
  for (let x = 1; x <= hops; x++) {
39531
39743
  const prev1 = nextSeg(seg1, dir1);
39532
39744
  const prev2 = nextSeg(seg2, dir2);
@@ -39536,8 +39748,8 @@ function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
39536
39748
  const target = seg1.isVert ? 2 /* B_LEFT */ : 1 /* B_UP */;
39537
39749
  const flip = speFlip(seg1.isVert, commCoordMatchesP1, lDir === target);
39538
39750
  const edgeSeen = edgeExists(chan.G, seg1.indNo, seg2.indNo);
39539
- if (edgeSeen === flip) insertEdge(nchan.G, prev2.indNo, prev1.indNo);
39540
- 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);
39541
39753
  chan = nchan;
39542
39754
  seg1 = prev1;
39543
39755
  seg2 = prev2;
@@ -39824,8 +40036,8 @@ function addEdgesInG(cp) {
39824
40036
  for (let y = x + 1; y < size; y++) {
39825
40037
  const cmp = segCmp(cp.segList[x], cp.segList[y]);
39826
40038
  if (cmp === -2) return -1;
39827
- if (cmp > 0) insertEdge(G, x, y);
39828
- 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);
39829
40041
  }
39830
40042
  }
39831
40043
  return 0;
@@ -40780,7 +40992,7 @@ function fillClustMap(g, map) {
40780
40992
  fillClustMap(cl, map);
40781
40993
  }
40782
40994
  }
40783
- function mkClustMap(g) {
40995
+ function mkClustMap2(g) {
40784
40996
  const map = /* @__PURE__ */ new Map();
40785
40997
  fillClustMap(g, map);
40786
40998
  return map;
@@ -40935,7 +41147,7 @@ function makeCompoundEdge(e, clustMap) {
40935
41147
  if (tailClipped && bez.sflag) restashArrow(e, bez.sp, bez.list[0], true);
40936
41148
  }
40937
41149
  function dotCompoundEdges(g) {
40938
- const clustMap = mkClustMap(g);
41150
+ const clustMap = mkClustMap2(g);
40939
41151
  for (const e of g.edges) makeCompoundEdge(e, clustMap);
40940
41152
  }
40941
41153
 
@@ -41499,20 +41711,33 @@ function copyParentAttrs(parent2, sg) {
41499
41711
  for (const [k, v] of parent2.attrs) sg.attrs.set(k, v);
41500
41712
  return sg;
41501
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
+ }
41502
41727
  function isLegal(p) {
41503
41728
  return /^[A-Za-z0-9_]*$/.test(p);
41504
41729
  }
41505
41730
  function setPrefix(pfx) {
41506
41731
  return pfx == null || !isLegal(pfx) ? "_cc_" : pfx;
41507
41732
  }
41508
- function ccomps(g, pfx) {
41733
+ function ccomps(g, pfx, reuse = true) {
41509
41734
  const visited = /* @__PURE__ */ new Set();
41510
41735
  const result = [];
41511
41736
  let idx = 0;
41512
41737
  for (const n of g.nodes.values()) {
41513
41738
  if (visited.has(n.name)) continue;
41514
41739
  const comp = dfsCollect(g, n, visited);
41515
- result.push(copyParentAttrs(g, buildSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`)));
41740
+ result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, reuse));
41516
41741
  }
41517
41742
  return result;
41518
41743
  }
@@ -41528,12 +41753,12 @@ function pccomps(g, pfx) {
41528
41753
  pinned = true;
41529
41754
  }
41530
41755
  if (pinnedNodes.length > 0) {
41531
- result.push(copyParentAttrs(g, buildSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`)));
41756
+ result.push(componentSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`, true));
41532
41757
  }
41533
41758
  for (const n of g.nodes.values()) {
41534
41759
  if (visited.has(n.name)) continue;
41535
41760
  const comp = dfsCollect(g, n, visited);
41536
- result.push(copyParentAttrs(g, buildSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`)));
41761
+ result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, true));
41537
41762
  }
41538
41763
  return { graphs: result, pinned };
41539
41764
  }
@@ -41986,8 +42211,15 @@ function setEdgeTypeFromAttr(g, defaultValue) {
41986
42211
  else et = edgeTypeFromString(s, defaultValue);
41987
42212
  setEdgeType(g, et);
41988
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
+ }
41989
42221
  function dotPhaseInit(g) {
41990
- for (const e of g.edges) e.info.weight = void 0;
42222
+ resetAbomShift(g);
41991
42223
  dotGraphInit(g);
41992
42224
  setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
41993
42225
  setAspect(g);
@@ -42068,6 +42300,7 @@ function doDot(g) {
42068
42300
  } else if (ratioIsNone(g)) {
42069
42301
  pinfo.doSplines = true;
42070
42302
  layoutAndPack(g, comps, pinfo, origOf);
42303
+ for (const comp of comps) resetAbomShift(comp);
42071
42304
  } else {
42072
42305
  dotLayoutPipeline(g);
42073
42306
  }
@@ -42795,6 +43028,109 @@ function buildMask(max) {
42795
43028
  return mask >>> 0;
42796
43029
  }
42797
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
+
42798
43134
  // src/layout/neato/start.ts
42799
43135
  var INIT_SELF = 0;
42800
43136
  var INIT_REGULAR = 1;
@@ -42833,6 +43169,7 @@ function parseStart(p, dflt) {
42833
43169
  return { init, seed };
42834
43170
  }
42835
43171
  function initRegular(g, nG) {
43172
+ const ndim = ndimOf(g);
42836
43173
  let a = 0;
42837
43174
  const da = 2 * Math.PI / nG;
42838
43175
  for (const np of g.nodes.values()) {
@@ -42840,6 +43177,7 @@ function initRegular(g, nG) {
42840
43177
  np.info.posSet = true;
42841
43178
  np.info.pinned = false;
42842
43179
  a += da;
43180
+ if (ndim > 2) jitter3d(np, nG, ndim);
42843
43181
  }
42844
43182
  }
42845
43183
  function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
@@ -43009,12 +43347,17 @@ function fisheryatesShuffle(terms, state3) {
43009
43347
  function hasPos(np) {
43010
43348
  return np.info.posSet === true || np.info.pinned === true;
43011
43349
  }
43350
+ function randompos(np, nG, ndim) {
43351
+ np.info.pos = [nG * drand48(), nG * drand48()];
43352
+ if (ndim > 2) jitter3d(np, nG, ndim);
43353
+ }
43012
43354
  function initialPositions(g, nG = g.nodes.size) {
43013
43355
  if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) return;
43014
43356
  checkStart(g, nG, INIT_RANDOM);
43357
+ const ndim = ndimOf(g);
43015
43358
  for (const np of g.nodes.values()) {
43016
43359
  if (hasPos(np)) continue;
43017
- np.info.pos = [drand48(), drand48()];
43360
+ randompos(np, 1, ndim);
43018
43361
  }
43019
43362
  }
43020
43363
  function computeSchedule(terms, maxIter, epsilon = SGD_EPSILON) {
@@ -43922,7 +44265,6 @@ function mdsModel2(dist5, n, edges) {
43922
44265
  }
43923
44266
 
43924
44267
  // src/layout/neato/kk.ts
43925
- var NDIM = 2;
43926
44268
  var DEFAULT_DAMPING = 0.99;
43927
44269
  var EPSILON_PER_NODE = 1e-4;
43928
44270
  var ITERATIONS_PER_NODE = 100;
@@ -43983,13 +44325,15 @@ function scanGraphMode(g, maxIter) {
43983
44325
  const damp = g.root.attrs.get("Damping");
43984
44326
  const { total, lens } = setEdgeLens(g, nodes);
43985
44327
  const ini = initialDist(g, total, epsilon);
44328
+ const ndim = ndimOf(g);
43986
44329
  const st = {
43987
44330
  n,
44331
+ ndim,
43988
44332
  nodes,
43989
44333
  dist: new Float64Array(n * n).fill(ini),
43990
44334
  spring: new Float64Array(n * n).fill(1),
43991
- sumT: new Float64Array(n * NDIM).fill(1),
43992
- t: new Float64Array(n * n * NDIM),
44335
+ sumT: new Float64Array(n * ndim).fill(1),
44336
+ t: new Float64Array(n * n * ndim),
43993
44337
  damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
43994
44338
  epsilon,
43995
44339
  maxIter,
@@ -43997,9 +44341,10 @@ function scanGraphMode(g, maxIter) {
43997
44341
  };
43998
44342
  return { st, adj: neighbours(g, nodes, lens), ini, lens };
43999
44343
  }
44000
- function randompos(np) {
44344
+ function randompos2(np, ndim) {
44001
44345
  np.info.pos[0] = drand48();
44002
44346
  np.info.pos[1] = drand48();
44347
+ if (ndim > 2) jitter3d(np, 1, ndim);
44003
44348
  }
44004
44349
  function initialPositions2(g, st) {
44005
44350
  const init = checkStart(g, st.n, INIT_RANDOM);
@@ -44007,12 +44352,12 @@ function initialPositions2(g, st) {
44007
44352
  if (init === INIT_SELF) warnStartSelfOnce();
44008
44353
  for (const np of st.nodes) {
44009
44354
  if (np.info.posSet === true || np.info.pinned === true) continue;
44010
- randompos(np);
44355
+ randompos2(np, st.ndim);
44011
44356
  }
44012
44357
  }
44013
- function distvec(p0, p1, del) {
44358
+ function distvec(p0, p1, del, ndim) {
44014
44359
  let dist5 = 0;
44015
- for (let k = 0; k < NDIM; k++) {
44360
+ for (let k = 0; k < ndim; k++) {
44016
44361
  del[k] = p0[k] - p1[k];
44017
44362
  dist5 = fma(del[k], del[k], dist5);
44018
44363
  }
@@ -44030,14 +44375,15 @@ function springFactors(g) {
44030
44375
  return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
44031
44376
  }
44032
44377
  function fillRow(st, i, del) {
44378
+ const { ndim } = st;
44033
44379
  const vi = st.nodes[i];
44034
44380
  for (let j = 0; j < st.n; j++) {
44035
44381
  if (i === j) continue;
44036
- const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
44037
- 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++) {
44038
44384
  const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
44039
- st.t[(i * st.n + j) * NDIM + k] = v;
44040
- st.sumT[i * NDIM + k] += v;
44385
+ st.t[(i * st.n + j) * ndim + k] = v;
44386
+ st.sumT[i * ndim + k] += v;
44041
44387
  }
44042
44388
  }
44043
44389
  }
@@ -44054,61 +44400,62 @@ function diffeqModel(g, st) {
44054
44400
  }
44055
44401
  }
44056
44402
  st.sumT.fill(0);
44057
- const del = new Float64Array(NDIM);
44403
+ const del = new Float64Array(st.ndim);
44058
44404
  for (let i = 0; i < n; i++) fillRow(st, i, del);
44059
44405
  }
44060
44406
  function updateArrays(st, i) {
44061
- const { n } = st;
44062
- const del = new Float64Array(NDIM);
44407
+ const { n, ndim } = st;
44408
+ const del = new Float64Array(ndim);
44063
44409
  const vi = st.nodes[i];
44064
- 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;
44065
44411
  for (let j = 0; j < n; j++) {
44066
44412
  if (i === j) continue;
44067
- const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
44068
- 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++) {
44069
44415
  const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
44070
- st.t[(i * n + j) * NDIM + k] = tij;
44071
- st.sumT[i * NDIM + k] += tij;
44072
- const old = st.t[(j * n + i) * NDIM + k];
44073
- st.t[(j * n + i) * NDIM + k] = -tij;
44074
- 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;
44075
44421
  }
44076
44422
  }
44077
44423
  }
44078
44424
  function d2e(st, m, M2) {
44079
- const { n } = st;
44425
+ const { n, ndim } = st;
44080
44426
  const vn = st.nodes[m];
44081
- const t = new Float64Array(NDIM);
44427
+ const t = new Float64Array(ndim);
44082
44428
  M2.fill(0);
44083
44429
  for (let i = 0; i < n; i++) {
44084
44430
  if (m === i) continue;
44085
44431
  const vi = st.nodes[i];
44086
44432
  let sq = 0;
44087
- for (let k = 0; k < NDIM; k++) {
44433
+ for (let k = 0; k < ndim; k++) {
44088
44434
  t[k] = vn.info.pos[k] - vi.info.pos[k];
44089
44435
  sq = fma(t[k], t[k], sq);
44090
44436
  }
44091
44437
  const scale = 1 / Math.pow(sq, 1.5);
44092
44438
  const K = st.spring[m * n + i];
44093
44439
  const D = st.dist[m * n + i];
44094
- for (let k = 0; k < NDIM; k++) {
44095
- 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]);
44096
44442
  const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
44097
- M2[k * NDIM + k] = fma(K, inner, M2[k * NDIM + k]);
44443
+ M2[k * ndim + k] = fma(K, inner, M2[k * ndim + k]);
44098
44444
  }
44099
44445
  }
44100
- for (let k = 1; k < NDIM; k++) {
44101
- 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];
44102
44448
  }
44103
44449
  }
44104
44450
  function chooseNode(st) {
44105
44451
  if (st.move >= st.maxIter) return -1;
44452
+ const { ndim } = st;
44106
44453
  let max = 0;
44107
44454
  let choice = -1;
44108
44455
  for (let i = 0; i < st.n; i++) {
44109
44456
  if (st.nodes[i].info.pinned === true) continue;
44110
44457
  let m = 0;
44111
- 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);
44112
44459
  if (m > max) {
44113
44460
  choice = i;
44114
44461
  max = m;
@@ -44117,14 +44464,15 @@ function chooseNode(st) {
44117
44464
  return max < st.epsilon * st.epsilon ? -1 : choice;
44118
44465
  }
44119
44466
  function moveNode(st, m) {
44120
- const a = new Float64Array(NDIM * NDIM);
44121
- const b = new Float64Array(NDIM);
44122
- 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);
44123
44471
  d2e(st, m, a);
44124
- for (let i = 0; i < NDIM; i++) c[i] = -st.sumT[m * NDIM + i];
44125
- 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);
44126
44474
  const pos = st.nodes[m].info.pos;
44127
- for (let i = 0; i < NDIM; i++) {
44475
+ for (let i = 0; i < ndim; i++) {
44128
44476
  b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
44129
44477
  pos[i] += b[i];
44130
44478
  }
@@ -44578,8 +44926,567 @@ function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
44578
44926
  return 0;
44579
44927
  }
44580
44928
 
44581
- // 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
44582
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;
44583
45490
  function computeApspPacked2(graph, n) {
44584
45491
  const Dij = new Float32Array(n * (n + 1) / 2);
44585
45492
  const Di = new Int32Array(n);
@@ -44603,6 +45510,7 @@ function initLayout(n, dim, coords, nodes) {
44603
45510
  if (hasPos2(np)) {
44604
45511
  coords[0][i] = np.info.pos?.[0] ?? 0;
44605
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;
44606
45514
  if (isFixed(np)) pinned = true;
44607
45515
  } else {
44608
45516
  coords[0][i] = drand48();
@@ -44652,7 +45560,7 @@ function buildLap1(lap1, lap2, coords, shape) {
44652
45560
  for (let k = 0; k < dim; k++) {
44653
45561
  const ck = coords[k];
44654
45562
  for (let x = 0; x < len; x++) {
44655
- const tmp = fr5(ck[i] + fr5(-1 * ck[i + 1 + x]));
45563
+ const tmp = fr7(ck[i] + fr7(-1 * ck[i + 1 + x]));
44656
45564
  distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]);
44657
45565
  }
44658
45566
  }
@@ -44665,7 +45573,7 @@ function buildLap1(lap1, lap2, coords, shape) {
44665
45573
  let degree = 0;
44666
45574
  if (exp === 2) {
44667
45575
  for (let j = 0; j < len; j++, count++) {
44668
- const val2 = lap1[count] = fr5(lap1[count] * distAccumulator[j]);
45576
+ const val2 = lap1[count] = fr7(lap1[count] * distAccumulator[j]);
44669
45577
  degree += val2;
44670
45578
  degrees[i + j + 1] = degrees[i + j + 1] - val2;
44671
45579
  }
@@ -44710,19 +45618,50 @@ function solveAxis(st, k, havePinned, nodes) {
44710
45618
  }
44711
45619
  return 0;
44712
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
+ }
44713
45650
  function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
44714
45651
  const { dim, maxi } = o;
44715
45652
  const exp = o.opts & OPT_EXP_FLAG;
44716
45653
  if (maxi < 0) return 0;
44717
- 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;
44718
45657
  if (n === 1 || maxi === 0) return 0;
44719
45658
  const coords = [];
44720
45659
  for (let i = 0; i < dim; i++) {
44721
45660
  const c = new Float32Array(n);
44722
- 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]);
44723
45662
  coords.push(c);
44724
45663
  }
44725
- const constantTerm = fr5(n * (n - 1) / 2);
45664
+ const constantTerm = fr7(n * (n - 1) / 2);
44726
45665
  const lap2 = Dij;
44727
45666
  buildLap2(lap2, n, exp);
44728
45667
  const lapLength = n * (n + 1) / 2;
@@ -44744,7 +45683,6 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
44744
45683
  for (; iterations < maxi && !converged; iterations++) {
44745
45684
  buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
44746
45685
  const newStress = computeStress(st);
44747
- if (typeof process !== "undefined" && process.env["STRESS_DEBUG"] && iterations % 5 === 0) console.error(newStress.toFixed(3));
44748
45686
  const change = Math.abs(oldStress - newStress);
44749
45687
  converged = change / oldStress < o.epsilon || newStress < o.epsilon;
44750
45688
  oldStress = newStress;
@@ -44862,7 +45800,7 @@ function stressModelDij(graph, n, model) {
44862
45800
  }
44863
45801
 
44864
45802
  // src/layout/neato/constrained-majorization.ts
44865
- var fr6 = Math.fround;
45803
+ var fr8 = Math.fround;
44866
45804
  var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
44867
45805
  var LEVELS_SEP_TOL = 0.1;
44868
45806
  var ABS_TOL = 0.01;
@@ -44871,18 +45809,15 @@ var FLT_MAX3 = 34028234663852886e22;
44871
45809
  var DBL_MAX = Number.MAX_VALUE;
44872
45810
  var MIN_LEVELS = 1;
44873
45811
  var Y_AXIS = 1;
44874
- function unsupported2(what) {
44875
- throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
44876
- }
44877
45812
  function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
44878
45813
  if (o.maxi < 0) return 0;
44879
45814
  const Dij = stressModelDij(graph, n, o.model);
44880
- if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
44881
45815
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
44882
45816
  dim: o.dim,
44883
45817
  opts: o.opts,
44884
45818
  maxi: o.maxi,
44885
- epsilon: o.epsilon
45819
+ epsilon: o.epsilon,
45820
+ smart: { graph, reweightGraph: o.model === MODEL_SUBSET2 }
44886
45821
  });
44887
45822
  }
44888
45823
  function hasDirectionality(graph, n) {
@@ -44930,14 +45865,6 @@ function plainInitLayers(graph, n, dCoords, nodes, dim) {
44930
45865
  const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, null);
44931
45866
  return h === null ? -1 : h;
44932
45867
  }
44933
- function distanceKD(coords, dim, i, j) {
44934
- let sum = 0;
44935
- for (let k = 0; k < dim; k++) {
44936
- const d = coords[k][i] - coords[k][j];
44937
- sum = fma(d, d, sum);
44938
- }
44939
- return Math.sqrt(sum);
44940
- }
44941
45868
  function scaleDownLayout(dCoords, n, dim) {
44942
45869
  let max = 1;
44943
45870
  for (let i = 0; i < dim; i++) {
@@ -44960,7 +45887,7 @@ function scaleDistances(Dij, dCoords, n, dim) {
44960
45887
  sum2 += distanceKD(dCoords, dim, i, j) / Dij[count];
44961
45888
  }
44962
45889
  }
44963
- const scaleRatio = fr6(sum2 / sum1);
45890
+ const scaleRatio = fr8(sum2 / sum1);
44964
45891
  for (let i = 0; i < length; i++) Dij[i] = Dij[i] * scaleRatio;
44965
45892
  }
44966
45893
  function centerLayout(dCoords, n, dim) {
@@ -45016,7 +45943,7 @@ function buildLap12(st) {
45016
45943
  count++;
45017
45944
  let degree = 0;
45018
45945
  for (let j = 0; j < len; j++, count++) {
45019
- const val2 = fr6(lap1[count] * distAccumulator[j]);
45946
+ const val2 = fr8(lap1[count] * distAccumulator[j]);
45020
45947
  lap1[count] = val2;
45021
45948
  degree += val2;
45022
45949
  degrees[i + j + 1] -= val2;
@@ -46569,8 +47496,8 @@ function genYConstraints(rects, vs) {
46569
47496
  }
46570
47497
 
46571
47498
  // src/layout/neato/quad-prog-vpsc-overlap.ts
46572
- var fr7 = Math.fround;
46573
- var X_GROWTH = fr7(1.0001);
47499
+ var fr9 = Math.fround;
47500
+ var X_GROWTH = fr9(1.0001);
46574
47501
  var BOUNDARY_WIDTH = 1e-4;
46575
47502
  var TMP_CLUSTER_VAR_ID = 123;
46576
47503
  function copyBox(b) {
@@ -46716,7 +47643,7 @@ function generateNonoverlapConstraints(e, a) {
46716
47643
  n -= 2 * a.opt.clusters.nclusters;
46717
47644
  }
46718
47645
  if (a.k === 0) {
46719
- nsizeScale = fr7(nsizeScale * X_GROWTH);
47646
+ nsizeScale = fr9(nsizeScale * X_GROWTH);
46720
47647
  }
46721
47648
  const bb = nodeBoxes(n, nsizeScale, a);
46722
47649
  let csol;
@@ -46779,15 +47706,15 @@ function getNumDigcolaConstraints(levels, numLevels) {
46779
47706
  }
46780
47707
 
46781
47708
  // src/layout/neato/quad-prog-vpsc.ts
46782
- var fr8 = Math.fround;
47709
+ var fr10 = Math.fround;
46783
47710
  var QUAD_PROG_TOL = 1e-4;
46784
47711
  var DUMMY_WEIGHT = 1e-6;
46785
47712
  var VECTOR_BLOCK = 4;
46786
47713
  function rowReduce(row, factor, v, n, acc) {
46787
47714
  const blocked = n - n % VECTOR_BLOCK;
46788
47715
  let j = 0;
46789
- for (; j < blocked; j++) acc = fr8(acc + fr8(fr8(factor * row[j]) * v[j]));
46790
- 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);
46791
47718
  return acc;
46792
47719
  }
46793
47720
  function project(e, place, n) {
@@ -46805,7 +47732,7 @@ function descentStep(e, b, place, n) {
46805
47732
  const oldPlace = e.fArray2;
46806
47733
  for (let i = 0; i < n; i++) {
46807
47734
  oldPlace[i] = place[i];
46808
- 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]));
46809
47736
  }
46810
47737
  let numerator = 0;
46811
47738
  let denominator = 0;
@@ -46814,7 +47741,7 @@ function descentStep(e, b, place, n) {
46814
47741
  const r = rowReduce(A3[i], 2, g, n, 0);
46815
47742
  denominator = fmaf(-r, g[i], denominator);
46816
47743
  }
46817
- return denominator !== 0 ? -fr8(numerator / denominator) : -1;
47744
+ return denominator !== 0 ? -fr10(numerator / denominator) : -1;
46818
47745
  }
46819
47746
  function lineSearchBeta(e, place, n) {
46820
47747
  const A3 = e.A;
@@ -46822,7 +47749,7 @@ function lineSearchBeta(e, place, n) {
46822
47749
  const oldPlace = e.fArray2;
46823
47750
  const d = e.fArray3;
46824
47751
  for (let i = 0; i < n; i++) {
46825
- d[i] = fr8(place[i] - oldPlace[i]);
47752
+ d[i] = fr10(place[i] - oldPlace[i]);
46826
47753
  }
46827
47754
  let numerator = 0;
46828
47755
  let denominator = 0;
@@ -46831,7 +47758,7 @@ function lineSearchBeta(e, place, n) {
46831
47758
  const r = rowReduce(A3[i], 2, d, n, 0);
46832
47759
  denominator = fmaf(r, d[i], denominator);
46833
47760
  }
46834
- 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);
46835
47762
  return 1;
46836
47763
  }
46837
47764
  function applyBeta(e, place, n, beta) {
@@ -46842,7 +47769,7 @@ function applyBeta(e, place, n, beta) {
46842
47769
  if (beta > 0 && beta < 1) {
46843
47770
  place[i] = fmaf(beta, d[i], oldPlace[i]);
46844
47771
  }
46845
- test = fr8(test + fr8(Math.abs(place[i] - oldPlace[i])));
47772
+ test = fr10(test + fr10(Math.abs(place[i] - oldPlace[i])));
46846
47773
  }
46847
47774
  return test;
46848
47775
  }
@@ -46988,11 +47915,11 @@ function deleteCMajEnvVPSC(e) {
46988
47915
  }
46989
47916
 
46990
47917
  // src/layout/neato/stress-cola.ts
46991
- var fr9 = Math.fround;
47918
+ var fr11 = Math.fround;
46992
47919
  var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
46993
47920
  var FLT_MAX4 = 34028234663852886e22;
46994
- var CLUSTER_WEIGHT_FLOOR = fr9(0.01);
46995
- var STRESS_GUARD = 1e-10;
47921
+ var CLUSTER_WEIGHT_FLOOR = fr11(0.01);
47922
+ var STRESS_GUARD2 = 1e-10;
46996
47923
  var NSIZE_SCALE_STEP = 0.1;
46997
47924
  var NSIZE_SCALE_LIMIT = 0.999;
46998
47925
  var NSIZE_SCALE_ACTIVE = 1e-3;
@@ -47003,7 +47930,7 @@ function maxEdgeLength(graph, n) {
47003
47930
  let maxEdgeLen = 0;
47004
47931
  for (let i = 0; i < n; i++) {
47005
47932
  for (let j = 1; j < graph[i].nedges; j++) {
47006
- maxEdgeLen = fr9(Math.max(graph[i].ewgts[j], maxEdgeLen));
47933
+ maxEdgeLen = fr11(Math.max(graph[i].ewgts[j], maxEdgeLen));
47007
47934
  }
47008
47935
  }
47009
47936
  return maxEdgeLen;
@@ -47055,8 +47982,8 @@ function clusterLaplacian(lap2, n, nclusters, maxEdgeLen) {
47055
47982
  if (i < n && j < n - i) {
47056
47983
  v = lap2[c0++];
47057
47984
  } else if (j === 1 && i % 2 === 1) {
47058
- v = fr9(maxEdgeLen * maxEdgeLen);
47059
- if (v > CLUSTER_WEIGHT_FLOOR) v = fr9(1 / v);
47985
+ v = fr11(maxEdgeLen * maxEdgeLen);
47986
+ if (v > CLUSTER_WEIGHT_FLOOR) v = fr11(1 / v);
47060
47987
  } else {
47061
47988
  v = 0;
47062
47989
  }
@@ -47114,7 +48041,7 @@ function colaState(Dij, origN, dCoords, o, maxEdgeLen) {
47114
48041
  degrees,
47115
48042
  coords: floatCoords(dCoords, o.dim, n, origN),
47116
48043
  /* compute constant term in stress sum which is \sum_{i<j} w_{ij}d_{ij}^2 */
47117
- constantTerm: fr9(n * (n - 1) / 2),
48044
+ constantTerm: fr11(n * (n - 1) / 2),
47118
48045
  b: Array.from({ length: o.dim }, () => new Float32Array(n)),
47119
48046
  tmpCoords: new Float32Array(n),
47120
48047
  distAccumulator: new Float32Array(n)
@@ -47146,7 +48073,7 @@ function buildLap13(st) {
47146
48073
  count++;
47147
48074
  let degree = 0;
47148
48075
  for (let j = 0; j < len; j++, count++) {
47149
- const val2 = lap1[count] = fr9(lap1[count] * st.distAccumulator[j]);
48076
+ const val2 = lap1[count] = fr11(lap1[count] * st.distAccumulator[j]);
47150
48077
  degree += val2;
47151
48078
  degrees[i + j + 1] = degrees[i + j + 1] - val2;
47152
48079
  }
@@ -47181,7 +48108,7 @@ var overlapDue = (opt, nsizeScale) => opt.noverlap === NOVERLAP_CONSTRAINTS && n
47181
48108
  function solveHorizontal(st, e, nsizeScale, opt) {
47182
48109
  if (overlapDue(opt, nsizeScale)) {
47183
48110
  generateNonoverlapConstraints(e, {
47184
- nsizeScale: fr9(nsizeScale),
48111
+ nsizeScale: fr11(nsizeScale),
47185
48112
  coords: st.coords,
47186
48113
  k: 0,
47187
48114
  transitiveClosure: nsizeScale >= TRANSITIVE_CLOSURE_SCALE,
@@ -47200,7 +48127,7 @@ function solveHorizontal(st, e, nsizeScale, opt) {
47200
48127
  }
47201
48128
  function solveVertical(st, e, nsizeScale, opt) {
47202
48129
  if (overlapDue(opt, nsizeScale)) {
47203
- 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 });
47204
48131
  }
47205
48132
  if (e.m > 0) {
47206
48133
  if (constrainedMajorizationVpsc(e, st.b[1], st.coords[1], LOCAL_CONSTR_MAJOR_ITERATIONS2) < 0) return -1;
@@ -47209,13 +48136,13 @@ function solveVertical(st, e, nsizeScale, opt) {
47209
48136
  }
47210
48137
  return 0;
47211
48138
  }
47212
- function iterate(st, envs, o, observe) {
48139
+ function iterate2(st, envs, o, observe) {
47213
48140
  const s = { iterations: 0, converged: false, oldStress: Number.MAX_VALUE, nsizeScale: 0 };
47214
48141
  for (; s.iterations < o.maxi && !s.converged; s.iterations++) {
47215
48142
  buildLap13(st);
47216
48143
  const newStress = computeStress2(st);
47217
48144
  observe?.(newStress);
47218
- 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;
47219
48146
  s.oldStress = newStress;
47220
48147
  scaleUpNodes(s, o.maxi, o.opt);
47221
48148
  if (solveHorizontal(st, envs.hor, s.nsizeScale, o.opt) < 0) return -1;
@@ -47229,7 +48156,7 @@ function optimize(st, graph, o, observe) {
47229
48156
  const vrt = initCMajVPSC(st.n, st.lap2, graph, o.opt, o.opt.diredges);
47230
48157
  if (vrt === null) return -1;
47231
48158
  st.lap1 = new Float32Array(st.lapLength);
47232
- const iterations = iterate(st, { hor, vrt }, o, observe);
48159
+ const iterations = iterate2(st, { hor, vrt }, o, observe);
47233
48160
  if (iterations < 0) return iterations;
47234
48161
  deleteCMajEnvVPSC(hor);
47235
48162
  deleteCMajEnvVPSC(vrt);
@@ -47334,7 +48261,7 @@ function realEdges(de) {
47334
48261
  function isNewEdge(de) {
47335
48262
  return de.info.alg === void 0;
47336
48263
  }
47337
- function addEdge2(de, e) {
48264
+ function addEdge3(de, e) {
47338
48265
  const el = de.info.alg;
47339
48266
  if (el === void 0) {
47340
48267
  de.info.alg = [e];
@@ -47882,10 +48809,10 @@ var Cdt = class {
47882
48809
  }
47883
48810
  /** gts_point_locate (guess=NULL): closest_face + barycenter walk. */
47884
48811
  pointLocate(x, y) {
47885
- const guess = this.closestFace(x, y);
47886
- if (guess === null) return null;
47887
- const [bx, by] = this.barycenter(guess);
47888
- 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);
47889
48816
  }
47890
48817
  // -------------------------------------------------------------------
47891
48818
  // Delaunay insertion (cdt.c: swap_if_in_circle, add_vertex_to_face)
@@ -51762,10 +52689,19 @@ var SMOOTHING_NONE = 0;
51762
52689
  var INT_MAX2 = 2147483647;
51763
52690
  var ELSCHEME_PENALTY2 = 2;
51764
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
+ }
51765
52700
  function sfdpInitGraph(g) {
51766
52701
  setEdgeTypeFromAttr(g, EDGETYPE_LINE);
52702
+ const ndim = sfdpInitDim(g);
51767
52703
  commonInitNodeEdge(g);
51768
- for (const n of g.nodes.values()) neatoInitNode(n);
52704
+ for (const n of g.nodes.values()) neatoInitNode(n, ndim);
51769
52705
  const measurer = layoutMeasurer(g);
51770
52706
  if (measurer !== void 0) {
51771
52707
  for (const n of g.nodes.values()) {
@@ -51882,12 +52818,12 @@ function makeMatrix(g) {
51882
52818
  MATRIX_TYPE_REAL
51883
52819
  );
51884
52820
  }
51885
- function getSizes(g, pad) {
51886
- 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);
51887
52823
  for (const n of g.nodes.values()) {
51888
52824
  const i = n.info.id;
51889
- sizes[i * 2] = (n.info.width ?? 0) * 0.5 + pad.x;
51890
- 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;
51891
52827
  }
51892
52828
  return sizes;
51893
52829
  }
@@ -52819,7 +53755,7 @@ var AM_PORTHOYX = 12;
52819
53755
  var SCALE = 10;
52820
53756
  var SCALE2 = SCALE / 2;
52821
53757
  var INT_MAX3 = 2147483647;
52822
- var POINTS_PER_INCH4 = 72;
53758
+ var POINTS_PER_INCH6 = 72;
52823
53759
  function cmpitem(a, b) {
52824
53760
  if (a < b) return -1;
52825
53761
  if (a > b) return 1;
@@ -53047,18 +53983,18 @@ function overlaps(p) {
53047
53983
  return false;
53048
53984
  }
53049
53985
  function initItem(n, margin) {
53050
- const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH4);
53051
- 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);
53052
53988
  const width2 = n.info.width ?? 0;
53053
53989
  const height2 = n.info.height ?? 0;
53054
53990
  let w2;
53055
53991
  let h2;
53056
53992
  if (margin.doAdd) {
53057
- w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH4) + margin.x));
53058
- 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));
53059
53995
  } else {
53060
- w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH4);
53061
- 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);
53062
53998
  }
53063
53999
  return {
53064
54000
  val: 0,
@@ -53093,8 +54029,8 @@ function cAdjust(g, mode) {
53093
54029
  if (!overlaps(nlist)) return 0;
53094
54030
  runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO));
53095
54031
  for (const p of nlist) {
53096
- const x = p.pos.x / POINTS_PER_INCH4 / SCALE;
53097
- 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;
53098
54034
  if (p.np.info.pos) {
53099
54035
  p.np.info.pos[0] = x;
53100
54036
  p.np.info.pos[1] = y;
@@ -53109,10 +54045,10 @@ function cAdjust(g, mode) {
53109
54045
  var POLY_BOX = 1;
53110
54046
  var POLY_CIRCLE = 2;
53111
54047
  var DFLT_SAMPLE2 = 20;
53112
- var POINTS_PER_INCH5 = 72;
54048
+ var POINTS_PER_INCH7 = 72;
53113
54049
  var MIN_SAMPLES = 3;
53114
54050
  function ps2inch2(a) {
53115
- return a / POINTS_PER_INCH5;
54051
+ return a / POINTS_PER_INCH7;
53116
54052
  }
53117
54053
  function isBoxKind(p) {
53118
54054
  return (p.kind & POLY_BOX) !== 0;
@@ -53405,7 +54341,7 @@ function polyOverlap(p, pp, q, qp) {
53405
54341
  // src/layout/neato/adjust-info.ts
53406
54342
  var DEFAULT_VORO_MARGIN = 0.05;
53407
54343
  var INCR = 0.05;
53408
- var POINTS_PER_INCH6 = 72;
54344
+ var POINTS_PER_INCH8 = 72;
53409
54345
  function newInfoState() {
53410
54346
  return {
53411
54347
  nodeInfo: [],
@@ -53460,8 +54396,8 @@ function chkBoundBox(st, graph) {
53460
54396
  function makeInfo(st, graph) {
53461
54397
  const pmargin = { ...sepFactor(graph) };
53462
54398
  if (pmargin.doAdd) {
53463
- pmargin.x /= POINTS_PER_INCH6;
53464
- pmargin.y /= POINTS_PER_INCH6;
54399
+ pmargin.x /= POINTS_PER_INCH8;
54400
+ pmargin.y /= POINTS_PER_INCH8;
53465
54401
  }
53466
54402
  const polyf = pmargin.doAdd ? makeAddPoly : makePoly;
53467
54403
  const info = [];
@@ -53595,7 +54531,7 @@ function sAdjustGraph(g) {
53595
54531
  }
53596
54532
 
53597
54533
  // src/layout/neato/vpsc-adjust.ts
53598
- var POINTS_PER_INCH7 = 72;
54534
+ var POINTS_PER_INCH9 = 72;
53599
54535
  function noClusters() {
53600
54536
  return {
53601
54537
  nvars: 0,
@@ -53621,21 +54557,30 @@ function vpscAdjust(g) {
53621
54557
  noverlap: 2,
53622
54558
  clusters: noClusters(),
53623
54559
  gap: {
53624
- x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH7),
53625
- 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)
53626
54562
  },
53627
54563
  nsize: nodes.map((n) => ({ x: n.info.width, y: n.info.height }))
53628
54564
  };
53629
54565
  removeoverlaps(nodes.length, coords, opt);
53630
54566
  nodes.forEach((n, j) => {
53631
- 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];
53632
54569
  });
53633
54570
  return 0;
53634
54571
  }
53635
54572
 
53636
54573
  // src/layout/neato/fdp-adjust.ts
53637
54574
  var DFLT_MARGIN2 = 4;
53638
- 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
+ }
53639
54584
  function mapBoolDflt(p, defaultValue) {
53640
54585
  if (p === void 0 || p === "") return defaultValue;
53641
54586
  const s = p.toLowerCase();
@@ -53677,14 +54622,14 @@ function overlapPrismTries(flag) {
53677
54622
  }
53678
54623
  function fdpAdjust(g, ntry) {
53679
54624
  const A0 = makeMatrix(g);
53680
- 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);
53681
54627
  const sep = sepFactor(g);
53682
54628
  const pad = sep.doAdd ? { x: sep.x / 72, y: sep.y / 72 } : { x: DFLT_MARGIN2 / 72, y: DFLT_MARGIN2 / 72 };
53683
- const sizes = getSizes(g, pad);
54629
+ const sizes = sizesByNdim(getSizes(g, pad), ndim);
53684
54630
  for (const n of g.nodes.values()) {
53685
54631
  const i = n.info.id;
53686
- pos[i * NDIM2] = n.info.pos?.[0] ?? 0;
53687
- 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;
53688
54633
  }
53689
54634
  const A3 = !smIsSymmetric(A0, false) || A0.type !== MATRIX_TYPE_REAL ? smGetRealAdjacencySymmetrized(A0) : smRemoveDiagonal(A0);
53690
54635
  const scaling = lateDouble(
@@ -53696,12 +54641,11 @@ function fdpAdjust(g, ntry) {
53696
54641
  g.attrs.get("overlap_shrink") ?? g.root.attrs.get("overlap_shrink"),
53697
54642
  true
53698
54643
  );
53699
- removeOverlapPrism(NDIM2, A3, pos, sizes, ntry, scaling, doShrinking);
54644
+ removeOverlapPrism(ndim, A3, pos, sizes, ntry, scaling, doShrinking);
53700
54645
  for (const n of g.nodes.values()) {
53701
54646
  const i = n.info.id;
53702
54647
  if (!n.info.pos) n.info.pos = [0, 0];
53703
- n.info.pos[0] = pos[i * NDIM2];
53704
- n.info.pos[1] = pos[i * NDIM2 + 1];
54648
+ for (let k = 0; k < ndim; k++) n.info.pos[k] = pos[i * ndim + k];
53705
54649
  }
53706
54650
  }
53707
54651
  var AM_NONE = 0;
@@ -53795,9 +54739,9 @@ function graphAdjustMode(g) {
53795
54739
  }
53796
54740
 
53797
54741
  // src/layout/neato/ipsep-opts.ts
53798
- var POINTS_PER_INCH8 = 72;
54742
+ var POINTS_PER_INCH10 = 72;
53799
54743
  var HIER_PREFIX = "hier";
53800
- var ps2inch3 = (points2) => points2 / POINTS_PER_INCH8;
54744
+ var ps2inch3 = (points2) => points2 / POINTS_PER_INCH10;
53801
54745
  var zeroBox = () => ({ ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } });
53802
54746
  function memberIndices(subg, nodes) {
53803
54747
  const members = nodesInSeq(subg);
@@ -53876,19 +54820,8 @@ function ipsepOptions(mg, g, nodes, am) {
53876
54820
  return { diredges, edgeGap, noverlap, gap, nsize, clusters };
53877
54821
  }
53878
54822
 
53879
- // src/common/utils-inputscale.ts
53880
- var POINTS_PER_INCH9 = 72;
53881
- function getInputscale(g) {
53882
- const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
53883
- return d === 0 ? POINTS_PER_INCH9 : d;
53884
- }
53885
- function inputscaleDivisor(g) {
53886
- const sc = getInputscale(g);
53887
- return sc > 0 ? sc : 1;
53888
- }
53889
-
53890
54823
  // src/layout/neato/set-aspect.ts
53891
- var POINTS_PER_INCH10 = 72;
54824
+ var POINTS_PER_INCH11 = 72;
53892
54825
  function neatoRatioKind(g) {
53893
54826
  const p = g.attrs.get("ratio");
53894
54827
  if (p === void 0) return null;
@@ -53936,8 +54869,8 @@ function neatoTranslate(g) {
53936
54869
  const bb = g.info.bb;
53937
54870
  if (!bb) return;
53938
54871
  const ll = bb.ll;
53939
- const ox = ll.x / POINTS_PER_INCH10;
53940
- const oy = ll.y / POINTS_PER_INCH10;
54872
+ const ox = ll.x / POINTS_PER_INCH11;
54873
+ const oy = ll.y / POINTS_PER_INCH11;
53941
54874
  for (const n of g.nodes.values()) {
53942
54875
  if (!n.info.pos) n.info.pos = [0, 0];
53943
54876
  n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
@@ -54022,8 +54955,7 @@ var MODEL_SHORTPATH2 = 0;
54022
54955
  var MODEL_CIRCUIT2 = 1;
54023
54956
  var MODEL_SUBSET2 = 2;
54024
54957
  var MODEL_MDS2 = 3;
54025
- var DFLT_DIM = 2;
54026
- var POINTS_PER_INCH11 = 72;
54958
+ var POINTS_PER_INCH12 = 72;
54027
54959
  function neatoInitNode(n, dim = DFLT_DIM) {
54028
54960
  if (!n.info.pos || n.info.pos.length < dim) {
54029
54961
  const pos = [];
@@ -54035,19 +54967,6 @@ function neatoInitNode(n, dim = DFLT_DIM) {
54035
54967
  if (!n.info.width && !plainShaped) n.info.width = 0.75;
54036
54968
  if (!n.info.height && !plainShaped) n.info.height = 0.5;
54037
54969
  }
54038
- function userPos(n) {
54039
- const p = n.attrs.get("pos");
54040
- if (p === void 0 || p.length === 0) return false;
54041
- const num2 = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
54042
- const m = new RegExp(`^\\s*${num2}\\s*,\\s*${num2}(.?)`).exec(p);
54043
- if (m === null) return false;
54044
- const div = inputscaleDivisor(n.root);
54045
- n.info.pos = [Number(m[1]) / div, Number(m[2]) / div];
54046
- n.info.posSet = true;
54047
- const pin = n.attrs.get("pin");
54048
- if (m[3] === "!" || pin !== void 0 && mapbool(pin)) n.info.pinned = true;
54049
- return true;
54050
- }
54051
54970
  function assignNodeIds2(g) {
54052
54971
  const nodeList = [];
54053
54972
  let idx = 0;
@@ -54067,10 +54986,11 @@ function solveStress(c, vtx, dCoords, nodeList) {
54067
54986
  const { g, mode, model, opts } = c;
54068
54987
  const n = nodeList.length;
54069
54988
  const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
54989
+ const dim = ndimOf(g);
54070
54990
  const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
54071
54991
  if (mode === MODE_HIER) {
54072
54992
  return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
54073
- dim: DFLT_DIM,
54993
+ dim,
54074
54994
  opts,
54075
54995
  model,
54076
54996
  maxi,
@@ -54081,7 +55001,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
54081
55001
  if (mode === MODE_IPSEP) {
54082
55002
  const opt = ipsepOptions(g.root, g, nodeList, c.am);
54083
55003
  return stressMajorizationCola(vtx, n, dCoords, nodeList, {
54084
- dim: DFLT_DIM,
55004
+ dim,
54085
55005
  model,
54086
55006
  maxi,
54087
55007
  epsilon,
@@ -54090,7 +55010,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
54090
55010
  }
54091
55011
  const Dij = stressModelDij(vtx, n, model);
54092
55012
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
54093
- dim: DFLT_DIM,
55013
+ dim,
54094
55014
  opts,
54095
55015
  maxi,
54096
55016
  epsilon
@@ -54105,13 +55025,14 @@ function runMajorization(g, mode, model, am) {
54105
55025
  const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
54106
55026
  const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
54107
55027
  const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
54108
- const dCoords = [new Float64Array(n), new Float64Array(n)];
55028
+ const ndim = ndimOf(g);
55029
+ const dCoords = Array.from({ length: ndim }, () => new Float64Array(n));
54109
55030
  if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
54110
55031
  agerr("prev", "layout aborted");
54111
55032
  return;
54112
55033
  }
54113
55034
  for (let i = 0; i < n; i++) {
54114
- nodeList[i].info.pos = [dCoords[0][i], dCoords[1][i]];
55035
+ nodeList[i].info.pos = dCoords.map((c) => c[i]);
54115
55036
  }
54116
55037
  }
54117
55038
  var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
@@ -54134,8 +55055,8 @@ function neatoSetAspect(g) {
54134
55055
  const pos = n.info.pos;
54135
55056
  if (!pos) continue;
54136
55057
  n.info.coord = {
54137
- x: (pos[0] ?? 0) * POINTS_PER_INCH11,
54138
- y: (pos[1] ?? 0) * POINTS_PER_INCH11
55058
+ x: (pos[0] ?? 0) * POINTS_PER_INCH12,
55059
+ y: (pos[1] ?? 0) * POINTS_PER_INCH12
54139
55060
  };
54140
55061
  }
54141
55062
  }
@@ -54151,7 +55072,7 @@ function neatoCleanup(g) {
54151
55072
  }
54152
55073
 
54153
55074
  // src/layout/twopi/init.ts
54154
- var POINTS_PER_INCH12 = 72;
55075
+ var POINTS_PER_INCH13 = 72;
54155
55076
  function makeRdata(INF) {
54156
55077
  return {
54157
55078
  kind: "twopi",
@@ -54203,8 +55124,8 @@ function finaliseCoords(g) {
54203
55124
  const pos = n.info.pos;
54204
55125
  if (!pos) continue;
54205
55126
  n.info.coord = {
54206
- x: (pos[0] ?? 0) * POINTS_PER_INCH12,
54207
- y: (pos[1] ?? 0) * POINTS_PER_INCH12
55127
+ x: (pos[0] ?? 0) * POINTS_PER_INCH13,
55128
+ y: (pos[1] ?? 0) * POINTS_PER_INCH13
54208
55129
  };
54209
55130
  }
54210
55131
  }
@@ -54440,7 +55361,10 @@ function circleLayout(sg, center) {
54440
55361
  if (center === null) center = findCenterNode(sg);
54441
55362
  if (center === null) return null;
54442
55363
  const maxN = setParentNodes(sg, center);
54443
- 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
+ }
54444
55368
  setSubtreeSize(sg);
54445
55369
  setSubtreeSpans(sg, center);
54446
55370
  setPositions(sg, center);
@@ -54531,18 +55455,21 @@ function parseModel(g) {
54531
55455
  function maybeRemoveOverlap(g, am) {
54532
55456
  removeOverlapWith(g, am);
54533
55457
  }
54534
- function neatoLayout(g) {
54535
- graphInit(g, false);
54536
- setEdgeTypeFromAttr(g, EDGETYPE_LINE);
54537
- commonInitNodeEdge(g);
55458
+ function neatoInitNodeEdge(g, ndim) {
54538
55459
  for (const [, n] of g.nodes) {
54539
- neatoInitNode(n);
54540
- userPos(n);
55460
+ neatoInitNode(n, ndim);
55461
+ userPos(n, ndim, g.nodes.size);
54541
55462
  }
54542
55463
  const measurer = layoutMeasurer(g);
54543
55464
  if (measurer !== void 0) {
54544
55465
  for (const e of g.edges) initEdgeLabels(e, g, measurer);
54545
55466
  }
55467
+ }
55468
+ function neatoLayout(g) {
55469
+ graphInit(g, false);
55470
+ setEdgeTypeFromAttr(g, EDGETYPE_LINE);
55471
+ commonInitNodeEdge(g);
55472
+ neatoInitNodeEdge(g, neatoInitGraphDim(g));
54546
55473
  const mode = parseMode(g);
54547
55474
  const am = graphAdjustMode(g);
54548
55475
  const model = parseModel(g);
@@ -54554,6 +55481,7 @@ function neatoLayout(g) {
54554
55481
  maybeRemoveOverlap(g, am);
54555
55482
  splineEdgesShifted(g);
54556
55483
  }
55484
+ addZ(g);
54557
55485
  addClusters(g);
54558
55486
  g.info.bb = computeSubgraphBB(g, 0);
54559
55487
  placeGraphLabel(g);
@@ -54745,127 +55673,6 @@ function initParams(g, xpms) {
54745
55673
  return ret;
54746
55674
  }
54747
55675
 
54748
- // src/layout/fdp/cluster-edges.ts
54749
- function fillMap(g, map) {
54750
- const n = g.info.n_cluster ?? 0;
54751
- for (let c = 0; c < n; c++) {
54752
- const cl = g.info.clust[c];
54753
- const s = cl.name;
54754
- if (!map.has(s)) map.set(s, cl);
54755
- fillMap(cl, map);
54756
- }
54757
- }
54758
- function mkClustMap2(g) {
54759
- const map = /* @__PURE__ */ new Map();
54760
- fillMap(g, map);
54761
- return map;
54762
- }
54763
- function mapc(cmap, n) {
54764
- if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
54765
- return null;
54766
- }
54767
- function edgeKey(t, h) {
54768
- return `${t.name}\0${h.name}`;
54769
- }
54770
- function mapEdge2(map, t, h) {
54771
- return map.get(edgeKey(t, h));
54772
- }
54773
- function insertEdge2(map, t, h, ce) {
54774
- map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
54775
- map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
54776
- }
54777
- function clustNode(n, cg, root, delSet, idx) {
54778
- const name = `__${idx.v}:${cg.name}`;
54779
- const cn = agnode(root, name, true);
54780
- cn.info.clustnode = true;
54781
- agsubnode(cg, cn, true);
54782
- delSet.add(n);
54783
- cn.attrs.set("label", "");
54784
- cn.attrs.set("style", "invis");
54785
- cn.attrs.set("shape", "box");
54786
- return cn;
54787
- }
54788
- function cloneEdge2(root, e, ct, ch) {
54789
- const ce = new Edge(ct, ch, "");
54790
- for (const [k, v] of e.attrs) ce.attrs.set(k, v);
54791
- ce.info.compound = 1;
54792
- root.edges.push(ce);
54793
- ce.graphSeq = root.edges.length;
54794
- return ce;
54795
- }
54796
- function checkCompound(e, root, cmap, map, delSet, idx) {
54797
- const t = e.tail;
54798
- const h = e.head;
54799
- if (h.info.clustnode) return 0;
54800
- const tg = mapc(cmap, t);
54801
- const hg = mapc(cmap, h);
54802
- if (!tg && !hg) return 0;
54803
- if (tg === hg) return 0;
54804
- const ip = mapEdge2(map, t, h);
54805
- if (ip) {
54806
- cloneEdge2(root, e, ip.t, ip.h);
54807
- return 1;
54808
- }
54809
- let cn;
54810
- let ce;
54811
- if (hg) {
54812
- if (tg) {
54813
- if (agContains(hg, tg) || agContains(tg, hg)) return 0;
54814
- cn = clustNode(t, tg, root, delSet, idx);
54815
- const cn1 = clustNode(h, hg, root, delSet, idx);
54816
- ce = cloneEdge2(root, e, cn, cn1);
54817
- insertEdge2(map, t, h, ce);
54818
- } else {
54819
- if (agContainsNode2(hg, t)) return 0;
54820
- cn = clustNode(h, hg, root, delSet, idx);
54821
- ce = cloneEdge2(root, e, t, cn);
54822
- insertEdge2(map, t, h, ce);
54823
- }
54824
- } else {
54825
- if (agContainsNode2(tg, h)) return 0;
54826
- cn = clustNode(t, tg, root, delSet, idx);
54827
- ce = cloneEdge2(root, e, cn, h);
54828
- insertEdge2(map, t, h, ce);
54829
- }
54830
- return 1;
54831
- }
54832
- function agContains(a, b) {
54833
- for (let g = b; g !== null; g = g.parent) {
54834
- if (g === a) return true;
54835
- }
54836
- return false;
54837
- }
54838
- function agContainsNode2(cg, n) {
54839
- return cg.nodes.has(n.name);
54840
- }
54841
- function deleteNodeAndEdges(root, n) {
54842
- const purge = (gr) => {
54843
- if (gr.edges.length > 0) {
54844
- gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
54845
- }
54846
- gr.nodes.delete(n.name);
54847
- for (const sg of gr.subgraphs.values()) purge(sg);
54848
- };
54849
- purge(root);
54850
- }
54851
- function processClusterEdges(g) {
54852
- const root = g.root;
54853
- const cmap = mkClustMap2(g);
54854
- if (cmap.size === 0) return;
54855
- const map = /* @__PURE__ */ new Map();
54856
- const delSet = /* @__PURE__ */ new Set();
54857
- const idx = { v: 0 };
54858
- let numClEdges = 0;
54859
- for (const n of [...g.nodes.values()]) {
54860
- if (n.info.clustnode) continue;
54861
- for (const e of n.outEdges(g)) {
54862
- numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
54863
- }
54864
- }
54865
- for (const n of delSet) deleteNodeAndEdges(root, n);
54866
- if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
54867
- }
54868
-
54869
55676
  // src/layout/fdp/init.ts
54870
55677
  function initialPositions3(g) {
54871
55678
  const div = inputscaleDivisor(g);
@@ -55723,7 +56530,7 @@ function deriveEdges(g, dg, byPair) {
55723
56530
  dndata(hd).deg++;
55724
56531
  dndata(tl).deg++;
55725
56532
  }
55726
- addEdge2(de, e);
56533
+ addEdge3(de, e);
55727
56534
  }
55728
56535
  }
55729
56536
  }
@@ -55745,7 +56552,7 @@ function derivePort(g, dg, byPair, port, m) {
55745
56552
  const de = deriveEdge(dg, byPair, m, dn);
55746
56553
  de.info.dist = port.e.info.dist;
55747
56554
  de.info.factor = port.e.info.factor;
55748
- addEdge2(de, port.e);
56555
+ addEdge3(de, port.e);
55749
56556
  dndata(dn).wdeg++;
55750
56557
  dndata(m).wdeg++;
55751
56558
  dndata(dn).deg++;
@@ -55855,7 +56662,7 @@ function expandCluster2(n, cg) {
55855
56662
  }
55856
56663
 
55857
56664
  // src/layout/fdp/layout.ts
55858
- var POINTS_PER_INCH13 = 72;
56665
+ var POINTS_PER_INCH14 = 72;
55859
56666
  var DEFAULT_NODEWIDTH_PTS = 54;
55860
56667
  var DEFAULT_NODEHEIGHT_PTS = 36;
55861
56668
  function initInfo(g) {
@@ -55950,7 +56757,7 @@ function shiftComponents(cc, pts, pt) {
55950
56757
  } else {
55951
56758
  p = pt;
55952
56759
  }
55953
- 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 };
55954
56761
  for (const n of cc[i].nodes.values()) {
55955
56762
  n.info.pos[0] += del.x;
55956
56763
  n.info.pos[1] += del.y;
@@ -55966,8 +56773,8 @@ function finalCC(g, cc, pts, rg, infop) {
55966
56773
  const pt = applyMarginAndBorder(rg, bb, margin);
55967
56774
  if (cc.length > 0) shiftComponents(cc, pts, pt);
55968
56775
  gdata(g).bb = {
55969
- ll: { x: bb.ll.x / POINTS_PER_INCH13, y: bb.ll.y / POINTS_PER_INCH13 },
55970
- 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 }
55971
56778
  };
55972
56779
  }
55973
56780
  function applyMarginAndBorder(rg, bb, margin) {
@@ -56013,8 +56820,8 @@ function translateOwnNodes(g, bb) {
56013
56820
  function setBB(g) {
56014
56821
  const bb = gdata(g).bb;
56015
56822
  g.info.bb = {
56016
- ll: { x: POINTS_PER_INCH13 * bb.ll.x, y: POINTS_PER_INCH13 * bb.ll.y },
56017
- 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 }
56018
56825
  };
56019
56826
  const nClusters = g.info.n_cluster ?? 0;
56020
56827
  for (let i = 0; i < nClusters; i++) {
@@ -56029,8 +56836,8 @@ function setClustNodes(root) {
56029
56836
  const bb = gdata(p).bb;
56030
56837
  const w = bb.ur.x - bb.ll.x;
56031
56838
  const h = bb.ur.y - bb.ll.y;
56032
- const w2 = POINTS_PER_INCH13 * (w / 2);
56033
- const h2 = POINTS_PER_INCH13 * (h / 2);
56839
+ const w2 = POINTS_PER_INCH14 * (w / 2);
56840
+ const h2 = POINTS_PER_INCH14 * (h / 2);
56034
56841
  n.info.pos[0] = w / 2;
56035
56842
  n.info.pos[1] = h / 2;
56036
56843
  n.info.width = w;
@@ -56039,7 +56846,7 @@ function setClustNodes(root) {
56039
56846
  n.info.outline_width = w + penwidth;
56040
56847
  n.info.outline_height = h + penwidth;
56041
56848
  n.info.lw = n.info.rw = w2;
56042
- n.info.ht = POINTS_PER_INCH13 * h;
56849
+ n.info.ht = POINTS_PER_INCH14 * h;
56043
56850
  const poly = n.info.shape_info;
56044
56851
  if (poly && poly.vertices) {
56045
56852
  poly.vertices[0] = { x: w2, y: h2 };
@@ -56052,8 +56859,8 @@ function setClustNodes(root) {
56052
56859
  function syncCoordFromPos(cg) {
56053
56860
  for (const n of cg.nodes.values()) {
56054
56861
  n.info.coord = {
56055
- x: POINTS_PER_INCH13 * n.info.pos[0],
56056
- 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]
56057
56864
  };
56058
56865
  }
56059
56866
  }
@@ -56065,8 +56872,8 @@ function expandComponentClusters(cg, infop, counter) {
56065
56872
  if (r !== 0) return r;
56066
56873
  n.info.width = gdata(sg).bb.ur.x;
56067
56874
  n.info.height = gdata(sg).bb.ur.y;
56068
- const ptx = POINTS_PER_INCH13 * gdata(sg).bb.ur.x;
56069
- 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;
56070
56877
  n.info.rw = n.info.lw = ptx / 2;
56071
56878
  n.info.ht = pty;
56072
56879
  } else if (isPort(n)) {
@@ -56630,15 +57437,15 @@ function multilevelSpringElectricalEmbedding(dim, A0, ctrl, labelSizes, x) {
56630
57437
  }
56631
57438
 
56632
57439
  // src/layout/sfdp/index.ts
56633
- var DIM = 2;
56634
57440
  function sfdpLayoutComponent(g, ctrl, pad) {
57441
+ const ndim = ndimOf(g);
56635
57442
  const A3 = makeMatrix(g);
56636
- const sizes = ctrl.overlap >= 0 ? getSizes(g, pad) : null;
56637
- const pos = getPos(g, DIM);
56638
- 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);
56639
57446
  for (const n of g.nodes.values()) {
56640
57447
  const i = n.info.id;
56641
- n.info.pos = [pos[i * DIM], pos[i * DIM + 1]];
57448
+ n.info.pos = pos.slice(i * ndim, (i + 1) * ndim);
56642
57449
  }
56643
57450
  }
56644
57451
  function resolveControl(g) {
@@ -56649,7 +57456,8 @@ function resolveControl(g) {
56649
57456
  const flag = overlap5 === void 0 ? "prism0" : overlap5;
56650
57457
  warnUnrecognizedOverlap(flag);
56651
57458
  const ntry = overlapPrismTries(flag);
56652
- if (ntry !== null) {
57459
+ const doAdjust = ndimOf(g) === 2;
57460
+ if (ntry !== null && doAdjust) {
56653
57461
  ctrl.overlap = ntry;
56654
57462
  ctrl.initialScaling = lateDouble(
56655
57463
  g.root.attrs.get("overlap_scaling"),
@@ -56664,7 +57472,7 @@ function resolveControl(g) {
56664
57472
  return { ctrl, pad, doAdjust: false };
56665
57473
  }
56666
57474
  ctrl.overlap = -1;
56667
- return { ctrl, pad, doAdjust: true };
57475
+ return { ctrl, pad, doAdjust };
56668
57476
  }
56669
57477
  function layoutComponents3(g, comps, ctrl, pad, doAdjust) {
56670
57478
  const pinfo = {
@@ -56712,6 +57520,7 @@ function sfdpLayout(g) {
56712
57520
  } else {
56713
57521
  layoutComponents3(g, comps, ctrl, pad, doAdjust);
56714
57522
  }
57523
+ for (const c of comps) agdelsubg(g, c);
56715
57524
  }
56716
57525
  postprocess(g, singleComponent);
56717
57526
  }
@@ -57625,7 +58434,7 @@ function buildDerivedEdges(g, dg) {
57625
58434
  return edges;
57626
58435
  }
57627
58436
  function derivedComponents(g, dg, allEdges3) {
57628
- const comps = ccomps(g);
58437
+ const comps = ccomps(g, null, false);
57629
58438
  return comps.map((sg, i) => {
57630
58439
  const nodes = [];
57631
58440
  for (const n of sg.nodes.values()) {
@@ -57759,6 +58568,7 @@ function twopiLayout(g) {
57759
58568
  } else {
57760
58569
  layoutMulti(g, comps, globalRoot, buildPackInfo(g));
57761
58570
  }
58571
+ for (const c of comps) agdelsubg(g, c);
57762
58572
  normalizeGraphBB(g);
57763
58573
  placeGraphLabel(g);
57764
58574
  gvPostprocess(g);
@@ -58571,8 +59381,8 @@ var forfunc = (cur, total, init) => (1 - cur / total) * init / 2;
58571
59381
  var revfunc = (cur, total, init) => cur / total * init / 2;
58572
59382
  var nonefunc = (_cur, _total, init) => init / 2;
58573
59383
  var bothfunc = (cur, total, init) => {
58574
- const fr10 = cur / total;
58575
- return fr10 <= 0.5 ? fr10 * init : (1 - fr10) * init;
59384
+ const fr12 = cur / total;
59385
+ return fr12 <= 0.5 ? fr12 * init : (1 - fr12) * init;
58576
59386
  };
58577
59387
  function taperfun(dir, directed) {
58578
59388
  if (dir === "forward") return forfunc;
@@ -59434,6 +60244,15 @@ function trimFixed3(v) {
59434
60244
  function edgeAttrsAttached(e) {
59435
60245
  return e.info.edge_type !== IGNORED && e.info.spl != null;
59436
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
+ }
59437
60256
  function appendRecordRects(n, f, out) {
59438
60257
  const c = n.info.coord;
59439
60258
  if (f.n_flds === 0) {
@@ -59905,7 +60724,7 @@ var DotWriterBase = class {
59905
60724
  nodeAttrs(n, scope) {
59906
60725
  const info = n.info;
59907
60726
  const defs = effectiveNodeDefaults2(scope);
59908
- const posRaw = gfmt5(info.coord.x) + "," + gfmt5(info.coord.y);
60727
+ const posRaw = nodePosRaw(n);
59909
60728
  const widthRaw = gfmt5((info.lw + info.rw) / 72);
59910
60729
  const heightRaw = gfmt5(info.ht / 72);
59911
60730
  const parts = [
@@ -60157,13 +60976,13 @@ var EdgeDrawBase = class extends DotWriterBase {
60157
60976
  };
60158
60977
 
60159
60978
  // src/render/dot/write-back.ts
60160
- var POINTS_PER_INCH14 = 72;
60979
+ var POINTS_PER_INCH15 = 72;
60161
60980
  function attachNode(n) {
60162
60981
  const attrs = ownAttrs(n);
60163
60982
  const info = n.info;
60164
- attrs.set("pos", gfmt5(info.coord.x) + "," + gfmt5(info.coord.y));
60165
- attrs.set("height", gfmt5(info.ht / POINTS_PER_INCH14));
60166
- 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));
60167
60986
  const xlabel = info.xlabel;
60168
60987
  if (xlabel?.set) attrs.set("xlp", lpStr(xlabel.pos));
60169
60988
  if (info.shape?.name === "record") {
@@ -60193,8 +61012,8 @@ function recAttachBb(g) {
60193
61012
  const label = g.info.label;
60194
61013
  if (label && label.text.length > 0) {
60195
61014
  g.attrs.set("lp", lpStr(label.pos));
60196
- g.attrs.set("lwidth", gfmt2(label.dimen.x / POINTS_PER_INCH14));
60197
- 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));
60198
61017
  }
60199
61018
  for (const sg of clustersOf(g)) recAttachBb(sg);
60200
61019
  }
@@ -61268,7 +62087,7 @@ function insertEdge3(g, root, edge) {
61268
62087
  cur.edges.push(edge);
61269
62088
  }
61270
62089
  }
61271
- function addEdge3(g, tail, head, name) {
62090
+ function addEdge4(g, tail, head, name) {
61272
62091
  requireObject("g", g);
61273
62092
  requireObject("tail", tail);
61274
62093
  requireObject("head", head);
@@ -61405,7 +62224,7 @@ var GraphBuilder = class _GraphBuilder {
61405
62224
  requireAttrs("attrs", attrs);
61406
62225
  const tailNode = resolveNode2(this._graph, tail);
61407
62226
  const headNode = resolveNode2(this._graph, head);
61408
- const edge = addEdge3(this._graph, tailNode, headNode);
62227
+ const edge = addEdge4(this._graph, tailNode, headNode);
61409
62228
  applyAttrs2(edge.attrs, attrs);
61410
62229
  return new EdgeHandle(edge);
61411
62230
  }
@@ -62055,7 +62874,7 @@ export {
62055
62874
  LutTextMeasurer,
62056
62875
  ParseError,
62057
62876
  RenderError,
62058
- addEdge3 as addEdge,
62877
+ addEdge4 as addEdge,
62059
62878
  createGraph,
62060
62879
  getDrawOps,
62061
62880
  getLayout,