@knowvah/dot-engine 2.10.3 → 2.12.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 (342) hide show
  1. package/dist/common/agerr.d.ts +12 -0
  2. package/dist/common/agerr.d.ts.map +1 -1
  3. package/dist/gvc/context.d.ts.map +1 -1
  4. package/dist/gvc/emit-xdot.d.ts.map +1 -1
  5. package/dist/gvc/layout-reset.d.ts +38 -1
  6. package/dist/gvc/layout-reset.d.ts.map +1 -1
  7. package/dist/index.d.ts +2 -0
  8. package/dist/index.d.ts.map +1 -1
  9. package/dist/index.js +1260 -387
  10. package/dist/index.js.map +4 -4
  11. package/dist/layout/circo/circular.d.ts.map +1 -1
  12. package/dist/layout/dot/edge-route-chain.d.ts.map +1 -1
  13. package/dist/layout/dot/edge-route-helpers.d.ts +6 -1
  14. package/dist/layout/dot/edge-route-helpers.d.ts.map +1 -1
  15. package/dist/layout/dot/edge-route-rank.d.ts +4 -1
  16. package/dist/layout/dot/edge-route-rank.d.ts.map +1 -1
  17. package/dist/layout/dot/index.d.ts.map +1 -1
  18. package/dist/layout/dot/init.d.ts.map +1 -1
  19. package/dist/layout/fdp/cluster-edges.d.ts +11 -0
  20. package/dist/layout/fdp/cluster-edges.d.ts.map +1 -1
  21. package/dist/layout/neato/closest.d.ts +20 -0
  22. package/dist/layout/neato/closest.d.ts.map +1 -0
  23. package/dist/layout/neato/constrained-majorization.d.ts +13 -0
  24. package/dist/layout/neato/constrained-majorization.d.ts.map +1 -1
  25. package/dist/layout/neato/embed-graph.d.ts +20 -0
  26. package/dist/layout/neato/embed-graph.d.ts.map +1 -0
  27. package/dist/layout/neato/fdp-adjust.d.ts.map +1 -1
  28. package/dist/layout/neato/index.d.ts.map +1 -1
  29. package/dist/layout/neato/init-dim.d.ts +54 -0
  30. package/dist/layout/neato/init-dim.d.ts.map +1 -0
  31. package/dist/layout/neato/init.d.ts +1 -11
  32. package/dist/layout/neato/init.d.ts.map +1 -1
  33. package/dist/layout/neato/kk.d.ts +4 -2
  34. package/dist/layout/neato/kk.d.ts.map +1 -1
  35. package/dist/layout/neato/matrix-ops-dense.d.ts +34 -0
  36. package/dist/layout/neato/matrix-ops-dense.d.ts.map +1 -0
  37. package/dist/layout/neato/pca.d.ts +14 -0
  38. package/dist/layout/neato/pca.d.ts.map +1 -0
  39. package/dist/layout/neato/sgd.d.ts +2 -3
  40. package/dist/layout/neato/sgd.d.ts.map +1 -1
  41. package/dist/layout/neato/start.d.ts +5 -5
  42. package/dist/layout/neato/start.d.ts.map +1 -1
  43. package/dist/layout/neato/stress-kernel.d.ts +10 -2
  44. package/dist/layout/neato/stress-kernel.d.ts.map +1 -1
  45. package/dist/layout/neato/stress-subspace.d.ts +39 -0
  46. package/dist/layout/neato/stress-subspace.d.ts.map +1 -0
  47. package/dist/layout/neato/vpsc-adjust.d.ts.map +1 -1
  48. package/dist/layout/pack/ccomps.d.ts +4 -2
  49. package/dist/layout/pack/ccomps.d.ts.map +1 -1
  50. package/dist/layout/sfdp/index.d.ts.map +1 -1
  51. package/dist/layout/sfdp/init.d.ts +6 -7
  52. package/dist/layout/sfdp/init.d.ts.map +1 -1
  53. package/dist/layout/twopi/circle.d.ts.map +1 -1
  54. package/dist/layout/twopi/index.d.ts.map +1 -1
  55. package/dist/render/dot/attrs.d.ts +7 -0
  56. package/dist/render/dot/attrs.d.ts.map +1 -1
  57. package/dist/render.js +1637 -770
  58. package/dist/render.js.map +4 -4
  59. package/package.json +4 -4
  60. package/src/common/agerr.ts +49 -1
  61. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.1 +20 -0
  62. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.2 +20 -0
  63. package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.3 +20 -0
  64. package/src/gvc/__fixtures__/rerender/abom-shift-pack.gv +1 -0
  65. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.1 +22 -0
  66. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.2 +22 -0
  67. package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.3 +22 -0
  68. package/src/gvc/__fixtures__/rerender/abom-shift-parity.gv +1 -0
  69. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.1 +13 -0
  70. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.2 +13 -0
  71. package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.3 +13 -0
  72. package/src/gvc/__fixtures__/rerender/abom-shift.gv +1 -0
  73. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.1 +10 -0
  74. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.2 +11 -0
  75. package/src/gvc/__fixtures__/rerender/cluster-edge-splines.gv +9 -0
  76. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.1 +40 -0
  77. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.2 +40 -0
  78. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.1 +15 -0
  79. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.2 +17 -0
  80. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.1 +40 -0
  81. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.2 +15 -0
  82. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.1 +40 -0
  83. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.2 +99 -0
  84. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.1 +489 -0
  85. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.2 +503 -0
  86. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.1 +40 -0
  87. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.2 +109 -0
  88. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.1 +69 -0
  89. package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.2 +70 -0
  90. package/src/gvc/__fixtures__/rerender/cluster-edges.gv +15 -0
  91. package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.1 +104 -0
  92. package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.2 +104 -0
  93. package/src/gvc/__fixtures__/rerender/fdp-1581.gv +26 -0
  94. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.1 +34 -0
  95. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.2 +34 -0
  96. package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.3 +34 -0
  97. package/src/gvc/__fixtures__/rerender/flat-rev-stale.gv +33 -0
  98. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.1 +181 -0
  99. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.2 +218 -0
  100. package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.3 +255 -0
  101. package/src/gvc/__fixtures__/rerender/regen.sh +25 -0
  102. package/src/gvc/context.ts +7 -2
  103. package/src/gvc/emit-xdot.ts +37 -7
  104. package/src/gvc/layout-reset.ts +59 -1
  105. package/src/index.ts +4 -0
  106. package/src/layout/circo/circular.ts +3 -1
  107. package/src/layout/dot/edge-route-chain.ts +79 -7
  108. package/src/layout/dot/edge-route-helpers.ts +8 -2
  109. package/src/layout/dot/edge-route-rank.ts +20 -2
  110. package/src/layout/dot/index.ts +17 -2
  111. package/src/layout/dot/init.ts +9 -17
  112. package/src/layout/dot/splines-flat.ts +12 -12
  113. package/src/layout/dot/splines.ts +2 -2
  114. package/src/layout/fdp/cluster-edges.ts +0 -0
  115. package/src/layout/fdp/index.ts +2 -2
  116. package/src/layout/neato/__fixtures__/dim/circuit-dim3.dot +33 -0
  117. package/src/layout/neato/__fixtures__/dim/circuit-dim3.gv +12 -0
  118. package/src/layout/neato/__fixtures__/dim/circuit-dim3.stderr +0 -0
  119. package/src/layout/neato/__fixtures__/dim/circuit-dim3.xdot +54 -0
  120. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.dot +32 -0
  121. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.gv +11 -0
  122. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.stderr +0 -0
  123. package/src/layout/neato/__fixtures__/dim/dim11-dimen11.xdot +53 -0
  124. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.dot +32 -0
  125. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.gv +11 -0
  126. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.stderr +0 -0
  127. package/src/layout/neato/__fixtures__/dim/dim3-dimen3.xdot +53 -0
  128. package/src/layout/neato/__fixtures__/dim/dim3.dot +31 -0
  129. package/src/layout/neato/__fixtures__/dim/dim3.gv +10 -0
  130. package/src/layout/neato/__fixtures__/dim/dim3.stderr +0 -0
  131. package/src/layout/neato/__fixtures__/dim/dim3.xdot +52 -0
  132. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.dot +32 -0
  133. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.gv +11 -0
  134. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.stderr +0 -0
  135. package/src/layout/neato/__fixtures__/dim/dim4-dimen4.xdot +53 -0
  136. package/src/layout/neato/__fixtures__/dim/dimen3.dot +31 -0
  137. package/src/layout/neato/__fixtures__/dim/dimen3.gv +10 -0
  138. package/src/layout/neato/__fixtures__/dim/dimen3.stderr +0 -0
  139. package/src/layout/neato/__fixtures__/dim/dimen3.xdot +52 -0
  140. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.dot +267 -0
  141. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.gv +84 -0
  142. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.stderr +0 -0
  143. package/src/layout/neato/__fixtures__/dim/hier-big-dim3.xdot +468 -0
  144. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.dot +267 -0
  145. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.gv +84 -0
  146. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.stderr +0 -0
  147. package/src/layout/neato/__fixtures__/dim/hier-big-dim4.xdot +468 -0
  148. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.dot +268 -0
  149. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.gv +85 -0
  150. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.stderr +0 -0
  151. package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.xdot +469 -0
  152. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.dot +484 -0
  153. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.gv +151 -0
  154. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.stderr +0 -0
  155. package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.xdot +852 -0
  156. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.dot +34 -0
  157. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.gv +13 -0
  158. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.stderr +0 -0
  159. package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.xdot +55 -0
  160. package/src/layout/neato/__fixtures__/dim/hier-dim3.dot +33 -0
  161. package/src/layout/neato/__fixtures__/dim/hier-dim3.gv +12 -0
  162. package/src/layout/neato/__fixtures__/dim/hier-dim3.stderr +0 -0
  163. package/src/layout/neato/__fixtures__/dim/hier-dim3.xdot +54 -0
  164. package/src/layout/neato/__fixtures__/dim/hier-dim4.dot +33 -0
  165. package/src/layout/neato/__fixtures__/dim/hier-dim4.gv +12 -0
  166. package/src/layout/neato/__fixtures__/dim/hier-dim4.stderr +0 -0
  167. package/src/layout/neato/__fixtures__/dim/hier-dim4.xdot +54 -0
  168. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.dot +32 -0
  169. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.gv +11 -0
  170. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.stderr +0 -0
  171. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.xdot +53 -0
  172. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.dot +34 -0
  173. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.gv +13 -0
  174. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.stderr +0 -0
  175. package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.xdot +55 -0
  176. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.dot +37 -0
  177. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.gv +12 -0
  178. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.stderr +0 -0
  179. package/src/layout/neato/__fixtures__/dim/hier-len-dim3.xdot +58 -0
  180. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.dot +141 -0
  181. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.gv +48 -0
  182. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.stderr +1 -0
  183. package/src/layout/neato/__fixtures__/dim/hier-noedge-big.xdot +233 -0
  184. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.dot +21 -0
  185. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.gv +8 -0
  186. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.stderr +1 -0
  187. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.xdot +33 -0
  188. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.dot +23 -0
  189. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.gv +10 -0
  190. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.stderr +1 -0
  191. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.xdot +35 -0
  192. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.dot +23 -0
  193. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.gv +10 -0
  194. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.stderr +1 -0
  195. package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.xdot +35 -0
  196. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.dot +26 -0
  197. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.gv +7 -0
  198. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.stderr +0 -0
  199. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.xdot +44 -0
  200. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.dot +28 -0
  201. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.gv +9 -0
  202. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.stderr +0 -0
  203. package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.xdot +46 -0
  204. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.dot +48 -0
  205. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.gv +15 -0
  206. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.stderr +0 -0
  207. package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.xdot +79 -0
  208. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.dot +56 -0
  209. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.gv +17 -0
  210. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.stderr +0 -0
  211. package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.xdot +94 -0
  212. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.dot +47 -0
  213. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.gv +14 -0
  214. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.stderr +0 -0
  215. package/src/layout/neato/__fixtures__/dim/hier-star-dim3.xdot +78 -0
  216. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.dot +34 -0
  217. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.gv +13 -0
  218. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.stderr +0 -0
  219. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.xdot +55 -0
  220. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.dot +34 -0
  221. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.gv +13 -0
  222. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.stderr +0 -0
  223. package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.xdot +55 -0
  224. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.dot +34 -0
  225. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.gv +13 -0
  226. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.stderr +0 -0
  227. package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.xdot +55 -0
  228. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.dot +15 -0
  229. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.gv +6 -0
  230. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.stderr +0 -0
  231. package/src/layout/neato/__fixtures__/dim/hier-two-dim3.xdot +22 -0
  232. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.dot +33 -0
  233. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.gv +12 -0
  234. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.stderr +0 -0
  235. package/src/layout/neato/__fixtures__/dim/ipsep-dim3.xdot +54 -0
  236. package/src/layout/neato/__fixtures__/dim/kk-dim3.dot +33 -0
  237. package/src/layout/neato/__fixtures__/dim/kk-dim3.gv +12 -0
  238. package/src/layout/neato/__fixtures__/dim/kk-dim3.stderr +0 -0
  239. package/src/layout/neato/__fixtures__/dim/kk-dim3.xdot +54 -0
  240. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.dot +33 -0
  241. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.gv +12 -0
  242. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.stderr +0 -0
  243. package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.xdot +54 -0
  244. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.dot +39 -0
  245. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.gv +15 -0
  246. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.stderr +0 -0
  247. package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.xdot +60 -0
  248. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.dot +33 -0
  249. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.gv +12 -0
  250. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.stderr +0 -0
  251. package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.xdot +54 -0
  252. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.dot +33 -0
  253. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.gv +12 -0
  254. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.stderr +0 -0
  255. package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.xdot +54 -0
  256. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.dot +33 -0
  257. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.gv +12 -0
  258. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.stderr +0 -0
  259. package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.xdot +54 -0
  260. package/src/layout/neato/__fixtures__/dim/pack-dim3.dot +47 -0
  261. package/src/layout/neato/__fixtures__/dim/pack-dim3.gv +14 -0
  262. package/src/layout/neato/__fixtures__/dim/pack-dim3.stderr +0 -0
  263. package/src/layout/neato/__fixtures__/dim/pack-dim3.xdot +78 -0
  264. package/src/layout/neato/__fixtures__/dim/pins-dim3.dot +38 -0
  265. package/src/layout/neato/__fixtures__/dim/pins-dim3.gv +14 -0
  266. package/src/layout/neato/__fixtures__/dim/pins-dim3.stderr +0 -0
  267. package/src/layout/neato/__fixtures__/dim/pins-dim3.xdot +59 -0
  268. package/src/layout/neato/__fixtures__/dim/regen.sh +24 -0
  269. package/src/layout/neato/__fixtures__/dim/regular-dim3.dot +33 -0
  270. package/src/layout/neato/__fixtures__/dim/regular-dim3.gv +12 -0
  271. package/src/layout/neato/__fixtures__/dim/regular-dim3.stderr +0 -0
  272. package/src/layout/neato/__fixtures__/dim/regular-dim3.xdot +54 -0
  273. package/src/layout/neato/__fixtures__/dim/sgd-dim3.dot +33 -0
  274. package/src/layout/neato/__fixtures__/dim/sgd-dim3.gv +12 -0
  275. package/src/layout/neato/__fixtures__/dim/sgd-dim3.stderr +0 -0
  276. package/src/layout/neato/__fixtures__/dim/sgd-dim3.xdot +54 -0
  277. package/src/layout/neato/__fixtures__/dim/smart-units.json +16 -0
  278. package/src/layout/neato/__fixtures__/dim/subset-dim3.dot +33 -0
  279. package/src/layout/neato/__fixtures__/dim/subset-dim3.gv +12 -0
  280. package/src/layout/neato/__fixtures__/dim/subset-dim3.stderr +0 -0
  281. package/src/layout/neato/__fixtures__/dim/subset-dim3.xdot +54 -0
  282. package/src/layout/neato/closest.ts +206 -0
  283. package/src/layout/neato/constrained-majorization.ts +4 -23
  284. package/src/layout/neato/embed-graph.ts +81 -0
  285. package/src/layout/neato/fdp-adjust.ts +22 -8
  286. package/src/layout/neato/index.ts +26 -17
  287. package/src/layout/neato/init-dim.ts +165 -0
  288. package/src/layout/neato/init.ts +9 -35
  289. package/src/layout/neato/kk.ts +47 -41
  290. package/src/layout/neato/matrix-ops-dense.ts +232 -0
  291. package/src/layout/neato/pca.ts +60 -0
  292. package/src/layout/neato/sgd.ts +14 -13
  293. package/src/layout/neato/start.ts +8 -5
  294. package/src/layout/neato/stress-kernel.ts +65 -5
  295. package/src/layout/neato/stress-subspace.ts +371 -0
  296. package/src/layout/neato/vpsc-adjust.ts +3 -1
  297. package/src/layout/pack/__fixtures__/cc-reuse/circo.dot +23 -0
  298. package/src/layout/pack/__fixtures__/cc-reuse/circo.gv +1 -0
  299. package/src/layout/pack/__fixtures__/cc-reuse/circo.stderr +0 -0
  300. package/src/layout/pack/__fixtures__/cc-reuse/circo.xdot +38 -0
  301. package/src/layout/pack/__fixtures__/cc-reuse/neato.dot +23 -0
  302. package/src/layout/pack/__fixtures__/cc-reuse/neato.gv +1 -0
  303. package/src/layout/pack/__fixtures__/cc-reuse/neato.stderr +0 -0
  304. package/src/layout/pack/__fixtures__/cc-reuse/neato.xdot +38 -0
  305. package/src/layout/pack/__fixtures__/cc-reuse/osage.dot +23 -0
  306. package/src/layout/pack/__fixtures__/cc-reuse/osage.gv +1 -0
  307. package/src/layout/pack/__fixtures__/cc-reuse/osage.stderr +0 -0
  308. package/src/layout/pack/__fixtures__/cc-reuse/osage.xdot +38 -0
  309. package/src/layout/pack/__fixtures__/cc-reuse/regen.sh +24 -0
  310. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.dot +21 -0
  311. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.gv +1 -0
  312. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.stderr +0 -0
  313. package/src/layout/pack/__fixtures__/cc-reuse/sfdp.xdot +36 -0
  314. package/src/layout/pack/__fixtures__/cc-reuse/twopi.dot +21 -0
  315. package/src/layout/pack/__fixtures__/cc-reuse/twopi.gv +1 -0
  316. package/src/layout/pack/__fixtures__/cc-reuse/twopi.stderr +1 -0
  317. package/src/layout/pack/__fixtures__/cc-reuse/twopi.xdot +36 -0
  318. package/src/layout/pack/ccomps.ts +34 -6
  319. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.dot +32 -0
  320. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.gv +11 -0
  321. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.stderr +0 -0
  322. package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.xdot +53 -0
  323. package/src/layout/sfdp/__fixtures__/dim/dim3.dot +31 -0
  324. package/src/layout/sfdp/__fixtures__/dim/dim3.gv +10 -0
  325. package/src/layout/sfdp/__fixtures__/dim/dim3.stderr +0 -0
  326. package/src/layout/sfdp/__fixtures__/dim/dim3.xdot +52 -0
  327. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.dot +32 -0
  328. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.gv +11 -0
  329. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.stderr +0 -0
  330. package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.xdot +53 -0
  331. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.dot +33 -0
  332. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.gv +12 -0
  333. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.stderr +0 -0
  334. package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.xdot +54 -0
  335. package/src/layout/sfdp/__fixtures__/dim/regen.sh +24 -0
  336. package/src/layout/sfdp/index.ts +15 -10
  337. package/src/layout/sfdp/init.ts +26 -11
  338. package/src/layout/twopi/circle.ts +5 -1
  339. package/src/layout/twopi/index.ts +3 -0
  340. package/src/render/dot/agwrite.ts +2 -2
  341. package/src/render/dot/attrs.ts +16 -0
  342. package/src/render/dot/write-back.ts +2 -2
package/dist/index.js CHANGED
@@ -18,6 +18,12 @@ var OCTAL_WIDTH = 3;
18
18
  var OCTAL_RADIX = 8;
19
19
  var lastLevel = "warning";
20
20
  var pending = { line: null, channel: "warn" };
21
+ var usererrf = null;
22
+ function agseterrf(newf) {
23
+ const oldf = usererrf;
24
+ usererrf = newf;
25
+ return oldf;
26
+ }
21
27
  registerRenderState(() => {
22
28
  flushPending();
23
29
  lastLevel = "warning";
@@ -43,7 +49,9 @@ function flushPending() {
43
49
  writeLine(channel, line);
44
50
  }
45
51
  function writeLine(channel, line) {
46
- if (channel === "warn") console.warn(escapeControl(line));
52
+ if (usererrf !== null) usererrf(`${line}
53
+ `);
54
+ else if (channel === "warn") console.warn(escapeControl(line));
47
55
  else console.error(escapeControl(line));
48
56
  }
49
57
  function assemble(level, msg) {
@@ -51,6 +59,13 @@ function assemble(level, msg) {
51
59
  const prefix = level === "error" ? PREFIX_ERROR : PREFIX_WARNING;
52
60
  return `${prefix}${PREFIX_SEP}${msg}`;
53
61
  }
62
+ function outToUser(errf, level, msg) {
63
+ if (level !== "prev") {
64
+ errf(level === "error" ? PREFIX_ERROR : PREFIX_WARNING);
65
+ errf(PREFIX_SEP);
66
+ }
67
+ errf(msg);
68
+ }
54
69
  function channelOf(level) {
55
70
  const eff = level === "prev" ? lastLevel : level;
56
71
  return eff === "warning" ? "warn" : "error";
@@ -58,6 +73,12 @@ function channelOf(level) {
58
73
  function emit(level, msg, channel, hold) {
59
74
  const target = channel ?? channelOf(level);
60
75
  if (level !== "prev") lastLevel = level;
76
+ if (usererrf !== null) {
77
+ flushPending();
78
+ outToUser(usererrf, level, hold ? msg : `${msg}
79
+ `);
80
+ return;
81
+ }
61
82
  const text = assemble(level, msg);
62
83
  if (pending.line === null) {
63
84
  pending.channel = target;
@@ -4195,8 +4216,8 @@ var StmtProcessor = class _StmtProcessor {
4195
4216
  * @see lib/cgraph/edge.c:agedge:274-275 (`if (e == NULL && agisundirected(g))`)
4196
4217
  */
4197
4218
  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}`;
4219
+ const swap4 = undirected && head.id < tail.id;
4220
+ return swap4 ? `${head.id}\0${tail.id}` : `${tail.id}\0${head.id}`;
4200
4221
  }
4201
4222
  /**
4202
4223
  * Apply the DOT-syntax `:port:compass` endpoints to an edge's attrs.
@@ -5575,12 +5596,184 @@ var P_LPROMOTER = {
5575
5596
  vertices: null
5576
5597
  };
5577
5598
 
5599
+ // src/layout/fdp/cluster-edges.ts
5600
+ function fillMap(g, map) {
5601
+ const n = g.info.n_cluster ?? 0;
5602
+ for (let c = 0; c < n; c++) {
5603
+ const cl = g.info.clust[c];
5604
+ const s = cl.name;
5605
+ if (!map.has(s)) map.set(s, cl);
5606
+ fillMap(cl, map);
5607
+ }
5608
+ }
5609
+ function mkClustMap(g) {
5610
+ const map = /* @__PURE__ */ new Map();
5611
+ fillMap(g, map);
5612
+ return map;
5613
+ }
5614
+ function mapc(cmap, n) {
5615
+ if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
5616
+ return null;
5617
+ }
5618
+ function edgeKey(t, h) {
5619
+ return `${t.name}\0${h.name}`;
5620
+ }
5621
+ function mapEdge(map, t, h) {
5622
+ return map.get(edgeKey(t, h));
5623
+ }
5624
+ function insertEdge(map, t, h, ce) {
5625
+ map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
5626
+ map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
5627
+ }
5628
+ function clustNode(n, cg, root, delSet, idx) {
5629
+ const name = `__${idx.v}:${cg.name}`;
5630
+ const cn = agnode(root, name, true);
5631
+ cn.info.clustnode = true;
5632
+ agsubnode(cg, cn, true);
5633
+ delSet.add(n);
5634
+ cn.attrs.set("label", "");
5635
+ cn.attrs.set("style", "invis");
5636
+ cn.attrs.set("shape", "box");
5637
+ return cn;
5638
+ }
5639
+ function nextEdgeSeq(root) {
5640
+ let max = 0;
5641
+ for (const e of root.edges) max = Math.max(max, e.graphSeq);
5642
+ return max + 1;
5643
+ }
5644
+ function cloneEdge(root, e, ct, ch) {
5645
+ const ce = new Edge(ct, ch, "");
5646
+ for (const [k, v] of e.attrs) ce.attrs.set(k, v);
5647
+ ce.info.compound = 1;
5648
+ ce.graphSeq = nextEdgeSeq(root);
5649
+ root.edges.push(ce);
5650
+ return ce;
5651
+ }
5652
+ function checkCompound(e, root, cmap, map, delSet, idx) {
5653
+ const t = e.tail;
5654
+ const h = e.head;
5655
+ if (h.info.clustnode) return 0;
5656
+ const tg = mapc(cmap, t);
5657
+ const hg = mapc(cmap, h);
5658
+ if (!tg && !hg) return 0;
5659
+ if (tg === hg) return 0;
5660
+ const ip = mapEdge(map, t, h);
5661
+ if (ip) {
5662
+ cloneEdge(root, e, ip.t, ip.h);
5663
+ return 1;
5664
+ }
5665
+ let cn;
5666
+ let ce;
5667
+ if (hg) {
5668
+ if (tg) {
5669
+ if (agContains(hg, tg) || agContains(tg, hg)) return 0;
5670
+ cn = clustNode(t, tg, root, delSet, idx);
5671
+ const cn1 = clustNode(h, hg, root, delSet, idx);
5672
+ ce = cloneEdge(root, e, cn, cn1);
5673
+ insertEdge(map, t, h, ce);
5674
+ } else {
5675
+ if (agContainsNode(hg, t)) return 0;
5676
+ cn = clustNode(h, hg, root, delSet, idx);
5677
+ ce = cloneEdge(root, e, t, cn);
5678
+ insertEdge(map, t, h, ce);
5679
+ }
5680
+ } else {
5681
+ if (agContainsNode(tg, h)) return 0;
5682
+ cn = clustNode(t, tg, root, delSet, idx);
5683
+ ce = cloneEdge(root, e, cn, h);
5684
+ insertEdge(map, t, h, ce);
5685
+ }
5686
+ return 1;
5687
+ }
5688
+ function agContains(a, b) {
5689
+ for (let g = b; g !== null; g = g.parent) {
5690
+ if (g === a) return true;
5691
+ }
5692
+ return false;
5693
+ }
5694
+ function agContainsNode(cg, n) {
5695
+ return cg.nodes.has(n.name);
5696
+ }
5697
+ function deleteNodeAndEdges(root, n) {
5698
+ const purge = (gr) => {
5699
+ if (gr.edges.length > 0) {
5700
+ gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
5701
+ }
5702
+ gr.nodes.delete(n.name);
5703
+ for (const sg of gr.subgraphs.values()) purge(sg);
5704
+ };
5705
+ purge(root);
5706
+ }
5707
+ function processClusterEdges(g) {
5708
+ const root = g.root;
5709
+ const cmap = mkClustMap(g);
5710
+ if (cmap.size === 0) return;
5711
+ const map = /* @__PURE__ */ new Map();
5712
+ const delSet = /* @__PURE__ */ new Set();
5713
+ const idx = { v: 0 };
5714
+ let numClEdges = 0;
5715
+ for (const n of [...g.nodes.values()]) {
5716
+ if (n.info.clustnode) continue;
5717
+ for (const e of n.outEdges(g)) {
5718
+ numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
5719
+ }
5720
+ }
5721
+ for (const n of delSet) deleteNodeAndEdges(root, n);
5722
+ if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
5723
+ }
5724
+ function mapN(n, delSet) {
5725
+ if (!n.info.clustnode) return n;
5726
+ delSet.add(n);
5727
+ const name = n.name.slice(n.name.indexOf(":") + 1);
5728
+ const existing = agnode(n.root, name, false);
5729
+ if (existing !== null) return existing;
5730
+ const nn = agnode(n.root, name, true);
5731
+ nn.info.clustnode = true;
5732
+ return nn;
5733
+ }
5734
+ function undoCompound(root, e, delSet) {
5735
+ const ntail = mapN(e.tail, delSet);
5736
+ const nhead = mapN(e.head, delSet);
5737
+ const ce = cloneEdge(root, e, ntail, nhead);
5738
+ ce.info.spl = e.info.spl;
5739
+ e.info.spl = void 0;
5740
+ ce.info.label = e.info.label;
5741
+ e.info.label = void 0;
5742
+ ce.info.xlabel = e.info.xlabel;
5743
+ e.info.xlabel = void 0;
5744
+ ce.info.head_label = e.info.head_label;
5745
+ e.info.head_label = void 0;
5746
+ ce.info.tail_label = e.info.tail_label;
5747
+ e.info.tail_label = void 0;
5748
+ }
5749
+ function undoClusterEdges(g) {
5750
+ if (!g.info.n_cluster_edges) return;
5751
+ const root = g.root;
5752
+ const delSet = /* @__PURE__ */ new Set();
5753
+ const edgelist = [];
5754
+ for (const n of g.nodes.values()) {
5755
+ for (const e of n.outEdges(g)) {
5756
+ if (e.info.compound && isProxyEdge(e)) edgelist.push(e);
5757
+ }
5758
+ }
5759
+ for (const e of edgelist) undoCompound(root, e, delSet);
5760
+ for (const n of delSet) deleteNodeAndEdges(root, n);
5761
+ }
5762
+ function isProxyEdge(e) {
5763
+ return e.tail.info.clustnode && e.tail.name.includes(":") || e.head.info.clustnode && e.head.name.includes(":");
5764
+ }
5765
+
5578
5766
  // src/gvc/layout-reset.ts
5579
5767
  function layoutWasFreed(g) {
5580
5768
  return g.info?.laidOut === true && g.info.cleanup === void 0;
5581
5769
  }
5770
+ function undoRenderedClusterEdges(g) {
5771
+ if (g.info?.n_cluster_edges && g.attrs.get("bb")?.includes(",")) undoClusterEdges(g);
5772
+ }
5582
5773
  function resetGraphRecords(g) {
5774
+ const clusterEdges = g.info.n_cluster_edges;
5583
5775
  g.info = makeGraphInfo();
5776
+ if (clusterEdges !== void 0) g.info.n_cluster_edges = clusterEdges;
5584
5777
  for (const subg of g.subgraphs.values()) resetGraphRecords(subg);
5585
5778
  }
5586
5779
  function resetLayoutRecords(g) {
@@ -5588,6 +5781,21 @@ function resetLayoutRecords(g) {
5588
5781
  for (const e of g.edges) e.info = makeEdgeInfo(makePort(), makePort());
5589
5782
  resetGraphRecords(g);
5590
5783
  }
5784
+ function resetFreedLayouts(g) {
5785
+ const visit = (h) => {
5786
+ if (layoutWasFreed(h)) resetLayoutRecords(h);
5787
+ else for (const subg of h.subgraphs.values()) visit(subg);
5788
+ };
5789
+ visit(g.root);
5790
+ }
5791
+ function bindDotRoot(g) {
5792
+ const droot = g === g.root ? void 0 : g;
5793
+ const visit = (h) => {
5794
+ h.info.dotroot = droot;
5795
+ for (const subg of h.subgraphs.values()) visit(subg);
5796
+ };
5797
+ visit(g);
5798
+ }
5591
5799
 
5592
5800
  // src/xdot/types.ts
5593
5801
  var XDOT_PARSE_ERROR = 1;
@@ -6257,7 +6465,12 @@ var GvcContext = class {
6257
6465
  }
6258
6466
  engine = override2;
6259
6467
  }
6260
- if (layoutWasFreed(g)) resetLayoutRecords(g);
6468
+ undoRenderedClusterEdges(g);
6469
+ if (g.root) {
6470
+ resetFreedLayouts(g);
6471
+ bindDotRoot(g);
6472
+ g.root.info.gvc = this;
6473
+ }
6261
6474
  if (g.info) g.info.gvc = this;
6262
6475
  initXdot(g);
6263
6476
  engine.layout(g);
@@ -22611,13 +22824,13 @@ function dfsNode(Xg, v, frames) {
22611
22824
  frames.push({ v, edges: v.outEdges(Xg).slice(), i: 0 });
22612
22825
  }
22613
22826
  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++];
22827
+ const fr12 = frames[frames.length - 1];
22828
+ if (fr12.i < fr12.edges.length) {
22829
+ const e = fr12.edges[fr12.i++];
22617
22830
  if (e.head.info.onstack) reverseEdge2(Xg, e);
22618
22831
  else if (!e.head.info.mark) dfsNode(Xg, e.head, frames);
22619
22832
  } else {
22620
- fr10.v.info.onstack = 0;
22833
+ fr12.v.info.onstack = 0;
22621
22834
  frames.pop();
22622
22835
  }
22623
22836
  }
@@ -22806,7 +23019,7 @@ function newMatrix(rows, cols) {
22806
23019
  function dotRoot(g) {
22807
23020
  return g.info.dotroot ?? g.root;
22808
23021
  }
22809
- function agContainsNode(g, n) {
23022
+ function agContainsNode2(g, n) {
22810
23023
  return g.nodes.get(n.name) === n;
22811
23024
  }
22812
23025
  function agContainsEdge(g, e) {
@@ -22819,7 +23032,7 @@ function rankSet(rank3, i, n) {
22819
23032
  rank3.v[(rank3.vStart ?? 0) + i] = n;
22820
23033
  }
22821
23034
  function isNormalNodeOf(g, v) {
22822
- return v.info.node_type === NORMAL && agContainsNode(g, v);
23035
+ return v.info.node_type === NORMAL && agContainsNode2(g, v);
22823
23036
  }
22824
23037
  function isVnodeOfEdgeOf(g, v) {
22825
23038
  if (v.info.node_type !== VIRTUAL) return false;
@@ -23255,7 +23468,7 @@ function flatSearchNormal(g, v, e, M2, hascl) {
23255
23468
  }
23256
23469
  function flatSearchEdge(g, v, e, M2, hascl) {
23257
23470
  if (!M2) return false;
23258
- if (hascl && !(agContainsNode(g, e.tail) && agContainsNode(g, e.head))) return false;
23471
+ if (hascl && !(agContainsNode2(g, e.tail) && agContainsNode2(g, e.head))) return false;
23259
23472
  if ((e.info.weight !== void 0 ? e.info.weight : 0) === 0) return false;
23260
23473
  if (e.head.info.onstack) return flatSearchOstack(g, v, e, M2);
23261
23474
  flatSearchNormal(g, v, e, M2, hascl);
@@ -27158,11 +27371,11 @@ function initSubgraphRankdir(g) {
27158
27371
  var CL_CROSS = 1e3;
27159
27372
  function dotInitNode(n) {
27160
27373
  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 };
27374
+ n.info.in = { list: [], size: 0 };
27375
+ n.info.out = { list: [], size: 0 };
27376
+ n.info.flat_in = { list: [], size: 0 };
27377
+ n.info.flat_out = { list: [], size: 0 };
27378
+ n.info.other = { list: [], size: 0 };
27166
27379
  if (n.info.lw === void 0) n.info.lw = 27;
27167
27380
  if (n.info.rw === void 0) n.info.rw = 27;
27168
27381
  if (n.info.ht === void 0) n.info.ht = 36;
@@ -27189,7 +27402,7 @@ function applyNonconstraintZero(e) {
27189
27402
  }
27190
27403
  function dotInitEdge(e) {
27191
27404
  initEdgeConstraint(e);
27192
- e.info.weight = e.attrs.has("weight") ? lateInt(e.attrs.get("weight"), 1, 0) : e.info.weight ?? 1;
27405
+ e.info.weight = lateInt(e.attrs.get("weight"), 1, 0);
27193
27406
  e.info.count = 1;
27194
27407
  e.info.xpenalty = 1;
27195
27408
  applyGroupPenalty(e);
@@ -27219,7 +27432,6 @@ function clearFastGraphLists(n) {
27219
27432
  function dotInitNodeEdge(g) {
27220
27433
  for (const n of nodesInSeq(g)) {
27221
27434
  commonInitNode(n, g);
27222
- clearFastGraphLists(n);
27223
27435
  dotInitNode(n);
27224
27436
  }
27225
27437
  const measurer = g.root.info.gvc?.textMeasurer;
@@ -29687,12 +29899,22 @@ function setGradientFill(obj, color) {
29687
29899
  obj.fill = 2 /* Linear */;
29688
29900
  }
29689
29901
  }
29902
+ var PEN_OF_STYLE = /* @__PURE__ */ new Map([
29903
+ ["solid", 3 /* Solid */],
29904
+ ["dashed", 1 /* Dashed */],
29905
+ ["dotted", 2 /* Dotted */],
29906
+ ["invis", 0 /* None */],
29907
+ ["invisible", 0 /* None */]
29908
+ ]);
29690
29909
  function setStyle(obj, tokens) {
29691
29910
  gvrenderSetStyle(tokens);
29692
29911
  obj.rawStyle = [...tokens];
29693
- const flags = parseStyleFlags(tokens.join(","));
29694
- obj.pen = resolvePenType(flags);
29695
- obj.penWidth = resolvePenWidth(flags, void 0);
29912
+ for (const token of tokens) {
29913
+ const pen = PEN_OF_STYLE.get(styleName(token));
29914
+ if (pen !== void 0) obj.pen = pen;
29915
+ const flags = parseStyleFlags(token);
29916
+ if (flags.bold || flags.setLineWidth !== null) obj.penWidth = resolvePenWidth(flags, void 0);
29917
+ }
29696
29918
  }
29697
29919
  function devicePoints(pts, job) {
29698
29920
  return pts.map((p) => transformPoint({ x: p.x, y: p.y }, job));
@@ -29759,11 +29981,14 @@ function emitXdot(g, renderer, job) {
29759
29981
  for (const op of xd.ops) {
29760
29982
  styled ||= op.kind === "style";
29761
29983
  if (op.kind === "text") continue;
29762
- if (!inClip && isDrawing(op)) continue;
29984
+ if (isDrawing(op) && !drawsNow(obj, inClip)) continue;
29763
29985
  if (!drawOp(op, renderer, job)) stateOp(op, obj, warned2);
29764
29986
  }
29765
29987
  if (styled) setStyle(obj, DEFAULT_LINE_STYLE2);
29766
29988
  }
29989
+ function drawsNow(obj, inClip) {
29990
+ return inClip && obj.pen !== 0 /* None */;
29991
+ }
29767
29992
  function isDrawing(op) {
29768
29993
  return op.kind.endsWith("ellipse") || op.kind.endsWith("polygon") || op.kind.endsWith("bezier") || op.kind === "polyline";
29769
29994
  }
@@ -30725,8 +30950,8 @@ function vnodeNotRelatedTo(g, v) {
30725
30950
  let e = v.info.save_out?.list[0];
30726
30951
  while (e?.info.to_orig) e = e.info.to_orig;
30727
30952
  if (!e) return false;
30728
- if (agContainsNode(g, e.tail)) return false;
30729
- if (agContainsNode(g, e.head)) return false;
30953
+ if (agContainsNode2(g, e.tail)) return false;
30954
+ if (agContainsNode2(g, e.head)) return false;
30730
30955
  return true;
30731
30956
  }
30732
30957
  function keepoutLeft(root, g, r, margin) {
@@ -33257,7 +33482,10 @@ function staleBezierCount(e) {
33257
33482
  return staleBeziersByEdge.get(e) ?? 0;
33258
33483
  }
33259
33484
  function staleAdjacent(e) {
33260
- return staleBezierCount(e) > 0 && (e.info.adjacent ?? 0) !== 0;
33485
+ let rep = e;
33486
+ while (rep.info.to_virt !== void 0 && rep.info.to_virt !== rep) rep = rep.info.to_virt;
33487
+ const samePair = rep.tail === e.tail && rep.head === e.head || rep.tail === e.head && rep.head === e.tail;
33488
+ return staleBezierCount(e) > 0 && ((samePair ? rep : e).info.adjacent ?? 0) !== 0;
33261
33489
  }
33262
33490
  function swapStaleBeziers(g) {
33263
33491
  for (const e of g.edges) {
@@ -33267,8 +33495,13 @@ function swapStaleBeziers(g) {
33267
33495
  const old = spl.list.splice(0, stale).reverse();
33268
33496
  for (const bz of old) swapBezier(bz);
33269
33497
  spl.list.push(...old);
33498
+ fillEdgeArrowSlots(e, old);
33270
33499
  }
33271
33500
  }
33501
+ function fillEdgeArrowSlots(e, old) {
33502
+ e.info.tailArrowOps ??= old.find((bz) => bz.sflag !== 0)?.sArrowOps;
33503
+ e.info.headArrowOps ??= old.find((bz) => bz.eflag !== 0)?.eArrowOps;
33504
+ }
33272
33505
  function rankEdgeInfoOf(g, tailNode, headNode) {
33273
33506
  const rankTable = g.info.rank;
33274
33507
  if (rankTable === void 0) return void 0;
@@ -34424,10 +34657,46 @@ function routeChainSegmented(g, beginEdge, endEdge, segs) {
34424
34657
  }
34425
34658
  return finishChain(w, endEdge, segs[ei], segFirst, segs) ? w.pts : null;
34426
34659
  }
34427
- function routeMultiRankEdgeFaithful(g, e) {
34660
+ function copyPort2(p) {
34661
+ return { ...p, p: { ...p.p } };
34662
+ }
34663
+ function hackflagBeginView(e, back, firstVnode) {
34664
+ const tailPort = back ? e.info.head_port : e.info.tail_port;
34665
+ return {
34666
+ ...e,
34667
+ tail: back ? e.head : e.tail,
34668
+ head: firstVnode,
34669
+ info: {
34670
+ ...e.info,
34671
+ tail_port: copyPort2(tailPort),
34672
+ head_port: { ...copyPort2(e.info.head_port), defined: false, p: { x: 0, y: 0 } },
34673
+ edge_type: VIRTUAL,
34674
+ to_orig: e
34675
+ }
34676
+ };
34677
+ }
34678
+ function hackflagEndView(e, back) {
34679
+ if (back) return makeFwdEdge(e);
34680
+ return {
34681
+ ...e,
34682
+ info: { ...e.info, tail_port: copyPort2(e.info.tail_port), head_port: copyPort2(e.info.head_port) }
34683
+ };
34684
+ }
34685
+ function chainEnds(e, segs) {
34686
+ const first = segs[0];
34687
+ const last = segs[segs.length - 1];
34688
+ const orig = resolveOrigEdge(e);
34689
+ if (resolveOrigEdge(first) === orig) return [first, last];
34690
+ const back = (orig.head.info.rank ?? 0) < (orig.tail.info.rank ?? 0);
34691
+ return [hackflagBeginView(orig, back, first.head), hackflagEndView(orig, back)];
34692
+ }
34693
+ function spansRanksForward(g, e) {
34428
34694
  const r = e.tail.info.rank;
34429
34695
  const rh = e.head.info.rank;
34430
- if (g.info.rank === void 0 || r === void 0 || rh === void 0 || rh <= r + 1) return null;
34696
+ return g.info.rank !== void 0 && r !== void 0 && rh !== void 0 && rh > r + 1;
34697
+ }
34698
+ function routeMultiRankEdgeFaithful(g, e) {
34699
+ if (!spansRanksForward(g, e)) return null;
34431
34700
  const et = edgeType(g);
34432
34701
  if (et === EDGETYPE_LINE) {
34433
34702
  const line = makeLineEdge(g, e);
@@ -34435,7 +34704,8 @@ function routeMultiRankEdgeFaithful(g, e) {
34435
34704
  }
34436
34705
  const segs = chainSegments(e);
34437
34706
  if (segs.length === 0 || segs[segs.length - 1].head !== e.head) return null;
34438
- return routeChainSegmented(g, segs[0], segs[segs.length - 1], segs) ?? "lost";
34707
+ const [beginEdge, endEdge] = chainEnds(e, segs);
34708
+ return routeChainSegmented(g, beginEdge, endEdge, segs) ?? "lost";
34439
34709
  }
34440
34710
  function entryRunSegments(e) {
34441
34711
  const segs = [e];
@@ -34506,7 +34776,8 @@ function routeBackEdge(e, _tailBox, _headBox, g) {
34506
34776
  const segs = backChainSegments(e);
34507
34777
  if (segs.length < 2 || segs[segs.length - 1].head !== e.tail) return;
34508
34778
  const fwdEdge = makeFwdEdge(e);
34509
- const fwd = routeChainSegmented(g, segs[0], segs[segs.length - 1], segs);
34779
+ const [beginEdge, endEdge] = chainEnds(e, segs);
34780
+ const fwd = routeChainSegmented(g, beginEdge, endEdge, segs);
34510
34781
  if (fwd === null) {
34511
34782
  e.info.lost = true;
34512
34783
  return;
@@ -34975,7 +35246,7 @@ function cloneNode(g, orign) {
34975
35246
  }
34976
35247
  return n;
34977
35248
  }
34978
- function cloneEdge(g, tn, hn, orig) {
35249
+ function cloneEdge2(g, tn, hn, orig) {
34979
35250
  const e = new Edge(tn, hn, orig.name);
34980
35251
  e.info.tail_port = { ...makePort(), ...orig.info.tail_port };
34981
35252
  e.info.head_port = { ...makePort(), ...orig.info.head_port };
@@ -36566,7 +36837,7 @@ function mapArrowOps(ops) {
36566
36837
  return m;
36567
36838
  });
36568
36839
  }
36569
- function mapEdge(e) {
36840
+ function mapEdge2(e) {
36570
36841
  const spl = e.info.spl;
36571
36842
  if (spl === void 0) return;
36572
36843
  mapSpl(spl);
@@ -36629,7 +36900,7 @@ function translateDrawing(g) {
36629
36900
  }
36630
36901
  continue;
36631
36902
  }
36632
- mapEdge(e);
36903
+ mapEdge2(e);
36633
36904
  }
36634
36905
  }
36635
36906
  translateBb(g, g.info.rankdir & 3);
@@ -36768,7 +37039,7 @@ function isPortless(e) {
36768
37039
  return !e.info.tail_port.defined && !e.info.head_port.defined;
36769
37040
  }
36770
37041
  function cloneFlatEdge(auxg, tn, auxt, auxh, orig) {
36771
- return orig.tail === tn ? cloneEdge(auxg, auxt, auxh, orig) : cloneEdge(auxg, auxh, auxt, orig);
37042
+ return orig.tail === tn ? cloneEdge2(auxg, auxt, auxh, orig) : cloneEdge2(auxg, auxh, auxt, orig);
36772
37043
  }
36773
37044
  function flatLeadPair(edges) {
36774
37045
  const t = edges[0].tail, h = edges[0].head;
@@ -36793,7 +37064,7 @@ function buildFlatAux(g, edges, cnt) {
36793
37064
  hvye = new Edge(auxt, auxh, "");
36794
37065
  auxg.edges.push(hvye);
36795
37066
  }
36796
- hvye.info.weight = 1e4;
37067
+ hvye.attrs.set("weight", "10000");
36797
37068
  return { auxg, auxt, auxh, alg };
36798
37069
  }
36799
37070
  function blocksAdjacency(vn) {
@@ -36821,8 +37092,9 @@ function repositionFlatAux(g, edges, aux) {
36821
37092
  else n.info.coord = { x: n.info.coord.x, y: midx };
36822
37093
  }
36823
37094
  }
37095
+ var transformArrowOps = (ops, del, flip) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
36824
37096
  function copyFlatArrow(orig, auxe, del, flip) {
36825
- const xf = (ops) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
37097
+ const xf = (ops) => transformArrowOps(ops, del, flip);
36826
37098
  const eflag = auxe.info.spl?.list[0]?.eflag;
36827
37099
  const head = auxe.info.headArrowOps ?? (eflag ? auxe.info.tailArrowOps : void 0);
36828
37100
  if (head !== void 0) orig.info.headArrowOps = xf(head);
@@ -36847,6 +37119,8 @@ function copyOneFlatSpline(orig, auxe, del, flip, g) {
36847
37119
  bz.eflag = auxbz.eflag;
36848
37120
  bz.sp = transformf(auxbz.sp, del, flip);
36849
37121
  bz.ep = transformf(auxbz.ep, del, flip);
37122
+ if (auxbz.sArrowOps) bz.sArrowOps = transformArrowOps(auxbz.sArrowOps, del, flip);
37123
+ if (auxbz.eArrowOps) bz.eArrowOps = transformArrowOps(auxbz.eArrowOps, del, flip);
36850
37124
  for (let j = 0; j < sz; j++) bz.list[j] = transformf(auxbz.list[j], del, flip);
36851
37125
  const bb = g.info.bb;
36852
37126
  if (bb !== void 0) {
@@ -37498,11 +37772,8 @@ function makeBezierRecord(bezierPts, arrowTip) {
37498
37772
  ep: arrowTip
37499
37773
  };
37500
37774
  }
37501
- function makeSplineRecord(bz) {
37502
- return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
37503
- }
37504
37775
  function installEdgeSpline(e, bezierPts, arrowTip) {
37505
- e.info.spl = makeSplineRecord(makeBezierRecord(bezierPts, arrowTip));
37776
+ Object.assign(newSpline(e, bezierPts.length), makeBezierRecord(bezierPts, arrowTip));
37506
37777
  const bb = e.tail.root.info.bb;
37507
37778
  if (bb != null) {
37508
37779
  for (let i = 0; i + 3 < bezierPts.length; i += 3) {
@@ -38599,7 +38870,7 @@ function makeGraph(n) {
38599
38870
  }
38600
38871
  return { nvs: n, vertices };
38601
38872
  }
38602
- function insertEdge(g, v1, v2) {
38873
+ function insertEdge2(g, v1, v2) {
38603
38874
  if (!edgeExists(g, v1, v2)) {
38604
38875
  g.vertices[v1].adjList.push(v2);
38605
38876
  }
@@ -39526,7 +39797,7 @@ function speFlip(isVert, commCoordMatchesP1, lDirMatchesTarget) {
39526
39797
  }
39527
39798
  function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
39528
39799
  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);
39800
+ insertEdge2(chan.G, seg1.indNo, seg2.indNo);
39530
39801
  for (let x = 1; x <= hops; x++) {
39531
39802
  const prev1 = nextSeg(seg1, dir1);
39532
39803
  const prev2 = nextSeg(seg2, dir2);
@@ -39536,8 +39807,8 @@ function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
39536
39807
  const target = seg1.isVert ? 2 /* B_LEFT */ : 1 /* B_UP */;
39537
39808
  const flip = speFlip(seg1.isVert, commCoordMatchesP1, lDir === target);
39538
39809
  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);
39810
+ if (edgeSeen === flip) insertEdge2(nchan.G, prev2.indNo, prev1.indNo);
39811
+ else insertEdge2(nchan.G, prev1.indNo, prev2.indNo);
39541
39812
  chan = nchan;
39542
39813
  seg1 = prev1;
39543
39814
  seg2 = prev2;
@@ -39824,8 +40095,8 @@ function addEdgesInG(cp) {
39824
40095
  for (let y = x + 1; y < size; y++) {
39825
40096
  const cmp = segCmp(cp.segList[x], cp.segList[y]);
39826
40097
  if (cmp === -2) return -1;
39827
- if (cmp > 0) insertEdge(G, x, y);
39828
- else if (cmp === -1) insertEdge(G, y, x);
40098
+ if (cmp > 0) insertEdge2(G, x, y);
40099
+ else if (cmp === -1) insertEdge2(G, y, x);
39829
40100
  }
39830
40101
  }
39831
40102
  return 0;
@@ -40618,7 +40889,7 @@ function orthoDispatch(g) {
40618
40889
  function curvedTop(g) {
40619
40890
  resetRW(g);
40620
40891
  if (((g.root.info.has_labels ?? 0) & EDGE_LABEL) !== 0) {
40621
- agerrLineOn("warn", "edge labels with splines=curved not supported in dot - use xlabels\n");
40892
+ agwarningf("edge labels with splines=curved not supported in dot - use xlabels");
40622
40893
  }
40623
40894
  }
40624
40895
  function finalizeSplines(g, et, normalize) {
@@ -40780,7 +41051,7 @@ function fillClustMap(g, map) {
40780
41051
  fillClustMap(cl, map);
40781
41052
  }
40782
41053
  }
40783
- function mkClustMap(g) {
41054
+ function mkClustMap2(g) {
40784
41055
  const map = /* @__PURE__ */ new Map();
40785
41056
  fillClustMap(g, map);
40786
41057
  return map;
@@ -40935,7 +41206,7 @@ function makeCompoundEdge(e, clustMap) {
40935
41206
  if (tailClipped && bez.sflag) restashArrow(e, bez.sp, bez.list[0], true);
40936
41207
  }
40937
41208
  function dotCompoundEdges(g) {
40938
- const clustMap = mkClustMap(g);
41209
+ const clustMap = mkClustMap2(g);
40939
41210
  for (const e of g.edges) makeCompoundEdge(e, clustMap);
40940
41211
  }
40941
41212
 
@@ -41499,20 +41770,33 @@ function copyParentAttrs(parent2, sg) {
41499
41770
  for (const [k, v] of parent2.attrs) sg.attrs.set(k, v);
41500
41771
  return sg;
41501
41772
  }
41773
+ function componentSubgraph(g, nodes, name, reuse) {
41774
+ const existing = reuse ? g.subgraphs.get(name) : void 0;
41775
+ if (existing === void 0) return copyParentAttrs(g, buildSubgraph(g, nodes, name));
41776
+ const members = /* @__PURE__ */ new Set([...existing.nodes.values(), ...nodes]);
41777
+ existing.nodes.clear();
41778
+ for (const n of [...members].sort((a, b) => a.id - b.id)) existing.nodes.set(n.name, n);
41779
+ const ns = new Set(nodes);
41780
+ const have = new Set(existing.edges);
41781
+ for (const e of g.edges) {
41782
+ if (ns.has(e.tail) && ns.has(e.head) && !have.has(e)) existing.edges.push(e);
41783
+ }
41784
+ return existing;
41785
+ }
41502
41786
  function isLegal(p) {
41503
41787
  return /^[A-Za-z0-9_]*$/.test(p);
41504
41788
  }
41505
41789
  function setPrefix(pfx) {
41506
41790
  return pfx == null || !isLegal(pfx) ? "_cc_" : pfx;
41507
41791
  }
41508
- function ccomps(g, pfx) {
41792
+ function ccomps(g, pfx, reuse = true) {
41509
41793
  const visited = /* @__PURE__ */ new Set();
41510
41794
  const result = [];
41511
41795
  let idx = 0;
41512
41796
  for (const n of g.nodes.values()) {
41513
41797
  if (visited.has(n.name)) continue;
41514
41798
  const comp = dfsCollect(g, n, visited);
41515
- result.push(copyParentAttrs(g, buildSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`)));
41799
+ result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, reuse));
41516
41800
  }
41517
41801
  return result;
41518
41802
  }
@@ -41528,12 +41812,12 @@ function pccomps(g, pfx) {
41528
41812
  pinned = true;
41529
41813
  }
41530
41814
  if (pinnedNodes.length > 0) {
41531
- result.push(copyParentAttrs(g, buildSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`)));
41815
+ result.push(componentSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`, true));
41532
41816
  }
41533
41817
  for (const n of g.nodes.values()) {
41534
41818
  if (visited.has(n.name)) continue;
41535
41819
  const comp = dfsCollect(g, n, visited);
41536
- result.push(copyParentAttrs(g, buildSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`)));
41820
+ result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, true));
41537
41821
  }
41538
41822
  return { graphs: result, pinned };
41539
41823
  }
@@ -41986,8 +42270,15 @@ function setEdgeTypeFromAttr(g, defaultValue) {
41986
42270
  else et = edgeTypeFromString(s, defaultValue);
41987
42271
  setEdgeType(g, et);
41988
42272
  }
42273
+ function resetAbomShift(g) {
42274
+ const shift = g.info.abomShift ?? 0;
42275
+ if (shift !== 0) {
42276
+ for (const n of g.nodes.values()) n.info.rank = (n.info.rank ?? 0) - shift;
42277
+ }
42278
+ g.info.abomShift = 0;
42279
+ }
41989
42280
  function dotPhaseInit(g) {
41990
- for (const e of g.edges) e.info.weight = void 0;
42281
+ resetAbomShift(g);
41991
42282
  dotGraphInit(g);
41992
42283
  setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
41993
42284
  setAspect(g);
@@ -42068,6 +42359,7 @@ function doDot(g) {
42068
42359
  } else if (ratioIsNone(g)) {
42069
42360
  pinfo.doSplines = true;
42070
42361
  layoutAndPack(g, comps, pinfo, origOf);
42362
+ for (const comp of comps) resetAbomShift(comp);
42071
42363
  } else {
42072
42364
  dotLayoutPipeline(g);
42073
42365
  }
@@ -42795,6 +43087,109 @@ function buildMask(max) {
42795
43087
  return mask >>> 0;
42796
43088
  }
42797
43089
 
43090
+ // src/common/utils-inputscale.ts
43091
+ var POINTS_PER_INCH4 = 72;
43092
+ function getInputscale(g) {
43093
+ const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
43094
+ return d === 0 ? POINTS_PER_INCH4 : d;
43095
+ }
43096
+ function inputscaleDivisor(g) {
43097
+ const sc = getInputscale(g);
43098
+ return sc > 0 ? sc : 1;
43099
+ }
43100
+
43101
+ // src/layout/neato/init-dim.ts
43102
+ var DFLT_DIM = 2;
43103
+ var MAXDIM = 10;
43104
+ var POINTS_PER_INCH5 = 72;
43105
+ var NUM = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
43106
+ var POS3 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
43107
+ var POS2 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
43108
+ var Z_NUM = new RegExp(`^\\s*${NUM}`);
43109
+ function neatoInitGraphDim(g) {
43110
+ const root = g.root;
43111
+ const outdim = lateInt(root.attrs.get("dimen"), DFLT_DIM, 2);
43112
+ const ndim = Math.min(lateInt(root.attrs.get("dim"), outdim, 2), MAXDIM);
43113
+ root.info.ndim = ndim;
43114
+ root.info.odim = Math.min(outdim, ndim);
43115
+ return ndim;
43116
+ }
43117
+ function ndimOf(g) {
43118
+ return g.root.info.ndim ?? DFLT_DIM;
43119
+ }
43120
+ function jitterD(np, nG, n, ndim) {
43121
+ const pos = np.info.pos;
43122
+ if (pos === void 0) return;
43123
+ for (let k = n; k < ndim; k++) pos[k] = nG * drand48();
43124
+ }
43125
+ function jitter3d(np, nG, ndim) {
43126
+ jitterD(np, nG, 2, ndim);
43127
+ }
43128
+ function nodeAttrDeclared(g, name) {
43129
+ if (g.nodeDefaults.has(name)) return true;
43130
+ for (const n of g.nodes.values()) if (n.attrs.has(name)) return true;
43131
+ for (const sub of g.subgraphs.values()) if (nodeAttrDeclared(sub, name)) return true;
43132
+ return false;
43133
+ }
43134
+ function zDeclared(g) {
43135
+ return nodeAttrDeclared(g.root, "z");
43136
+ }
43137
+ function zValue(np) {
43138
+ return np.attrs.get("z") ?? np.nodeDefaultsSnapshot?.get("z") ?? "";
43139
+ }
43140
+ function scalePos(pvec, ndim, div) {
43141
+ for (let i = 0; i < ndim; i++) pvec[i] = pvec[i] / div;
43142
+ }
43143
+ function userPos3(np, m, nG, ndim) {
43144
+ const pvec = np.info.pos;
43145
+ pvec[0] = Number(m[1]);
43146
+ pvec[1] = Number(m[2]);
43147
+ pvec[2] = Number(m[3]);
43148
+ scalePos(pvec, ndim, inputscaleDivisor(np.root));
43149
+ if (ndim > 3) jitterD(np, nG, 3, ndim);
43150
+ }
43151
+ function userPos2(np, m, nG, ndim) {
43152
+ const pvec = np.info.pos;
43153
+ const div = inputscaleDivisor(np.root);
43154
+ pvec[0] = Number(m[1]);
43155
+ pvec[1] = Number(m[2]);
43156
+ scalePos(pvec, ndim, div);
43157
+ if (ndim <= 2) return;
43158
+ const zm = zDeclared(np.root) ? Z_NUM.exec(zValue(np)) : null;
43159
+ if (zm === null) {
43160
+ jitter3d(np, nG, ndim);
43161
+ return;
43162
+ }
43163
+ pvec[2] = Number(zm[1]) / div;
43164
+ jitterD(np, nG, 3, ndim);
43165
+ }
43166
+ function ensurePos(n, ndim) {
43167
+ if (n.info.pos === void 0 || n.info.pos.length < ndim) n.info.pos = new Array(ndim).fill(0);
43168
+ }
43169
+ function pinRequested(n, c) {
43170
+ const pin = n.attrs.get("pin");
43171
+ return c === "!" || pin !== void 0 && mapbool(pin);
43172
+ }
43173
+ function userPos(n, ndim = DFLT_DIM, nG = n.root.nodes.size) {
43174
+ const p = n.attrs.get("pos");
43175
+ if (p === void 0 || p.length === 0) return false;
43176
+ const m3 = ndim >= 3 ? POS3.exec(p) : null;
43177
+ const m = m3 ?? POS2.exec(p);
43178
+ if (m === null) return false;
43179
+ n.info.posSet = true;
43180
+ ensurePos(n, ndim);
43181
+ if (m3 !== null) userPos3(n, m3, nG, ndim);
43182
+ else userPos2(n, m, nG, ndim);
43183
+ if (pinRequested(n, m[m.length - 1])) n.info.pinned = true;
43184
+ return true;
43185
+ }
43186
+ function addZ(g) {
43187
+ if (ndimOf(g) < 3 || !zDeclared(g)) return;
43188
+ for (const n of g.nodes.values()) {
43189
+ ownAttrs(n).set("z", (POINTS_PER_INCH5 * (n.info.pos?.[2] ?? 0)).toFixed(6));
43190
+ }
43191
+ }
43192
+
42798
43193
  // src/layout/neato/start.ts
42799
43194
  var INIT_SELF = 0;
42800
43195
  var INIT_REGULAR = 1;
@@ -42833,6 +43228,7 @@ function parseStart(p, dflt) {
42833
43228
  return { init, seed };
42834
43229
  }
42835
43230
  function initRegular(g, nG) {
43231
+ const ndim = ndimOf(g);
42836
43232
  let a = 0;
42837
43233
  const da = 2 * Math.PI / nG;
42838
43234
  for (const np of g.nodes.values()) {
@@ -42840,6 +43236,7 @@ function initRegular(g, nG) {
42840
43236
  np.info.posSet = true;
42841
43237
  np.info.pinned = false;
42842
43238
  a += da;
43239
+ if (ndim > 2) jitter3d(np, nG, ndim);
42843
43240
  }
42844
43241
  }
42845
43242
  function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
@@ -43009,12 +43406,17 @@ function fisheryatesShuffle(terms, state3) {
43009
43406
  function hasPos(np) {
43010
43407
  return np.info.posSet === true || np.info.pinned === true;
43011
43408
  }
43409
+ function randompos(np, nG, ndim) {
43410
+ np.info.pos = [nG * drand48(), nG * drand48()];
43411
+ if (ndim > 2) jitter3d(np, nG, ndim);
43412
+ }
43012
43413
  function initialPositions(g, nG = g.nodes.size) {
43013
43414
  if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) return;
43014
43415
  checkStart(g, nG, INIT_RANDOM);
43416
+ const ndim = ndimOf(g);
43015
43417
  for (const np of g.nodes.values()) {
43016
43418
  if (hasPos(np)) continue;
43017
- np.info.pos = [drand48(), drand48()];
43419
+ randompos(np, 1, ndim);
43018
43420
  }
43019
43421
  }
43020
43422
  function computeSchedule(terms, maxIter, epsilon = SGD_EPSILON) {
@@ -43080,17 +43482,11 @@ function buildUnfixed(g, n) {
43080
43482
  }
43081
43483
  function resolveModel(model) {
43082
43484
  if (model === MODEL_CIRCUIT) {
43083
- agerrLineOn(
43084
- "warn",
43085
- "circuit model not yet supported in Gmode=sgd, reverting to shortpath model"
43086
- );
43485
+ agwarningf("circuit model not yet supported in Gmode=sgd, reverting to shortpath model");
43087
43486
  return MODEL_SHORTPATH;
43088
43487
  }
43089
43488
  if (model === MODEL_MDS) {
43090
- agerrLineOn(
43091
- "warn",
43092
- "mds model not yet supported in Gmode=sgd, reverting to shortpath model"
43093
- );
43489
+ agwarningf("mds model not yet supported in Gmode=sgd, reverting to shortpath model");
43094
43490
  return MODEL_SHORTPATH;
43095
43491
  }
43096
43492
  return model;
@@ -43922,7 +44318,6 @@ function mdsModel2(dist5, n, edges) {
43922
44318
  }
43923
44319
 
43924
44320
  // src/layout/neato/kk.ts
43925
- var NDIM = 2;
43926
44321
  var DEFAULT_DAMPING = 0.99;
43927
44322
  var EPSILON_PER_NODE = 1e-4;
43928
44323
  var ITERATIONS_PER_NODE = 100;
@@ -43983,13 +44378,15 @@ function scanGraphMode(g, maxIter) {
43983
44378
  const damp = g.root.attrs.get("Damping");
43984
44379
  const { total, lens } = setEdgeLens(g, nodes);
43985
44380
  const ini = initialDist(g, total, epsilon);
44381
+ const ndim = ndimOf(g);
43986
44382
  const st = {
43987
44383
  n,
44384
+ ndim,
43988
44385
  nodes,
43989
44386
  dist: new Float64Array(n * n).fill(ini),
43990
44387
  spring: new Float64Array(n * n).fill(1),
43991
- sumT: new Float64Array(n * NDIM).fill(1),
43992
- t: new Float64Array(n * n * NDIM),
44388
+ sumT: new Float64Array(n * ndim).fill(1),
44389
+ t: new Float64Array(n * n * ndim),
43993
44390
  damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
43994
44391
  epsilon,
43995
44392
  maxIter,
@@ -43997,9 +44394,10 @@ function scanGraphMode(g, maxIter) {
43997
44394
  };
43998
44395
  return { st, adj: neighbours(g, nodes, lens), ini, lens };
43999
44396
  }
44000
- function randompos(np) {
44397
+ function randompos2(np, ndim) {
44001
44398
  np.info.pos[0] = drand48();
44002
44399
  np.info.pos[1] = drand48();
44400
+ if (ndim > 2) jitter3d(np, 1, ndim);
44003
44401
  }
44004
44402
  function initialPositions2(g, st) {
44005
44403
  const init = checkStart(g, st.n, INIT_RANDOM);
@@ -44007,12 +44405,12 @@ function initialPositions2(g, st) {
44007
44405
  if (init === INIT_SELF) warnStartSelfOnce();
44008
44406
  for (const np of st.nodes) {
44009
44407
  if (np.info.posSet === true || np.info.pinned === true) continue;
44010
- randompos(np);
44408
+ randompos2(np, st.ndim);
44011
44409
  }
44012
44410
  }
44013
- function distvec(p0, p1, del) {
44411
+ function distvec(p0, p1, del, ndim) {
44014
44412
  let dist5 = 0;
44015
- for (let k = 0; k < NDIM; k++) {
44413
+ for (let k = 0; k < ndim; k++) {
44016
44414
  del[k] = p0[k] - p1[k];
44017
44415
  dist5 = fma(del[k], del[k], dist5);
44018
44416
  }
@@ -44030,14 +44428,15 @@ function springFactors(g) {
44030
44428
  return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
44031
44429
  }
44032
44430
  function fillRow(st, i, del) {
44431
+ const { ndim } = st;
44033
44432
  const vi = st.nodes[i];
44034
44433
  for (let j = 0; j < st.n; j++) {
44035
44434
  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++) {
44435
+ const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
44436
+ for (let k = 0; k < ndim; k++) {
44038
44437
  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;
44438
+ st.t[(i * st.n + j) * ndim + k] = v;
44439
+ st.sumT[i * ndim + k] += v;
44041
44440
  }
44042
44441
  }
44043
44442
  }
@@ -44054,61 +44453,62 @@ function diffeqModel(g, st) {
44054
44453
  }
44055
44454
  }
44056
44455
  st.sumT.fill(0);
44057
- const del = new Float64Array(NDIM);
44456
+ const del = new Float64Array(st.ndim);
44058
44457
  for (let i = 0; i < n; i++) fillRow(st, i, del);
44059
44458
  }
44060
44459
  function updateArrays(st, i) {
44061
- const { n } = st;
44062
- const del = new Float64Array(NDIM);
44460
+ const { n, ndim } = st;
44461
+ const del = new Float64Array(ndim);
44063
44462
  const vi = st.nodes[i];
44064
- for (let k = 0; k < NDIM; k++) st.sumT[i * NDIM + k] = 0;
44463
+ for (let k = 0; k < ndim; k++) st.sumT[i * ndim + k] = 0;
44065
44464
  for (let j = 0; j < n; j++) {
44066
44465
  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++) {
44466
+ const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
44467
+ for (let k = 0; k < ndim; k++) {
44069
44468
  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;
44469
+ st.t[(i * n + j) * ndim + k] = tij;
44470
+ st.sumT[i * ndim + k] += tij;
44471
+ const old = st.t[(j * n + i) * ndim + k];
44472
+ st.t[(j * n + i) * ndim + k] = -tij;
44473
+ st.sumT[j * ndim + k] += -tij - old;
44075
44474
  }
44076
44475
  }
44077
44476
  }
44078
44477
  function d2e(st, m, M2) {
44079
- const { n } = st;
44478
+ const { n, ndim } = st;
44080
44479
  const vn = st.nodes[m];
44081
- const t = new Float64Array(NDIM);
44480
+ const t = new Float64Array(ndim);
44082
44481
  M2.fill(0);
44083
44482
  for (let i = 0; i < n; i++) {
44084
44483
  if (m === i) continue;
44085
44484
  const vi = st.nodes[i];
44086
44485
  let sq = 0;
44087
- for (let k = 0; k < NDIM; k++) {
44486
+ for (let k = 0; k < ndim; k++) {
44088
44487
  t[k] = vn.info.pos[k] - vi.info.pos[k];
44089
44488
  sq = fma(t[k], t[k], sq);
44090
44489
  }
44091
44490
  const scale = 1 / Math.pow(sq, 1.5);
44092
44491
  const K = st.spring[m * n + i];
44093
44492
  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]);
44493
+ for (let k = 0; k < ndim; k++) {
44494
+ for (let l = 0; l < k; l++) M2[l * ndim + k] = fma(K * D * t[k] * t[l], scale, M2[l * ndim + k]);
44096
44495
  const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
44097
- M2[k * NDIM + k] = fma(K, inner, M2[k * NDIM + k]);
44496
+ M2[k * ndim + k] = fma(K, inner, M2[k * ndim + k]);
44098
44497
  }
44099
44498
  }
44100
- for (let k = 1; k < NDIM; k++) {
44101
- for (let l = 0; l < k; l++) M2[k * NDIM + l] = M2[l * NDIM + k];
44499
+ for (let k = 1; k < ndim; k++) {
44500
+ for (let l = 0; l < k; l++) M2[k * ndim + l] = M2[l * ndim + k];
44102
44501
  }
44103
44502
  }
44104
44503
  function chooseNode(st) {
44105
44504
  if (st.move >= st.maxIter) return -1;
44505
+ const { ndim } = st;
44106
44506
  let max = 0;
44107
44507
  let choice = -1;
44108
44508
  for (let i = 0; i < st.n; i++) {
44109
44509
  if (st.nodes[i].info.pinned === true) continue;
44110
44510
  let m = 0;
44111
- for (let k = 0; k < NDIM; k++) m = fma(st.sumT[i * NDIM + k], st.sumT[i * NDIM + k], m);
44511
+ for (let k = 0; k < ndim; k++) m = fma(st.sumT[i * ndim + k], st.sumT[i * ndim + k], m);
44112
44512
  if (m > max) {
44113
44513
  choice = i;
44114
44514
  max = m;
@@ -44117,14 +44517,15 @@ function chooseNode(st) {
44117
44517
  return max < st.epsilon * st.epsilon ? -1 : choice;
44118
44518
  }
44119
44519
  function moveNode(st, m) {
44120
- const a = new Float64Array(NDIM * NDIM);
44121
- const b = new Float64Array(NDIM);
44122
- const c = new Float64Array(NDIM);
44520
+ const { ndim } = st;
44521
+ const a = new Float64Array(ndim * ndim);
44522
+ const b = new Float64Array(ndim);
44523
+ const c = new Float64Array(ndim);
44123
44524
  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);
44525
+ for (let i = 0; i < ndim; i++) c[i] = -st.sumT[m * ndim + i];
44526
+ solve(a, b, c, ndim);
44126
44527
  const pos = st.nodes[m].info.pos;
44127
- for (let i = 0; i < NDIM; i++) {
44528
+ for (let i = 0; i < ndim; i++) {
44128
44529
  b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
44129
44530
  pos[i] += b[i];
44130
44531
  }
@@ -44578,8 +44979,567 @@ function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
44578
44979
  return 0;
44579
44980
  }
44580
44981
 
44581
- // src/layout/neato/stress-kernel.ts
44982
+ // src/layout/neato/embed-graph.ts
44983
+ function saveWeights(graph, n) {
44984
+ return graph[0].ewgts.length === 0 ? null : graph.slice(0, n).map((v) => v.ewgts);
44985
+ }
44986
+ function pivotDistances(node, graph, n, reweightGraph, dist5) {
44987
+ if (reweightGraph) ngdijkstra(node, graph, n, dist5);
44988
+ else bfs(node, graph, n, dist5);
44989
+ }
44990
+ function embedGraph(graph, n, dim, reweightGraph) {
44991
+ const dist5 = new Int32Array(n);
44992
+ const oldWeights = saveWeights(graph, n);
44993
+ const coords = Array.from({ length: dim }, () => new Int32Array(n));
44994
+ if (reweightGraph) computeNewWeights(graph, n);
44995
+ let node = crand() % n;
44996
+ pivotDistances(node, graph, n, reweightGraph, coords[0]);
44997
+ let maxDist = 0;
44998
+ for (let i = 0; i < n; i++) {
44999
+ dist5[i] = coords[0][i];
45000
+ if (dist5[i] > maxDist) {
45001
+ node = i;
45002
+ maxDist = dist5[i];
45003
+ }
45004
+ }
45005
+ for (let i = 1; i < dim; i++) {
45006
+ pivotDistances(node, graph, n, reweightGraph, coords[i]);
45007
+ maxDist = 0;
45008
+ for (let j = 0; j < n; j++) {
45009
+ dist5[j] = Math.min(dist5[j], coords[i][j]);
45010
+ if (dist5[j] > maxDist) {
45011
+ node = j;
45012
+ maxDist = dist5[j];
45013
+ }
45014
+ }
45015
+ }
45016
+ if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
45017
+ return coords;
45018
+ }
45019
+ function centerCoordinate(coords, n, dim) {
45020
+ for (let i = 0; i < dim; i++) {
45021
+ let sum = 0;
45022
+ for (let j = 0; j < n; j++) sum += coords[i][j];
45023
+ const avg = Math.trunc(sum / n);
45024
+ for (let j = 0; j < n; j++) coords[i][j] = coords[i][j] - avg;
45025
+ }
45026
+ }
45027
+
45028
+ // src/layout/neato/matrix-ops-dense.ts
44582
45029
  var fr5 = Math.fround;
45030
+ var P_ITERATION_THRESHOLD = 1e-3;
45031
+ var POWER_LENGTH_FLOOR2 = 1e-10;
45032
+ var GUESS_RANGE = 100;
45033
+ var BLOCK_ROW = 8;
45034
+ function rightMultWithVectorD(matrix, dim1, dim2, vector, result) {
45035
+ const blocked = dim2 - dim2 % BLOCK_ROW;
45036
+ for (let i = 0; i < dim1; i++) {
45037
+ const row = matrix[i];
45038
+ let res = 0;
45039
+ let j = 0;
45040
+ for (; j < blocked; j++) res += row[j] * vector[j];
45041
+ for (; j < dim2; j++) res = fma(row[j], vector[j], res);
45042
+ result[i] = res;
45043
+ }
45044
+ }
45045
+ function rightMultWithVectorTranspose(matrix, dim1, dim2, vector, result) {
45046
+ for (let i = 0; i < dim1; i++) {
45047
+ let res = 0;
45048
+ for (let j = 0; j < dim2; j++) res = fma(matrix[j][i], vector[j], res);
45049
+ result[i] = res;
45050
+ }
45051
+ }
45052
+ function multDenseMat(A3, B2, dim1, dim2, dim3) {
45053
+ const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim3));
45054
+ for (let i = 0; i < dim1; i++) {
45055
+ for (let j = 0; j < dim3; j++) {
45056
+ let sum = 0;
45057
+ for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
45058
+ C6[i][j] = sum;
45059
+ }
45060
+ }
45061
+ return C6;
45062
+ }
45063
+ function multDenseMatD(A3, B2, dim1, dim2, dim3) {
45064
+ const C6 = Array.from({ length: dim1 }, () => new Float64Array(dim3));
45065
+ for (let i = 0; i < dim1; i++) {
45066
+ for (let j = 0; j < dim3; j++) {
45067
+ let sum = 0;
45068
+ for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
45069
+ C6[i][j] = sum;
45070
+ }
45071
+ }
45072
+ return C6;
45073
+ }
45074
+ function multSparseDenseMatTranspose(A3, B2, dim1, dim2) {
45075
+ const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim2));
45076
+ for (let i = 0; i < dim1; i++) {
45077
+ const { edges, ewgts, nedges } = A3[i];
45078
+ for (let j = 0; j < dim2; j++) {
45079
+ let sum = 0;
45080
+ for (let k = 0; k < nedges; k++) sum = fma(fr5(ewgts[k]), B2[j][edges[k]], sum);
45081
+ C6[i][j] = sum;
45082
+ }
45083
+ }
45084
+ return C6;
45085
+ }
45086
+ function orthogonalize(st, i, vec) {
45087
+ for (let j = 0; j < i; j++) {
45088
+ const alpha = -innerProduct(st.n, st.eigs[j], vec, BLOCK_ROW);
45089
+ scadd(vec, st.n - 1, alpha, st.eigs[j]);
45090
+ }
45091
+ }
45092
+ function guess(st, i) {
45093
+ const curr = st.eigs[i];
45094
+ for (let j = 0; j < st.n; j++) curr[j] = crand() % GUESS_RANGE;
45095
+ orthogonalize(st, i, curr);
45096
+ return norm(curr, st.n - 1, BLOCK_NONE);
45097
+ }
45098
+ function iterate(st, i) {
45099
+ const { n, mat, tmpVec, lastVec } = st;
45100
+ const curr = st.eigs[i];
45101
+ let angle;
45102
+ let len;
45103
+ st.iteration = 0;
45104
+ do {
45105
+ st.iteration++;
45106
+ copyVector(n, curr, lastVec);
45107
+ rightMultWithVectorD(mat, n, n, curr, tmpVec);
45108
+ copyVector(n, tmpVec, curr);
45109
+ orthogonalize(st, i, curr);
45110
+ len = norm(curr, n - 1, BLOCK_NONE);
45111
+ if (len < POWER_LENGTH_FLOOR2 || st.iteration > st.maxIterations) return null;
45112
+ vectorsScalarMult(n, curr, 1 / len, curr);
45113
+ angle = innerProduct(n, curr, lastVec, BLOCK_ROW);
45114
+ } while (Math.abs(angle) < st.tol);
45115
+ return angle * len;
45116
+ }
45117
+ function fillNullSpace(st, from, neigs) {
45118
+ for (let i = from; i < neigs; i++) {
45119
+ const len = guess(st, i);
45120
+ vectorsScalarMult(st.n, st.eigs[i], 1 / len, st.eigs[i]);
45121
+ st.evals[i] = 0;
45122
+ }
45123
+ }
45124
+ function sortByEval(st, neigs) {
45125
+ const { n, eigs, evals, tmpVec } = st;
45126
+ for (let i = 0; i < neigs - 1; i++) {
45127
+ let largestIndex = i;
45128
+ let largestEval = evals[largestIndex];
45129
+ for (let j = i + 1; j < neigs; j++) {
45130
+ if (largestEval < evals[j]) {
45131
+ largestIndex = j;
45132
+ largestEval = evals[largestIndex];
45133
+ }
45134
+ }
45135
+ if (largestIndex !== i) {
45136
+ copyVector(n, eigs[i], tmpVec);
45137
+ copyVector(n, eigs[largestIndex], eigs[i]);
45138
+ copyVector(n, tmpVec, eigs[largestIndex]);
45139
+ evals[largestIndex] = evals[i];
45140
+ evals[i] = largestEval;
45141
+ }
45142
+ }
45143
+ }
45144
+ function powerIteration(mat, n, neigsIn, eigs) {
45145
+ const neigs = neigsIn >= n ? n : neigsIn;
45146
+ const st = {
45147
+ mat,
45148
+ n,
45149
+ eigs,
45150
+ evals: new Float64Array(neigs),
45151
+ tmpVec: new Float64Array(n),
45152
+ lastVec: new Float64Array(n),
45153
+ maxIterations: 30 * n,
45154
+ tol: 1 - P_ITERATION_THRESHOLD,
45155
+ iteration: 0
45156
+ };
45157
+ let i = 0;
45158
+ for (; i < neigs; i++) {
45159
+ let len = guess(st, i);
45160
+ while (len < POWER_LENGTH_FLOOR2) len = guess(st, i);
45161
+ vectorsScalarMult(n, eigs[i], 1 / len, eigs[i]);
45162
+ const rayleigh = iterate(st, i);
45163
+ if (rayleigh === null) break;
45164
+ st.evals[i] = rayleigh;
45165
+ }
45166
+ fillNullSpace(st, i, neigs);
45167
+ sortByEval(st, neigs);
45168
+ return st.iteration <= st.maxIterations;
45169
+ }
45170
+
45171
+ // src/layout/neato/closest.ts
45172
+ function greaterPriority2(h, i, j) {
45173
+ const a = h.data[i].dist;
45174
+ const b = h.data[j].dist;
45175
+ return a < b || a === b && crand() % 2 !== 0;
45176
+ }
45177
+ function swap3(h, i, j) {
45178
+ const t = h.data[i];
45179
+ h.data[i] = h.data[j];
45180
+ h.data[j] = t;
45181
+ }
45182
+ function heapify2(h, start) {
45183
+ let i = start;
45184
+ for (; ; ) {
45185
+ const l = 2 * i;
45186
+ const r = 2 * i + 1;
45187
+ let largest = l < h.heapSize && greaterPriority2(h, l, i) ? l : i;
45188
+ if (r < h.heapSize && greaterPriority2(h, r, largest)) largest = r;
45189
+ if (largest === i) break;
45190
+ swap3(h, largest, i);
45191
+ i = largest;
45192
+ }
45193
+ }
45194
+ function initHeap2(place, ordering, n) {
45195
+ const h = { data: [], heapSize: n - 1 };
45196
+ for (let i = 0; i < n - 1; i++) {
45197
+ const left2 = ordering[i];
45198
+ const right2 = ordering[i + 1];
45199
+ h.data.push({ left: left2, right: right2, dist: place[right2] - place[left2] });
45200
+ }
45201
+ for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapify2(h, j);
45202
+ return h;
45203
+ }
45204
+ function extractMax2(h) {
45205
+ if (h.heapSize === 0) return null;
45206
+ const max = h.data[0];
45207
+ h.data[0] = h.data[h.heapSize - 1];
45208
+ h.heapSize--;
45209
+ heapify2(h, 0);
45210
+ return max;
45211
+ }
45212
+ function insert(h, edge) {
45213
+ let i = h.heapSize;
45214
+ h.heapSize++;
45215
+ h.data[i] = edge;
45216
+ while (i > 0 && greaterPriority2(h, i, Math.trunc(i / 2))) {
45217
+ swap3(h, i, Math.trunc(i / 2));
45218
+ i = Math.trunc(i / 2);
45219
+ }
45220
+ }
45221
+ function insertDescendants(s, pair) {
45222
+ const { place, ordering, invOrdering, left: left2, right: right2, heap } = s;
45223
+ const leftIndex = invOrdering[pair.left];
45224
+ const rightIndex = invOrdering[pair.right];
45225
+ if (leftIndex > 0) {
45226
+ const neighbor2 = ordering[leftIndex - 1];
45227
+ if (invOrdering[right2[neighbor2]] < rightIndex) {
45228
+ insert(heap, { left: neighbor2, right: pair.right, dist: place[pair.right] - place[neighbor2] });
45229
+ right2[neighbor2] = pair.right;
45230
+ left2[pair.right] = neighbor2;
45231
+ }
45232
+ }
45233
+ if (rightIndex < s.n - 1) {
45234
+ const neighbor2 = ordering[rightIndex + 1];
45235
+ if (invOrdering[left2[neighbor2]] > leftIndex) {
45236
+ insert(heap, { left: pair.left, right: neighbor2, dist: place[neighbor2] - place[pair.left] });
45237
+ left2[neighbor2] = pair.left;
45238
+ right2[pair.left] = neighbor2;
45239
+ }
45240
+ }
45241
+ }
45242
+ function orderByPlace(place, n) {
45243
+ const ordering = Array.from({ length: n }, (_, i) => i);
45244
+ return gvQsort(ordering, (x, y) => {
45245
+ if (place[x] < place[y]) return -1;
45246
+ if (place[x] > place[y]) return 1;
45247
+ return 0;
45248
+ });
45249
+ }
45250
+ function findClosestPairs(place, n, numPairs) {
45251
+ const ordering = orderByPlace(place, n);
45252
+ const invOrdering = new Int32Array(n);
45253
+ for (let i = 0; i < n; i++) invOrdering[ordering[i]] = i;
45254
+ const left2 = new Int32Array(n);
45255
+ const right2 = new Int32Array(n);
45256
+ const heap = initHeap2(place, ordering, n);
45257
+ for (let i = 1; i < n; i++) left2[ordering[i]] = ordering[i - 1];
45258
+ for (let i = 0; i < n - 1; i++) right2[ordering[i]] = ordering[i + 1];
45259
+ const scan = { place, n, ordering, invOrdering, left: left2, right: right2, heap };
45260
+ const stack = [];
45261
+ for (let i = 0; i < numPairs; i++) {
45262
+ const pair = extractMax2(heap);
45263
+ if (pair === null) break;
45264
+ stack.push(pair);
45265
+ insertDescendants(scan, pair);
45266
+ }
45267
+ return stack;
45268
+ }
45269
+ function addEdge2(graph, u, v) {
45270
+ const gu = graph[u];
45271
+ const gv = graph[v];
45272
+ if (gu.edges.includes(v)) return;
45273
+ gu.edges.push(v);
45274
+ gu.ewgts.push(1);
45275
+ gu.nedges++;
45276
+ gv.edges.push(u);
45277
+ gv.ewgts.push(1);
45278
+ gv.nedges++;
45279
+ gu.ewgts[0]--;
45280
+ gv.ewgts[0]--;
45281
+ }
45282
+ function constructGraph(n, edgesStack) {
45283
+ const graph = Array.from({ length: n }, (_, i) => ({ nedges: 1, edges: [i], ewgts: [0] }));
45284
+ for (let top = edgesStack.length - 1; top >= 0; top--) {
45285
+ addEdge2(graph, edgesStack[top].left, edgesStack[top].right);
45286
+ }
45287
+ return graph;
45288
+ }
45289
+ function closestPairs2Graph(place, n, numPairs) {
45290
+ return constructGraph(n, findClosestPairs(place, n, numPairs));
45291
+ }
45292
+
45293
+ // src/layout/neato/pca.ts
45294
+ var NUM_PAIRS = 4;
45295
+ function pcaAlloc(coords, dim, n, newCoords, newDim) {
45296
+ const eigs = Array.from({ length: newDim }, () => new Float64Array(dim));
45297
+ const DD = Array.from({ length: dim }, () => new Float64Array(dim));
45298
+ for (let i = 0; i < dim; i++) {
45299
+ for (let j = 0; j <= i; j++) {
45300
+ let sum = 0;
45301
+ for (let k = 0; k < n; k++) sum += Math.imul(coords[i][k], coords[j][k]);
45302
+ DD[i][j] = DD[j][i] = sum;
45303
+ }
45304
+ }
45305
+ powerIteration(DD, dim, newDim, eigs);
45306
+ for (let j = 0; j < newDim; j++) {
45307
+ for (let i = 0; i < n; i++) {
45308
+ let sum = 0;
45309
+ for (let k = 0; k < dim; k++) sum = fma(coords[k][i], eigs[j][k], sum);
45310
+ newCoords[j][i] = sum;
45311
+ }
45312
+ }
45313
+ }
45314
+ function iterativePCA1D(coords, dim, n, newDirection) {
45315
+ const laplacian = closestPairs2Graph(coords[0], n, NUM_PAIRS * n);
45316
+ const mat1 = multSparseDenseMatTranspose(laplacian, coords, n, dim);
45317
+ const mat = multDenseMatD(coords, mat1, dim, n, dim);
45318
+ return powerIteration(mat, dim, 1, [newDirection]);
45319
+ }
45320
+
45321
+ // src/layout/neato/stress-subspace.ts
45322
+ var fr6 = Math.fround;
45323
+ var STRESS_PCA_DIM = 50;
45324
+ var MIN_EMBEDDING_PIVOTS = 50;
45325
+ var ZERO_DISTANCE = 1e-30;
45326
+ var STRESS_GUARD = 1e-10;
45327
+ function distanceKD(coords, dim, i, j) {
45328
+ let sum = 0;
45329
+ for (let k = 0; k < dim; k++) {
45330
+ const d = coords[k][i] - coords[k][j];
45331
+ sum = fma(d, d, sum);
45332
+ }
45333
+ return Math.sqrt(sum);
45334
+ }
45335
+ function computeStress1(coords, distances, dim, n, exp) {
45336
+ let sum = 0;
45337
+ for (let i = 0; i < n; i++) {
45338
+ const row = distances[i];
45339
+ for (let j = 0; j < row.nedges; j++) {
45340
+ const node = row.edges[j];
45341
+ if (node <= i) continue;
45342
+ const dist5 = distanceKD(coords, dim, i, node);
45343
+ const Dij = row.edist[j];
45344
+ sum += exp === 2 ? (Dij - dist5) * (Dij - dist5) / (Dij * Dij) : (Dij - dist5) * (Dij - dist5) / Dij;
45345
+ }
45346
+ }
45347
+ return sum;
45348
+ }
45349
+ function nextPivot(dist5, Di, n, from) {
45350
+ let node = from;
45351
+ let maxDist = 0;
45352
+ for (let j = 0; j < n; j++) {
45353
+ dist5[j] = Math.min(dist5[j], Di[j]);
45354
+ if (dist5[j] > maxDist || dist5[j] === maxDist && crand() % (j + 1) === 0) {
45355
+ node = j;
45356
+ maxDist = dist5[j];
45357
+ }
45358
+ }
45359
+ return node;
45360
+ }
45361
+ function selectPivots(graph, n, numCenters, reweightGraph) {
45362
+ const centerIndex = new Int32Array(n).fill(-1);
45363
+ const invCenterIndex = new Int32Array(numCenters);
45364
+ const Dij = Array.from({ length: numCenters }, () => new Int32Array(n));
45365
+ const dist5 = new Int32Array(n);
45366
+ let node = crand() % n;
45367
+ centerIndex[node] = 0;
45368
+ invCenterIndex[0] = node;
45369
+ pivotDistances(node, graph, n, reweightGraph, Dij[0]);
45370
+ let maxDist = 0;
45371
+ for (let i = 0; i < n; i++) {
45372
+ dist5[i] = Dij[0][i];
45373
+ if (dist5[i] > maxDist) {
45374
+ node = i;
45375
+ maxDist = dist5[i];
45376
+ }
45377
+ }
45378
+ for (let i = 1; i < numCenters; i++) {
45379
+ centerIndex[node] = i;
45380
+ invCenterIndex[i] = node;
45381
+ pivotDistances(node, graph, n, reweightGraph, Dij[i]);
45382
+ node = nextPivot(dist5, Dij[i], n, node);
45383
+ }
45384
+ return { centerIndex, invCenterIndex, Dij };
45385
+ }
45386
+ function pivotRow(i, n, Di) {
45387
+ const edges = new Int32Array(n - 1);
45388
+ const edist = new Int32Array(n - 1);
45389
+ for (let j = 0; j < i; j++) {
45390
+ edges[j] = j;
45391
+ edist[j] = Di[j];
45392
+ }
45393
+ for (let j = i + 1; j < n; j++) {
45394
+ edges[j - 1] = j;
45395
+ edist[j - 1] = Di[j];
45396
+ }
45397
+ return { nedges: n - 1, edges, edist };
45398
+ }
45399
+ function nonPivotRow(i, numCenters, p) {
45400
+ const edges = new Int32Array(numCenters);
45401
+ const edist = new Int32Array(numCenters);
45402
+ for (let j = 0; j < numCenters; j++) {
45403
+ edges[j] = p.invCenterIndex[j];
45404
+ edist[j] = p.Dij[j][i];
45405
+ }
45406
+ return { nedges: numCenters, edges, edist };
45407
+ }
45408
+ function buildDistances(n, numCenters, p) {
45409
+ const distances = [];
45410
+ for (let i = 0; i < n; i++) {
45411
+ const index = p.centerIndex[i];
45412
+ distances.push(index >= 0 ? pivotRow(i, n, p.Dij[index]) : nonPivotRow(i, numCenters, p));
45413
+ }
45414
+ return distances;
45415
+ }
45416
+ function buildSparseLaplacian(distances, n, exp) {
45417
+ const lap = [];
45418
+ for (let i = 0; i < n; i++) {
45419
+ const row = distances[i];
45420
+ const edges = [i];
45421
+ const ewgts = [0];
45422
+ let degree = 0;
45423
+ for (let j = 0; j < row.nedges; j++) {
45424
+ const d = fr6(row.edist[j]);
45425
+ const w = exp === 2 ? fr6(-1 / fr6(d * d)) : fr6(-1 / d);
45426
+ edges.push(row.edges[j]);
45427
+ ewgts.push(w);
45428
+ degree -= w;
45429
+ }
45430
+ ewgts[0] = fr6(degree);
45431
+ lap.push({ nedges: row.nedges + 1, edges, ewgts });
45432
+ }
45433
+ return lap;
45434
+ }
45435
+ function initialDirections(subspace, subspaceDim, n, dim) {
45436
+ const storage = new Float64Array(dim * subspaceDim);
45437
+ const directions = Array.from({ length: dim }, (_, k) => storage.subarray(k * subspaceDim, (k + 1) * subspaceDim));
45438
+ if (dim !== 2) {
45439
+ for (let k = 0; k < dim; k++) storage[k * subspaceDim + k] = 1;
45440
+ return directions;
45441
+ }
45442
+ directions[0][0] = 1;
45443
+ if (!iterativePCA1D(subspace, subspaceDim, n, directions[1])) {
45444
+ directions[1].fill(0);
45445
+ directions[1][1] = 1;
45446
+ }
45447
+ return directions;
45448
+ }
45449
+ function computeB(st, k) {
45450
+ const { n, dim, coords, distances, lap, b } = st;
45451
+ const ck = coords[k];
45452
+ for (let i = 0; i < n; i++) {
45453
+ let degree = 0;
45454
+ let bi = 0;
45455
+ const { edges, ewgts, nedges } = lap[i];
45456
+ const edist = distances[i].edist;
45457
+ for (let j = 1; j < nedges; j++) {
45458
+ const node = edges[j];
45459
+ const distIj = distanceKD(coords, dim, i, node);
45460
+ if (distIj > ZERO_DISTANCE) {
45461
+ const Lij = fr6(-ewgts[j] * fr6(edist[j - 1])) / distIj;
45462
+ degree -= Lij;
45463
+ bi = fma(Lij, ck[node], bi);
45464
+ }
45465
+ }
45466
+ b[i] = fma(degree, ck[i], bi);
45467
+ }
45468
+ }
45469
+ function optimizeAxes(st) {
45470
+ const { n, dim, subspaceDim, subspace, matrix, directions, coords, b, bRestricted } = st;
45471
+ for (let k = 0; k < dim; k++) {
45472
+ computeB(st, k);
45473
+ rightMultWithVectorD(subspace, subspaceDim, n, b, bRestricted);
45474
+ const rc = conjugateGradientF(matrix, directions[k], bRestricted, subspaceDim, {
45475
+ tol: TOLERANCE_CG,
45476
+ maxIterations: subspaceDim,
45477
+ ortho1: false
45478
+ });
45479
+ if (rc !== 0) return true;
45480
+ rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
45481
+ }
45482
+ return false;
45483
+ }
45484
+ function optimizeLayout(st, o) {
45485
+ let oldStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
45486
+ let converged = false;
45487
+ let iterations = 0;
45488
+ for (; iterations < o.nIterations && !converged; iterations++) {
45489
+ if (optimizeAxes(st)) return -1;
45490
+ if (iterations % 2 === 0) {
45491
+ const newStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
45492
+ converged = Math.abs(newStress - oldStress) / (newStress + STRESS_GUARD) < o.epsilon;
45493
+ oldStress = newStress;
45494
+ }
45495
+ }
45496
+ return iterations;
45497
+ }
45498
+ function computeSubspace(graph, n, subspaceDim, reweightGraph) {
45499
+ const subspace = Array.from({ length: subspaceDim }, () => new Float64Array(n));
45500
+ const numCentersLocal = Math.min(n, Math.max(2 * subspaceDim, MIN_EMBEDDING_PIVOTS));
45501
+ const fullCoords = embedGraph(graph, n, numCentersLocal, reweightGraph);
45502
+ centerCoordinate(fullCoords, n, numCentersLocal);
45503
+ pcaAlloc(fullCoords, numCentersLocal, n, subspace, subspaceDim);
45504
+ return subspace;
45505
+ }
45506
+ function sparseStressSubspaceMajorizationKD(graph, n, coords, o) {
45507
+ const { dim, exp, reweightGraph, numCenters } = o;
45508
+ const subspaceDim = Math.min(STRESS_PCA_DIM, n);
45509
+ const subspace = computeSubspace(graph, n, subspaceDim, reweightGraph);
45510
+ const oldWeights = saveWeights(graph, n);
45511
+ if (reweightGraph) computeNewWeights(graph, n);
45512
+ const pivots = selectPivots(graph, n, numCenters, reweightGraph);
45513
+ const distances = buildDistances(n, numCenters, pivots);
45514
+ const lap = buildSparseLaplacian(distances, n, exp);
45515
+ const directions = initialDirections(subspace, subspaceDim, n, dim);
45516
+ for (let k = 0; k < dim; k++) {
45517
+ rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
45518
+ }
45519
+ const tmpMat = multSparseDenseMatTranspose(lap, subspace, n, subspaceDim);
45520
+ const matrix = multDenseMat(subspace, tmpMat, subspaceDim, n, subspaceDim);
45521
+ const iterations = optimizeLayout({
45522
+ n,
45523
+ dim,
45524
+ subspaceDim,
45525
+ subspace,
45526
+ distances,
45527
+ lap,
45528
+ matrix,
45529
+ directions,
45530
+ coords,
45531
+ b: new Float64Array(n),
45532
+ bRestricted: new Float64Array(subspaceDim)
45533
+ }, o);
45534
+ if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
45535
+ return iterations;
45536
+ }
45537
+
45538
+ // src/layout/neato/stress-kernel.ts
45539
+ var fr7 = Math.fround;
45540
+ var SMART_SUBSPACE_ITERATIONS = 50;
45541
+ var NUM_PIVOTS_STRESS = 40;
45542
+ var SMART_NOISE = 1e-6;
44583
45543
  function computeApspPacked2(graph, n) {
44584
45544
  const Dij = new Float32Array(n * (n + 1) / 2);
44585
45545
  const Di = new Int32Array(n);
@@ -44603,6 +45563,7 @@ function initLayout(n, dim, coords, nodes) {
44603
45563
  if (hasPos2(np)) {
44604
45564
  coords[0][i] = np.info.pos?.[0] ?? 0;
44605
45565
  coords[1][i] = np.info.pos?.[1] ?? 0;
45566
+ for (let d = 2; d < dim; d++) coords[d][i] = np.info.pos?.[d] ?? 0;
44606
45567
  if (isFixed(np)) pinned = true;
44607
45568
  } else {
44608
45569
  coords[0][i] = drand48();
@@ -44652,7 +45613,7 @@ function buildLap1(lap1, lap2, coords, shape) {
44652
45613
  for (let k = 0; k < dim; k++) {
44653
45614
  const ck = coords[k];
44654
45615
  for (let x = 0; x < len; x++) {
44655
- const tmp = fr5(ck[i] + fr5(-1 * ck[i + 1 + x]));
45616
+ const tmp = fr7(ck[i] + fr7(-1 * ck[i + 1 + x]));
44656
45617
  distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]);
44657
45618
  }
44658
45619
  }
@@ -44665,7 +45626,7 @@ function buildLap1(lap1, lap2, coords, shape) {
44665
45626
  let degree = 0;
44666
45627
  if (exp === 2) {
44667
45628
  for (let j = 0; j < len; j++, count++) {
44668
- const val2 = lap1[count] = fr5(lap1[count] * distAccumulator[j]);
45629
+ const val2 = lap1[count] = fr7(lap1[count] * distAccumulator[j]);
44669
45630
  degree += val2;
44670
45631
  degrees[i + j + 1] = degrees[i + j + 1] - val2;
44671
45632
  }
@@ -44710,19 +45671,50 @@ function solveAxis(st, k, havePinned, nodes) {
44710
45671
  }
44711
45672
  return 0;
44712
45673
  }
45674
+ function smartLayout(smart, n, dCoords, o) {
45675
+ const { dim } = o;
45676
+ const iterations = sparseStressSubspaceMajorizationKD(smart.graph, n, dCoords, {
45677
+ dim,
45678
+ exp: o.opts & OPT_EXP_FLAG,
45679
+ reweightGraph: smart.reweightGraph,
45680
+ nIterations: SMART_SUBSPACE_ITERATIONS,
45681
+ numCenters: NUM_PIVOTS_STRESS,
45682
+ epsilon: o.epsilon
45683
+ });
45684
+ if (iterations < 0) return -1;
45685
+ for (let i = 0; i < dim; i++) {
45686
+ const c = dCoords[i];
45687
+ let max = 1;
45688
+ for (let j = 0; j < n; j++) {
45689
+ if (Math.abs(c[j]) > max) max = Math.abs(c[j]);
45690
+ }
45691
+ for (let j = 0; j < n; j++) c[j] = c[j] / max;
45692
+ for (let j = 0; j < n; j++) c[j] = fma(drand48() - 0.5, SMART_NOISE, c[j]);
45693
+ orthog1(n, c);
45694
+ }
45695
+ return 0;
45696
+ }
45697
+ function initialLayout(n, dCoords, nodes, o) {
45698
+ if (o.smart !== void 0 && (o.opts & OPT_SMART_INIT) !== 0 && n > 1) {
45699
+ return smartLayout(o.smart, n, dCoords, o);
45700
+ }
45701
+ return initLayout(n, o.dim, dCoords, nodes) ? 1 : 0;
45702
+ }
44713
45703
  function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
44714
45704
  const { dim, maxi } = o;
44715
45705
  const exp = o.opts & OPT_EXP_FLAG;
44716
45706
  if (maxi < 0) return 0;
44717
- const havePinned = initLayout(n, dim, dCoords, nodes);
45707
+ const layout2 = initialLayout(n, dCoords, nodes, o);
45708
+ if (layout2 < 0) return -1;
45709
+ const havePinned = layout2 === 1;
44718
45710
  if (n === 1 || maxi === 0) return 0;
44719
45711
  const coords = [];
44720
45712
  for (let i = 0; i < dim; i++) {
44721
45713
  const c = new Float32Array(n);
44722
- for (let j = 0; j < n; j++) c[j] = fr5(dCoords[i][j]);
45714
+ for (let j = 0; j < n; j++) c[j] = fr7(dCoords[i][j]);
44723
45715
  coords.push(c);
44724
45716
  }
44725
- const constantTerm = fr5(n * (n - 1) / 2);
45717
+ const constantTerm = fr7(n * (n - 1) / 2);
44726
45718
  const lap2 = Dij;
44727
45719
  buildLap2(lap2, n, exp);
44728
45720
  const lapLength = n * (n + 1) / 2;
@@ -44744,7 +45736,6 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
44744
45736
  for (; iterations < maxi && !converged; iterations++) {
44745
45737
  buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
44746
45738
  const newStress = computeStress(st);
44747
- if (typeof process !== "undefined" && process.env["STRESS_DEBUG"] && iterations % 5 === 0) console.error(newStress.toFixed(3));
44748
45739
  const change = Math.abs(oldStress - newStress);
44749
45740
  converged = change / oldStress < o.epsilon || newStress < o.epsilon;
44750
45741
  oldStress = newStress;
@@ -44862,7 +45853,7 @@ function stressModelDij(graph, n, model) {
44862
45853
  }
44863
45854
 
44864
45855
  // src/layout/neato/constrained-majorization.ts
44865
- var fr6 = Math.fround;
45856
+ var fr8 = Math.fround;
44866
45857
  var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
44867
45858
  var LEVELS_SEP_TOL = 0.1;
44868
45859
  var ABS_TOL = 0.01;
@@ -44871,18 +45862,15 @@ var FLT_MAX3 = 34028234663852886e22;
44871
45862
  var DBL_MAX = Number.MAX_VALUE;
44872
45863
  var MIN_LEVELS = 1;
44873
45864
  var Y_AXIS = 1;
44874
- function unsupported2(what) {
44875
- throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
44876
- }
44877
45865
  function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
44878
45866
  if (o.maxi < 0) return 0;
44879
45867
  const Dij = stressModelDij(graph, n, o.model);
44880
- if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
44881
45868
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
44882
45869
  dim: o.dim,
44883
45870
  opts: o.opts,
44884
45871
  maxi: o.maxi,
44885
- epsilon: o.epsilon
45872
+ epsilon: o.epsilon,
45873
+ smart: { graph, reweightGraph: o.model === MODEL_SUBSET2 }
44886
45874
  });
44887
45875
  }
44888
45876
  function hasDirectionality(graph, n) {
@@ -44930,14 +45918,6 @@ function plainInitLayers(graph, n, dCoords, nodes, dim) {
44930
45918
  const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, null);
44931
45919
  return h === null ? -1 : h;
44932
45920
  }
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
45921
  function scaleDownLayout(dCoords, n, dim) {
44942
45922
  let max = 1;
44943
45923
  for (let i = 0; i < dim; i++) {
@@ -44960,7 +45940,7 @@ function scaleDistances(Dij, dCoords, n, dim) {
44960
45940
  sum2 += distanceKD(dCoords, dim, i, j) / Dij[count];
44961
45941
  }
44962
45942
  }
44963
- const scaleRatio = fr6(sum2 / sum1);
45943
+ const scaleRatio = fr8(sum2 / sum1);
44964
45944
  for (let i = 0; i < length; i++) Dij[i] = Dij[i] * scaleRatio;
44965
45945
  }
44966
45946
  function centerLayout(dCoords, n, dim) {
@@ -45016,7 +45996,7 @@ function buildLap12(st) {
45016
45996
  count++;
45017
45997
  let degree = 0;
45018
45998
  for (let j = 0; j < len; j++, count++) {
45019
- const val2 = fr6(lap1[count] * distAccumulator[j]);
45999
+ const val2 = fr8(lap1[count] * distAccumulator[j]);
45020
46000
  lap1[count] = val2;
45021
46001
  degree += val2;
45022
46002
  degrees[i + j + 1] -= val2;
@@ -46569,8 +47549,8 @@ function genYConstraints(rects, vs) {
46569
47549
  }
46570
47550
 
46571
47551
  // src/layout/neato/quad-prog-vpsc-overlap.ts
46572
- var fr7 = Math.fround;
46573
- var X_GROWTH = fr7(1.0001);
47552
+ var fr9 = Math.fround;
47553
+ var X_GROWTH = fr9(1.0001);
46574
47554
  var BOUNDARY_WIDTH = 1e-4;
46575
47555
  var TMP_CLUSTER_VAR_ID = 123;
46576
47556
  function copyBox(b) {
@@ -46716,7 +47696,7 @@ function generateNonoverlapConstraints(e, a) {
46716
47696
  n -= 2 * a.opt.clusters.nclusters;
46717
47697
  }
46718
47698
  if (a.k === 0) {
46719
- nsizeScale = fr7(nsizeScale * X_GROWTH);
47699
+ nsizeScale = fr9(nsizeScale * X_GROWTH);
46720
47700
  }
46721
47701
  const bb = nodeBoxes(n, nsizeScale, a);
46722
47702
  let csol;
@@ -46779,15 +47759,15 @@ function getNumDigcolaConstraints(levels, numLevels) {
46779
47759
  }
46780
47760
 
46781
47761
  // src/layout/neato/quad-prog-vpsc.ts
46782
- var fr8 = Math.fround;
47762
+ var fr10 = Math.fround;
46783
47763
  var QUAD_PROG_TOL = 1e-4;
46784
47764
  var DUMMY_WEIGHT = 1e-6;
46785
47765
  var VECTOR_BLOCK = 4;
46786
47766
  function rowReduce(row, factor, v, n, acc) {
46787
47767
  const blocked = n - n % VECTOR_BLOCK;
46788
47768
  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);
47769
+ for (; j < blocked; j++) acc = fr10(acc + fr10(fr10(factor * row[j]) * v[j]));
47770
+ for (; j < n; j++) acc = fmaf(fr10(factor * row[j]), v[j], acc);
46791
47771
  return acc;
46792
47772
  }
46793
47773
  function project(e, place, n) {
@@ -46805,7 +47785,7 @@ function descentStep(e, b, place, n) {
46805
47785
  const oldPlace = e.fArray2;
46806
47786
  for (let i = 0; i < n; i++) {
46807
47787
  oldPlace[i] = place[i];
46808
- g[i] = rowReduce(A3[i], -2, place, n, fr8(2 * b[i]));
47788
+ g[i] = rowReduce(A3[i], -2, place, n, fr10(2 * b[i]));
46809
47789
  }
46810
47790
  let numerator = 0;
46811
47791
  let denominator = 0;
@@ -46814,7 +47794,7 @@ function descentStep(e, b, place, n) {
46814
47794
  const r = rowReduce(A3[i], 2, g, n, 0);
46815
47795
  denominator = fmaf(-r, g[i], denominator);
46816
47796
  }
46817
- return denominator !== 0 ? -fr8(numerator / denominator) : -1;
47797
+ return denominator !== 0 ? -fr10(numerator / denominator) : -1;
46818
47798
  }
46819
47799
  function lineSearchBeta(e, place, n) {
46820
47800
  const A3 = e.A;
@@ -46822,7 +47802,7 @@ function lineSearchBeta(e, place, n) {
46822
47802
  const oldPlace = e.fArray2;
46823
47803
  const d = e.fArray3;
46824
47804
  for (let i = 0; i < n; i++) {
46825
- d[i] = fr8(place[i] - oldPlace[i]);
47805
+ d[i] = fr10(place[i] - oldPlace[i]);
46826
47806
  }
46827
47807
  let numerator = 0;
46828
47808
  let denominator = 0;
@@ -46831,7 +47811,7 @@ function lineSearchBeta(e, place, n) {
46831
47811
  const r = rowReduce(A3[i], 2, d, n, 0);
46832
47812
  denominator = fmaf(r, d[i], denominator);
46833
47813
  }
46834
- if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return fr8(numerator / denominator);
47814
+ if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return fr10(numerator / denominator);
46835
47815
  return 1;
46836
47816
  }
46837
47817
  function applyBeta(e, place, n, beta) {
@@ -46842,7 +47822,7 @@ function applyBeta(e, place, n, beta) {
46842
47822
  if (beta > 0 && beta < 1) {
46843
47823
  place[i] = fmaf(beta, d[i], oldPlace[i]);
46844
47824
  }
46845
- test = fr8(test + fr8(Math.abs(place[i] - oldPlace[i])));
47825
+ test = fr10(test + fr10(Math.abs(place[i] - oldPlace[i])));
46846
47826
  }
46847
47827
  return test;
46848
47828
  }
@@ -46988,11 +47968,11 @@ function deleteCMajEnvVPSC(e) {
46988
47968
  }
46989
47969
 
46990
47970
  // src/layout/neato/stress-cola.ts
46991
- var fr9 = Math.fround;
47971
+ var fr11 = Math.fround;
46992
47972
  var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
46993
47973
  var FLT_MAX4 = 34028234663852886e22;
46994
- var CLUSTER_WEIGHT_FLOOR = fr9(0.01);
46995
- var STRESS_GUARD = 1e-10;
47974
+ var CLUSTER_WEIGHT_FLOOR = fr11(0.01);
47975
+ var STRESS_GUARD2 = 1e-10;
46996
47976
  var NSIZE_SCALE_STEP = 0.1;
46997
47977
  var NSIZE_SCALE_LIMIT = 0.999;
46998
47978
  var NSIZE_SCALE_ACTIVE = 1e-3;
@@ -47003,7 +47983,7 @@ function maxEdgeLength(graph, n) {
47003
47983
  let maxEdgeLen = 0;
47004
47984
  for (let i = 0; i < n; i++) {
47005
47985
  for (let j = 1; j < graph[i].nedges; j++) {
47006
- maxEdgeLen = fr9(Math.max(graph[i].ewgts[j], maxEdgeLen));
47986
+ maxEdgeLen = fr11(Math.max(graph[i].ewgts[j], maxEdgeLen));
47007
47987
  }
47008
47988
  }
47009
47989
  return maxEdgeLen;
@@ -47055,8 +48035,8 @@ function clusterLaplacian(lap2, n, nclusters, maxEdgeLen) {
47055
48035
  if (i < n && j < n - i) {
47056
48036
  v = lap2[c0++];
47057
48037
  } else if (j === 1 && i % 2 === 1) {
47058
- v = fr9(maxEdgeLen * maxEdgeLen);
47059
- if (v > CLUSTER_WEIGHT_FLOOR) v = fr9(1 / v);
48038
+ v = fr11(maxEdgeLen * maxEdgeLen);
48039
+ if (v > CLUSTER_WEIGHT_FLOOR) v = fr11(1 / v);
47060
48040
  } else {
47061
48041
  v = 0;
47062
48042
  }
@@ -47114,7 +48094,7 @@ function colaState(Dij, origN, dCoords, o, maxEdgeLen) {
47114
48094
  degrees,
47115
48095
  coords: floatCoords(dCoords, o.dim, n, origN),
47116
48096
  /* compute constant term in stress sum which is \sum_{i<j} w_{ij}d_{ij}^2 */
47117
- constantTerm: fr9(n * (n - 1) / 2),
48097
+ constantTerm: fr11(n * (n - 1) / 2),
47118
48098
  b: Array.from({ length: o.dim }, () => new Float32Array(n)),
47119
48099
  tmpCoords: new Float32Array(n),
47120
48100
  distAccumulator: new Float32Array(n)
@@ -47146,7 +48126,7 @@ function buildLap13(st) {
47146
48126
  count++;
47147
48127
  let degree = 0;
47148
48128
  for (let j = 0; j < len; j++, count++) {
47149
- const val2 = lap1[count] = fr9(lap1[count] * st.distAccumulator[j]);
48129
+ const val2 = lap1[count] = fr11(lap1[count] * st.distAccumulator[j]);
47150
48130
  degree += val2;
47151
48131
  degrees[i + j + 1] = degrees[i + j + 1] - val2;
47152
48132
  }
@@ -47181,7 +48161,7 @@ var overlapDue = (opt, nsizeScale) => opt.noverlap === NOVERLAP_CONSTRAINTS && n
47181
48161
  function solveHorizontal(st, e, nsizeScale, opt) {
47182
48162
  if (overlapDue(opt, nsizeScale)) {
47183
48163
  generateNonoverlapConstraints(e, {
47184
- nsizeScale: fr9(nsizeScale),
48164
+ nsizeScale: fr11(nsizeScale),
47185
48165
  coords: st.coords,
47186
48166
  k: 0,
47187
48167
  transitiveClosure: nsizeScale >= TRANSITIVE_CLOSURE_SCALE,
@@ -47200,7 +48180,7 @@ function solveHorizontal(st, e, nsizeScale, opt) {
47200
48180
  }
47201
48181
  function solveVertical(st, e, nsizeScale, opt) {
47202
48182
  if (overlapDue(opt, nsizeScale)) {
47203
- generateNonoverlapConstraints(e, { nsizeScale: fr9(nsizeScale), coords: st.coords, k: 1, transitiveClosure: false, opt });
48183
+ generateNonoverlapConstraints(e, { nsizeScale: fr11(nsizeScale), coords: st.coords, k: 1, transitiveClosure: false, opt });
47204
48184
  }
47205
48185
  if (e.m > 0) {
47206
48186
  if (constrainedMajorizationVpsc(e, st.b[1], st.coords[1], LOCAL_CONSTR_MAJOR_ITERATIONS2) < 0) return -1;
@@ -47209,13 +48189,13 @@ function solveVertical(st, e, nsizeScale, opt) {
47209
48189
  }
47210
48190
  return 0;
47211
48191
  }
47212
- function iterate(st, envs, o, observe) {
48192
+ function iterate2(st, envs, o, observe) {
47213
48193
  const s = { iterations: 0, converged: false, oldStress: Number.MAX_VALUE, nsizeScale: 0 };
47214
48194
  for (; s.iterations < o.maxi && !s.converged; s.iterations++) {
47215
48195
  buildLap13(st);
47216
48196
  const newStress = computeStress2(st);
47217
48197
  observe?.(newStress);
47218
- s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress + STRESS_GUARD) < o.epsilon;
48198
+ s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress + STRESS_GUARD2) < o.epsilon;
47219
48199
  s.oldStress = newStress;
47220
48200
  scaleUpNodes(s, o.maxi, o.opt);
47221
48201
  if (solveHorizontal(st, envs.hor, s.nsizeScale, o.opt) < 0) return -1;
@@ -47229,7 +48209,7 @@ function optimize(st, graph, o, observe) {
47229
48209
  const vrt = initCMajVPSC(st.n, st.lap2, graph, o.opt, o.opt.diredges);
47230
48210
  if (vrt === null) return -1;
47231
48211
  st.lap1 = new Float32Array(st.lapLength);
47232
- const iterations = iterate(st, { hor, vrt }, o, observe);
48212
+ const iterations = iterate2(st, { hor, vrt }, o, observe);
47233
48213
  if (iterations < 0) return iterations;
47234
48214
  deleteCMajEnvVPSC(hor);
47235
48215
  deleteCMajEnvVPSC(vrt);
@@ -47334,7 +48314,7 @@ function realEdges(de) {
47334
48314
  function isNewEdge(de) {
47335
48315
  return de.info.alg === void 0;
47336
48316
  }
47337
- function addEdge2(de, e) {
48317
+ function addEdge3(de, e) {
47338
48318
  const el = de.info.alg;
47339
48319
  if (el === void 0) {
47340
48320
  de.info.alg = [e];
@@ -47882,10 +48862,10 @@ var Cdt = class {
47882
48862
  }
47883
48863
  /** gts_point_locate (guess=NULL): closest_face + barycenter walk. */
47884
48864
  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);
48865
+ const guess2 = this.closestFace(x, y);
48866
+ if (guess2 === null) return null;
48867
+ const [bx, by] = this.barycenter(guess2);
48868
+ return this.pointLocateWalk(bx, by, x, y, guess2);
47889
48869
  }
47890
48870
  // -------------------------------------------------------------------
47891
48871
  // Delaunay insertion (cdt.c: swap_if_in_circle, add_vertex_to_face)
@@ -51762,10 +52742,19 @@ var SMOOTHING_NONE = 0;
51762
52742
  var INT_MAX2 = 2147483647;
51763
52743
  var ELSCHEME_PENALTY2 = 2;
51764
52744
  var EDGE_LABEL_NODE_PREFIX = "|edgelabel|";
52745
+ function sfdpInitDim(g) {
52746
+ const root = g.root;
52747
+ const outdim = lateInt(aggetGraph(g, "dimen"), DFLT_DIM, 2);
52748
+ const ndim = Math.min(lateInt(aggetGraph(g, "dim"), outdim, 2), MAXDIM);
52749
+ root.info.ndim = ndim;
52750
+ root.info.odim = Math.min(outdim, ndim);
52751
+ return ndim;
52752
+ }
51765
52753
  function sfdpInitGraph(g) {
51766
52754
  setEdgeTypeFromAttr(g, EDGETYPE_LINE);
52755
+ const ndim = sfdpInitDim(g);
51767
52756
  commonInitNodeEdge(g);
51768
- for (const n of g.nodes.values()) neatoInitNode(n);
52757
+ for (const n of g.nodes.values()) neatoInitNode(n, ndim);
51769
52758
  const measurer = layoutMeasurer(g);
51770
52759
  if (measurer !== void 0) {
51771
52760
  for (const n of g.nodes.values()) {
@@ -51882,12 +52871,12 @@ function makeMatrix(g) {
51882
52871
  MATRIX_TYPE_REAL
51883
52872
  );
51884
52873
  }
51885
- function getSizes(g, pad) {
51886
- const sizes = new Array(2 * g.nodes.size).fill(0);
52874
+ function getSizes(g, pad, ndim = DFLT_DIM) {
52875
+ const sizes = new Array(ndim * g.nodes.size).fill(0);
51887
52876
  for (const n of g.nodes.values()) {
51888
52877
  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;
52878
+ sizes[i * ndim] = (n.info.width ?? 0) * 0.5 + pad.x;
52879
+ sizes[i * ndim + 1] = (n.info.height ?? 0) * 0.5 + pad.y;
51891
52880
  }
51892
52881
  return sizes;
51893
52882
  }
@@ -52819,7 +53808,7 @@ var AM_PORTHOYX = 12;
52819
53808
  var SCALE = 10;
52820
53809
  var SCALE2 = SCALE / 2;
52821
53810
  var INT_MAX3 = 2147483647;
52822
- var POINTS_PER_INCH4 = 72;
53811
+ var POINTS_PER_INCH6 = 72;
52823
53812
  function cmpitem(a, b) {
52824
53813
  if (a < b) return -1;
52825
53814
  if (a > b) return 1;
@@ -53047,18 +54036,18 @@ function overlaps(p) {
53047
54036
  return false;
53048
54037
  }
53049
54038
  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);
54039
+ const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH6);
54040
+ const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH6);
53052
54041
  const width2 = n.info.width ?? 0;
53053
54042
  const height2 = n.info.height ?? 0;
53054
54043
  let w2;
53055
54044
  let h2;
53056
54045
  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));
54046
+ w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH6) + margin.x));
54047
+ h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH6) + margin.y));
53059
54048
  } else {
53060
- w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH4);
53061
- h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH4);
54049
+ w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH6);
54050
+ h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH6);
53062
54051
  }
53063
54052
  return {
53064
54053
  val: 0,
@@ -53093,8 +54082,8 @@ function cAdjust(g, mode) {
53093
54082
  if (!overlaps(nlist)) return 0;
53094
54083
  runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO));
53095
54084
  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;
54085
+ const x = p.pos.x / POINTS_PER_INCH6 / SCALE;
54086
+ const y = p.pos.y / POINTS_PER_INCH6 / SCALE;
53098
54087
  if (p.np.info.pos) {
53099
54088
  p.np.info.pos[0] = x;
53100
54089
  p.np.info.pos[1] = y;
@@ -53109,10 +54098,10 @@ function cAdjust(g, mode) {
53109
54098
  var POLY_BOX = 1;
53110
54099
  var POLY_CIRCLE = 2;
53111
54100
  var DFLT_SAMPLE2 = 20;
53112
- var POINTS_PER_INCH5 = 72;
54101
+ var POINTS_PER_INCH7 = 72;
53113
54102
  var MIN_SAMPLES = 3;
53114
54103
  function ps2inch2(a) {
53115
- return a / POINTS_PER_INCH5;
54104
+ return a / POINTS_PER_INCH7;
53116
54105
  }
53117
54106
  function isBoxKind(p) {
53118
54107
  return (p.kind & POLY_BOX) !== 0;
@@ -53405,7 +54394,7 @@ function polyOverlap(p, pp, q, qp) {
53405
54394
  // src/layout/neato/adjust-info.ts
53406
54395
  var DEFAULT_VORO_MARGIN = 0.05;
53407
54396
  var INCR = 0.05;
53408
- var POINTS_PER_INCH6 = 72;
54397
+ var POINTS_PER_INCH8 = 72;
53409
54398
  function newInfoState() {
53410
54399
  return {
53411
54400
  nodeInfo: [],
@@ -53460,8 +54449,8 @@ function chkBoundBox(st, graph) {
53460
54449
  function makeInfo(st, graph) {
53461
54450
  const pmargin = { ...sepFactor(graph) };
53462
54451
  if (pmargin.doAdd) {
53463
- pmargin.x /= POINTS_PER_INCH6;
53464
- pmargin.y /= POINTS_PER_INCH6;
54452
+ pmargin.x /= POINTS_PER_INCH8;
54453
+ pmargin.y /= POINTS_PER_INCH8;
53465
54454
  }
53466
54455
  const polyf = pmargin.doAdd ? makeAddPoly : makePoly;
53467
54456
  const info = [];
@@ -53595,7 +54584,7 @@ function sAdjustGraph(g) {
53595
54584
  }
53596
54585
 
53597
54586
  // src/layout/neato/vpsc-adjust.ts
53598
- var POINTS_PER_INCH7 = 72;
54587
+ var POINTS_PER_INCH9 = 72;
53599
54588
  function noClusters() {
53600
54589
  return {
53601
54590
  nvars: 0,
@@ -53621,21 +54610,30 @@ function vpscAdjust(g) {
53621
54610
  noverlap: 2,
53622
54611
  clusters: noClusters(),
53623
54612
  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)
54613
+ x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH9),
54614
+ y: 2 * ((margin.doAdd ? margin.y : DFLT_MARGIN) / POINTS_PER_INCH9)
53626
54615
  },
53627
54616
  nsize: nodes.map((n) => ({ x: n.info.width, y: n.info.height }))
53628
54617
  };
53629
54618
  removeoverlaps(nodes.length, coords, opt);
53630
54619
  nodes.forEach((n, j) => {
53631
- n.info.pos = [coords[0][j], coords[1][j]];
54620
+ n.info.pos[0] = coords[0][j];
54621
+ n.info.pos[1] = coords[1][j];
53632
54622
  });
53633
54623
  return 0;
53634
54624
  }
53635
54625
 
53636
54626
  // src/layout/neato/fdp-adjust.ts
53637
54627
  var DFLT_MARGIN2 = 4;
53638
- var NDIM2 = 2;
54628
+ function sizesByNdim(sizes2, ndim) {
54629
+ if (ndim === 2) return sizes2;
54630
+ const sizes = new Array(sizes2.length / 2 * ndim).fill(0);
54631
+ for (let i = 0; i < sizes2.length / 2; i++) {
54632
+ sizes[i * ndim] = sizes2[i * 2];
54633
+ sizes[i * ndim + 1] = sizes2[i * 2 + 1];
54634
+ }
54635
+ return sizes;
54636
+ }
53639
54637
  function mapBoolDflt(p, defaultValue) {
53640
54638
  if (p === void 0 || p === "") return defaultValue;
53641
54639
  const s = p.toLowerCase();
@@ -53677,14 +54675,14 @@ function overlapPrismTries(flag) {
53677
54675
  }
53678
54676
  function fdpAdjust(g, ntry) {
53679
54677
  const A0 = makeMatrix(g);
53680
- const pos = new Array(NDIM2 * g.nodes.size).fill(0);
54678
+ const ndim = ndimOf(g);
54679
+ const pos = new Array(ndim * g.nodes.size).fill(0);
53681
54680
  const sep = sepFactor(g);
53682
54681
  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);
54682
+ const sizes = sizesByNdim(getSizes(g, pad), ndim);
53684
54683
  for (const n of g.nodes.values()) {
53685
54684
  const i = n.info.id;
53686
- pos[i * NDIM2] = n.info.pos?.[0] ?? 0;
53687
- pos[i * NDIM2 + 1] = n.info.pos?.[1] ?? 0;
54685
+ for (let k = 0; k < ndim; k++) pos[i * ndim + k] = n.info.pos?.[k] ?? 0;
53688
54686
  }
53689
54687
  const A3 = !smIsSymmetric(A0, false) || A0.type !== MATRIX_TYPE_REAL ? smGetRealAdjacencySymmetrized(A0) : smRemoveDiagonal(A0);
53690
54688
  const scaling = lateDouble(
@@ -53696,12 +54694,11 @@ function fdpAdjust(g, ntry) {
53696
54694
  g.attrs.get("overlap_shrink") ?? g.root.attrs.get("overlap_shrink"),
53697
54695
  true
53698
54696
  );
53699
- removeOverlapPrism(NDIM2, A3, pos, sizes, ntry, scaling, doShrinking);
54697
+ removeOverlapPrism(ndim, A3, pos, sizes, ntry, scaling, doShrinking);
53700
54698
  for (const n of g.nodes.values()) {
53701
54699
  const i = n.info.id;
53702
54700
  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];
54701
+ for (let k = 0; k < ndim; k++) n.info.pos[k] = pos[i * ndim + k];
53705
54702
  }
53706
54703
  }
53707
54704
  var AM_NONE = 0;
@@ -53795,9 +54792,9 @@ function graphAdjustMode(g) {
53795
54792
  }
53796
54793
 
53797
54794
  // src/layout/neato/ipsep-opts.ts
53798
- var POINTS_PER_INCH8 = 72;
54795
+ var POINTS_PER_INCH10 = 72;
53799
54796
  var HIER_PREFIX = "hier";
53800
- var ps2inch3 = (points2) => points2 / POINTS_PER_INCH8;
54797
+ var ps2inch3 = (points2) => points2 / POINTS_PER_INCH10;
53801
54798
  var zeroBox = () => ({ ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } });
53802
54799
  function memberIndices(subg, nodes) {
53803
54800
  const members = nodesInSeq(subg);
@@ -53876,19 +54873,8 @@ function ipsepOptions(mg, g, nodes, am) {
53876
54873
  return { diredges, edgeGap, noverlap, gap, nsize, clusters };
53877
54874
  }
53878
54875
 
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
54876
  // src/layout/neato/set-aspect.ts
53891
- var POINTS_PER_INCH10 = 72;
54877
+ var POINTS_PER_INCH11 = 72;
53892
54878
  function neatoRatioKind(g) {
53893
54879
  const p = g.attrs.get("ratio");
53894
54880
  if (p === void 0) return null;
@@ -53936,8 +54922,8 @@ function neatoTranslate(g) {
53936
54922
  const bb = g.info.bb;
53937
54923
  if (!bb) return;
53938
54924
  const ll = bb.ll;
53939
- const ox = ll.x / POINTS_PER_INCH10;
53940
- const oy = ll.y / POINTS_PER_INCH10;
54925
+ const ox = ll.x / POINTS_PER_INCH11;
54926
+ const oy = ll.y / POINTS_PER_INCH11;
53941
54927
  for (const n of g.nodes.values()) {
53942
54928
  if (!n.info.pos) n.info.pos = [0, 0];
53943
54929
  n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
@@ -54022,8 +55008,7 @@ var MODEL_SHORTPATH2 = 0;
54022
55008
  var MODEL_CIRCUIT2 = 1;
54023
55009
  var MODEL_SUBSET2 = 2;
54024
55010
  var MODEL_MDS2 = 3;
54025
- var DFLT_DIM = 2;
54026
- var POINTS_PER_INCH11 = 72;
55011
+ var POINTS_PER_INCH12 = 72;
54027
55012
  function neatoInitNode(n, dim = DFLT_DIM) {
54028
55013
  if (!n.info.pos || n.info.pos.length < dim) {
54029
55014
  const pos = [];
@@ -54035,19 +55020,6 @@ function neatoInitNode(n, dim = DFLT_DIM) {
54035
55020
  if (!n.info.width && !plainShaped) n.info.width = 0.75;
54036
55021
  if (!n.info.height && !plainShaped) n.info.height = 0.5;
54037
55022
  }
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
55023
  function assignNodeIds2(g) {
54052
55024
  const nodeList = [];
54053
55025
  let idx = 0;
@@ -54067,10 +55039,11 @@ function solveStress(c, vtx, dCoords, nodeList) {
54067
55039
  const { g, mode, model, opts } = c;
54068
55040
  const n = nodeList.length;
54069
55041
  const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
55042
+ const dim = ndimOf(g);
54070
55043
  const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
54071
55044
  if (mode === MODE_HIER) {
54072
55045
  return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
54073
- dim: DFLT_DIM,
55046
+ dim,
54074
55047
  opts,
54075
55048
  model,
54076
55049
  maxi,
@@ -54081,7 +55054,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
54081
55054
  if (mode === MODE_IPSEP) {
54082
55055
  const opt = ipsepOptions(g.root, g, nodeList, c.am);
54083
55056
  return stressMajorizationCola(vtx, n, dCoords, nodeList, {
54084
- dim: DFLT_DIM,
55057
+ dim,
54085
55058
  model,
54086
55059
  maxi,
54087
55060
  epsilon,
@@ -54090,7 +55063,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
54090
55063
  }
54091
55064
  const Dij = stressModelDij(vtx, n, model);
54092
55065
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
54093
- dim: DFLT_DIM,
55066
+ dim,
54094
55067
  opts,
54095
55068
  maxi,
54096
55069
  epsilon
@@ -54105,13 +55078,14 @@ function runMajorization(g, mode, model, am) {
54105
55078
  const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
54106
55079
  const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
54107
55080
  const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
54108
- const dCoords = [new Float64Array(n), new Float64Array(n)];
55081
+ const ndim = ndimOf(g);
55082
+ const dCoords = Array.from({ length: ndim }, () => new Float64Array(n));
54109
55083
  if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
54110
55084
  agerr("prev", "layout aborted");
54111
55085
  return;
54112
55086
  }
54113
55087
  for (let i = 0; i < n; i++) {
54114
- nodeList[i].info.pos = [dCoords[0][i], dCoords[1][i]];
55088
+ nodeList[i].info.pos = dCoords.map((c) => c[i]);
54115
55089
  }
54116
55090
  }
54117
55091
  var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
@@ -54134,8 +55108,8 @@ function neatoSetAspect(g) {
54134
55108
  const pos = n.info.pos;
54135
55109
  if (!pos) continue;
54136
55110
  n.info.coord = {
54137
- x: (pos[0] ?? 0) * POINTS_PER_INCH11,
54138
- y: (pos[1] ?? 0) * POINTS_PER_INCH11
55111
+ x: (pos[0] ?? 0) * POINTS_PER_INCH12,
55112
+ y: (pos[1] ?? 0) * POINTS_PER_INCH12
54139
55113
  };
54140
55114
  }
54141
55115
  }
@@ -54151,7 +55125,7 @@ function neatoCleanup(g) {
54151
55125
  }
54152
55126
 
54153
55127
  // src/layout/twopi/init.ts
54154
- var POINTS_PER_INCH12 = 72;
55128
+ var POINTS_PER_INCH13 = 72;
54155
55129
  function makeRdata(INF) {
54156
55130
  return {
54157
55131
  kind: "twopi",
@@ -54203,8 +55177,8 @@ function finaliseCoords(g) {
54203
55177
  const pos = n.info.pos;
54204
55178
  if (!pos) continue;
54205
55179
  n.info.coord = {
54206
- x: (pos[0] ?? 0) * POINTS_PER_INCH12,
54207
- y: (pos[1] ?? 0) * POINTS_PER_INCH12
55180
+ x: (pos[0] ?? 0) * POINTS_PER_INCH13,
55181
+ y: (pos[1] ?? 0) * POINTS_PER_INCH13
54208
55182
  };
54209
55183
  }
54210
55184
  }
@@ -54440,7 +55414,10 @@ function circleLayout(sg, center) {
54440
55414
  if (center === null) center = findCenterNode(sg);
54441
55415
  if (center === null) return null;
54442
55416
  const maxN = setParentNodes(sg, center);
54443
- if (maxN === Number.MAX_SAFE_INTEGER) return center;
55417
+ if (maxN === Number.MAX_SAFE_INTEGER) {
55418
+ agerrorf("twopi: use of weight=0 creates disconnected component.");
55419
+ return center;
55420
+ }
54444
55421
  setSubtreeSize(sg);
54445
55422
  setSubtreeSpans(sg, center);
54446
55423
  setPositions(sg, center);
@@ -54531,18 +55508,21 @@ function parseModel(g) {
54531
55508
  function maybeRemoveOverlap(g, am) {
54532
55509
  removeOverlapWith(g, am);
54533
55510
  }
54534
- function neatoLayout(g) {
54535
- graphInit(g, false);
54536
- setEdgeTypeFromAttr(g, EDGETYPE_LINE);
54537
- commonInitNodeEdge(g);
55511
+ function neatoInitNodeEdge(g, ndim) {
54538
55512
  for (const [, n] of g.nodes) {
54539
- neatoInitNode(n);
54540
- userPos(n);
55513
+ neatoInitNode(n, ndim);
55514
+ userPos(n, ndim, g.nodes.size);
54541
55515
  }
54542
55516
  const measurer = layoutMeasurer(g);
54543
55517
  if (measurer !== void 0) {
54544
55518
  for (const e of g.edges) initEdgeLabels(e, g, measurer);
54545
55519
  }
55520
+ }
55521
+ function neatoLayout(g) {
55522
+ graphInit(g, false);
55523
+ setEdgeTypeFromAttr(g, EDGETYPE_LINE);
55524
+ commonInitNodeEdge(g);
55525
+ neatoInitNodeEdge(g, neatoInitGraphDim(g));
54546
55526
  const mode = parseMode(g);
54547
55527
  const am = graphAdjustMode(g);
54548
55528
  const model = parseModel(g);
@@ -54554,6 +55534,7 @@ function neatoLayout(g) {
54554
55534
  maybeRemoveOverlap(g, am);
54555
55535
  splineEdgesShifted(g);
54556
55536
  }
55537
+ addZ(g);
54557
55538
  addClusters(g);
54558
55539
  g.info.bb = computeSubgraphBB(g, 0);
54559
55540
  placeGraphLabel(g);
@@ -54745,127 +55726,6 @@ function initParams(g, xpms) {
54745
55726
  return ret;
54746
55727
  }
54747
55728
 
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
55729
  // src/layout/fdp/init.ts
54870
55730
  function initialPositions3(g) {
54871
55731
  const div = inputscaleDivisor(g);
@@ -55723,7 +56583,7 @@ function deriveEdges(g, dg, byPair) {
55723
56583
  dndata(hd).deg++;
55724
56584
  dndata(tl).deg++;
55725
56585
  }
55726
- addEdge2(de, e);
56586
+ addEdge3(de, e);
55727
56587
  }
55728
56588
  }
55729
56589
  }
@@ -55745,7 +56605,7 @@ function derivePort(g, dg, byPair, port, m) {
55745
56605
  const de = deriveEdge(dg, byPair, m, dn);
55746
56606
  de.info.dist = port.e.info.dist;
55747
56607
  de.info.factor = port.e.info.factor;
55748
- addEdge2(de, port.e);
56608
+ addEdge3(de, port.e);
55749
56609
  dndata(dn).wdeg++;
55750
56610
  dndata(m).wdeg++;
55751
56611
  dndata(dn).deg++;
@@ -55855,7 +56715,7 @@ function expandCluster2(n, cg) {
55855
56715
  }
55856
56716
 
55857
56717
  // src/layout/fdp/layout.ts
55858
- var POINTS_PER_INCH13 = 72;
56718
+ var POINTS_PER_INCH14 = 72;
55859
56719
  var DEFAULT_NODEWIDTH_PTS = 54;
55860
56720
  var DEFAULT_NODEHEIGHT_PTS = 36;
55861
56721
  function initInfo(g) {
@@ -55950,7 +56810,7 @@ function shiftComponents(cc, pts, pt) {
55950
56810
  } else {
55951
56811
  p = pt;
55952
56812
  }
55953
- const del = { x: p.x / POINTS_PER_INCH13, y: p.y / POINTS_PER_INCH13 };
56813
+ const del = { x: p.x / POINTS_PER_INCH14, y: p.y / POINTS_PER_INCH14 };
55954
56814
  for (const n of cc[i].nodes.values()) {
55955
56815
  n.info.pos[0] += del.x;
55956
56816
  n.info.pos[1] += del.y;
@@ -55966,8 +56826,8 @@ function finalCC(g, cc, pts, rg, infop) {
55966
56826
  const pt = applyMarginAndBorder(rg, bb, margin);
55967
56827
  if (cc.length > 0) shiftComponents(cc, pts, pt);
55968
56828
  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 }
56829
+ ll: { x: bb.ll.x / POINTS_PER_INCH14, y: bb.ll.y / POINTS_PER_INCH14 },
56830
+ ur: { x: bb.ur.x / POINTS_PER_INCH14, y: bb.ur.y / POINTS_PER_INCH14 }
55971
56831
  };
55972
56832
  }
55973
56833
  function applyMarginAndBorder(rg, bb, margin) {
@@ -56013,8 +56873,8 @@ function translateOwnNodes(g, bb) {
56013
56873
  function setBB(g) {
56014
56874
  const bb = gdata(g).bb;
56015
56875
  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 }
56876
+ ll: { x: POINTS_PER_INCH14 * bb.ll.x, y: POINTS_PER_INCH14 * bb.ll.y },
56877
+ ur: { x: POINTS_PER_INCH14 * bb.ur.x, y: POINTS_PER_INCH14 * bb.ur.y }
56018
56878
  };
56019
56879
  const nClusters = g.info.n_cluster ?? 0;
56020
56880
  for (let i = 0; i < nClusters; i++) {
@@ -56029,8 +56889,8 @@ function setClustNodes(root) {
56029
56889
  const bb = gdata(p).bb;
56030
56890
  const w = bb.ur.x - bb.ll.x;
56031
56891
  const h = bb.ur.y - bb.ll.y;
56032
- const w2 = POINTS_PER_INCH13 * (w / 2);
56033
- const h2 = POINTS_PER_INCH13 * (h / 2);
56892
+ const w2 = POINTS_PER_INCH14 * (w / 2);
56893
+ const h2 = POINTS_PER_INCH14 * (h / 2);
56034
56894
  n.info.pos[0] = w / 2;
56035
56895
  n.info.pos[1] = h / 2;
56036
56896
  n.info.width = w;
@@ -56039,7 +56899,7 @@ function setClustNodes(root) {
56039
56899
  n.info.outline_width = w + penwidth;
56040
56900
  n.info.outline_height = h + penwidth;
56041
56901
  n.info.lw = n.info.rw = w2;
56042
- n.info.ht = POINTS_PER_INCH13 * h;
56902
+ n.info.ht = POINTS_PER_INCH14 * h;
56043
56903
  const poly = n.info.shape_info;
56044
56904
  if (poly && poly.vertices) {
56045
56905
  poly.vertices[0] = { x: w2, y: h2 };
@@ -56052,8 +56912,8 @@ function setClustNodes(root) {
56052
56912
  function syncCoordFromPos(cg) {
56053
56913
  for (const n of cg.nodes.values()) {
56054
56914
  n.info.coord = {
56055
- x: POINTS_PER_INCH13 * n.info.pos[0],
56056
- y: POINTS_PER_INCH13 * n.info.pos[1]
56915
+ x: POINTS_PER_INCH14 * n.info.pos[0],
56916
+ y: POINTS_PER_INCH14 * n.info.pos[1]
56057
56917
  };
56058
56918
  }
56059
56919
  }
@@ -56065,8 +56925,8 @@ function expandComponentClusters(cg, infop, counter) {
56065
56925
  if (r !== 0) return r;
56066
56926
  n.info.width = gdata(sg).bb.ur.x;
56067
56927
  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;
56928
+ const ptx = POINTS_PER_INCH14 * gdata(sg).bb.ur.x;
56929
+ const pty = POINTS_PER_INCH14 * gdata(sg).bb.ur.y;
56070
56930
  n.info.rw = n.info.lw = ptx / 2;
56071
56931
  n.info.ht = pty;
56072
56932
  } else if (isPort(n)) {
@@ -56179,7 +57039,7 @@ function fdpSplines(g) {
56179
57039
  );
56180
57040
  }
56181
57041
  if (g.info.n_cluster_edges) {
56182
- agerrLineOn("warn", CLUSTER_EDGE_WARNING);
57042
+ agwarningf(CLUSTER_EDGE_WARNING);
56183
57043
  et = EDGETYPE_LINE;
56184
57044
  } else {
56185
57045
  splineEdges1(g, et);
@@ -56630,15 +57490,15 @@ function multilevelSpringElectricalEmbedding(dim, A0, ctrl, labelSizes, x) {
56630
57490
  }
56631
57491
 
56632
57492
  // src/layout/sfdp/index.ts
56633
- var DIM = 2;
56634
57493
  function sfdpLayoutComponent(g, ctrl, pad) {
57494
+ const ndim = ndimOf(g);
56635
57495
  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);
57496
+ const sizes = ctrl.overlap >= 0 ? getSizes(g, pad, ndim) : null;
57497
+ const pos = getPos(g, ndim);
57498
+ multilevelSpringElectricalEmbedding(ndim, A3, ctrl, sizes, pos);
56639
57499
  for (const n of g.nodes.values()) {
56640
57500
  const i = n.info.id;
56641
- n.info.pos = [pos[i * DIM], pos[i * DIM + 1]];
57501
+ n.info.pos = pos.slice(i * ndim, (i + 1) * ndim);
56642
57502
  }
56643
57503
  }
56644
57504
  function resolveControl(g) {
@@ -56649,7 +57509,8 @@ function resolveControl(g) {
56649
57509
  const flag = overlap5 === void 0 ? "prism0" : overlap5;
56650
57510
  warnUnrecognizedOverlap(flag);
56651
57511
  const ntry = overlapPrismTries(flag);
56652
- if (ntry !== null) {
57512
+ const doAdjust = ndimOf(g) === 2;
57513
+ if (ntry !== null && doAdjust) {
56653
57514
  ctrl.overlap = ntry;
56654
57515
  ctrl.initialScaling = lateDouble(
56655
57516
  g.root.attrs.get("overlap_scaling"),
@@ -56664,7 +57525,7 @@ function resolveControl(g) {
56664
57525
  return { ctrl, pad, doAdjust: false };
56665
57526
  }
56666
57527
  ctrl.overlap = -1;
56667
- return { ctrl, pad, doAdjust: true };
57528
+ return { ctrl, pad, doAdjust };
56668
57529
  }
56669
57530
  function layoutComponents3(g, comps, ctrl, pad, doAdjust) {
56670
57531
  const pinfo = {
@@ -56712,6 +57573,7 @@ function sfdpLayout(g) {
56712
57573
  } else {
56713
57574
  layoutComponents3(g, comps, ctrl, pad, doAdjust);
56714
57575
  }
57576
+ for (const c of comps) agdelsubg(g, c);
56715
57577
  }
56716
57578
  postprocess(g, singleComponent);
56717
57579
  }
@@ -57625,7 +58487,7 @@ function buildDerivedEdges(g, dg) {
57625
58487
  return edges;
57626
58488
  }
57627
58489
  function derivedComponents(g, dg, allEdges3) {
57628
- const comps = ccomps(g);
58490
+ const comps = ccomps(g, null, false);
57629
58491
  return comps.map((sg, i) => {
57630
58492
  const nodes = [];
57631
58493
  for (const n of sg.nodes.values()) {
@@ -57759,6 +58621,7 @@ function twopiLayout(g) {
57759
58621
  } else {
57760
58622
  layoutMulti(g, comps, globalRoot, buildPackInfo(g));
57761
58623
  }
58624
+ for (const c of comps) agdelsubg(g, c);
57762
58625
  normalizeGraphBB(g);
57763
58626
  placeGraphLabel(g);
57764
58627
  gvPostprocess(g);
@@ -58571,8 +59434,8 @@ var forfunc = (cur, total, init) => (1 - cur / total) * init / 2;
58571
59434
  var revfunc = (cur, total, init) => cur / total * init / 2;
58572
59435
  var nonefunc = (_cur, _total, init) => init / 2;
58573
59436
  var bothfunc = (cur, total, init) => {
58574
- const fr10 = cur / total;
58575
- return fr10 <= 0.5 ? fr10 * init : (1 - fr10) * init;
59437
+ const fr12 = cur / total;
59438
+ return fr12 <= 0.5 ? fr12 * init : (1 - fr12) * init;
58576
59439
  };
58577
59440
  function taperfun(dir, directed) {
58578
59441
  if (dir === "forward") return forfunc;
@@ -59434,6 +60297,15 @@ function trimFixed3(v) {
59434
60297
  function edgeAttrsAttached(e) {
59435
60298
  return e.info.edge_type !== IGNORED && e.info.spl != null;
59436
60299
  }
60300
+ function nodePosRaw(n) {
60301
+ const c = n.info.coord;
60302
+ let raw = gfmt5(c.x) + "," + gfmt5(c.y);
60303
+ const odim = n.root.info.odim ?? 2;
60304
+ for (let k = 2; odim >= 3 && k < odim; k++) {
60305
+ raw += "," + gfmt5(POINTS_PER_INCH * (n.info.pos?.[k] ?? 0));
60306
+ }
60307
+ return raw;
60308
+ }
59437
60309
  function appendRecordRects(n, f, out) {
59438
60310
  const c = n.info.coord;
59439
60311
  if (f.n_flds === 0) {
@@ -59905,7 +60777,7 @@ var DotWriterBase = class {
59905
60777
  nodeAttrs(n, scope) {
59906
60778
  const info = n.info;
59907
60779
  const defs = effectiveNodeDefaults2(scope);
59908
- const posRaw = gfmt5(info.coord.x) + "," + gfmt5(info.coord.y);
60780
+ const posRaw = nodePosRaw(n);
59909
60781
  const widthRaw = gfmt5((info.lw + info.rw) / 72);
59910
60782
  const heightRaw = gfmt5(info.ht / 72);
59911
60783
  const parts = [
@@ -60157,13 +61029,13 @@ var EdgeDrawBase = class extends DotWriterBase {
60157
61029
  };
60158
61030
 
60159
61031
  // src/render/dot/write-back.ts
60160
- var POINTS_PER_INCH14 = 72;
61032
+ var POINTS_PER_INCH15 = 72;
60161
61033
  function attachNode(n) {
60162
61034
  const attrs = ownAttrs(n);
60163
61035
  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));
61036
+ attrs.set("pos", nodePosRaw(n));
61037
+ attrs.set("height", gfmt5(info.ht / POINTS_PER_INCH15));
61038
+ attrs.set("width", gfmt5((info.lw + info.rw) / POINTS_PER_INCH15));
60167
61039
  const xlabel = info.xlabel;
60168
61040
  if (xlabel?.set) attrs.set("xlp", lpStr(xlabel.pos));
60169
61041
  if (info.shape?.name === "record") {
@@ -60193,8 +61065,8 @@ function recAttachBb(g) {
60193
61065
  const label = g.info.label;
60194
61066
  if (label && label.text.length > 0) {
60195
61067
  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));
61068
+ g.attrs.set("lwidth", gfmt2(label.dimen.x / POINTS_PER_INCH15));
61069
+ g.attrs.set("lheight", gfmt2(label.dimen.y / POINTS_PER_INCH15));
60198
61070
  }
60199
61071
  for (const sg of clustersOf(g)) recAttachBb(sg);
60200
61072
  }
@@ -61268,7 +62140,7 @@ function insertEdge3(g, root, edge) {
61268
62140
  cur.edges.push(edge);
61269
62141
  }
61270
62142
  }
61271
- function addEdge3(g, tail, head, name) {
62143
+ function addEdge4(g, tail, head, name) {
61272
62144
  requireObject("g", g);
61273
62145
  requireObject("tail", tail);
61274
62146
  requireObject("head", head);
@@ -61405,7 +62277,7 @@ var GraphBuilder = class _GraphBuilder {
61405
62277
  requireAttrs("attrs", attrs);
61406
62278
  const tailNode = resolveNode2(this._graph, tail);
61407
62279
  const headNode = resolveNode2(this._graph, head);
61408
- const edge = addEdge3(this._graph, tailNode, headNode);
62280
+ const edge = addEdge4(this._graph, tailNode, headNode);
61409
62281
  applyAttrs2(edge.attrs, attrs);
61410
62282
  return new EdgeHandle(edge);
61411
62283
  }
@@ -62055,7 +62927,8 @@ export {
62055
62927
  LutTextMeasurer,
62056
62928
  ParseError,
62057
62929
  RenderError,
62058
- addEdge3 as addEdge,
62930
+ addEdge4 as addEdge,
62931
+ agseterrf,
62059
62932
  createGraph,
62060
62933
  getDrawOps,
62061
62934
  getLayout,