@knowvah/dot-engine 2.9.0 → 2.10.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 (220) hide show
  1. package/dist/common/graph-init.d.ts.map +1 -1
  2. package/dist/common/htmltable.d.ts +1 -1
  3. package/dist/common/htmltable.d.ts.map +1 -1
  4. package/dist/common/poly-init.d.ts +8 -8
  5. package/dist/common/poly-init.d.ts.map +1 -1
  6. package/dist/common/safefile.d.ts +15 -0
  7. package/dist/common/safefile.d.ts.map +1 -1
  8. package/dist/gvc/image-resolver.d.ts +5 -0
  9. package/dist/gvc/image-resolver.d.ts.map +1 -1
  10. package/dist/gvc/usershape.d.ts +2 -0
  11. package/dist/gvc/usershape.d.ts.map +1 -1
  12. package/dist/index.js +914 -813
  13. package/dist/index.js.map +4 -4
  14. package/dist/layout/neato/__fixtures__/kk-models.d.ts +59 -0
  15. package/dist/layout/neato/__fixtures__/kk-models.d.ts.map +1 -0
  16. package/dist/layout/neato/__fixtures__/quad-prog-vpsc.d.ts +6 -0
  17. package/dist/layout/neato/__fixtures__/quad-prog-vpsc.d.ts.map +1 -1
  18. package/dist/layout/neato/circuit.d.ts +38 -0
  19. package/dist/layout/neato/circuit.d.ts.map +1 -1
  20. package/dist/layout/neato/constrained-majorization.d.ts.map +1 -1
  21. package/dist/layout/neato/index.d.ts +6 -3
  22. package/dist/layout/neato/index.d.ts.map +1 -1
  23. package/dist/layout/neato/init.d.ts.map +1 -1
  24. package/dist/layout/neato/kk-paths.d.ts +11 -1
  25. package/dist/layout/neato/kk-paths.d.ts.map +1 -1
  26. package/dist/layout/neato/kk-solve.d.ts.map +1 -1
  27. package/dist/layout/neato/kk.d.ts +5 -3
  28. package/dist/layout/neato/kk.d.ts.map +1 -1
  29. package/dist/layout/neato/kkutils.d.ts +45 -0
  30. package/dist/layout/neato/kkutils.d.ts.map +1 -1
  31. package/dist/layout/neato/start.d.ts +11 -10
  32. package/dist/layout/neato/start.d.ts.map +1 -1
  33. package/dist/layout/neato/stress-models.d.ts +25 -19
  34. package/dist/layout/neato/stress-models.d.ts.map +1 -1
  35. package/dist/render.js +914 -813
  36. package/dist/render.js.map +4 -4
  37. package/dist/vpsc/SweepLine.d.ts +21 -8
  38. package/dist/vpsc/SweepLine.d.ts.map +1 -1
  39. package/dist/vpsc/sweepTypes.d.ts +12 -2
  40. package/dist/vpsc/sweepTypes.d.ts.map +1 -1
  41. package/package.json +1 -1
  42. package/src/common/graph-init.ts +5 -1
  43. package/src/common/htmltable.ts +6 -4
  44. package/src/common/poly-init.ts +35 -15
  45. package/src/common/safefile.ts +20 -2
  46. package/src/gvc/__fixtures__/p8/bad.png +1 -0
  47. package/src/gvc/__fixtures__/p8/d/r.png +0 -0
  48. package/src/gvc/__fixtures__/p8/html-img-bad.gv +1 -0
  49. package/src/gvc/__fixtures__/p8/html-img-bad.svg +19 -0
  50. package/src/gvc/__fixtures__/p8/html-img-bad.svg.stderr +3 -0
  51. package/src/gvc/__fixtures__/p8/html-img-bad.xdot +13 -0
  52. package/src/gvc/__fixtures__/p8/html-img-bad.xdot.stderr +3 -0
  53. package/src/gvc/__fixtures__/p8/ip-shapefile.gv +1 -0
  54. package/src/gvc/__fixtures__/p8/ip-shapefile.svg +19 -0
  55. package/src/gvc/__fixtures__/p8/ip-shapefile.svg.stderr +0 -0
  56. package/src/gvc/__fixtures__/p8/ip-shapefile.xdot +15 -0
  57. package/src/gvc/__fixtures__/p8/ip-shapefile.xdot.stderr +0 -0
  58. package/src/gvc/__fixtures__/p8/regen.sh +13 -0
  59. package/src/gvc/image-resolver.ts +8 -0
  60. package/src/gvc/usershape.ts +5 -0
  61. package/src/layout/neato/__fixtures__/kk-models.ts +82 -0
  62. package/src/layout/neato/__fixtures__/models/hier-circuit.gv +15 -0
  63. package/src/layout/neato/__fixtures__/models/hier-circuit.xdot +92 -0
  64. package/src/layout/neato/__fixtures__/models/hier-circuit.xdot.stderr +0 -0
  65. package/src/layout/neato/__fixtures__/models/hier-default.gv +14 -0
  66. package/src/layout/neato/__fixtures__/models/hier-default.xdot +91 -0
  67. package/src/layout/neato/__fixtures__/models/hier-default.xdot.stderr +0 -0
  68. package/src/layout/neato/__fixtures__/models/hier-disc-circuit.gv +9 -0
  69. package/src/layout/neato/__fixtures__/models/hier-disc-circuit.xdot +54 -0
  70. package/src/layout/neato/__fixtures__/models/hier-disc-circuit.xdot.stderr +0 -0
  71. package/src/layout/neato/__fixtures__/models/hier-len-circuit.gv +15 -0
  72. package/src/layout/neato/__fixtures__/models/hier-len-circuit.xdot +97 -0
  73. package/src/layout/neato/__fixtures__/models/hier-len-circuit.xdot.stderr +0 -0
  74. package/src/layout/neato/__fixtures__/models/hier-len-mds.gv +15 -0
  75. package/src/layout/neato/__fixtures__/models/hier-len-mds.xdot +97 -0
  76. package/src/layout/neato/__fixtures__/models/hier-len-mds.xdot.stderr +0 -0
  77. package/src/layout/neato/__fixtures__/models/hier-len-subset.gv +15 -0
  78. package/src/layout/neato/__fixtures__/models/hier-len-subset.xdot +97 -0
  79. package/src/layout/neato/__fixtures__/models/hier-len-subset.xdot.stderr +0 -0
  80. package/src/layout/neato/__fixtures__/models/hier-long-mds.gv +15 -0
  81. package/src/layout/neato/__fixtures__/models/hier-long-mds.xdot +95 -0
  82. package/src/layout/neato/__fixtures__/models/hier-long-mds.xdot.stderr +0 -0
  83. package/src/layout/neato/__fixtures__/models/hier-mds-nolen.gv +15 -0
  84. package/src/layout/neato/__fixtures__/models/hier-mds-nolen.xdot +92 -0
  85. package/src/layout/neato/__fixtures__/models/hier-mds-nolen.xdot.stderr +2 -0
  86. package/src/layout/neato/__fixtures__/models/hier-pin-disc-circuit.gv +10 -0
  87. package/src/layout/neato/__fixtures__/models/hier-pin-disc-circuit.xdot +54 -0
  88. package/src/layout/neato/__fixtures__/models/hier-pin-disc-circuit.xdot.stderr +3 -0
  89. package/src/layout/neato/__fixtures__/models/hier-shortpath.gv +15 -0
  90. package/src/layout/neato/__fixtures__/models/hier-shortpath.xdot +92 -0
  91. package/src/layout/neato/__fixtures__/models/hier-shortpath.xdot.stderr +0 -0
  92. package/src/layout/neato/__fixtures__/models/hier-subset.gv +15 -0
  93. package/src/layout/neato/__fixtures__/models/hier-subset.xdot +92 -0
  94. package/src/layout/neato/__fixtures__/models/hier-subset.xdot.stderr +0 -0
  95. package/src/layout/neato/__fixtures__/models/kk-circuit.gv +15 -0
  96. package/src/layout/neato/__fixtures__/models/kk-circuit.xdot +81 -0
  97. package/src/layout/neato/__fixtures__/models/kk-circuit.xdot.stderr +4 -0
  98. package/src/layout/neato/__fixtures__/models/kk-default.gv +14 -0
  99. package/src/layout/neato/__fixtures__/models/kk-default.xdot +80 -0
  100. package/src/layout/neato/__fixtures__/models/kk-default.xdot.stderr +0 -0
  101. package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.gv +10 -0
  102. package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.native-crash +1 -0
  103. package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.xdot +0 -0
  104. package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.xdot.stderr +0 -0
  105. package/src/layout/neato/__fixtures__/models/kk-disc-circuit.gv +9 -0
  106. package/src/layout/neato/__fixtures__/models/kk-disc-circuit.xdot +49 -0
  107. package/src/layout/neato/__fixtures__/models/kk-disc-circuit.xdot.stderr +4 -0
  108. package/src/layout/neato/__fixtures__/models/kk-disc-shortpath-pack.gv +10 -0
  109. package/src/layout/neato/__fixtures__/models/kk-disc-shortpath-pack.xdot +50 -0
  110. package/src/layout/neato/__fixtures__/models/kk-disc-shortpath-pack.xdot.stderr +0 -0
  111. package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.gv +13 -0
  112. package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.native-crash +1 -0
  113. package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.xdot +0 -0
  114. package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.xdot.stderr +4 -0
  115. package/src/layout/neato/__fixtures__/models/kk-disc4-shortpath-pack.gv +13 -0
  116. package/src/layout/neato/__fixtures__/models/kk-disc4-shortpath-pack.xdot +66 -0
  117. package/src/layout/neato/__fixtures__/models/kk-disc4-shortpath-pack.xdot.stderr +0 -0
  118. package/src/layout/neato/__fixtures__/models/kk-iso-circuit.gv +11 -0
  119. package/src/layout/neato/__fixtures__/models/kk-iso-circuit.xdot +51 -0
  120. package/src/layout/neato/__fixtures__/models/kk-iso-circuit.xdot.stderr +4 -0
  121. package/src/layout/neato/__fixtures__/models/kk-iso-len-circuit.gv +11 -0
  122. package/src/layout/neato/__fixtures__/models/kk-iso-len-circuit.xdot +57 -0
  123. package/src/layout/neato/__fixtures__/models/kk-iso-len-circuit.xdot.stderr +4 -0
  124. package/src/layout/neato/__fixtures__/models/kk-iso-len-mds.gv +11 -0
  125. package/src/layout/neato/__fixtures__/models/kk-iso-len-mds.xdot +57 -0
  126. package/src/layout/neato/__fixtures__/models/kk-iso-len-mds.xdot.stderr +0 -0
  127. package/src/layout/neato/__fixtures__/models/kk-iso-long-mds.gv +11 -0
  128. package/src/layout/neato/__fixtures__/models/kk-iso-long-mds.xdot +57 -0
  129. package/src/layout/neato/__fixtures__/models/kk-iso-long-mds.xdot.stderr +0 -0
  130. package/src/layout/neato/__fixtures__/models/kk-large.gv +203 -0
  131. package/src/layout/neato/__fixtures__/models/kk-large.pow.json +1088 -0
  132. package/src/layout/neato/__fixtures__/models/kk-large.xdot +1208 -0
  133. package/src/layout/neato/__fixtures__/models/kk-large.xdot.stderr +0 -0
  134. package/src/layout/neato/__fixtures__/models/kk-len-circuit.gv +15 -0
  135. package/src/layout/neato/__fixtures__/models/kk-len-circuit.xdot +86 -0
  136. package/src/layout/neato/__fixtures__/models/kk-len-circuit.xdot.stderr +4 -0
  137. package/src/layout/neato/__fixtures__/models/kk-len-mds.gv +15 -0
  138. package/src/layout/neato/__fixtures__/models/kk-len-mds.xdot +86 -0
  139. package/src/layout/neato/__fixtures__/models/kk-len-mds.xdot.stderr +0 -0
  140. package/src/layout/neato/__fixtures__/models/kk-len-subset.gv +15 -0
  141. package/src/layout/neato/__fixtures__/models/kk-len-subset.xdot +86 -0
  142. package/src/layout/neato/__fixtures__/models/kk-len-subset.xdot.stderr +0 -0
  143. package/src/layout/neato/__fixtures__/models/kk-mds-nolen.gv +15 -0
  144. package/src/layout/neato/__fixtures__/models/kk-mds-nolen.xdot +81 -0
  145. package/src/layout/neato/__fixtures__/models/kk-mds-nolen.xdot.stderr +2 -0
  146. package/src/layout/neato/__fixtures__/models/kk-shortpath.gv +15 -0
  147. package/src/layout/neato/__fixtures__/models/kk-shortpath.xdot +81 -0
  148. package/src/layout/neato/__fixtures__/models/kk-shortpath.xdot.stderr +0 -0
  149. package/src/layout/neato/__fixtures__/models/kk-subset.gv +15 -0
  150. package/src/layout/neato/__fixtures__/models/kk-subset.xdot +81 -0
  151. package/src/layout/neato/__fixtures__/models/kk-subset.xdot.stderr +0 -0
  152. package/src/layout/neato/__fixtures__/models/large-circuit.gv +203 -0
  153. package/src/layout/neato/__fixtures__/models/large-circuit.xdot +1208 -0
  154. package/src/layout/neato/__fixtures__/models/large-circuit.xdot.stderr +0 -0
  155. package/src/layout/neato/__fixtures__/models/major-circuit.gv +14 -0
  156. package/src/layout/neato/__fixtures__/models/major-circuit.xdot +80 -0
  157. package/src/layout/neato/__fixtures__/models/major-circuit.xdot.stderr +0 -0
  158. package/src/layout/neato/__fixtures__/models/major-default.gv +13 -0
  159. package/src/layout/neato/__fixtures__/models/major-default.xdot +79 -0
  160. package/src/layout/neato/__fixtures__/models/major-default.xdot.stderr +0 -0
  161. package/src/layout/neato/__fixtures__/models/major-disc-circuit.gv +8 -0
  162. package/src/layout/neato/__fixtures__/models/major-disc-circuit.xdot +48 -0
  163. package/src/layout/neato/__fixtures__/models/major-disc-circuit.xdot.stderr +0 -0
  164. package/src/layout/neato/__fixtures__/models/major-len-circuit.gv +14 -0
  165. package/src/layout/neato/__fixtures__/models/major-len-circuit.xdot +85 -0
  166. package/src/layout/neato/__fixtures__/models/major-len-circuit.xdot.stderr +0 -0
  167. package/src/layout/neato/__fixtures__/models/major-len-mds.gv +14 -0
  168. package/src/layout/neato/__fixtures__/models/major-len-mds.xdot +85 -0
  169. package/src/layout/neato/__fixtures__/models/major-len-mds.xdot.stderr +0 -0
  170. package/src/layout/neato/__fixtures__/models/major-len-subset.gv +14 -0
  171. package/src/layout/neato/__fixtures__/models/major-len-subset.xdot +85 -0
  172. package/src/layout/neato/__fixtures__/models/major-len-subset.xdot.stderr +0 -0
  173. package/src/layout/neato/__fixtures__/models/major-long-mds.gv +14 -0
  174. package/src/layout/neato/__fixtures__/models/major-long-mds.xdot +83 -0
  175. package/src/layout/neato/__fixtures__/models/major-long-mds.xdot.stderr +0 -0
  176. package/src/layout/neato/__fixtures__/models/major-long-shortpath.gv +14 -0
  177. package/src/layout/neato/__fixtures__/models/major-long-shortpath.xdot +83 -0
  178. package/src/layout/neato/__fixtures__/models/major-long-shortpath.xdot.stderr +0 -0
  179. package/src/layout/neato/__fixtures__/models/major-mds-edge-default.gv +15 -0
  180. package/src/layout/neato/__fixtures__/models/major-mds-edge-default.xdot +81 -0
  181. package/src/layout/neato/__fixtures__/models/major-mds-edge-default.xdot.stderr +0 -0
  182. package/src/layout/neato/__fixtures__/models/major-mds-nolen-anon.gv +14 -0
  183. package/src/layout/neato/__fixtures__/models/major-mds-nolen-anon.xdot +80 -0
  184. package/src/layout/neato/__fixtures__/models/major-mds-nolen-anon.xdot.stderr +2 -0
  185. package/src/layout/neato/__fixtures__/models/major-mds-nolen.gv +14 -0
  186. package/src/layout/neato/__fixtures__/models/major-mds-nolen.xdot +80 -0
  187. package/src/layout/neato/__fixtures__/models/major-mds-nolen.xdot.stderr +2 -0
  188. package/src/layout/neato/__fixtures__/models/major-model-Subset.gv +14 -0
  189. package/src/layout/neato/__fixtures__/models/major-model-Subset.xdot +80 -0
  190. package/src/layout/neato/__fixtures__/models/major-model-Subset.xdot.stderr +1 -0
  191. package/src/layout/neato/__fixtures__/models/major-model-foo-anon.gv +14 -0
  192. package/src/layout/neato/__fixtures__/models/major-model-foo-anon.xdot +80 -0
  193. package/src/layout/neato/__fixtures__/models/major-model-foo-anon.xdot.stderr +1 -0
  194. package/src/layout/neato/__fixtures__/models/major-model-foo.gv +14 -0
  195. package/src/layout/neato/__fixtures__/models/major-model-foo.xdot +80 -0
  196. package/src/layout/neato/__fixtures__/models/major-model-foo.xdot.stderr +1 -0
  197. package/src/layout/neato/__fixtures__/models/major-pin-disc-circuit.gv +9 -0
  198. package/src/layout/neato/__fixtures__/models/major-pin-disc-circuit.xdot +48 -0
  199. package/src/layout/neato/__fixtures__/models/major-pin-disc-circuit.xdot.stderr +2 -0
  200. package/src/layout/neato/__fixtures__/models/major-shortpath.gv +14 -0
  201. package/src/layout/neato/__fixtures__/models/major-shortpath.xdot +80 -0
  202. package/src/layout/neato/__fixtures__/models/major-shortpath.xdot.stderr +0 -0
  203. package/src/layout/neato/__fixtures__/models/major-subset.gv +14 -0
  204. package/src/layout/neato/__fixtures__/models/major-subset.xdot +80 -0
  205. package/src/layout/neato/__fixtures__/models/major-subset.xdot.stderr +0 -0
  206. package/src/layout/neato/__fixtures__/models/regen.sh +46 -0
  207. package/src/layout/neato/__fixtures__/quad-prog-vpsc.ts +7 -1
  208. package/src/layout/neato/circuit.ts +67 -2
  209. package/src/layout/neato/constrained-majorization.ts +5 -22
  210. package/src/layout/neato/index.ts +41 -14
  211. package/src/layout/neato/init.ts +9 -13
  212. package/src/layout/neato/kk-paths.ts +23 -1
  213. package/src/layout/neato/kk-solve.ts +5 -3
  214. package/src/layout/neato/kk.ts +53 -21
  215. package/src/layout/neato/kkutils.ts +108 -3
  216. package/src/layout/neato/start.ts +20 -65
  217. package/src/layout/neato/stress-models.ts +55 -59
  218. package/src/layout/pack/index.ts +2 -2
  219. package/src/vpsc/SweepLine.ts +39 -26
  220. package/src/vpsc/sweepTypes.ts +13 -2
package/dist/index.js CHANGED
@@ -6107,6 +6107,9 @@ function gvrenderTextspan(renderer, pos, span, job) {
6107
6107
 
6108
6108
  // src/gvc/image-resolver.ts
6109
6109
  var activeResolver = null;
6110
+ function getGlobalImageResolver() {
6111
+ return activeResolver;
6112
+ }
6110
6113
  function setImageResolver(fn) {
6111
6114
  if (fn !== null && typeof fn !== "function") {
6112
6115
  throw invalidArgType("resolver", "function or null", fn);
@@ -6178,6 +6181,18 @@ var imagePathState = { value: void 0 };
6178
6181
  registerRenderState(() => {
6179
6182
  imagePathState.value = void 0;
6180
6183
  });
6184
+ var imageHooksState = {
6185
+ sizer: void 0,
6186
+ resolver: void 0
6187
+ };
6188
+ registerRenderState(() => {
6189
+ imageHooksState.sizer = void 0;
6190
+ imageHooksState.resolver = void 0;
6191
+ });
6192
+ function setImageHooks(sizer, resolver) {
6193
+ imageHooksState.sizer = sizer;
6194
+ imageHooksState.resolver = resolver;
6195
+ }
6181
6196
  function setImagePath(imagepath) {
6182
6197
  imagePathState.value = imagepath;
6183
6198
  }
@@ -6185,7 +6200,7 @@ function mkDirlist(list) {
6185
6200
  return list === "" ? [] : list.split(PATHSEP);
6186
6201
  }
6187
6202
  function findPath(dirs, str) {
6188
- return dirs.length > 0 && imageIsSupplied(str) ? str : null;
6203
+ return dirs.length > 0 && imageIsSupplied(str, imageHooksState.sizer, imageHooksState.resolver) ? str : null;
6189
6204
  }
6190
6205
  function safefile(filename) {
6191
6206
  if (filename === void 0 || filename === "") return null;
@@ -6284,6 +6299,13 @@ function usershapeType(name, resolver) {
6284
6299
  const found = findImageBytes(name, resolver);
6285
6300
  return found === null ? null : imagetype(found.bytes);
6286
6301
  }
6302
+ function imageNotFoundWarning(name) {
6303
+ return `"${name}" was not found as a file or as a shape library member`;
6304
+ }
6305
+ function imageOpenFailure(name, sizer, resolver) {
6306
+ if (!imageIsSupplied(name, sizer, resolver)) return imageOpenWarning(name);
6307
+ return usershapeType(name, resolver)?.type === ImageType.FT_NULL ? imageNotFoundWarning(name) : null;
6308
+ }
6287
6309
  function imageOpenWarning(name) {
6288
6310
  if (safefile(name) === null) return `Filename "${name}" is unsafe`;
6289
6311
  return `${STRERROR_ENOENT} while opening ${name}`;
@@ -13564,13 +13586,15 @@ var sizeTextContent = (texts, measurer, env = defaultSizeEnv()) => {
13564
13586
  var missingImages = { set: /* @__PURE__ */ new WeakSet() };
13565
13587
  var sizeHtmlImg = (img, { imageSizer, imageResolver, imageDpi, stderr }) => {
13566
13588
  if (img.width !== void 0 && img.height !== void 0) return missingImages.set.has(img) ? 1 : 0;
13567
- const sz = usershapeSizePts(img.src, imageDpi ?? DEFAULT_DPI, imageSizer);
13589
+ const resolver = imageResolver ?? getGlobalImageResolver() ?? void 0;
13590
+ const sz = usershapeSizePts(img.src, imageDpi ?? DEFAULT_DPI, imageSizer, resolver);
13568
13591
  if (sz !== null) {
13569
13592
  img.width = sz.x;
13570
13593
  img.height = sz.y;
13571
13594
  return 0;
13572
13595
  }
13573
- if (!imageIsSupplied(img.src, imageSizer, imageResolver)) agerrLine(stderr, `Warning: ${imageOpenWarning(img.src)}`);
13596
+ const failure = imageOpenFailure(img.src, imageSizer, resolver);
13597
+ if (failure !== null) agerrLine(stderr, `Warning: ${failure}`);
13574
13598
  agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
13575
13599
  img.width = 0;
13576
13600
  img.height = 0;
@@ -25515,29 +25539,44 @@ function buildNodeLabel(n, g, measurer) {
25515
25539
  const content = isHtml ? htmlValueContent(labelAttr) : labelAttr ?? n.name;
25516
25540
  n.info.label = makeAnyLabel(content, isHtml, font, measurer, n);
25517
25541
  }
25542
+ function warnShapefileOpen(g, shapefile) {
25543
+ const gvc = g.root.info.gvc;
25544
+ const resolver = gvc?.imageResolver ?? getGlobalImageResolver() ?? void 0;
25545
+ if (usershapeSizePts(shapefile, usershapeDpi(g.root.attrs), gvc?.imageSizer, resolver) !== null) return true;
25546
+ const failure = imageOpenFailure(shapefile, gvc?.imageSizer, resolver);
25547
+ if (failure !== null) agwarningf(failure);
25548
+ return false;
25549
+ }
25518
25550
  function warnPolyInitImages(n, g) {
25519
25551
  const shape = boundShape(n, g);
25520
25552
  if (shape.usershape) {
25521
25553
  if (shape.name !== CUSTOM_SHAPE_NAME) return;
25522
25554
  const shapefile = nodeAttr(n, g, "shapefile");
25523
- if (shapefile !== void 0 && shapefile !== "") agwarningf(imageOpenWarning(shapefile));
25555
+ if (shapefile !== void 0 && shapefile !== "" && warnShapefileOpen(g, shapefile)) return;
25524
25556
  agwarningf(`No or improper shapefile="${shapefile ?? "<nil>"}" for node "${n.name}"`);
25525
25557
  return;
25526
25558
  }
25527
25559
  const image = nodeAttr(n, g, "image");
25528
25560
  if (image === void 0 || image === "") return;
25529
25561
  const gvc = g.root.info.gvc;
25530
- if (imageIsSupplied(image, gvc?.imageSizer, gvc?.imageResolver)) return;
25531
- agwarningf(imageOpenWarning(image));
25562
+ const failure = imageOpenFailure(image, gvc?.imageSizer, gvc?.imageResolver ?? getGlobalImageResolver() ?? void 0);
25563
+ if (failure === null) return;
25564
+ agwarningf(failure);
25532
25565
  agwarningf(`No or improper image="${image}" for node "${n.name}"`);
25533
25566
  }
25534
25567
  function boundShape(n, g) {
25535
25568
  return n.info.shape ?? bindShape(nodeAttr(n, g, "shape") ?? "ellipse", nodeAttr(n, g, "shapefile"));
25536
25569
  }
25537
25570
  function nodeImageSize(n, g) {
25538
- if (boundShape(n, g).usershape) return void 0;
25571
+ const shape = boundShape(n, g);
25572
+ if (shape.usershape && shape.name !== CUSTOM_SHAPE_NAME) return void 0;
25539
25573
  const gvc = g.root.info.gvc;
25540
- const sz = usershapeSizePts(nodeAttr(n, g, "image"), usershapeDpi(g.root.attrs), gvc?.imageSizer);
25574
+ const sz = usershapeSizePts(
25575
+ shape.usershape ? nodeAttr(n, g, "shapefile") : nodeAttr(n, g, "image"),
25576
+ usershapeDpi(g.root.attrs),
25577
+ gvc?.imageSizer,
25578
+ gvc?.imageResolver ?? getGlobalImageResolver() ?? void 0
25579
+ );
25541
25580
  if (sz === null) return void 0;
25542
25581
  g.root.info.has_images = true;
25543
25582
  return { x: sz.x + 2, y: sz.y + 2 };
@@ -26627,6 +26666,8 @@ function fontnameCodes() {
26627
26666
  function graphInit(g, useRankdir) {
26628
26667
  g.info.charset = findCharset(g);
26629
26668
  setImagePath(g.attrs.get("imagepath"));
26669
+ const gvc = g.root.info.gvc;
26670
+ setImageHooks(gvc?.imageSizer, gvc?.imageResolver);
26630
26671
  let rankdir = RANKDIR_TB;
26631
26672
  const rd = g.attrs.get("rankdir");
26632
26673
  if (rd === "LR") rankdir = RANKDIR_LR;
@@ -41069,12 +41110,12 @@ function pccomps(g, pfx) {
41069
41110
  pinned = true;
41070
41111
  }
41071
41112
  if (pinnedNodes.length > 0) {
41072
- result.push(buildSubgraph(g, pinnedNodes, `${pfx}_${idx++}`));
41113
+ result.push(buildSubgraph(g, pinnedNodes, `${pfx}${idx++}`));
41073
41114
  }
41074
41115
  for (const n of g.nodes.values()) {
41075
41116
  if (visited.has(n.name)) continue;
41076
41117
  const comp = dfsCollect(g, n, visited);
41077
- result.push(buildSubgraph(g, comp, `${pfx}_${idx++}`));
41118
+ result.push(buildSubgraph(g, comp, `${pfx}${idx++}`));
41078
41119
  }
41079
41120
  return { graphs: result, pinned };
41080
41121
  }
@@ -42170,7 +42211,11 @@ var selfOnce = { warned: false };
42170
42211
  registerRenderState(() => {
42171
42212
  selfOnce.warned = false;
42172
42213
  });
42173
- var circuitWarned = /* @__PURE__ */ new WeakSet();
42214
+ function warnStartSelfOnce() {
42215
+ if (selfOnce.warned) return;
42216
+ selfOnce.warned = true;
42217
+ agwarningf(WARN_SELF_IGNORED);
42218
+ }
42174
42219
  function parseStart(p, dflt) {
42175
42220
  let init = dflt;
42176
42221
  let rest = p ?? "";
@@ -42200,7 +42245,7 @@ function initRegular(g, nG) {
42200
42245
  function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
42201
42246
  const { init, seed } = parseStart(g.root.attrs.get("start"), dflt);
42202
42247
  if (init !== INIT_RANDOM && [...g.nodes.values()].some((n) => n.attrs.has("pos"))) {
42203
- agerrLineOn("warn", WARN_POS_IGNORED);
42248
+ agwarningf(WARN_POS_IGNORED);
42204
42249
  }
42205
42250
  if (init === INIT_REGULAR) initRegular(g, nG);
42206
42251
  srand48(seed);
@@ -42234,65 +42279,17 @@ function checkStartAttr(g, mode) {
42234
42279
  const value = g.root.attrs.get("start");
42235
42280
  if (parseStart(value, INIT_RANDOM).init !== INIT_SELF) return;
42236
42281
  if (mode === MODE_MAJOR) unsupported("start", value ?? "", "smart initialisation");
42237
- if ((mode === MODE_KK || mode === MODE_SGD) && !selfOnce.warned) {
42238
- selfOnce.warned = true;
42239
- agerrLineOn("warn", WARN_SELF_IGNORED);
42240
- }
42241
- }
42242
- function isConnected(g) {
42243
- const nodes = [...g.nodes.values()];
42244
- if (nodes.length === 0) return true;
42245
- const adj = new Map(nodes.map((n) => [n, []]));
42246
- for (const e of g.edges) {
42247
- adj.get(e.tail)?.push(e.head);
42248
- adj.get(e.head)?.push(e.tail);
42249
- }
42250
- const seen2 = /* @__PURE__ */ new Set([nodes[0]]);
42251
- const stack = [nodes[0]];
42252
- for (let n = stack.pop(); n !== void 0; n = stack.pop()) {
42253
- for (const m of adj.get(n) ?? []) if (!seen2.has(m)) {
42254
- seen2.add(m);
42255
- stack.push(m);
42256
- }
42257
- }
42258
- return seen2.size === nodes.length;
42259
- }
42260
- function kkCircuitFallsBack(g) {
42261
- const packed = getPack(g.root, -1, 0) >= 0 || (g.root.attrs.get("packmode") ?? "") !== "";
42262
- return !packed && !isConnected(g.root);
42263
- }
42264
- function warnCircuitDisconnected(g) {
42265
- if (circuitWarned.has(g.root)) return;
42266
- circuitWarned.add(g.root);
42267
- agerrLineOn(
42268
- "warn",
42269
- `graph ${agNameOf(g.root)} is disconnected. Hence, the circuit model
42270
- is undefined. Reverting to the shortest path model.
42271
- Alternatively, consider running neato using -Gpack=true or decomposing
42272
- the graph into connected components.`
42273
- );
42274
- }
42275
- function checkModel(g, mode, model) {
42276
- const value = g.root.attrs.get("model") ?? "";
42277
- const stressPath = mode === MODE_MAJOR || mode === MODE_KK;
42278
- if (model === MODEL_SUBSET && stressPath) unsupported("model", value, "the subset distance model");
42279
- if (model !== MODEL_CIRCUIT || !stressPath) return;
42280
- if (mode === MODE_KK && kkCircuitFallsBack(g)) {
42281
- warnCircuitDisconnected(g);
42282
- return;
42283
- }
42284
- unsupported("model", value, "the circuit distance model");
42282
+ if (mode === MODE_SGD) warnStartSelfOnce();
42285
42283
  }
42286
- function assertSupported(g, mode, model) {
42284
+ function assertSupported(g, mode) {
42287
42285
  if (maxIterNegative(g)) return;
42288
42286
  checkStartAttr(g, mode);
42289
- checkModel(g, mode, model);
42290
42287
  }
42291
42288
 
42292
42289
  // src/layout/neato/sgd.ts
42293
42290
  var MODEL_SHORTPATH = 0;
42294
- var MODEL_CIRCUIT2 = 1;
42295
- var MODEL_SUBSET2 = 2;
42291
+ var MODEL_CIRCUIT = 1;
42292
+ var MODEL_SUBSET = 2;
42296
42293
  var MODEL_MDS = 3;
42297
42294
  var SGD_EPSILON = 0.01;
42298
42295
  var SGD_DFLT_ITERATIONS = 30;
@@ -42384,7 +42381,7 @@ function extractAdjacency(g, model) {
42384
42381
  pinneds: new Array(nNodes).fill(false)
42385
42382
  };
42386
42383
  fillCsrEdges(g, graph);
42387
- if (model === MODEL_SUBSET2) {
42384
+ if (model === MODEL_SUBSET) {
42388
42385
  applySubsetWeights(graph);
42389
42386
  }
42390
42387
  return graph;
@@ -42482,7 +42479,7 @@ function buildUnfixed(g, n) {
42482
42479
  return unfixed;
42483
42480
  }
42484
42481
  function resolveModel(model) {
42485
- if (model === MODEL_CIRCUIT2) {
42482
+ if (model === MODEL_CIRCUIT) {
42486
42483
  agerrLineOn(
42487
42484
  "warn",
42488
42485
  "circuit model not yet supported in Gmode=sgd, reverting to shortpath model"
@@ -42530,461 +42527,28 @@ function sgdLayout(g, model) {
42530
42527
  posFromArray(g, pos);
42531
42528
  }
42532
42529
 
42533
- // src/layout/neato/kk-solve.ts
42534
- var MIN_PIVOT = 1e-10;
42535
- function swap2(x, i, j) {
42536
- const t = x[i];
42537
- x[i] = x[j];
42538
- x[j] = t;
42539
- }
42540
- function eliminate(a, c, n, i) {
42541
- let amax = 0;
42542
- let istar = 0;
42543
- for (let ii = i; ii < n; ii++) {
42544
- const dum = Math.abs(a[ii * n + i]);
42545
- if (dum < amax) continue;
42546
- istar = ii;
42547
- amax = dum;
42548
- }
42549
- if (amax < MIN_PIVOT) return false;
42550
- for (let j = i; j < n; j++) swap2(a, istar * n + j, i * n + j);
42551
- swap2(c, istar, i);
42552
- for (let ii = i + 1; ii < n; ii++) {
42553
- const pivot = a[ii * n + i] / a[i * n + i];
42554
- c[ii] -= pivot * c[i];
42555
- for (let j = 0; j < n; j++) a[ii * n + j] = a[ii * n + j] - pivot * a[i * n + j];
42556
- }
42557
- return true;
42558
- }
42559
- function solve(a, b, c, n) {
42560
- const asave = Float64Array.from(a);
42561
- const csave = Float64Array.from(c);
42562
- let ok = true;
42563
- for (let i = 0; i < n - 1 && ok; i++) ok = eliminate(a, c, n, i);
42564
- if (!ok || Math.abs(a[n * n - 1]) < MIN_PIVOT) {
42565
- console.warn("ill-conditioned");
42566
- return;
42567
- }
42568
- b[n - 1] = c[n - 1] / a[n * n - 1];
42569
- for (let k = 0; k < n - 1; k++) {
42570
- const m = n - k - 2;
42571
- b[m] = c[m];
42572
- for (let j = m + 1; j < n; j++) b[m] -= a[m * n + j] * b[j];
42573
- b[m] /= a[m * n + m];
42574
- }
42575
- c.set(csave);
42576
- a.set(asave);
42577
- }
42578
-
42579
- // src/layout/neato/kk-paths.ts
42580
- function newPathState(n, dist5, adj, initialDist2) {
42581
- return {
42582
- n,
42583
- dist: dist5,
42584
- adj,
42585
- initialDist: initialDist2,
42586
- heap: new Int32Array(n + 1),
42587
- heapSize: 0,
42588
- heapIndex: new Int32Array(n).fill(-1),
42589
- nd: new Float64Array(n),
42590
- hops: new Int32Array(n)
42591
- };
42592
- }
42593
- function heapUp(s, v) {
42594
- for (let i = s.heapIndex[v], par; i > 0; i = par) {
42595
- par = i - 1 >> 1;
42596
- const u = s.heap[par];
42597
- if (s.nd[u] <= s.nd[v]) break;
42598
- s.heap[par] = v;
42599
- s.heapIndex[v] = par;
42600
- s.heap[i] = u;
42601
- s.heapIndex[u] = i;
42602
- }
42603
- }
42604
- function heapDown(s, v) {
42605
- let i = s.heapIndex[v];
42606
- for (let left2 = 2 * i + 1; left2 < s.heapSize; left2 = 2 * i + 1) {
42607
- const right2 = left2 + 1;
42608
- const c = right2 < s.heapSize && s.nd[s.heap[right2]] < s.nd[s.heap[left2]] ? right2 : left2;
42609
- const u = s.heap[c];
42610
- if (s.nd[v] <= s.nd[u]) break;
42611
- s.heap[c] = v;
42612
- s.heapIndex[v] = c;
42613
- s.heap[i] = u;
42614
- s.heapIndex[u] = i;
42615
- i = c;
42616
- }
42617
- }
42618
- function enqueue(s, v) {
42619
- const i = s.heapSize++;
42620
- s.heapIndex[v] = i;
42621
- s.heap[i] = v;
42622
- if (i > 0) heapUp(s, v);
42623
- }
42624
- function dequeue(s) {
42625
- if (s.heapSize === 0) return -1;
42626
- const rv = s.heap[0];
42627
- const i = --s.heapSize;
42628
- const v = s.heap[i];
42629
- s.heap[0] = v;
42630
- s.heapIndex[v] = 0;
42631
- if (i > 1) heapDown(s, v);
42632
- s.heapIndex[rv] = -1;
42633
- return rv;
42634
- }
42635
- function makeSpring(s, u, v, f) {
42636
- s.dist[u * s.n + v] = f;
42637
- s.dist[v * s.n + u] = f;
42638
- }
42639
- function s1(s, src) {
42640
- s.nd.fill(s.initialDist);
42641
- s.nd[src] = 0;
42642
- s.hops[src] = 0;
42643
- enqueue(s, src);
42644
- for (let v = dequeue(s); v >= 0; v = dequeue(s)) {
42645
- if (v !== src) makeSpring(s, src, v, s.nd[v]);
42646
- for (const { id: u, len } of s.adj[v]) {
42647
- const f = s.nd[v] + len;
42648
- if (s.nd[u] <= f) continue;
42649
- s.nd[u] = f;
42650
- if (s.heapIndex[u] >= 0) heapUp(s, u);
42651
- else {
42652
- s.hops[u] = s.hops[v] + 1;
42653
- enqueue(s, u);
42654
- }
42655
- }
42656
- }
42657
- }
42658
- function shortestPath2(s) {
42659
- for (let v = 0; v < s.n; v++) s1(s, v);
42660
- }
42661
- function mdsModel2(dist5, n, edges) {
42662
- for (const { tailSeq: i, headSeq: j, len } of edges) {
42663
- if (i === j) continue;
42664
- for (const k of [i * n + j, j * n + i]) if (k < dist5.length) dist5[k] = len;
42665
- }
42666
- }
42667
-
42668
- // src/layout/neato/kk.ts
42669
- var NDIM = 2;
42670
- var DEFAULT_DAMPING = 0.99;
42671
- var EPSILON_PER_NODE = 1e-4;
42672
- var ITERATIONS_PER_NODE = 100;
42673
- var SPRING_COEFF2 = 1;
42674
- function atoi(s) {
42675
- const v = parseInt(s, 10);
42676
- return Number.isNaN(v) ? 0 : v;
42677
- }
42678
- function setEdgeLens(g, nodes) {
42679
- const out = buildOutEdgeIndex(g);
42680
- const lens = /* @__PURE__ */ new Map();
42681
- let total = 0;
42682
- for (const np of nodes) {
42683
- for (const ep of out.get(np) ?? []) {
42684
- const len = lenattr(ep, g);
42685
- lens.set(ep, len);
42686
- total += len;
42687
- }
42688
- }
42689
- return { total, lens };
42690
- }
42691
- function initialDist(g, total, epsilon) {
42692
- const str = g.attrs.get("defaultdist");
42693
- if (str !== void 0 && str !== "") return Math.max(epsilon, parseFloat(str) || 0);
42694
- const nE = g.edges.length;
42695
- return total / (nE > 0 ? nE : 1) * Math.sqrt(g.nodes.size) + 1;
42696
- }
42697
- function epsilonOf(g, nV) {
42698
- const v = parseFloat(g.attrs.get("epsilon") ?? "");
42699
- return Number.isNaN(v) ? EPSILON_PER_NODE * nV : v;
42700
- }
42701
- function neighbours(g, nodes, lens) {
42702
- const out = buildOutEdgeIndex(g);
42703
- const inn = /* @__PURE__ */ new Map();
42704
- for (const e of g.edges) {
42705
- if (e.head === e.tail) continue;
42706
- const l = inn.get(e.head);
42707
- if (l === void 0) inn.set(e.head, [e]);
42708
- else l.push(e);
42709
- }
42710
- return nodes.map((np) => {
42711
- const ins = (inn.get(np) ?? []).sort((a, b) => a.tail.id - b.tail.id || a.seq - b.seq);
42712
- const outs = (out.get(np) ?? []).filter((e) => e.head !== e.tail);
42713
- return [...outs, ...ins].map((e) => ({
42714
- id: (e.tail === np ? e.head : e.tail).info.id,
42715
- len: lens.get(e)
42716
- }));
42717
- });
42718
- }
42719
- function scanGraphMode(g, maxIter) {
42720
- const nodes = [...g.nodes.values()];
42721
- const n = nodes.length;
42722
- nodes.forEach((np, i) => {
42723
- np.info.id = i;
42724
- np.info.heapindex = -1;
42725
- });
42726
- const epsilon = epsilonOf(g, n);
42727
- const damp = g.root.attrs.get("Damping");
42728
- const { total, lens } = setEdgeLens(g, nodes);
42729
- const ini = initialDist(g, total, epsilon);
42730
- const st = {
42731
- n,
42732
- nodes,
42733
- dist: new Float64Array(n * n).fill(ini),
42734
- spring: new Float64Array(n * n).fill(1),
42735
- sumT: new Float64Array(n * NDIM).fill(1),
42736
- t: new Float64Array(n * n * NDIM),
42737
- damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
42738
- epsilon,
42739
- maxIter,
42740
- move: 0
42741
- };
42742
- return { st, adj: neighbours(g, nodes, lens), ini, lens };
42743
- }
42744
- function randompos(np) {
42745
- np.info.pos[0] = drand48();
42746
- np.info.pos[1] = drand48();
42747
- }
42748
- function initialPositions2(g, st) {
42749
- const init = checkStart(g, st.n, INIT_RANDOM);
42750
- if (init === INIT_REGULAR) return;
42751
- for (const np of st.nodes) {
42752
- if (np.info.posSet === true || np.info.pinned === true) continue;
42753
- randompos(np);
42754
- }
42755
- }
42756
- function distvec(p0, p1, del) {
42757
- let dist5 = 0;
42758
- for (let k = 0; k < NDIM; k++) {
42759
- del[k] = p0[k] - p1[k];
42760
- dist5 += del[k] * del[k];
42761
- }
42762
- return Math.sqrt(dist5);
42763
- }
42764
- function springFactors(g) {
42765
- const byEnds = /* @__PURE__ */ new Map();
42766
- const undirected = g.kind.endsWith("undirected");
42767
- for (const e of g.edges) {
42768
- const key = `${e.tail.info.id}:${e.head.info.id}`;
42769
- if (!byEnds.has(key)) {
42770
- byEnds.set(key, e.info.factor ?? lateDouble(e.attrs.get("weight"), 1, 1));
42771
- }
42772
- }
42773
- return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
42774
- }
42775
- function fillRow(st, i, del) {
42776
- const vi = st.nodes[i];
42777
- for (let j = 0; j < st.n; j++) {
42778
- if (i === j) continue;
42779
- const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
42780
- for (let k = 0; k < NDIM; k++) {
42781
- const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
42782
- st.t[(i * st.n + j) * NDIM + k] = v;
42783
- st.sumT[i * NDIM + k] += v;
42784
- }
42785
- }
42786
- }
42787
- function diffeqModel(g, st) {
42788
- const { n } = st;
42789
- const factor = springFactors(g);
42790
- for (let i = 0; i < n; i++) {
42791
- for (let j = 0; j < i; j++) {
42792
- let f = SPRING_COEFF2 / (st.dist[i * n + j] * st.dist[i * n + j]);
42793
- const w = factor(st.nodes[i], st.nodes[j]);
42794
- if (w !== void 0) f *= w;
42795
- st.spring[i * n + j] = f;
42796
- st.spring[j * n + i] = f;
42797
- }
42798
- }
42799
- st.sumT.fill(0);
42800
- const del = new Float64Array(NDIM);
42801
- for (let i = 0; i < n; i++) fillRow(st, i, del);
42802
- }
42803
- function updateArrays(st, i) {
42804
- const { n } = st;
42805
- const del = new Float64Array(NDIM);
42806
- const vi = st.nodes[i];
42807
- for (let k = 0; k < NDIM; k++) st.sumT[i * NDIM + k] = 0;
42808
- for (let j = 0; j < n; j++) {
42809
- if (i === j) continue;
42810
- const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
42811
- for (let k = 0; k < NDIM; k++) {
42812
- const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
42813
- st.t[(i * n + j) * NDIM + k] = tij;
42814
- st.sumT[i * NDIM + k] += tij;
42815
- const old = st.t[(j * n + i) * NDIM + k];
42816
- st.t[(j * n + i) * NDIM + k] = -tij;
42817
- st.sumT[j * NDIM + k] += -tij - old;
42818
- }
42819
- }
42820
- }
42821
- function d2e(st, m, M2) {
42822
- const { n } = st;
42823
- const vn = st.nodes[m];
42824
- const t = new Float64Array(NDIM);
42825
- M2.fill(0);
42826
- for (let i = 0; i < n; i++) {
42827
- if (m === i) continue;
42828
- const vi = st.nodes[i];
42829
- let sq = 0;
42830
- for (let k = 0; k < NDIM; k++) {
42831
- t[k] = vn.info.pos[k] - vi.info.pos[k];
42832
- sq += t[k] * t[k];
42833
- }
42834
- const scale = 1 / Math.pow(sq, 1.5);
42835
- const K = st.spring[m * n + i];
42836
- const D = st.dist[m * n + i];
42837
- for (let k = 0; k < NDIM; k++) {
42838
- for (let l = 0; l < k; l++) M2[l * NDIM + k] += K * D * t[k] * t[l] * scale;
42839
- M2[k * NDIM + k] += K * (1 - D * (sq - t[k] * t[k]) * scale);
42840
- }
42841
- }
42842
- for (let k = 1; k < NDIM; k++) {
42843
- for (let l = 0; l < k; l++) M2[k * NDIM + l] = M2[l * NDIM + k];
42844
- }
42845
- }
42846
- function chooseNode(st) {
42847
- if (st.move >= st.maxIter) return -1;
42848
- let max = 0;
42849
- let choice = -1;
42850
- for (let i = 0; i < st.n; i++) {
42851
- if (st.nodes[i].info.pinned === true) continue;
42852
- let m = 0;
42853
- for (let k = 0; k < NDIM; k++) m += st.sumT[i * NDIM + k] * st.sumT[i * NDIM + k];
42854
- if (m > max) {
42855
- choice = i;
42856
- max = m;
42857
- }
42858
- }
42859
- return max < st.epsilon * st.epsilon ? -1 : choice;
42860
- }
42861
- function moveNode(st, m) {
42862
- const a = new Float64Array(NDIM * NDIM);
42863
- const b = new Float64Array(NDIM);
42864
- const c = new Float64Array(NDIM);
42865
- d2e(st, m, a);
42866
- for (let i = 0; i < NDIM; i++) c[i] = -st.sumT[m * NDIM + i];
42867
- solve(a, b, c, NDIM);
42868
- const pos = st.nodes[m].info.pos;
42869
- for (let i = 0; i < NDIM; i++) {
42870
- b[i] = (st.damping + 2 * (1 - st.damping) * drand48()) * b[i];
42871
- pos[i] += b[i];
42872
- }
42873
- st.move++;
42874
- updateArrays(st, m);
42875
- }
42876
- function solveModel(g, st) {
42877
- for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
42878
- if (st.move === st.maxIter) {
42879
- agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${agNameOf(g)}`);
42880
- }
42881
- }
42882
- function mdsEdges(g, nodes, lens) {
42883
- const out = buildOutEdgeIndex(g);
42884
- return nodes.flatMap((v) => (out.get(v) ?? []).map((e) => ({ tailSeq: e.tail.id + 1, headSeq: e.head.id + 1, len: lens.get(e) })));
42885
- }
42886
- function kkNeato(g, nG, model) {
42887
- const maxiter = g.attrs.get("maxiter");
42888
- const maxIter = maxiter !== void 0 ? atoi(maxiter) : ITERATIONS_PER_NODE * g.nodes.size;
42889
- if (nG < 2 || maxIter < 0) return;
42890
- const { st, adj, ini, lens } = scanGraphMode(g, maxIter);
42891
- shortestPath2(newPathState(st.n, st.dist, adj, ini));
42892
- if (model === MODEL_MDS2) mdsModel2(st.dist, st.n, mdsEdges(g, st.nodes, lens));
42893
- initialPositions2(g, st);
42894
- diffeqModel(g, st);
42895
- solveModel(g, st);
42896
- }
42897
-
42898
- // src/layout/neato/make-graph-data.ts
42899
- var MODE_IPSEP2 = 3;
42900
- var EDIST_IN = 1;
42901
- var EDIST_OUT = -1;
42902
- var EDIST_NONE = 0;
42903
- function graphHasLen(g) {
42904
- for (const e of g.edges) {
42905
- if (e.attrs.has("len")) return true;
42906
- }
42907
- return false;
42908
- }
42909
- var edistsOf = (v) => v.edists;
42910
- function reverseBackEdge(graph, i, e, mode) {
42911
- const node = graph[i];
42912
- const j = node.edges[e];
42913
- edistsOf(node)[e] = mode === MODE_IPSEP2 ? EDIST_OUT : EDIST_IN;
42914
- const target = graph[j];
42915
- let f = 1;
42916
- while (f < target.nedges && target.edges[f] !== i) f++;
42917
- if (f >= target.nedges) throw new Error(`neato: edge ${i}-${j} has no reverse entry`);
42918
- edistsOf(target)[f] = EDIST_OUT;
42919
- }
42920
- function dfsCycle(graph, start, st) {
42921
- const { mode, mark, onstack } = st;
42922
- const stack = [{ i: start, e: 1 }];
42923
- mark[start] = 1;
42924
- onstack[start] = 1;
42925
- for (let frame = stack.at(-1); frame !== void 0; frame = stack.at(-1)) {
42926
- const { i } = frame;
42927
- const node = graph[i];
42928
- if (frame.e >= node.nedges) {
42929
- onstack[i] = 0;
42930
- stack.pop();
42931
- continue;
42932
- }
42933
- const e = frame.e++;
42934
- if (edistsOf(node)[e] === EDIST_IN) continue;
42935
- const j = node.edges[e];
42936
- if (onstack[j]) {
42937
- reverseBackEdge(graph, i, e, mode);
42938
- } else if (!mark[j]) {
42939
- mark[j] = 1;
42940
- onstack[j] = 1;
42941
- stack.push({ i: j, e: 1 });
42530
+ // src/layout/neato/kkutils.ts
42531
+ var SIZE_T_MODULUS = 2 ** 64;
42532
+ function commonNeighbors(graph, u, vVector) {
42533
+ let numSharedNeighbors = 0;
42534
+ for (let j = 1; j < graph[u].nedges; j++) {
42535
+ const neighbor2 = graph[u].edges[j];
42536
+ if (vVector[neighbor2] > 0) {
42537
+ numSharedNeighbors++;
42942
42538
  }
42943
42539
  }
42540
+ return numSharedNeighbors;
42944
42541
  }
42945
- function acyclic2(graph, nv, mode) {
42946
- const st = { mode, mark: new Uint8Array(nv), onstack: new Uint8Array(nv) };
42947
- for (let i = 0; i < nv; i++) {
42948
- if (st.mark[i]) continue;
42949
- dfsCycle(graph, i, st);
42542
+ function fillNeighborsVecUnweighted(graph, vtx, vtxVec) {
42543
+ for (let j = 1; j < graph[vtx].nedges; j++) {
42544
+ vtxVec[graph[vtx].edges[j]] = 1;
42950
42545
  }
42951
42546
  }
42952
- function edgeDist2(dir, np, head) {
42953
- if (dir !== void 0 && dir.startsWith("none")) return EDIST_NONE;
42954
- return np === head ? EDIST_IN : EDIST_OUT;
42955
- }
42956
- function addNeighbours(g, np, entry, o) {
42957
- const seen2 = /* @__PURE__ */ new Map();
42958
- for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
42959
- if (ep.head === ep.tail) continue;
42960
- const vp = ep.tail === np ? ep.head : ep.tail;
42961
- const vid = vp.info.id;
42962
- const dist5 = o.haveLen ? ep.info.dist ?? 0 : 1;
42963
- const idx = seen2.get(vid);
42964
- if (idx !== void 0) {
42965
- if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist5);
42966
- continue;
42967
- }
42968
- seen2.set(vid, entry.nedges);
42969
- entry.edges.push(vid);
42970
- if (o.haveLen || o.haveDir) entry.ewgts.push(dist5);
42971
- if (o.haveDir) edistsOf(entry).push(edgeDist2(ep.attrs.get("dir"), np, ep.head));
42972
- entry.nedges++;
42547
+ function emptyNeighborsVec(graph, vtx, vtxVec) {
42548
+ for (let j = 1; j < graph[vtx].nedges; j++) {
42549
+ vtxVec[graph[vtx].edges[j]] = 0;
42973
42550
  }
42974
42551
  }
42975
- function makeGraphDataC(g, nodeList, haveLen, haveDir, mode = -1) {
42976
- const vtx = nodeList.map((_, i) => ({
42977
- nedges: 1,
42978
- edges: [i],
42979
- ewgts: haveLen || haveDir ? [0] : [],
42980
- ...haveDir ? { edists: [0] } : {}
42981
- }));
42982
- for (const np of nodeList) addNeighbours(g, np, vtx[np.info.id], { haveLen, haveDir });
42983
- if (haveDir) acyclic2(vtx, nodeList.length, mode);
42984
- return vtx;
42985
- }
42986
-
42987
- // src/layout/neato/kkutils.ts
42988
42552
  function compareKeys(a, b) {
42989
42553
  if (a < b) return -1;
42990
42554
  if (a > b) return 1;
@@ -43018,6 +42582,40 @@ function computeApspSimple(graph, n) {
43018
42582
  function computeApsp(graph, n) {
43019
42583
  return graph[0].ewgts.length > 0 ? computeApspDijkstra(graph, n) : computeApspSimple(graph, n);
43020
42584
  }
42585
+ function artificialWeight(graph, degI, neighbor2, vtxVec) {
42586
+ const degJ = graph[neighbor2].nedges - 1;
42587
+ const w = degI + degJ - 2 * commonNeighbors(graph, neighbor2, vtxVec);
42588
+ return Math.fround(w < 0 ? w + SIZE_T_MODULUS : w);
42589
+ }
42590
+ function computeNewWeights(graph, n) {
42591
+ const vtxVec = new Int32Array(n);
42592
+ for (let i = 0; i < n; i++) {
42593
+ const weights = new Array(graph[i].nedges).fill(0);
42594
+ graph[i].ewgts = weights;
42595
+ fillNeighborsVecUnweighted(graph, i, vtxVec);
42596
+ const degI = graph[i].nedges - 1;
42597
+ for (let j = 1; j <= degI; j++) {
42598
+ const neighbor2 = graph[i].edges[j];
42599
+ weights[j] = artificialWeight(graph, degI, neighbor2, vtxVec);
42600
+ }
42601
+ emptyNeighborsVec(graph, i, vtxVec);
42602
+ }
42603
+ }
42604
+ function restoreOldWeights(graph, n, oldWeights) {
42605
+ graph[0].ewgts = [];
42606
+ if (oldWeights !== null) {
42607
+ for (let i = 0; i < n; i++) {
42608
+ graph[i].ewgts = oldWeights[i];
42609
+ }
42610
+ }
42611
+ }
42612
+ function computeApspArtificialWeights(graph, n) {
42613
+ const oldWeights = graph[0].ewgts.length === 0 ? null : graph.slice(0, n).map((v) => v.ewgts);
42614
+ computeNewWeights(graph, n);
42615
+ const Dij = computeApspDijkstra(graph, n);
42616
+ restoreOldWeights(graph, n, oldWeights);
42617
+ return Dij;
42618
+ }
43021
42619
 
43022
42620
  // src/layout/neato/quad-prog-solve.ts
43023
42621
  var fr2 = Math.fround;
@@ -43326,6 +42924,654 @@ function initConstrainedMajorization(packedMat, n, ordering, levels, numLevels)
43326
42924
  };
43327
42925
  }
43328
42926
 
42927
+ // src/layout/neato/lu.ts
42928
+ var DOT_VECTOR_TERMS = 8;
42929
+ function newArray(m, n, ival) {
42930
+ const mem = new Float64Array(m * n);
42931
+ const rv = [];
42932
+ for (let i = 0; i < m; i++) {
42933
+ rv.push(mem.subarray(i * n, (i + 1) * n));
42934
+ rv[i].fill(ival);
42935
+ }
42936
+ return rv;
42937
+ }
42938
+ function luScaleRows(lu, a, n, scales) {
42939
+ const m = lu.lu;
42940
+ const ps = lu.ps;
42941
+ for (let i = 0; i < n; i++) {
42942
+ let biggest = 0;
42943
+ for (let j = 0; j < n; j++) biggest = fmaxf(biggest, Math.abs(m[i][j] = a[i][j]));
42944
+ if (biggest > 0) scales[i] = 1 / biggest;
42945
+ else return false;
42946
+ ps[i] = i;
42947
+ }
42948
+ return true;
42949
+ }
42950
+ function luFindPivot(lu, k, n, scales, pivotindex) {
42951
+ const m = lu.lu;
42952
+ const ps = lu.ps;
42953
+ let biggest = 0;
42954
+ for (let i = k; i < n; i++) {
42955
+ const tempf = Math.abs(m[ps[i]][k]) * scales[ps[i]];
42956
+ if (biggest < tempf) {
42957
+ biggest = tempf;
42958
+ pivotindex = i;
42959
+ }
42960
+ }
42961
+ if (biggest <= 0) return -1;
42962
+ return pivotindex;
42963
+ }
42964
+ function luEliminate(lu, k, n) {
42965
+ const m = lu.lu;
42966
+ const ps = lu.ps;
42967
+ const rowK = m[ps[k]];
42968
+ const pivot = rowK[k];
42969
+ for (let i = k + 1; i < n; i++) {
42970
+ const rowI = m[ps[i]];
42971
+ const mult = rowI[k] = rowI[k] / pivot;
42972
+ for (let j = k + 1; j < n; j++) rowI[j] = fma(-mult, rowK[j], rowI[j]);
42973
+ }
42974
+ }
42975
+ function luDecompose(lu, a, n) {
42976
+ lu.lu = newArray(n, n, 0);
42977
+ lu.ps = new Int32Array(n);
42978
+ const scales = new Float64Array(n);
42979
+ if (!luScaleRows(lu, a, n, scales)) {
42980
+ luFree(lu);
42981
+ return 0;
42982
+ }
42983
+ for (let k = 0, pivotindex = 0; k < n - 1; k++) {
42984
+ pivotindex = luFindPivot(lu, k, n, scales, pivotindex);
42985
+ if (pivotindex < 0) {
42986
+ luFree(lu);
42987
+ return 0;
42988
+ }
42989
+ if (pivotindex !== k) {
42990
+ const ps = lu.ps;
42991
+ const t = ps[k];
42992
+ ps[k] = ps[pivotindex];
42993
+ ps[pivotindex] = t;
42994
+ }
42995
+ luEliminate(lu, k, n);
42996
+ }
42997
+ if (lu.lu[lu.ps[n - 1]][n - 1] === 0) {
42998
+ luFree(lu);
42999
+ return 0;
43000
+ }
43001
+ return 1;
43002
+ }
43003
+ function luDot(row, x, from, to) {
43004
+ const vecEnd = from + (to - from) - (to - from) % DOT_VECTOR_TERMS;
43005
+ let dot = 0;
43006
+ let j = from;
43007
+ for (; j < vecEnd; j++) dot += row[j] * x[j];
43008
+ for (; j < to; j++) dot = fma(row[j], x[j], dot);
43009
+ return dot;
43010
+ }
43011
+ function luSolve(lu, x, bi, n) {
43012
+ const m = lu.lu;
43013
+ const ps = lu.ps;
43014
+ for (let i = 0; i < n; i++) {
43015
+ const dot = luDot(m[ps[i]], x, 0, i);
43016
+ x[i] = (ps[i] === bi ? 1 : 0) - dot;
43017
+ }
43018
+ for (let i = n - 1; i >= 0; i--) {
43019
+ const row = m[ps[i]];
43020
+ const dot = luDot(row, x, i + 1, n);
43021
+ x[i] = (x[i] - dot) / row[i];
43022
+ }
43023
+ }
43024
+ function luFree(lu) {
43025
+ if (lu === null) {
43026
+ return;
43027
+ }
43028
+ lu.lu = null;
43029
+ lu.ps = null;
43030
+ }
43031
+
43032
+ // src/layout/neato/matinv.ts
43033
+ function matinv(A3, Ainv, n) {
43034
+ const lu = { lu: null, ps: null };
43035
+ if (luDecompose(lu, A3, n) === 0) return 0;
43036
+ for (let i = 0; i < n; i++) {
43037
+ luSolve(lu, Ainv[i], i, n);
43038
+ }
43039
+ luFree(lu);
43040
+ for (let i = 0; i < n; i++) {
43041
+ for (let j = 0; j < i; j++) {
43042
+ const t = Ainv[i][j];
43043
+ Ainv[i][j] = Ainv[j][i];
43044
+ Ainv[j][i] = t;
43045
+ }
43046
+ }
43047
+ return 1;
43048
+ }
43049
+
43050
+ // src/layout/neato/circuit.ts
43051
+ function solveCircuit(nG, Gm, GmInv) {
43052
+ for (let i = 0; i < nG; i++) {
43053
+ const row = Gm[i];
43054
+ let sum = 0;
43055
+ for (let j = 0; j < nG; j++) {
43056
+ if (i !== j) sum += row[j];
43057
+ }
43058
+ row[i] = -sum;
43059
+ }
43060
+ return matinv(Gm, GmInv, nG - 1);
43061
+ }
43062
+ function circuitConductances(g, nG, lens) {
43063
+ const Gm = newArray(nG, nG, 0);
43064
+ const cells = new Float64Array(Gm[0].buffer);
43065
+ for (const v of g.nodes.values()) {
43066
+ for (const e of [...v.outEdges(g), ...v.inEdges(g)]) {
43067
+ const i = e.tail.id + 1;
43068
+ const j = e.head.id + 1;
43069
+ if (i === j) continue;
43070
+ const conductance = -1 / lens.get(e);
43071
+ for (const k of [j * nG + i, i * nG + j]) if (k < cells.length) cells[k] = conductance;
43072
+ }
43073
+ }
43074
+ return Gm;
43075
+ }
43076
+ function circuitDistances(GmInv, nG, dist5) {
43077
+ for (let i = 0; i < nG; i++) {
43078
+ for (let j = 0; j < nG; j++) {
43079
+ dist5[i * nG + j] = GmInv[i][i] + GmInv[j][j] - 2 * GmInv[i][j];
43080
+ }
43081
+ }
43082
+ }
43083
+ function circuitModel(g, nG, dist5, lens) {
43084
+ const Gm = circuitConductances(g, nG, lens);
43085
+ const GmInv = newArray(nG, nG, 0);
43086
+ const rv = solveCircuit(nG, Gm, GmInv);
43087
+ if (rv) circuitDistances(GmInv, nG, dist5);
43088
+ return rv === 1;
43089
+ }
43090
+
43091
+ // src/layout/neato/kk-solve.ts
43092
+ var MIN_PIVOT = 1e-10;
43093
+ function swap2(x, i, j) {
43094
+ const t = x[i];
43095
+ x[i] = x[j];
43096
+ x[j] = t;
43097
+ }
43098
+ function eliminate(a, c, n, i) {
43099
+ let amax = 0;
43100
+ let istar = 0;
43101
+ for (let ii = i; ii < n; ii++) {
43102
+ const dum = Math.abs(a[ii * n + i]);
43103
+ if (dum < amax) continue;
43104
+ istar = ii;
43105
+ amax = dum;
43106
+ }
43107
+ if (amax < MIN_PIVOT) return false;
43108
+ for (let j = i; j < n; j++) swap2(a, istar * n + j, i * n + j);
43109
+ swap2(c, istar, i);
43110
+ for (let ii = i + 1; ii < n; ii++) {
43111
+ const pivot = a[ii * n + i] / a[i * n + i];
43112
+ c[ii] = fms(pivot, c[i], c[ii]);
43113
+ for (let j = 0; j < n; j++) a[ii * n + j] = fms(pivot, a[i * n + j], a[ii * n + j]);
43114
+ }
43115
+ return true;
43116
+ }
43117
+ function solve(a, b, c, n) {
43118
+ const asave = Float64Array.from(a);
43119
+ const csave = Float64Array.from(c);
43120
+ let ok = true;
43121
+ for (let i = 0; i < n - 1 && ok; i++) ok = eliminate(a, c, n, i);
43122
+ if (!ok || Math.abs(a[n * n - 1]) < MIN_PIVOT) {
43123
+ console.warn("ill-conditioned");
43124
+ return;
43125
+ }
43126
+ b[n - 1] = c[n - 1] / a[n * n - 1];
43127
+ for (let k = 0; k < n - 1; k++) {
43128
+ const m = n - k - 2;
43129
+ b[m] = c[m];
43130
+ for (let j = m + 1; j < n; j++) b[m] = fms(a[m * n + j], b[j], b[m]);
43131
+ b[m] /= a[m * n + m];
43132
+ }
43133
+ c.set(csave);
43134
+ a.set(asave);
43135
+ }
43136
+
43137
+ // src/layout/neato/make-graph-data.ts
43138
+ var MODE_IPSEP2 = 3;
43139
+ var EDIST_IN = 1;
43140
+ var EDIST_OUT = -1;
43141
+ var EDIST_NONE = 0;
43142
+ function graphHasLen(g) {
43143
+ for (const e of g.edges) {
43144
+ if (e.attrs.has("len")) return true;
43145
+ }
43146
+ return false;
43147
+ }
43148
+ var edistsOf = (v) => v.edists;
43149
+ function reverseBackEdge(graph, i, e, mode) {
43150
+ const node = graph[i];
43151
+ const j = node.edges[e];
43152
+ edistsOf(node)[e] = mode === MODE_IPSEP2 ? EDIST_OUT : EDIST_IN;
43153
+ const target = graph[j];
43154
+ let f = 1;
43155
+ while (f < target.nedges && target.edges[f] !== i) f++;
43156
+ if (f >= target.nedges) throw new Error(`neato: edge ${i}-${j} has no reverse entry`);
43157
+ edistsOf(target)[f] = EDIST_OUT;
43158
+ }
43159
+ function dfsCycle(graph, start, st) {
43160
+ const { mode, mark, onstack } = st;
43161
+ const stack = [{ i: start, e: 1 }];
43162
+ mark[start] = 1;
43163
+ onstack[start] = 1;
43164
+ for (let frame = stack.at(-1); frame !== void 0; frame = stack.at(-1)) {
43165
+ const { i } = frame;
43166
+ const node = graph[i];
43167
+ if (frame.e >= node.nedges) {
43168
+ onstack[i] = 0;
43169
+ stack.pop();
43170
+ continue;
43171
+ }
43172
+ const e = frame.e++;
43173
+ if (edistsOf(node)[e] === EDIST_IN) continue;
43174
+ const j = node.edges[e];
43175
+ if (onstack[j]) {
43176
+ reverseBackEdge(graph, i, e, mode);
43177
+ } else if (!mark[j]) {
43178
+ mark[j] = 1;
43179
+ onstack[j] = 1;
43180
+ stack.push({ i: j, e: 1 });
43181
+ }
43182
+ }
43183
+ }
43184
+ function acyclic2(graph, nv, mode) {
43185
+ const st = { mode, mark: new Uint8Array(nv), onstack: new Uint8Array(nv) };
43186
+ for (let i = 0; i < nv; i++) {
43187
+ if (st.mark[i]) continue;
43188
+ dfsCycle(graph, i, st);
43189
+ }
43190
+ }
43191
+ function edgeDist2(dir, np, head) {
43192
+ if (dir !== void 0 && dir.startsWith("none")) return EDIST_NONE;
43193
+ return np === head ? EDIST_IN : EDIST_OUT;
43194
+ }
43195
+ function addNeighbours(g, np, entry, o) {
43196
+ const seen2 = /* @__PURE__ */ new Map();
43197
+ for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
43198
+ if (ep.head === ep.tail) continue;
43199
+ const vp = ep.tail === np ? ep.head : ep.tail;
43200
+ const vid = vp.info.id;
43201
+ const dist5 = o.haveLen ? ep.info.dist ?? 0 : 1;
43202
+ const idx = seen2.get(vid);
43203
+ if (idx !== void 0) {
43204
+ if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist5);
43205
+ continue;
43206
+ }
43207
+ seen2.set(vid, entry.nedges);
43208
+ entry.edges.push(vid);
43209
+ if (o.haveLen || o.haveDir) entry.ewgts.push(dist5);
43210
+ if (o.haveDir) edistsOf(entry).push(edgeDist2(ep.attrs.get("dir"), np, ep.head));
43211
+ entry.nedges++;
43212
+ }
43213
+ }
43214
+ function makeGraphDataC(g, nodeList, haveLen, haveDir, mode = -1) {
43215
+ const vtx = nodeList.map((_, i) => ({
43216
+ nedges: 1,
43217
+ edges: [i],
43218
+ ewgts: haveLen || haveDir ? [0] : [],
43219
+ ...haveDir ? { edists: [0] } : {}
43220
+ }));
43221
+ for (const np of nodeList) addNeighbours(g, np, vtx[np.info.id], { haveLen, haveDir });
43222
+ if (haveDir) acyclic2(vtx, nodeList.length, mode);
43223
+ return vtx;
43224
+ }
43225
+
43226
+ // src/layout/neato/kk-paths.ts
43227
+ function newPathState(n, dist5, adj, initialDist2) {
43228
+ return {
43229
+ n,
43230
+ dist: dist5,
43231
+ adj,
43232
+ initialDist: initialDist2,
43233
+ heap: new Int32Array(n + 1),
43234
+ heapSize: 0,
43235
+ heapIndex: new Int32Array(n).fill(-1),
43236
+ nd: new Float64Array(n),
43237
+ hops: new Int32Array(n)
43238
+ };
43239
+ }
43240
+ function heapUp(s, v) {
43241
+ for (let i = s.heapIndex[v], par; i > 0; i = par) {
43242
+ par = i - 1 >> 1;
43243
+ const u = s.heap[par];
43244
+ if (s.nd[u] <= s.nd[v]) break;
43245
+ s.heap[par] = v;
43246
+ s.heapIndex[v] = par;
43247
+ s.heap[i] = u;
43248
+ s.heapIndex[u] = i;
43249
+ }
43250
+ }
43251
+ function heapDown(s, v) {
43252
+ let i = s.heapIndex[v];
43253
+ for (let left2 = 2 * i + 1; left2 < s.heapSize; left2 = 2 * i + 1) {
43254
+ const right2 = left2 + 1;
43255
+ const c = right2 < s.heapSize && s.nd[s.heap[right2]] < s.nd[s.heap[left2]] ? right2 : left2;
43256
+ const u = s.heap[c];
43257
+ if (s.nd[v] <= s.nd[u]) break;
43258
+ s.heap[c] = v;
43259
+ s.heapIndex[v] = c;
43260
+ s.heap[i] = u;
43261
+ s.heapIndex[u] = i;
43262
+ i = c;
43263
+ }
43264
+ }
43265
+ function enqueue(s, v) {
43266
+ const i = s.heapSize++;
43267
+ s.heapIndex[v] = i;
43268
+ s.heap[i] = v;
43269
+ if (i > 0) heapUp(s, v);
43270
+ }
43271
+ function dequeue(s) {
43272
+ if (s.heapSize === 0) return -1;
43273
+ const rv = s.heap[0];
43274
+ const i = --s.heapSize;
43275
+ const v = s.heap[i];
43276
+ s.heap[0] = v;
43277
+ s.heapIndex[v] = 0;
43278
+ if (i > 1) heapDown(s, v);
43279
+ s.heapIndex[rv] = -1;
43280
+ return rv;
43281
+ }
43282
+ function makeSpring(s, u, v, f) {
43283
+ s.dist[u * s.n + v] = f;
43284
+ s.dist[v * s.n + u] = f;
43285
+ }
43286
+ function s1(s, src) {
43287
+ s.nd.fill(s.initialDist);
43288
+ s.nd[src] = 0;
43289
+ s.hops[src] = 0;
43290
+ enqueue(s, src);
43291
+ for (let v = dequeue(s); v >= 0; v = dequeue(s)) {
43292
+ if (v !== src) makeSpring(s, src, v, s.nd[v]);
43293
+ for (const { id: u, len } of s.adj[v]) {
43294
+ const f = s.nd[v] + len;
43295
+ if (s.nd[u] <= f) continue;
43296
+ s.nd[u] = f;
43297
+ if (s.heapIndex[u] >= 0) heapUp(s, u);
43298
+ else {
43299
+ s.hops[u] = s.hops[v] + 1;
43300
+ enqueue(s, u);
43301
+ }
43302
+ }
43303
+ }
43304
+ }
43305
+ function shortestPath2(s) {
43306
+ for (let v = 0; v < s.n; v++) s1(s, v);
43307
+ }
43308
+ function subsetModel(g, nG, dist5) {
43309
+ const gp = makeGraphDataC(g, [...g.nodes.values()], false, false);
43310
+ const Dij = computeApspArtificialWeights(gp, nG);
43311
+ for (let i = 0; i < nG; i++) {
43312
+ for (let j = 0; j < nG; j++) {
43313
+ dist5[i * nG + j] = Dij[i][j];
43314
+ }
43315
+ }
43316
+ }
43317
+ function mdsModel2(dist5, n, edges) {
43318
+ for (const { tailSeq: i, headSeq: j, len } of edges) {
43319
+ if (i === j) continue;
43320
+ for (const k of [i * n + j, j * n + i]) if (k < dist5.length) dist5[k] = len;
43321
+ }
43322
+ }
43323
+
43324
+ // src/layout/neato/kk.ts
43325
+ var NDIM = 2;
43326
+ var DEFAULT_DAMPING = 0.99;
43327
+ var EPSILON_PER_NODE = 1e-4;
43328
+ var ITERATIONS_PER_NODE = 100;
43329
+ var SPRING_COEFF2 = 1;
43330
+ function atoi(s) {
43331
+ const v = parseInt(s, 10);
43332
+ return Number.isNaN(v) ? 0 : v;
43333
+ }
43334
+ function setEdgeLens(g, nodes) {
43335
+ const out = buildOutEdgeIndex(g);
43336
+ const lens = /* @__PURE__ */ new Map();
43337
+ let total = 0;
43338
+ for (const np of nodes) {
43339
+ for (const ep of out.get(np) ?? []) {
43340
+ const len = lenattr(ep, g);
43341
+ lens.set(ep, len);
43342
+ total += len;
43343
+ }
43344
+ }
43345
+ return { total, lens };
43346
+ }
43347
+ function initialDist(g, total, epsilon) {
43348
+ const str = g.attrs.get("defaultdist");
43349
+ if (str !== void 0 && str !== "") return Math.max(epsilon, parseFloat(str) || 0);
43350
+ const nE = g.edges.length;
43351
+ return fma(total / (nE > 0 ? nE : 1), Math.sqrt(g.nodes.size), 1);
43352
+ }
43353
+ function epsilonOf(g, nV) {
43354
+ const v = parseFloat(g.attrs.get("epsilon") ?? "");
43355
+ return Number.isNaN(v) ? EPSILON_PER_NODE * nV : v;
43356
+ }
43357
+ function neighbours(g, nodes, lens) {
43358
+ const out = buildOutEdgeIndex(g);
43359
+ const inn = /* @__PURE__ */ new Map();
43360
+ for (const e of g.edges) {
43361
+ if (e.head === e.tail) continue;
43362
+ const l = inn.get(e.head);
43363
+ if (l === void 0) inn.set(e.head, [e]);
43364
+ else l.push(e);
43365
+ }
43366
+ return nodes.map((np) => {
43367
+ const ins = (inn.get(np) ?? []).sort((a, b) => a.tail.id - b.tail.id || a.seq - b.seq);
43368
+ const outs = (out.get(np) ?? []).filter((e) => e.head !== e.tail);
43369
+ return [...outs, ...ins].map((e) => ({
43370
+ id: (e.tail === np ? e.head : e.tail).info.id,
43371
+ len: lens.get(e)
43372
+ }));
43373
+ });
43374
+ }
43375
+ function scanGraphMode(g, maxIter) {
43376
+ const nodes = [...g.nodes.values()];
43377
+ const n = nodes.length;
43378
+ nodes.forEach((np, i) => {
43379
+ np.info.id = i;
43380
+ np.info.heapindex = -1;
43381
+ });
43382
+ const epsilon = epsilonOf(g, n);
43383
+ const damp = g.root.attrs.get("Damping");
43384
+ const { total, lens } = setEdgeLens(g, nodes);
43385
+ const ini = initialDist(g, total, epsilon);
43386
+ const st = {
43387
+ n,
43388
+ nodes,
43389
+ dist: new Float64Array(n * n).fill(ini),
43390
+ spring: new Float64Array(n * n).fill(1),
43391
+ sumT: new Float64Array(n * NDIM).fill(1),
43392
+ t: new Float64Array(n * n * NDIM),
43393
+ damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
43394
+ epsilon,
43395
+ maxIter,
43396
+ move: 0
43397
+ };
43398
+ return { st, adj: neighbours(g, nodes, lens), ini, lens };
43399
+ }
43400
+ function randompos(np) {
43401
+ np.info.pos[0] = drand48();
43402
+ np.info.pos[1] = drand48();
43403
+ }
43404
+ function initialPositions2(g, st) {
43405
+ const init = checkStart(g, st.n, INIT_RANDOM);
43406
+ if (init === INIT_REGULAR) return;
43407
+ if (init === INIT_SELF) warnStartSelfOnce();
43408
+ for (const np of st.nodes) {
43409
+ if (np.info.posSet === true || np.info.pinned === true) continue;
43410
+ randompos(np);
43411
+ }
43412
+ }
43413
+ function distvec(p0, p1, del) {
43414
+ let dist5 = 0;
43415
+ for (let k = 0; k < NDIM; k++) {
43416
+ del[k] = p0[k] - p1[k];
43417
+ dist5 = fma(del[k], del[k], dist5);
43418
+ }
43419
+ return Math.sqrt(dist5);
43420
+ }
43421
+ function springFactors(g) {
43422
+ const byEnds = /* @__PURE__ */ new Map();
43423
+ const undirected = g.kind.endsWith("undirected");
43424
+ for (const e of g.edges) {
43425
+ const key = `${e.tail.info.id}:${e.head.info.id}`;
43426
+ if (!byEnds.has(key)) {
43427
+ byEnds.set(key, e.info.factor ?? lateDouble(e.attrs.get("weight"), 1, 1));
43428
+ }
43429
+ }
43430
+ return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
43431
+ }
43432
+ function fillRow(st, i, del) {
43433
+ const vi = st.nodes[i];
43434
+ for (let j = 0; j < st.n; j++) {
43435
+ if (i === j) continue;
43436
+ const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
43437
+ for (let k = 0; k < NDIM; k++) {
43438
+ const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
43439
+ st.t[(i * st.n + j) * NDIM + k] = v;
43440
+ st.sumT[i * NDIM + k] += v;
43441
+ }
43442
+ }
43443
+ }
43444
+ function diffeqModel(g, st) {
43445
+ const { n } = st;
43446
+ const factor = springFactors(g);
43447
+ for (let i = 0; i < n; i++) {
43448
+ for (let j = 0; j < i; j++) {
43449
+ let f = SPRING_COEFF2 / (st.dist[i * n + j] * st.dist[i * n + j]);
43450
+ const w = factor(st.nodes[i], st.nodes[j]);
43451
+ if (w !== void 0) f *= w;
43452
+ st.spring[i * n + j] = f;
43453
+ st.spring[j * n + i] = f;
43454
+ }
43455
+ }
43456
+ st.sumT.fill(0);
43457
+ const del = new Float64Array(NDIM);
43458
+ for (let i = 0; i < n; i++) fillRow(st, i, del);
43459
+ }
43460
+ function updateArrays(st, i) {
43461
+ const { n } = st;
43462
+ const del = new Float64Array(NDIM);
43463
+ const vi = st.nodes[i];
43464
+ for (let k = 0; k < NDIM; k++) st.sumT[i * NDIM + k] = 0;
43465
+ for (let j = 0; j < n; j++) {
43466
+ if (i === j) continue;
43467
+ const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
43468
+ for (let k = 0; k < NDIM; k++) {
43469
+ const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
43470
+ st.t[(i * n + j) * NDIM + k] = tij;
43471
+ st.sumT[i * NDIM + k] += tij;
43472
+ const old = st.t[(j * n + i) * NDIM + k];
43473
+ st.t[(j * n + i) * NDIM + k] = -tij;
43474
+ st.sumT[j * NDIM + k] += -tij - old;
43475
+ }
43476
+ }
43477
+ }
43478
+ function d2e(st, m, M2) {
43479
+ const { n } = st;
43480
+ const vn = st.nodes[m];
43481
+ const t = new Float64Array(NDIM);
43482
+ M2.fill(0);
43483
+ for (let i = 0; i < n; i++) {
43484
+ if (m === i) continue;
43485
+ const vi = st.nodes[i];
43486
+ let sq = 0;
43487
+ for (let k = 0; k < NDIM; k++) {
43488
+ t[k] = vn.info.pos[k] - vi.info.pos[k];
43489
+ sq = fma(t[k], t[k], sq);
43490
+ }
43491
+ const scale = 1 / Math.pow(sq, 1.5);
43492
+ const K = st.spring[m * n + i];
43493
+ const D = st.dist[m * n + i];
43494
+ for (let k = 0; k < NDIM; k++) {
43495
+ for (let l = 0; l < k; l++) M2[l * NDIM + k] = fma(K * D * t[k] * t[l], scale, M2[l * NDIM + k]);
43496
+ const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
43497
+ M2[k * NDIM + k] = fma(K, inner, M2[k * NDIM + k]);
43498
+ }
43499
+ }
43500
+ for (let k = 1; k < NDIM; k++) {
43501
+ for (let l = 0; l < k; l++) M2[k * NDIM + l] = M2[l * NDIM + k];
43502
+ }
43503
+ }
43504
+ function chooseNode(st) {
43505
+ if (st.move >= st.maxIter) return -1;
43506
+ let max = 0;
43507
+ let choice = -1;
43508
+ for (let i = 0; i < st.n; i++) {
43509
+ if (st.nodes[i].info.pinned === true) continue;
43510
+ let m = 0;
43511
+ for (let k = 0; k < NDIM; k++) m = fma(st.sumT[i * NDIM + k], st.sumT[i * NDIM + k], m);
43512
+ if (m > max) {
43513
+ choice = i;
43514
+ max = m;
43515
+ }
43516
+ }
43517
+ return max < st.epsilon * st.epsilon ? -1 : choice;
43518
+ }
43519
+ function moveNode(st, m) {
43520
+ const a = new Float64Array(NDIM * NDIM);
43521
+ const b = new Float64Array(NDIM);
43522
+ const c = new Float64Array(NDIM);
43523
+ d2e(st, m, a);
43524
+ for (let i = 0; i < NDIM; i++) c[i] = -st.sumT[m * NDIM + i];
43525
+ solve(a, b, c, NDIM);
43526
+ const pos = st.nodes[m].info.pos;
43527
+ for (let i = 0; i < NDIM; i++) {
43528
+ b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
43529
+ pos[i] += b[i];
43530
+ }
43531
+ st.move++;
43532
+ updateArrays(st, m);
43533
+ }
43534
+ function solveModel(g, st) {
43535
+ for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
43536
+ if (st.move === st.maxIter) {
43537
+ agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${agNameOf(g)}`);
43538
+ }
43539
+ }
43540
+ function mdsEdges(g, nodes, lens) {
43541
+ const out = buildOutEdgeIndex(g);
43542
+ return nodes.flatMap((v) => (out.get(v) ?? []).map((e) => ({ tailSeq: e.tail.id + 1, headSeq: e.head.id + 1, len: lens.get(e) })));
43543
+ }
43544
+ function kkModel(g, nG, model, run) {
43545
+ const { st, adj, ini, lens } = run;
43546
+ const shortest = () => shortestPath2(newPathState(st.n, st.dist, adj, ini));
43547
+ if (model === MODEL_SUBSET2) {
43548
+ subsetModel(g, nG, st.dist);
43549
+ } else if (model === MODEL_CIRCUIT2) {
43550
+ if (!circuitModel(g, nG, st.dist, lens)) {
43551
+ agwarningf(`graph ${agNameOf(g)} is disconnected. Hence, the circuit model`);
43552
+ agerr("prev", "is undefined. Reverting to the shortest path model.");
43553
+ agerr("prev", "Alternatively, consider running neato using -Gpack=true or decomposing");
43554
+ agerr("prev", "the graph into connected components.");
43555
+ shortest();
43556
+ }
43557
+ } else if (model === MODEL_MDS2) {
43558
+ shortest();
43559
+ mdsModel2(st.dist, st.n, mdsEdges(g, st.nodes, lens));
43560
+ } else {
43561
+ shortest();
43562
+ }
43563
+ }
43564
+ function kkNeato(g, nG, model) {
43565
+ const maxiter = g.attrs.get("maxiter");
43566
+ const maxIter = maxiter !== void 0 ? atoi(maxiter) : ITERATIONS_PER_NODE * g.nodes.size;
43567
+ if (nG < 2 || maxIter < 0) return;
43568
+ const run = scanGraphMode(g, maxIter);
43569
+ kkModel(g, nG, model, run);
43570
+ initialPositions2(g, run.st);
43571
+ diffeqModel(g, run.st);
43572
+ solveModel(g, run.st);
43573
+ }
43574
+
43329
43575
  // src/layout/neato/conjgrad-mkernel.ts
43330
43576
  var fr3 = Math.fround;
43331
43577
  var RIGHT_MULT_BLOCK = 16;
@@ -43744,16 +43990,6 @@ function computeApspPacked2(graph, n) {
43744
43990
  }
43745
43991
  return Dij;
43746
43992
  }
43747
- function computeWeightedApspPacked2(graph, n) {
43748
- const Dij = new Float32Array(n * (n + 1) / 2);
43749
- const Di = new Float32Array(n);
43750
- let count = 0;
43751
- for (let i = 0; i < n; i++) {
43752
- dijkstra(i, graph, n, Di);
43753
- for (let j = i; j < n; j++) Dij[count++] = Di[j];
43754
- }
43755
- return Dij;
43756
- }
43757
43993
  function hasPos2(n) {
43758
43994
  return n.info.posSet === true || n.info.pinned === true;
43759
43995
  }
@@ -43922,6 +44158,109 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
43922
44158
  return iterations;
43923
44159
  }
43924
44160
 
44161
+ // src/layout/neato/stress-models.ts
44162
+ function circuitModel2(graph, nG) {
44163
+ let Dij = new Float32Array(nG * (nG + 1) / 2);
44164
+ const Gm = newArray(nG, nG, 0);
44165
+ const GmInv = newArray(nG, nG, 0);
44166
+ if (graph[0].ewgts.length !== 0) {
44167
+ for (let i = 0; i < nG; i++) {
44168
+ for (let e = 1; e < graph[i].nedges; e++) {
44169
+ const j = graph[i].edges[e];
44170
+ Gm[i][j] = Gm[j][i] = -1 / Math.fround(graph[i].ewgts[e]);
44171
+ }
44172
+ }
44173
+ } else {
44174
+ for (let i = 0; i < nG; i++) {
44175
+ for (let e = 1; e < graph[i].nedges; e++) {
44176
+ const j = graph[i].edges[e];
44177
+ Gm[i][j] = Gm[j][i] = -1;
44178
+ }
44179
+ }
44180
+ }
44181
+ const rv = solveCircuit(nG, Gm, GmInv);
44182
+ if (rv) {
44183
+ circuitDistances2(GmInv, nG, Dij);
44184
+ } else {
44185
+ Dij = null;
44186
+ }
44187
+ return Dij;
44188
+ }
44189
+ function circuitDistances2(GmInv, nG, Dij) {
44190
+ let count = 0;
44191
+ for (let i = 0; i < nG; i++) {
44192
+ for (let j = i; j < nG; j++) {
44193
+ Dij[count++] = i === j ? 0 : GmInv[i][i] + GmInv[j][j] - 2 * GmInv[i][j];
44194
+ }
44195
+ }
44196
+ }
44197
+ function weightGraphKeepingLengths(graph, n, vtxVec) {
44198
+ for (let i = 0; i < n; i++) {
44199
+ const weights = new Array(graph[i].nedges).fill(0);
44200
+ fillNeighborsVecUnweighted(graph, i, vtxVec);
44201
+ const degI = graph[i].nedges - 1;
44202
+ for (let j = 1; j <= degI; j++) {
44203
+ const neighbor2 = graph[i].edges[j];
44204
+ weights[j] = fmaxf(artificialWeight(graph, degI, neighbor2, vtxVec), Math.fround(graph[i].ewgts[j]));
44205
+ }
44206
+ emptyNeighborsVec(graph, i, vtxVec);
44207
+ graph[i].ewgts = weights;
44208
+ }
44209
+ }
44210
+ function weightGraph(graph, n, vtxVec) {
44211
+ for (let i = 0; i < n; i++) {
44212
+ const weights = new Array(graph[i].nedges).fill(0);
44213
+ graph[i].ewgts = weights;
44214
+ fillNeighborsVecUnweighted(graph, i, vtxVec);
44215
+ const degI = graph[i].nedges - 1;
44216
+ for (let j = 1; j <= degI; j++) {
44217
+ const neighbor2 = graph[i].edges[j];
44218
+ weights[j] = artificialWeight(graph, degI, neighbor2, vtxVec);
44219
+ }
44220
+ emptyNeighborsVec(graph, i, vtxVec);
44221
+ }
44222
+ }
44223
+ function computeApspArtificialWeightsPacked(graph, n) {
44224
+ const oldWeights = graph[0].ewgts;
44225
+ const savedWeights = graph.slice(0, n).map((v) => v.ewgts);
44226
+ const vtxVec = new Int32Array(n);
44227
+ let Dij;
44228
+ if (graph[0].ewgts.length !== 0) {
44229
+ weightGraphKeepingLengths(graph, n, vtxVec);
44230
+ Dij = computeWeightedApspPacked(graph, n);
44231
+ } else {
44232
+ weightGraph(graph, n, vtxVec);
44233
+ Dij = computeApspPacked(graph, n);
44234
+ }
44235
+ graph[0].ewgts = [];
44236
+ if (oldWeights.length !== 0) {
44237
+ for (let i = 0; i < n; i++) {
44238
+ graph[i].ewgts = savedWeights[i];
44239
+ }
44240
+ }
44241
+ return Dij;
44242
+ }
44243
+ function modelDistances(graph, n, model) {
44244
+ let Dij = null;
44245
+ if (model === MODEL_SUBSET2) {
44246
+ Dij = computeApspArtificialWeightsPacked(graph, n);
44247
+ } else if (model === MODEL_CIRCUIT2) {
44248
+ Dij = circuitModel2(graph, n);
44249
+ if (Dij === null) {
44250
+ agwarningf("graph is disconnected. Hence, the circuit model");
44251
+ agerr("prev", "is undefined. Reverting to the shortest path model.");
44252
+ }
44253
+ } else if (model === MODEL_MDS2) {
44254
+ Dij = mdsModel(graph, n);
44255
+ }
44256
+ return Dij;
44257
+ }
44258
+ function stressModelDij(graph, n, model) {
44259
+ const Dij = modelDistances(graph, n, model);
44260
+ if (Dij !== null) return Dij;
44261
+ return graph[0].ewgts.length !== 0 ? computeWeightedApspPacked(graph, n) : computeApspPacked(graph, n);
44262
+ }
44263
+
43925
44264
  // src/layout/neato/constrained-majorization.ts
43926
44265
  var fr6 = Math.fround;
43927
44266
  var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
@@ -43935,15 +44274,9 @@ var Y_AXIS = 1;
43935
44274
  function unsupported2(what) {
43936
44275
  throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
43937
44276
  }
43938
- function modelDistances(graph, n, model) {
43939
- if (model === MODEL_SUBSET) unsupported2("the subset distance model");
43940
- if (model === MODEL_CIRCUIT) unsupported2("the circuit distance model");
43941
- return model === MODEL_MDS2 ? mdsModel(graph, n) : null;
43942
- }
43943
44277
  function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
43944
44278
  if (o.maxi < 0) return 0;
43945
- const weighted = (graph[0]?.ewgts.length ?? 0) > 0;
43946
- const Dij = modelDistances(graph, n, o.model) ?? (weighted ? computeWeightedApspPacked2(graph, n) : computeApspPacked2(graph, n));
44279
+ const Dij = stressModelDij(graph, n, o.model);
43947
44280
  if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
43948
44281
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
43949
44282
  dim: o.dim,
@@ -45015,15 +45348,16 @@ var IncVPSC = class extends VPSC {
45015
45348
  var EvType = { Open: 0, Close: 1 };
45016
45349
 
45017
45350
  // src/vpsc/SweepLine.ts
45018
- function makeNode(v, r, pos) {
45351
+ function makeNode(v, r, pos, seq2) {
45019
45352
  return {
45020
45353
  v,
45021
45354
  r,
45022
45355
  pos,
45356
+ seq: seq2,
45023
45357
  firstAbove: null,
45024
45358
  firstBelow: null,
45025
- leftNeighbours: /* @__PURE__ */ new Set(),
45026
- rightNeighbours: /* @__PURE__ */ new Set()
45359
+ leftNeighbours: [],
45360
+ rightNeighbours: []
45027
45361
  };
45028
45362
  }
45029
45363
  function compareEventsSameRect(ea, eb) {
@@ -45039,7 +45373,7 @@ function compareEvents(ea, eb) {
45039
45373
  function nodePosLt(a, b) {
45040
45374
  if (a.pos < b.pos) return true;
45041
45375
  if (b.pos < a.pos) return false;
45042
- return a < b;
45376
+ return a.seq < b.seq;
45043
45377
  }
45044
45378
  function scanlineInsert(sl, node) {
45045
45379
  let lo = 0;
@@ -45049,35 +45383,35 @@ function scanlineInsert(sl, node) {
45049
45383
  if (nodePosLt(sl[mid], node)) lo = mid + 1;
45050
45384
  else hi = mid;
45051
45385
  }
45052
- sl.splice(lo, 0, node);
45386
+ if (sl[lo] !== node) sl.splice(lo, 0, node);
45053
45387
  }
45054
45388
  function scanlineRemove(sl, node) {
45055
45389
  const i = sl.indexOf(node);
45056
45390
  if (i !== -1) sl.splice(i, 1);
45057
45391
  }
45058
45392
  function getLeftNeighbours(sl, v) {
45059
- const result = /* @__PURE__ */ new Set();
45393
+ const result = [];
45060
45394
  const idx = sl.indexOf(v);
45061
45395
  for (let i = idx - 1; i >= 0; i--) {
45062
45396
  const u = sl[i];
45063
45397
  if (u.r.overlapX(v.r) <= 0) {
45064
- result.add(u);
45398
+ scanlineInsert(result, u);
45065
45399
  return result;
45066
45400
  }
45067
- if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) result.add(u);
45401
+ if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) scanlineInsert(result, u);
45068
45402
  }
45069
45403
  return result;
45070
45404
  }
45071
45405
  function getRightNeighbours(sl, v) {
45072
- const result = /* @__PURE__ */ new Set();
45406
+ const result = [];
45073
45407
  const idx = sl.indexOf(v);
45074
45408
  for (let i = idx + 1; i < sl.length; i++) {
45075
45409
  const u = sl[i];
45076
45410
  if (u.r.overlapX(v.r) <= 0) {
45077
- result.add(u);
45411
+ scanlineInsert(result, u);
45078
45412
  return result;
45079
45413
  }
45080
- if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) result.add(u);
45414
+ if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) scanlineInsert(result, u);
45081
45415
  }
45082
45416
  return result;
45083
45417
  }
@@ -45086,8 +45420,8 @@ function xOpenNeighbour(sl, v) {
45086
45420
  const right2 = getRightNeighbours(sl, v);
45087
45421
  v.leftNeighbours = left2;
45088
45422
  v.rightNeighbours = right2;
45089
- for (const n of left2) n.rightNeighbours.add(v);
45090
- for (const n of right2) n.leftNeighbours.add(v);
45423
+ for (const n of left2) scanlineInsert(n.rightNeighbours, v);
45424
+ for (const n of right2) scanlineInsert(n.leftNeighbours, v);
45091
45425
  }
45092
45426
  function openLinkChain(sl, v) {
45093
45427
  const idx = sl.indexOf(v);
@@ -45105,13 +45439,13 @@ function openLinkChain(sl, v) {
45105
45439
  function xCloseLeft(v, cs) {
45106
45440
  for (const u of v.leftNeighbours) {
45107
45441
  cs.push(new Constraint(u.v, v.v, (v.r.width() + u.r.width()) / 2));
45108
- u.rightNeighbours.delete(v);
45442
+ scanlineRemove(u.rightNeighbours, v);
45109
45443
  }
45110
45444
  }
45111
45445
  function xCloseRight(v, cs) {
45112
45446
  for (const u of v.rightNeighbours) {
45113
45447
  cs.push(new Constraint(v.v, u.v, (v.r.width() + u.r.width()) / 2));
45114
- u.leftNeighbours.delete(v);
45448
+ scanlineRemove(u.leftNeighbours, v);
45115
45449
  }
45116
45450
  }
45117
45451
  function xCloseNeighbour(v, cs) {
@@ -45147,7 +45481,7 @@ function buildXEvents(rects, vs) {
45147
45481
  for (let i = 0; i < rects.length; i++) {
45148
45482
  const r = rects[i];
45149
45483
  vs[i].desiredPosition = r.getCentreX();
45150
- const node = makeNode(vs[i], r, r.getCentreX());
45484
+ const node = makeNode(vs[i], r, r.getCentreX(), i);
45151
45485
  events.push({ type: EvType.Open, node, pos: r.getMinY() });
45152
45486
  events.push({ type: EvType.Close, node, pos: r.getMaxY() });
45153
45487
  }
@@ -45158,7 +45492,7 @@ function buildYEvents(rects, vs) {
45158
45492
  for (let i = 0; i < rects.length; i++) {
45159
45493
  const r = rects[i];
45160
45494
  vs[i].desiredPosition = r.getCentreY();
45161
- const node = makeNode(vs[i], r, r.getCentreY());
45495
+ const node = makeNode(vs[i], r, r.getCentreY(), i);
45162
45496
  events.push({ type: EvType.Open, node, pos: r.getMinX() });
45163
45497
  events.push({ type: EvType.Close, node, pos: r.getMaxX() });
45164
45498
  }
@@ -45659,251 +45993,6 @@ function deleteCMajEnvVPSC(e) {
45659
45993
  }
45660
45994
  }
45661
45995
 
45662
- // src/layout/neato/lu.ts
45663
- var DOT_VECTOR_TERMS = 8;
45664
- function newArray(m, n, ival) {
45665
- const mem = new Float64Array(m * n);
45666
- const rv = [];
45667
- for (let i = 0; i < m; i++) {
45668
- rv.push(mem.subarray(i * n, (i + 1) * n));
45669
- rv[i].fill(ival);
45670
- }
45671
- return rv;
45672
- }
45673
- function luScaleRows(lu, a, n, scales) {
45674
- const m = lu.lu;
45675
- const ps = lu.ps;
45676
- for (let i = 0; i < n; i++) {
45677
- let biggest = 0;
45678
- for (let j = 0; j < n; j++) biggest = fmaxf(biggest, Math.abs(m[i][j] = a[i][j]));
45679
- if (biggest > 0) scales[i] = 1 / biggest;
45680
- else return false;
45681
- ps[i] = i;
45682
- }
45683
- return true;
45684
- }
45685
- function luFindPivot(lu, k, n, scales, pivotindex) {
45686
- const m = lu.lu;
45687
- const ps = lu.ps;
45688
- let biggest = 0;
45689
- for (let i = k; i < n; i++) {
45690
- const tempf = Math.abs(m[ps[i]][k]) * scales[ps[i]];
45691
- if (biggest < tempf) {
45692
- biggest = tempf;
45693
- pivotindex = i;
45694
- }
45695
- }
45696
- if (biggest <= 0) return -1;
45697
- return pivotindex;
45698
- }
45699
- function luEliminate(lu, k, n) {
45700
- const m = lu.lu;
45701
- const ps = lu.ps;
45702
- const rowK = m[ps[k]];
45703
- const pivot = rowK[k];
45704
- for (let i = k + 1; i < n; i++) {
45705
- const rowI = m[ps[i]];
45706
- const mult = rowI[k] = rowI[k] / pivot;
45707
- for (let j = k + 1; j < n; j++) rowI[j] = fma(-mult, rowK[j], rowI[j]);
45708
- }
45709
- }
45710
- function luDecompose(lu, a, n) {
45711
- lu.lu = newArray(n, n, 0);
45712
- lu.ps = new Int32Array(n);
45713
- const scales = new Float64Array(n);
45714
- if (!luScaleRows(lu, a, n, scales)) {
45715
- luFree(lu);
45716
- return 0;
45717
- }
45718
- for (let k = 0, pivotindex = 0; k < n - 1; k++) {
45719
- pivotindex = luFindPivot(lu, k, n, scales, pivotindex);
45720
- if (pivotindex < 0) {
45721
- luFree(lu);
45722
- return 0;
45723
- }
45724
- if (pivotindex !== k) {
45725
- const ps = lu.ps;
45726
- const t = ps[k];
45727
- ps[k] = ps[pivotindex];
45728
- ps[pivotindex] = t;
45729
- }
45730
- luEliminate(lu, k, n);
45731
- }
45732
- if (lu.lu[lu.ps[n - 1]][n - 1] === 0) {
45733
- luFree(lu);
45734
- return 0;
45735
- }
45736
- return 1;
45737
- }
45738
- function luDot(row, x, from, to) {
45739
- const vecEnd = from + (to - from) - (to - from) % DOT_VECTOR_TERMS;
45740
- let dot = 0;
45741
- let j = from;
45742
- for (; j < vecEnd; j++) dot += row[j] * x[j];
45743
- for (; j < to; j++) dot = fma(row[j], x[j], dot);
45744
- return dot;
45745
- }
45746
- function luSolve(lu, x, bi, n) {
45747
- const m = lu.lu;
45748
- const ps = lu.ps;
45749
- for (let i = 0; i < n; i++) {
45750
- const dot = luDot(m[ps[i]], x, 0, i);
45751
- x[i] = (ps[i] === bi ? 1 : 0) - dot;
45752
- }
45753
- for (let i = n - 1; i >= 0; i--) {
45754
- const row = m[ps[i]];
45755
- const dot = luDot(row, x, i + 1, n);
45756
- x[i] = (x[i] - dot) / row[i];
45757
- }
45758
- }
45759
- function luFree(lu) {
45760
- if (lu === null) {
45761
- return;
45762
- }
45763
- lu.lu = null;
45764
- lu.ps = null;
45765
- }
45766
-
45767
- // src/layout/neato/matinv.ts
45768
- function matinv(A3, Ainv, n) {
45769
- const lu = { lu: null, ps: null };
45770
- if (luDecompose(lu, A3, n) === 0) return 0;
45771
- for (let i = 0; i < n; i++) {
45772
- luSolve(lu, Ainv[i], i, n);
45773
- }
45774
- luFree(lu);
45775
- for (let i = 0; i < n; i++) {
45776
- for (let j = 0; j < i; j++) {
45777
- const t = Ainv[i][j];
45778
- Ainv[i][j] = Ainv[j][i];
45779
- Ainv[j][i] = t;
45780
- }
45781
- }
45782
- return 1;
45783
- }
45784
-
45785
- // src/layout/neato/circuit.ts
45786
- function solveCircuit(nG, Gm, GmInv) {
45787
- for (let i = 0; i < nG; i++) {
45788
- const row = Gm[i];
45789
- let sum = 0;
45790
- for (let j = 0; j < nG; j++) {
45791
- if (i !== j) sum += row[j];
45792
- }
45793
- row[i] = -sum;
45794
- }
45795
- return matinv(Gm, GmInv, nG - 1);
45796
- }
45797
-
45798
- // src/layout/neato/stress-models.ts
45799
- var SIZE_T_MODULUS = 2 ** 64;
45800
- function commonNeighbors(graph, u, vVector) {
45801
- let numSharedNeighbors = 0;
45802
- for (let j = 1; j < graph[u].nedges; j++) {
45803
- const neighbor2 = graph[u].edges[j];
45804
- if (vVector[neighbor2] > 0) {
45805
- numSharedNeighbors++;
45806
- }
45807
- }
45808
- return numSharedNeighbors;
45809
- }
45810
- function fillNeighborsVecUnweighted(graph, vtx, vtxVec) {
45811
- for (let j = 1; j < graph[vtx].nedges; j++) {
45812
- vtxVec[graph[vtx].edges[j]] = 1;
45813
- }
45814
- }
45815
- function emptyNeighborsVec(graph, vtx, vtxVec) {
45816
- for (let j = 1; j < graph[vtx].nedges; j++) {
45817
- vtxVec[graph[vtx].edges[j]] = 0;
45818
- }
45819
- }
45820
- function circuitModel(graph, nG) {
45821
- let Dij = new Float32Array(nG * (nG + 1) / 2);
45822
- const Gm = newArray(nG, nG, 0);
45823
- const GmInv = newArray(nG, nG, 0);
45824
- if (graph[0].ewgts.length !== 0) {
45825
- for (let i = 0; i < nG; i++) {
45826
- for (let e = 1; e < graph[i].nedges; e++) {
45827
- const j = graph[i].edges[e];
45828
- Gm[i][j] = Gm[j][i] = -1 / Math.fround(graph[i].ewgts[e]);
45829
- }
45830
- }
45831
- } else {
45832
- for (let i = 0; i < nG; i++) {
45833
- for (let e = 1; e < graph[i].nedges; e++) {
45834
- const j = graph[i].edges[e];
45835
- Gm[i][j] = Gm[j][i] = -1;
45836
- }
45837
- }
45838
- }
45839
- const rv = solveCircuit(nG, Gm, GmInv);
45840
- if (rv) {
45841
- circuitDistances(GmInv, nG, Dij);
45842
- } else {
45843
- Dij = null;
45844
- }
45845
- return Dij;
45846
- }
45847
- function circuitDistances(GmInv, nG, Dij) {
45848
- let count = 0;
45849
- for (let i = 0; i < nG; i++) {
45850
- for (let j = i; j < nG; j++) {
45851
- Dij[count++] = i === j ? 0 : GmInv[i][i] + GmInv[j][j] - 2 * GmInv[i][j];
45852
- }
45853
- }
45854
- }
45855
- function artificialWeight(graph, degI, neighbor2, vtxVec) {
45856
- const degJ = graph[neighbor2].nedges - 1;
45857
- const w = degI + degJ - 2 * commonNeighbors(graph, neighbor2, vtxVec);
45858
- return Math.fround(w < 0 ? w + SIZE_T_MODULUS : w);
45859
- }
45860
- function weightGraphKeepingLengths(graph, n, vtxVec) {
45861
- for (let i = 0; i < n; i++) {
45862
- const weights = new Array(graph[i].nedges).fill(0);
45863
- fillNeighborsVecUnweighted(graph, i, vtxVec);
45864
- const degI = graph[i].nedges - 1;
45865
- for (let j = 1; j <= degI; j++) {
45866
- const neighbor2 = graph[i].edges[j];
45867
- weights[j] = fmaxf(artificialWeight(graph, degI, neighbor2, vtxVec), Math.fround(graph[i].ewgts[j]));
45868
- }
45869
- emptyNeighborsVec(graph, i, vtxVec);
45870
- graph[i].ewgts = weights;
45871
- }
45872
- }
45873
- function weightGraph(graph, n, vtxVec) {
45874
- for (let i = 0; i < n; i++) {
45875
- const weights = new Array(graph[i].nedges).fill(0);
45876
- graph[i].ewgts = weights;
45877
- fillNeighborsVecUnweighted(graph, i, vtxVec);
45878
- const degI = graph[i].nedges - 1;
45879
- for (let j = 1; j <= degI; j++) {
45880
- const neighbor2 = graph[i].edges[j];
45881
- weights[j] = artificialWeight(graph, degI, neighbor2, vtxVec);
45882
- }
45883
- emptyNeighborsVec(graph, i, vtxVec);
45884
- }
45885
- }
45886
- function computeApspArtificialWeightsPacked(graph, n) {
45887
- const oldWeights = graph[0].ewgts;
45888
- const savedWeights = graph.slice(0, n).map((v) => v.ewgts);
45889
- const vtxVec = new Int32Array(n);
45890
- let Dij;
45891
- if (graph[0].ewgts.length !== 0) {
45892
- weightGraphKeepingLengths(graph, n, vtxVec);
45893
- Dij = computeWeightedApspPacked(graph, n);
45894
- } else {
45895
- weightGraph(graph, n, vtxVec);
45896
- Dij = computeApspPacked(graph, n);
45897
- }
45898
- graph[0].ewgts = [];
45899
- if (oldWeights.length !== 0) {
45900
- for (let i = 0; i < n; i++) {
45901
- graph[i].ewgts = savedWeights[i];
45902
- }
45903
- }
45904
- return Dij;
45905
- }
45906
-
45907
45996
  // src/layout/neato/stress-cola.ts
45908
45997
  var fr9 = Math.fround;
45909
45998
  var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
@@ -45927,10 +46016,10 @@ function maxEdgeLength(graph, n) {
45927
46016
  }
45928
46017
  function modelDistances2(graph, n, model) {
45929
46018
  let Dij = null;
45930
- if (model === MODEL_SUBSET) {
46019
+ if (model === MODEL_SUBSET2) {
45931
46020
  Dij = computeApspArtificialWeightsPacked(graph, n);
45932
- } else if (model === MODEL_CIRCUIT) {
45933
- Dij = circuitModel(graph, n);
46021
+ } else if (model === MODEL_CIRCUIT2) {
46022
+ Dij = circuitModel2(graph, n);
45934
46023
  if (!Dij) {
45935
46024
  agwarningf("graph is disconnected. Hence, the circuit model");
45936
46025
  agerr("prev", "is undefined. Reverting to the shortest path model.");
@@ -52928,8 +53017,8 @@ var MODE_IPSEP = 3;
52928
53017
  var MODE_SGD = 4;
52929
53018
  var SGD_ITERATIONS = 30;
52930
53019
  var MODEL_SHORTPATH2 = 0;
52931
- var MODEL_CIRCUIT = 1;
52932
- var MODEL_SUBSET = 2;
53020
+ var MODEL_CIRCUIT2 = 1;
53021
+ var MODEL_SUBSET2 = 2;
52933
53022
  var MODEL_MDS2 = 3;
52934
53023
  var DFLT_DIM = 2;
52935
53024
  var POINTS_PER_INCH11 = 72;
@@ -52973,7 +53062,7 @@ function neatoMaxIter(maxiter, mode, n) {
52973
53062
  }
52974
53063
  var levelsGapOf = (g) => lateDouble(g.root.attrs.get("levelsgap"), 0, -Number.MAX_VALUE);
52975
53064
  function solveStress(c, vtx, dCoords, nodeList) {
52976
- const { g, mode, model, haveLen, opts } = c;
53065
+ const { g, mode, model, opts } = c;
52977
53066
  const n = nodeList.length;
52978
53067
  const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
52979
53068
  const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
@@ -52997,7 +53086,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
52997
53086
  opt
52998
53087
  });
52999
53088
  }
53000
- const Dij = haveLen ? computeWeightedApspPacked2(vtx, n) : computeApspPacked2(vtx, n);
53089
+ const Dij = stressModelDij(vtx, n, model);
53001
53090
  return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
53002
53091
  dim: DFLT_DIM,
53003
53092
  opts,
@@ -53009,13 +53098,13 @@ function runMajorization(g, mode, model, am) {
53009
53098
  const nodeList = assignNodeIds2(g);
53010
53099
  setEdgeLen(g);
53011
53100
  const n = nodeList.length;
53012
- const haveLen = graphHasLen(g);
53101
+ const haveLen = model !== MODEL_SUBSET2 && graphHasLen(g);
53013
53102
  const init = checkStart(g, n, mode === MODE_HIER ? INIT_SELF : INIT_RANDOM);
53014
53103
  const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
53015
53104
  const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
53016
53105
  const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
53017
53106
  const dCoords = [new Float64Array(n), new Float64Array(n)];
53018
- if (solveStress({ g, mode, model, haveLen, opts, am }, vtx, dCoords, nodeList) < 0) {
53107
+ if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
53019
53108
  agerr("prev", "layout aborted");
53020
53109
  return;
53021
53110
  }
@@ -53025,8 +53114,9 @@ function runMajorization(g, mode, model, am) {
53025
53114
  }
53026
53115
  var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
53027
53116
  function solveModel2(g, mode, model, am = NO_ADJUST) {
53028
- if (g.nodes.size < 2) return;
53029
- assertSupported(g, mode, model);
53117
+ const nG = g.nodes.size;
53118
+ if (nG < 2 || neatoMaxIter(g.attrs.get("maxiter"), mode, nG) < 0) return;
53119
+ assertSupported(g, mode);
53030
53120
  if (mode === MODE_KK) return kkNeato(g, g.nodes.size, model);
53031
53121
  if (mode === MODE_SGD) {
53032
53122
  if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) checkStart(g);
@@ -53418,16 +53508,27 @@ function layoutMulti(g, comps, globalRoot, pinfo) {
53418
53508
  function parseMode(g) {
53419
53509
  return neatoMode(g);
53420
53510
  }
53421
- var MODEL_MAP = {
53422
- shortpath: MODEL_SHORTPATH2,
53423
- circuit: MODEL_CIRCUIT,
53424
- subset: MODEL_SUBSET,
53425
- mds: MODEL_MDS2
53426
- };
53511
+ var EDGE_LEN_ATTR = "len";
53512
+ function edgeLenDeclared(g) {
53513
+ if (g.edgeDefaults.has(EDGE_LEN_ATTR)) return true;
53514
+ for (const e of g.edges) if (e.attrs.has(EDGE_LEN_ATTR)) return true;
53515
+ for (const sub of g.subgraphs.values()) if (edgeLenDeclared(sub)) return true;
53516
+ return false;
53517
+ }
53427
53518
  function parseModel(g) {
53428
- const s = g.attrs.get("model");
53429
- if (!s) return MODEL_SHORTPATH2;
53430
- return MODEL_MAP[s] ?? MODEL_SHORTPATH2;
53519
+ const p = g.attrs.get("model");
53520
+ if (p === void 0 || p === "") return MODEL_SHORTPATH2;
53521
+ if (p === "circuit") return MODEL_CIRCUIT2;
53522
+ if (p === "subset") return MODEL_SUBSET2;
53523
+ if (p === "shortpath") return MODEL_SHORTPATH2;
53524
+ if (p === "mds") {
53525
+ if (edgeLenDeclared(g)) return MODEL_MDS2;
53526
+ agwarningf(`edges in graph ${agNameOf(g.root)} have no len attribute. Hence, the mds model`);
53527
+ agerr("prev", "is inappropriate. Reverting to the shortest path model.");
53528
+ return MODEL_SHORTPATH2;
53529
+ }
53530
+ agwarningf(`Unknown value ${p} for attribute "model" in graph ${agNameOf(g.root)} - ignored`);
53531
+ return MODEL_SHORTPATH2;
53431
53532
  }
53432
53533
  function maybeRemoveOverlap(g, am) {
53433
53534
  removeOverlapWith(g, am);