@dpuse/dpuse-tool-d3-visualiser 0.0.41 → 0.0.45
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.
- package/dist/dpuse-tool-d3-visualiser.es.js +7 -7
- package/dist/dpuse-tool-d3-visualiser.es.js.map +1 -1
- package/dist/{erdDiagram-Ds-nrw7Q.js → erdDiagram-Ds1hsQDD.js} +491 -452
- package/dist/erdDiagram-Ds1hsQDD.js.map +1 -0
- package/dist/tanStackCharts-DCMs4Y_D.js +3476 -0
- package/dist/tanStackCharts-DCMs4Y_D.js.map +1 -0
- package/dist/types/src/index.d.ts +2 -1
- package/dist/types/src/tanStackCharts.d.ts +2 -1
- package/package.json +11 -10
- package/dist/erdDiagram-Ds-nrw7Q.js.map +0 -1
- package/dist/tanStackCharts-BJAX22lS.js +0 -2356
- package/dist/tanStackCharts-BJAX22lS.js.map +0 -1
|
@@ -12,10 +12,8 @@ var t = Object.defineProperty, n = (e, n, r) => n in e ? t(e, n, {
|
|
|
12
12
|
});
|
|
13
13
|
}, i = (e, t, r) => n(e, typeof t == "symbol" ? t : t + "", r), a = {};
|
|
14
14
|
r(a, {
|
|
15
|
-
Graph: () =>
|
|
16
|
-
alg: () =>
|
|
17
|
-
json: () => h,
|
|
18
|
-
version: () => m
|
|
15
|
+
Graph: () => E,
|
|
16
|
+
alg: () => v
|
|
19
17
|
});
|
|
20
18
|
var o = Object.defineProperty, s = (e, t) => {
|
|
21
19
|
for (var n in t) o(e, n, {
|
|
@@ -116,14 +114,14 @@ var o = Object.defineProperty, s = (e, t) => {
|
|
|
116
114
|
neighbors(e) {
|
|
117
115
|
let t = this.predecessors(e);
|
|
118
116
|
if (t) {
|
|
119
|
-
let n = new Set(t);
|
|
120
|
-
for (let
|
|
117
|
+
let n = new Set(t), r = this.successors(e);
|
|
118
|
+
if (r) for (let e of r) n.add(e);
|
|
121
119
|
return Array.from(n.values());
|
|
122
120
|
}
|
|
123
121
|
}
|
|
124
122
|
isLeaf(e) {
|
|
125
123
|
let t;
|
|
126
|
-
return t = this.isDirected() ? this.successors(e) : this.neighbors(e), t
|
|
124
|
+
return t = this.isDirected() ? this.successors(e) : this.neighbors(e), (t?.length ?? 0) === 0;
|
|
127
125
|
}
|
|
128
126
|
filterNodes(e) {
|
|
129
127
|
let t = new this.constructor({
|
|
@@ -138,7 +136,7 @@ var o = Object.defineProperty, s = (e, t) => {
|
|
|
138
136
|
});
|
|
139
137
|
let n = {}, r = (e) => {
|
|
140
138
|
let i = this.parent(e);
|
|
141
|
-
return !i || t.hasNode(i) ? (n[e] = i
|
|
139
|
+
return !i || t.hasNode(i) ? (n[e] = i, i) : i in n ? n[i] : r(i);
|
|
142
140
|
};
|
|
143
141
|
return this._isCompound && t.nodes().forEach((e) => t.setParent(e, r(e))), t;
|
|
144
142
|
}
|
|
@@ -170,7 +168,7 @@ var o = Object.defineProperty, s = (e, t) => {
|
|
|
170
168
|
}
|
|
171
169
|
edgeAsObj(e, t, n) {
|
|
172
170
|
let r = arguments.length === 1 ? this.edge(e) : this.edge(e, t, n);
|
|
173
|
-
return typeof r
|
|
171
|
+
return typeof r != "object" || !r ? { label: r } : r;
|
|
174
172
|
}
|
|
175
173
|
hasEdge(e, t, n) {
|
|
176
174
|
return (arguments.length === 1 ? p(this._isDirected, e) : d(this._isDirected, e, t, n)) in this._edgeLabels;
|
|
@@ -233,30 +231,29 @@ function f(e, t, n, r) {
|
|
|
233
231
|
function p(e, t) {
|
|
234
232
|
return d(e, t.v, t.w, t.name);
|
|
235
233
|
}
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
write: () => g
|
|
234
|
+
s({}, {
|
|
235
|
+
read: () => _,
|
|
236
|
+
write: () => m
|
|
240
237
|
});
|
|
241
|
-
function
|
|
238
|
+
function m(e) {
|
|
242
239
|
let t = {
|
|
243
240
|
options: {
|
|
244
241
|
directed: e.isDirected(),
|
|
245
242
|
multigraph: e.isMultigraph(),
|
|
246
243
|
compound: e.isCompound()
|
|
247
244
|
},
|
|
248
|
-
nodes:
|
|
249
|
-
edges:
|
|
245
|
+
nodes: h(e),
|
|
246
|
+
edges: g(e)
|
|
250
247
|
}, n = e.graph();
|
|
251
248
|
return n !== void 0 && (t.value = structuredClone(n)), t;
|
|
252
249
|
}
|
|
253
|
-
function
|
|
250
|
+
function h(e) {
|
|
254
251
|
return e.nodes().map((t) => {
|
|
255
252
|
let n = e.node(t), r = e.parent(t), i = { v: t };
|
|
256
253
|
return n !== void 0 && (i.value = n), r !== void 0 && (i.parent = r), i;
|
|
257
254
|
});
|
|
258
255
|
}
|
|
259
|
-
function
|
|
256
|
+
function g(e) {
|
|
260
257
|
return e.edges().map((t) => {
|
|
261
258
|
let n = e.edge(t), r = {
|
|
262
259
|
v: t.v,
|
|
@@ -265,7 +262,7 @@ function v(e) {
|
|
|
265
262
|
return t.name !== void 0 && (r.name = t.name), n !== void 0 && (r.value = n), r;
|
|
266
263
|
});
|
|
267
264
|
}
|
|
268
|
-
function
|
|
265
|
+
function _(e) {
|
|
269
266
|
let t = new c(e.options);
|
|
270
267
|
return e.value !== void 0 && t.setGraph(e.value), e.nodes.forEach((e) => {
|
|
271
268
|
t.setNode(e.v, e.value), e.parent && t.setParent(e.v, e.parent);
|
|
@@ -277,34 +274,36 @@ function y(e) {
|
|
|
277
274
|
}, e.value);
|
|
278
275
|
}), t;
|
|
279
276
|
}
|
|
280
|
-
var
|
|
281
|
-
s(
|
|
282
|
-
CycleException: () =>
|
|
283
|
-
bellmanFord: () =>
|
|
284
|
-
components: () =>
|
|
277
|
+
var v = {};
|
|
278
|
+
s(v, {
|
|
279
|
+
CycleException: () => w,
|
|
280
|
+
bellmanFord: () => b,
|
|
281
|
+
components: () => te,
|
|
285
282
|
dijkstra: () => S,
|
|
286
|
-
dijkstraAll: () =>
|
|
287
|
-
findCycles: () =>
|
|
288
|
-
floydWarshall: () =>
|
|
289
|
-
isAcyclic: () =>
|
|
290
|
-
postorder: () =>
|
|
291
|
-
preorder: () =>
|
|
292
|
-
prim: () =>
|
|
293
|
-
shortestPaths: () =>
|
|
294
|
-
tarjan: () =>
|
|
295
|
-
topsort: () =>
|
|
283
|
+
dijkstraAll: () => ie,
|
|
284
|
+
findCycles: () => ae,
|
|
285
|
+
floydWarshall: () => se,
|
|
286
|
+
isAcyclic: () => ue,
|
|
287
|
+
postorder: () => pe,
|
|
288
|
+
preorder: () => me,
|
|
289
|
+
prim: () => he,
|
|
290
|
+
shortestPaths: () => ge,
|
|
291
|
+
tarjan: () => C,
|
|
292
|
+
topsort: () => le
|
|
296
293
|
});
|
|
297
|
-
var
|
|
298
|
-
function
|
|
299
|
-
return
|
|
300
|
-
return e.outEdges(t);
|
|
294
|
+
var y = () => 1;
|
|
295
|
+
function b(e, t, n, r) {
|
|
296
|
+
return ee(e, String(t), n || y, r || function(t) {
|
|
297
|
+
return e.outEdges(t) ?? [];
|
|
301
298
|
});
|
|
302
299
|
}
|
|
303
|
-
function
|
|
300
|
+
function ee(e, t, n, r) {
|
|
304
301
|
let i = {}, a, o = 0, s = e.nodes(), c = function(e) {
|
|
305
|
-
let t =
|
|
306
|
-
|
|
307
|
-
|
|
302
|
+
let t = i[e.v], r = i[e.w];
|
|
303
|
+
if (!t || !r) return;
|
|
304
|
+
let o = n(e);
|
|
305
|
+
t.distance + o < r.distance && (i[e.w] = {
|
|
306
|
+
distance: t.distance + o,
|
|
308
307
|
predecessor: e.v
|
|
309
308
|
}, a = !0);
|
|
310
309
|
}, l = function() {
|
|
@@ -329,16 +328,17 @@ function te(e, t, n, r) {
|
|
|
329
328
|
if (o === u - 1 && (a = !1, l(), a)) throw Error("The graph contains a negative weight cycle");
|
|
330
329
|
return i;
|
|
331
330
|
}
|
|
332
|
-
function
|
|
331
|
+
function te(e) {
|
|
333
332
|
let t = {}, n = [], r;
|
|
334
333
|
function i(n) {
|
|
335
|
-
|
|
334
|
+
var a, o;
|
|
335
|
+
n in t || (t[n] = !0, r.push(n), (a = e.successors(n)) == null || a.forEach(i), (o = e.predecessors(n)) == null || o.forEach(i));
|
|
336
336
|
}
|
|
337
337
|
return e.nodes().forEach(function(e) {
|
|
338
338
|
r = [], i(e), r.length && n.push(r);
|
|
339
339
|
}), n;
|
|
340
340
|
}
|
|
341
|
-
var
|
|
341
|
+
var x = class {
|
|
342
342
|
constructor() {
|
|
343
343
|
this._arr = [], this._keyIndices = {};
|
|
344
344
|
}
|
|
@@ -371,6 +371,7 @@ var re = class {
|
|
|
371
371
|
return !1;
|
|
372
372
|
}
|
|
373
373
|
removeMin() {
|
|
374
|
+
if (this.size() === 0) throw Error("Queue underflow");
|
|
374
375
|
this._swap(0, this._arr.length - 1);
|
|
375
376
|
let e = this._arr.pop();
|
|
376
377
|
return delete this._keyIndices[e.key], this._heapify(0), e.key;
|
|
@@ -394,15 +395,17 @@ var re = class {
|
|
|
394
395
|
let n = this._arr, r = this._keyIndices, i = n[e], a = n[t];
|
|
395
396
|
n[e] = a, n[t] = i, r[a.key] = e, r[i.key] = t;
|
|
396
397
|
}
|
|
397
|
-
},
|
|
398
|
+
}, ne = () => 1;
|
|
398
399
|
function S(e, t, n, r) {
|
|
399
|
-
return
|
|
400
|
-
return e.outEdges(t);
|
|
400
|
+
return re(e, String(t), n || ne, r || function(t) {
|
|
401
|
+
return e.outEdges(t) ?? [];
|
|
401
402
|
});
|
|
402
403
|
}
|
|
403
|
-
function
|
|
404
|
-
let i = {}, a = new
|
|
405
|
-
let t = e.v === o ? e.w : e.v, r = i[t]
|
|
404
|
+
function re(e, t, n, r) {
|
|
405
|
+
let i = {}, a = new x(), o, s, c = function(e) {
|
|
406
|
+
let t = e.v === o ? e.w : e.v, r = i[t];
|
|
407
|
+
if (!r) return;
|
|
408
|
+
let c = n(e), l = s.distance + c;
|
|
406
409
|
if (c < 0) throw Error("dijkstra does not allow negative edge weights. Bad edge: " + e + " Weight: " + c);
|
|
407
410
|
l < r.distance && (r.distance = l, r.predecessor = o, a.decrease(t, l));
|
|
408
411
|
};
|
|
@@ -412,29 +415,44 @@ function ae(e, t, n, r) {
|
|
|
412
415
|
distance: n,
|
|
413
416
|
predecessor: ""
|
|
414
417
|
}, a.add(e, n);
|
|
415
|
-
}); a.size() > 0
|
|
418
|
+
}); a.size() > 0;) {
|
|
419
|
+
o = a.removeMin();
|
|
420
|
+
let e = i[o];
|
|
421
|
+
if (!e || e.distance === Infinity) break;
|
|
422
|
+
s = e, r(o).forEach(c);
|
|
423
|
+
}
|
|
416
424
|
return i;
|
|
417
425
|
}
|
|
418
|
-
function
|
|
426
|
+
function ie(e, t, n) {
|
|
419
427
|
return e.nodes().reduce(function(r, i) {
|
|
420
428
|
return r[i] = S(e, i, t, n), r;
|
|
421
429
|
}, {});
|
|
422
430
|
}
|
|
423
|
-
function
|
|
431
|
+
function C(e) {
|
|
424
432
|
let t = 0, n = [], r = {}, i = [];
|
|
425
433
|
function a(o) {
|
|
426
|
-
|
|
434
|
+
var s;
|
|
435
|
+
let c = r[o] = {
|
|
427
436
|
onStack: !0,
|
|
428
437
|
lowlink: t,
|
|
429
438
|
index: t++
|
|
430
439
|
};
|
|
431
|
-
if (n.push(o), e.successors(o).forEach(function(e) {
|
|
432
|
-
e in r
|
|
433
|
-
|
|
440
|
+
if (n.push(o), (s = e.successors(o)) == null || s.forEach(function(e) {
|
|
441
|
+
if (e in r) {
|
|
442
|
+
let t = r[e];
|
|
443
|
+
t != null && t.onStack && (c.lowlink = Math.min(c.lowlink, t.index));
|
|
444
|
+
} else {
|
|
445
|
+
a(e);
|
|
446
|
+
let t = r[e];
|
|
447
|
+
t && (c.lowlink = Math.min(c.lowlink, t.lowlink));
|
|
448
|
+
}
|
|
449
|
+
}), c.lowlink === c.index) {
|
|
434
450
|
let e = [], t;
|
|
435
|
-
do
|
|
436
|
-
t = n.pop()
|
|
437
|
-
|
|
451
|
+
do {
|
|
452
|
+
t = n.pop();
|
|
453
|
+
let i = r[t];
|
|
454
|
+
i && (i.onStack = !1), e.push(t);
|
|
455
|
+
} while (o !== t);
|
|
438
456
|
i.push(e);
|
|
439
457
|
}
|
|
440
458
|
}
|
|
@@ -442,143 +460,157 @@ function se(e) {
|
|
|
442
460
|
e in r || a(e);
|
|
443
461
|
}), i;
|
|
444
462
|
}
|
|
445
|
-
function
|
|
446
|
-
return
|
|
447
|
-
|
|
463
|
+
function ae(e) {
|
|
464
|
+
return C(e).filter(function(t) {
|
|
465
|
+
let n = t[0];
|
|
466
|
+
return n ? t.length > 1 || t.length === 1 && (e.outEdges(n, n) ?? []).length > 0 : !1;
|
|
448
467
|
});
|
|
449
468
|
}
|
|
450
|
-
var
|
|
451
|
-
function
|
|
452
|
-
return
|
|
453
|
-
return e.outEdges(t);
|
|
469
|
+
var oe = () => 1;
|
|
470
|
+
function se(e, t, n) {
|
|
471
|
+
return ce(e, t || oe, n || function(t) {
|
|
472
|
+
return e.outEdges(t) ?? [];
|
|
454
473
|
});
|
|
455
474
|
}
|
|
456
|
-
function
|
|
475
|
+
function ce(e, t, n) {
|
|
457
476
|
let r = {}, i = e.nodes();
|
|
458
477
|
return i.forEach(function(e) {
|
|
459
|
-
|
|
478
|
+
let a = {};
|
|
479
|
+
r[e] = a, a[e] = {
|
|
460
480
|
distance: 0,
|
|
461
481
|
predecessor: ""
|
|
462
482
|
}, i.forEach(function(t) {
|
|
463
|
-
e !== t && (
|
|
483
|
+
e !== t && (a[t] = {
|
|
464
484
|
distance: Infinity,
|
|
465
485
|
predecessor: ""
|
|
466
486
|
});
|
|
467
487
|
}), n(e).forEach(function(n) {
|
|
468
|
-
let
|
|
469
|
-
r
|
|
470
|
-
distance:
|
|
488
|
+
let r = n.v === e ? n.w : n.v, i = t(n);
|
|
489
|
+
a[r] = {
|
|
490
|
+
distance: i,
|
|
471
491
|
predecessor: e
|
|
472
492
|
};
|
|
473
493
|
});
|
|
474
494
|
}), i.forEach(function(e) {
|
|
475
495
|
let t = r[e];
|
|
476
|
-
i.forEach(function(n) {
|
|
496
|
+
t && i.forEach(function(n) {
|
|
477
497
|
let a = r[n];
|
|
478
|
-
i.forEach(function(n) {
|
|
479
|
-
let r = a[e], i = t[n], o = a[n]
|
|
480
|
-
|
|
498
|
+
a && i.forEach(function(n) {
|
|
499
|
+
let r = a[e], i = t[n], o = a[n];
|
|
500
|
+
if (r && i && o) {
|
|
501
|
+
let e = r.distance + i.distance;
|
|
502
|
+
e < o.distance && (o.distance = e, o.predecessor = i.predecessor);
|
|
503
|
+
}
|
|
481
504
|
});
|
|
482
505
|
});
|
|
483
506
|
}), r;
|
|
484
507
|
}
|
|
485
|
-
var
|
|
486
|
-
constructor(
|
|
487
|
-
super(
|
|
508
|
+
var w = class extends Error {
|
|
509
|
+
constructor(e) {
|
|
510
|
+
super(e), this.name = "CycleException";
|
|
488
511
|
}
|
|
489
512
|
};
|
|
490
|
-
function
|
|
513
|
+
function le(e) {
|
|
491
514
|
let t = {}, n = {}, r = [];
|
|
492
515
|
function i(a) {
|
|
493
|
-
|
|
494
|
-
a in
|
|
516
|
+
var o;
|
|
517
|
+
if (a in n) throw new w();
|
|
518
|
+
a in t || (n[a] = !0, t[a] = !0, (o = e.predecessors(a)) == null || o.forEach(i), delete n[a], r.push(a));
|
|
495
519
|
}
|
|
496
|
-
if (e.sinks().forEach(i), Object.keys(t).length !== e.nodeCount()) throw new
|
|
520
|
+
if (e.sinks().forEach(i), Object.keys(t).length !== e.nodeCount()) throw new w();
|
|
497
521
|
return r;
|
|
498
522
|
}
|
|
499
|
-
function
|
|
523
|
+
function ue(e) {
|
|
500
524
|
try {
|
|
501
|
-
|
|
525
|
+
le(e);
|
|
502
526
|
} catch (e) {
|
|
503
|
-
if (e instanceof
|
|
527
|
+
if (e instanceof w) return !1;
|
|
504
528
|
throw e;
|
|
505
529
|
}
|
|
506
530
|
return !0;
|
|
507
531
|
}
|
|
508
|
-
function
|
|
532
|
+
function de(e, t, n, r, i) {
|
|
509
533
|
Array.isArray(t) || (t = [t]);
|
|
510
534
|
let a = ((t) => (e.isDirected() ? e.successors(t) : e.neighbors(t)) ?? []), o = {};
|
|
511
535
|
return t.forEach(function(t) {
|
|
512
536
|
if (!e.hasNode(t)) throw Error("Graph does not have node: " + t);
|
|
513
|
-
i =
|
|
537
|
+
i = fe(e, t, n === "post", o, a, r, i);
|
|
514
538
|
}), i;
|
|
515
539
|
}
|
|
516
|
-
function
|
|
540
|
+
function fe(e, t, n, r, i, a, o) {
|
|
517
541
|
return t in r || (r[t] = !0, n || (o = a(o, t)), i(t).forEach(function(t) {
|
|
518
|
-
o =
|
|
542
|
+
o = fe(e, t, n, r, i, a, o);
|
|
519
543
|
}), n && (o = a(o, t))), o;
|
|
520
544
|
}
|
|
521
|
-
function
|
|
522
|
-
return
|
|
545
|
+
function T(e, t, n) {
|
|
546
|
+
return de(e, t, n, function(e, t) {
|
|
523
547
|
return e.push(t), e;
|
|
524
548
|
}, []);
|
|
525
549
|
}
|
|
526
|
-
function
|
|
527
|
-
return
|
|
550
|
+
function pe(e, t) {
|
|
551
|
+
return T(e, t, "post");
|
|
528
552
|
}
|
|
529
|
-
function
|
|
530
|
-
return
|
|
553
|
+
function me(e, t) {
|
|
554
|
+
return T(e, t, "pre");
|
|
531
555
|
}
|
|
532
|
-
function
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
556
|
+
function he(e, t) {
|
|
557
|
+
var n;
|
|
558
|
+
let r = new c(), i = {}, a = new x(), o;
|
|
559
|
+
function s(e) {
|
|
560
|
+
let n = e.v === o ? e.w : e.v, r = a.priority(n);
|
|
561
|
+
if (r !== void 0) {
|
|
537
562
|
let s = t(e);
|
|
538
|
-
s <
|
|
563
|
+
s < r && (i[n] = o, a.decrease(n, s));
|
|
539
564
|
}
|
|
540
565
|
}
|
|
541
|
-
if (e.nodeCount() === 0) return
|
|
566
|
+
if (e.nodeCount() === 0) return r;
|
|
542
567
|
e.nodes().forEach(function(e) {
|
|
543
|
-
|
|
544
|
-
})
|
|
545
|
-
let
|
|
546
|
-
|
|
547
|
-
|
|
568
|
+
a.add(e, Infinity), r.setNode(e);
|
|
569
|
+
});
|
|
570
|
+
let l = e.nodes()[0];
|
|
571
|
+
l !== void 0 && a.decrease(l, 0);
|
|
572
|
+
let u = !1;
|
|
573
|
+
for (; a.size() > 0;) {
|
|
574
|
+
if (o = a.removeMin(), o in i) r.setEdge(o, i[o]);
|
|
548
575
|
else {
|
|
549
|
-
if (
|
|
550
|
-
|
|
576
|
+
if (u) throw Error("Input graph is not connected: " + e);
|
|
577
|
+
u = !0;
|
|
551
578
|
}
|
|
552
|
-
e.nodeEdges(
|
|
579
|
+
(n = e.nodeEdges(o)) == null || n.forEach(s);
|
|
553
580
|
}
|
|
554
|
-
return
|
|
581
|
+
return r;
|
|
555
582
|
}
|
|
556
|
-
function
|
|
557
|
-
return
|
|
583
|
+
function ge(e, t, n, r) {
|
|
584
|
+
return _e(e, t, n, r ?? ((t) => e.outEdges(t) ?? []));
|
|
558
585
|
}
|
|
559
|
-
function
|
|
586
|
+
function _e(e, t, n, r) {
|
|
560
587
|
if (n === void 0) return S(e, t, n, r);
|
|
561
588
|
let i = !1, a = e.nodes();
|
|
562
589
|
for (let o = 0; o < a.length; o++) {
|
|
563
|
-
let s =
|
|
564
|
-
|
|
565
|
-
|
|
590
|
+
let s = a[o];
|
|
591
|
+
if (s === void 0) continue;
|
|
592
|
+
let c = r(s);
|
|
593
|
+
for (let e = 0; e < c.length; e++) {
|
|
594
|
+
let t = c[e];
|
|
595
|
+
if (!t) continue;
|
|
596
|
+
let r = t.v === s ? t.v : t.w;
|
|
566
597
|
n({
|
|
567
598
|
v: r,
|
|
568
599
|
w: r === t.v ? t.w : t.v
|
|
569
600
|
}) < 0 && (i = !0);
|
|
570
601
|
}
|
|
571
|
-
if (i) return
|
|
602
|
+
if (i) return b(e, t, n, r);
|
|
572
603
|
}
|
|
573
604
|
return S(e, t, n, r);
|
|
574
605
|
}
|
|
575
|
-
|
|
606
|
+
var E = c;
|
|
607
|
+
function D(e, t, n, r) {
|
|
576
608
|
let i = r;
|
|
577
|
-
for (; e.hasNode(i);) i =
|
|
609
|
+
for (; e.hasNode(i);) i = M(r);
|
|
578
610
|
return n.dummy = t, e.setNode(i, n), i;
|
|
579
611
|
}
|
|
580
|
-
function
|
|
581
|
-
let t = new
|
|
612
|
+
function ve(e) {
|
|
613
|
+
let t = new E().setGraph(e.graph());
|
|
582
614
|
return e.nodes().forEach((n) => t.setNode(n, e.node(n))), e.edges().forEach((n) => {
|
|
583
615
|
let r = t.edge(n.v, n.w) || {
|
|
584
616
|
weight: 0,
|
|
@@ -590,15 +622,15 @@ function xe(e) {
|
|
|
590
622
|
});
|
|
591
623
|
}), t;
|
|
592
624
|
}
|
|
593
|
-
function
|
|
594
|
-
let t = new
|
|
625
|
+
function ye(e) {
|
|
626
|
+
let t = new E({ multigraph: e.isMultigraph() }).setGraph(e.graph());
|
|
595
627
|
return e.nodes().forEach((n) => {
|
|
596
628
|
e.children(n).length || t.setNode(n, e.node(n));
|
|
597
629
|
}), e.edges().forEach((n) => {
|
|
598
630
|
t.setEdge(n, e.edge(n));
|
|
599
631
|
}), t;
|
|
600
632
|
}
|
|
601
|
-
function
|
|
633
|
+
function O(e, t) {
|
|
602
634
|
let n = e.x, r = e.y, i = t.x - n, a = t.y - r, o = e.width / 2, s = e.height / 2;
|
|
603
635
|
if (!i && !a) throw Error("Not possible to find intersection inside of the rectangle");
|
|
604
636
|
let c, l;
|
|
@@ -607,25 +639,25 @@ function D(e, t) {
|
|
|
607
639
|
y: r + l
|
|
608
640
|
};
|
|
609
641
|
}
|
|
610
|
-
function
|
|
611
|
-
let t = j(
|
|
642
|
+
function k(e) {
|
|
643
|
+
let t = N(j(e) + 1).map(() => []);
|
|
612
644
|
return e.nodes().forEach((n) => {
|
|
613
645
|
let r = e.node(n), i = r.rank;
|
|
614
646
|
i !== void 0 && (t[i] || (t[i] = []), t[i][r.order] = n);
|
|
615
647
|
}), t;
|
|
616
648
|
}
|
|
617
|
-
function
|
|
649
|
+
function be(e) {
|
|
618
650
|
let t = e.nodes().map((t) => {
|
|
619
651
|
let n = e.node(t).rank;
|
|
620
652
|
return n === void 0 ? Number.MAX_VALUE : n;
|
|
621
|
-
}), n =
|
|
653
|
+
}), n = A(Math.min, t);
|
|
622
654
|
e.nodes().forEach((t) => {
|
|
623
655
|
let r = e.node(t);
|
|
624
656
|
Object.hasOwn(r, "rank") && (r.rank -= n);
|
|
625
657
|
});
|
|
626
658
|
}
|
|
627
|
-
function
|
|
628
|
-
let t = e.nodes().map((t) => e.node(t).rank).filter((e) => e !== void 0), n =
|
|
659
|
+
function xe(e) {
|
|
660
|
+
let t = e.nodes().map((t) => e.node(t).rank).filter((e) => e !== void 0), n = A(Math.min, t), r = [];
|
|
629
661
|
e.nodes().forEach((t) => {
|
|
630
662
|
let i = e.node(t).rank - n;
|
|
631
663
|
r[i] || (r[i] = []), r[i].push(t);
|
|
@@ -635,14 +667,14 @@ function Ce(e) {
|
|
|
635
667
|
t === void 0 && n % a !== 0 ? --i : t !== void 0 && i && t.forEach((t) => e.node(t).rank += i);
|
|
636
668
|
});
|
|
637
669
|
}
|
|
638
|
-
function
|
|
670
|
+
function Se(e, t, n, r) {
|
|
639
671
|
let i = {
|
|
640
672
|
width: 0,
|
|
641
673
|
height: 0
|
|
642
674
|
};
|
|
643
|
-
return arguments.length >= 4 && (i.rank = n, i.order = r),
|
|
675
|
+
return arguments.length >= 4 && (i.rank = n, i.order = r), D(e, "border", i, t);
|
|
644
676
|
}
|
|
645
|
-
function
|
|
677
|
+
function Ce(e, t = we) {
|
|
646
678
|
let n = [];
|
|
647
679
|
for (let r = 0; r < e.length; r += t) {
|
|
648
680
|
let i = e.slice(r, r + t);
|
|
@@ -650,18 +682,18 @@ function Te(e, t = Ee) {
|
|
|
650
682
|
}
|
|
651
683
|
return n;
|
|
652
684
|
}
|
|
653
|
-
var
|
|
654
|
-
function
|
|
655
|
-
return t.length >
|
|
685
|
+
var we = 65535;
|
|
686
|
+
function A(e, t) {
|
|
687
|
+
return t.length > we ? e(...Ce(t).map((t) => e(...t))) : e(...t);
|
|
656
688
|
}
|
|
657
|
-
function
|
|
689
|
+
function j(e) {
|
|
658
690
|
let t = e.nodes().map((t) => {
|
|
659
691
|
let n = e.node(t).rank;
|
|
660
692
|
return n === void 0 ? Number.MIN_VALUE : n;
|
|
661
693
|
});
|
|
662
|
-
return
|
|
694
|
+
return A(Math.max, t);
|
|
663
695
|
}
|
|
664
|
-
function
|
|
696
|
+
function Te(e, t) {
|
|
665
697
|
let n = {
|
|
666
698
|
lhs: [],
|
|
667
699
|
rhs: []
|
|
@@ -670,14 +702,14 @@ function Oe(e, t) {
|
|
|
670
702
|
t(e) ? n.lhs.push(e) : n.rhs.push(e);
|
|
671
703
|
}), n;
|
|
672
704
|
}
|
|
673
|
-
function
|
|
705
|
+
function Ee(e, t) {
|
|
674
706
|
return t();
|
|
675
707
|
}
|
|
676
|
-
var
|
|
677
|
-
function
|
|
678
|
-
return e + ("" + ++
|
|
708
|
+
var De = 0;
|
|
709
|
+
function M(e) {
|
|
710
|
+
return e + ("" + ++De);
|
|
679
711
|
}
|
|
680
|
-
function
|
|
712
|
+
function N(e, t, n = 1) {
|
|
681
713
|
t ?? (t = e, e = 0);
|
|
682
714
|
let r = (e) => e < t;
|
|
683
715
|
n < 0 && (r = (e) => t < e);
|
|
@@ -685,20 +717,20 @@ function j(e, t, n = 1) {
|
|
|
685
717
|
for (let t = e; r(t); t += n) i.push(t);
|
|
686
718
|
return i;
|
|
687
719
|
}
|
|
688
|
-
function
|
|
720
|
+
function P(e, t) {
|
|
689
721
|
let n = {};
|
|
690
722
|
for (let r of t) e[r] !== void 0 && (n[r] = e[r]);
|
|
691
723
|
return n;
|
|
692
724
|
}
|
|
693
|
-
function
|
|
725
|
+
function F(e, t) {
|
|
694
726
|
let n;
|
|
695
727
|
return n = typeof t == "string" ? (e) => e[t] : t, Object.entries(e).reduce((e, [t, r]) => (e[t] = n(r, t), e), {});
|
|
696
728
|
}
|
|
697
|
-
function
|
|
729
|
+
function Oe(e, t) {
|
|
698
730
|
return e.reduce((e, n, r) => (e[n] = t[r], e), {});
|
|
699
731
|
}
|
|
700
|
-
var
|
|
701
|
-
function
|
|
732
|
+
var I = "\0";
|
|
733
|
+
function ke(e, t, n) {
|
|
702
734
|
if (!(e && t && n && t.dummy === "edge" && n.dummy === "edge" && t.edgeObj && n.edgeObj && e[t.edgeObj.v] && e[n.edgeObj.v] && e[t.edgeObj.w] && e[n.edgeObj.w])) return 0;
|
|
703
735
|
let r = !0;
|
|
704
736
|
t.edgeObj.w === n.edgeObj.w && (r = !1);
|
|
@@ -707,7 +739,7 @@ function Me(e, t, n) {
|
|
|
707
739
|
let s = a[1].order ?? NaN, c = o[1].order ?? NaN;
|
|
708
740
|
return isNaN(s - c) ? 0 : s - c;
|
|
709
741
|
}
|
|
710
|
-
var
|
|
742
|
+
var Ae = class {
|
|
711
743
|
constructor() {
|
|
712
744
|
i(this, "_sentinel");
|
|
713
745
|
let e = {};
|
|
@@ -715,59 +747,59 @@ var Ne = class {
|
|
|
715
747
|
}
|
|
716
748
|
dequeue() {
|
|
717
749
|
let e = this._sentinel, t = e._prev;
|
|
718
|
-
if (t !== e) return
|
|
750
|
+
if (t !== e) return je(t), t;
|
|
719
751
|
}
|
|
720
752
|
enqueue(e) {
|
|
721
753
|
let t = this._sentinel;
|
|
722
|
-
e._prev && e._next &&
|
|
754
|
+
e._prev && e._next && je(e), e._next = t._next, t._next._prev = e, t._next = e, e._prev = t;
|
|
723
755
|
}
|
|
724
756
|
toString() {
|
|
725
757
|
let e = [], t = this._sentinel, n = t._prev;
|
|
726
|
-
for (; n !== t;) e.push(JSON.stringify(n,
|
|
758
|
+
for (; n !== t;) e.push(JSON.stringify(n, Me)), n = n._prev;
|
|
727
759
|
return "[" + e.join(", ") + "]";
|
|
728
760
|
}
|
|
729
761
|
};
|
|
730
|
-
function
|
|
762
|
+
function je(e) {
|
|
731
763
|
e._prev._next = e._next, e._next._prev = e._prev, delete e._next, delete e._prev;
|
|
732
764
|
}
|
|
733
|
-
function
|
|
765
|
+
function Me(e, t) {
|
|
734
766
|
if (e !== "_next" && e !== "_prev") return t;
|
|
735
767
|
}
|
|
736
|
-
var
|
|
737
|
-
function
|
|
768
|
+
var Ne = Ae, Pe = () => 1;
|
|
769
|
+
function Fe(e, t) {
|
|
738
770
|
if (e.nodeCount() <= 1) return [];
|
|
739
|
-
let n =
|
|
740
|
-
return
|
|
771
|
+
let n = Le(e, t || Pe);
|
|
772
|
+
return Ie(n.graph, n.buckets, n.zeroIdx).flatMap((t) => e.outEdges(t.v, t.w) || []);
|
|
741
773
|
}
|
|
742
|
-
function
|
|
774
|
+
function Ie(e, t, n) {
|
|
743
775
|
let r = [], i = t[t.length - 1], a = t[0], o;
|
|
744
776
|
for (; e.nodeCount();) {
|
|
745
|
-
for (; o = a.dequeue();)
|
|
746
|
-
for (; o = i.dequeue();)
|
|
777
|
+
for (; o = a.dequeue();) L(e, t, n, o);
|
|
778
|
+
for (; o = i.dequeue();) L(e, t, n, o);
|
|
747
779
|
if (e.nodeCount()) {
|
|
748
780
|
for (let i = t.length - 2; i > 0; --i) if (o = t[i]?.dequeue(), o) {
|
|
749
|
-
r = r.concat(
|
|
781
|
+
r = r.concat(L(e, t, n, o, !0) || []);
|
|
750
782
|
break;
|
|
751
783
|
}
|
|
752
784
|
}
|
|
753
785
|
}
|
|
754
786
|
return r;
|
|
755
787
|
}
|
|
756
|
-
function
|
|
788
|
+
function L(e, t, n, r, i) {
|
|
757
789
|
let a = [], o = i ? a : void 0;
|
|
758
790
|
return (e.inEdges(r.v) || []).forEach((r) => {
|
|
759
791
|
let o = e.edge(r), s = e.node(r.v);
|
|
760
792
|
i && a.push({
|
|
761
793
|
v: r.v,
|
|
762
794
|
w: r.w
|
|
763
|
-
}), s.out -= o,
|
|
795
|
+
}), s.out -= o, R(t, n, s);
|
|
764
796
|
}), (e.outEdges(r.v) || []).forEach((r) => {
|
|
765
797
|
let i = e.edge(r), a = r.w, o = e.node(a);
|
|
766
|
-
o.in -= i,
|
|
798
|
+
o.in -= i, R(t, n, o);
|
|
767
799
|
}), e.removeNode(r.v), o;
|
|
768
800
|
}
|
|
769
|
-
function
|
|
770
|
-
let n = new
|
|
801
|
+
function Le(e, t) {
|
|
802
|
+
let n = new E(), r = 0, i = 0;
|
|
771
803
|
e.nodes().forEach((e) => {
|
|
772
804
|
n.setNode(e, {
|
|
773
805
|
v: e,
|
|
@@ -780,34 +812,34 @@ function Be(e, t) {
|
|
|
780
812
|
let c = n.node(e.v), l = n.node(e.w);
|
|
781
813
|
i = Math.max(i, c.out += o), r = Math.max(r, l.in += o);
|
|
782
814
|
});
|
|
783
|
-
let a =
|
|
815
|
+
let a = Re(i + r + 3).map(() => new Ne()), o = r + 1;
|
|
784
816
|
return n.nodes().forEach((e) => {
|
|
785
|
-
|
|
817
|
+
R(a, o, n.node(e));
|
|
786
818
|
}), {
|
|
787
819
|
graph: n,
|
|
788
820
|
buckets: a,
|
|
789
821
|
zeroIdx: o
|
|
790
822
|
};
|
|
791
823
|
}
|
|
792
|
-
function
|
|
824
|
+
function R(e, t, n) {
|
|
793
825
|
var r, i, a;
|
|
794
826
|
n.out ? n.in ? (a = e[n.out - n.in + t]) == null || a.enqueue(n) : (i = e[e.length - 1]) == null || i.enqueue(n) : (r = e[0]) == null || r.enqueue(n);
|
|
795
827
|
}
|
|
796
|
-
function
|
|
828
|
+
function Re(e) {
|
|
797
829
|
let t = [];
|
|
798
830
|
for (let n = 0; n < e; n++) t.push(n);
|
|
799
831
|
return t;
|
|
800
832
|
}
|
|
801
|
-
function
|
|
802
|
-
(e.graph().acyclicer === "greedy" ?
|
|
833
|
+
function ze(e, t) {
|
|
834
|
+
(e.graph().acyclicer === "greedy" ? Fe(e, n(e)) : Be(e, t ?? null)).forEach((t) => {
|
|
803
835
|
let n = e.edge(t);
|
|
804
|
-
e.removeEdge(t), n.forwardName = t.name, n.reversed = !0, e.setEdge(t.w, t.v, n,
|
|
836
|
+
e.removeEdge(t), n.forwardName = t.name, n.reversed = !0, e.setEdge(t.w, t.v, n, M("rev"));
|
|
805
837
|
});
|
|
806
838
|
function n(e) {
|
|
807
839
|
return (t) => e.edge(t).weight;
|
|
808
840
|
}
|
|
809
841
|
}
|
|
810
|
-
function
|
|
842
|
+
function Be(e, t) {
|
|
811
843
|
let n = [], r = {}, i = {};
|
|
812
844
|
function a(t) {
|
|
813
845
|
Object.hasOwn(i, t) || (i[t] = !0, r[t] = !0, e.outEdges(t).forEach((e) => {
|
|
@@ -817,13 +849,13 @@ function Ue(e, t) {
|
|
|
817
849
|
function o(a) {
|
|
818
850
|
var s;
|
|
819
851
|
Object.hasOwn(i, a) || (i[a] = !0, r[a] = !0, (s = e.outEdges(a)) == null || s.forEach((i) => {
|
|
820
|
-
Object.hasOwn(r, i.w) || t.node(a)?.rank > t.node(i.w)?.rank &&
|
|
852
|
+
Object.hasOwn(r, i.w) || t.node(a)?.rank > t.node(i.w)?.rank && He(e, i.w, i) ? n.push(i) : o(i.w);
|
|
821
853
|
}), delete r[a]);
|
|
822
854
|
}
|
|
823
855
|
let s = a;
|
|
824
856
|
return t && typeof t.node == "function" && (s = o), e.sources().forEach(s), e.nodes().forEach(s), n;
|
|
825
857
|
}
|
|
826
|
-
function
|
|
858
|
+
function Ve(e) {
|
|
827
859
|
e.edges().forEach((t) => {
|
|
828
860
|
let n = e.edge(t);
|
|
829
861
|
if (n.reversed) {
|
|
@@ -833,7 +865,7 @@ function We(e) {
|
|
|
833
865
|
}
|
|
834
866
|
});
|
|
835
867
|
}
|
|
836
|
-
function
|
|
868
|
+
function He(e, t, n) {
|
|
837
869
|
let r = /* @__PURE__ */ new Set();
|
|
838
870
|
function i(t) {
|
|
839
871
|
if (e.sources().includes(t)) return !0;
|
|
@@ -843,10 +875,10 @@ function Ge(e, t, n) {
|
|
|
843
875
|
}
|
|
844
876
|
return i(t);
|
|
845
877
|
}
|
|
846
|
-
function
|
|
847
|
-
e.graph().dummyChains = [], e.edges().forEach((t) =>
|
|
878
|
+
function Ue(e) {
|
|
879
|
+
e.graph().dummyChains = [], e.edges().forEach((t) => We(e, t));
|
|
848
880
|
}
|
|
849
|
-
function
|
|
881
|
+
function We(e, t) {
|
|
850
882
|
let n = t.v, r = e.node(n).rank, i = t.w, a = e.node(i).rank, o = t.name, s = e.edge(t), c = s.labelRank;
|
|
851
883
|
if (a === r + 1) return;
|
|
852
884
|
e.removeEdge(t);
|
|
@@ -857,10 +889,10 @@ function qe(e, t) {
|
|
|
857
889
|
edgeLabel: s,
|
|
858
890
|
edgeObj: t,
|
|
859
891
|
rank: r
|
|
860
|
-
}, l =
|
|
892
|
+
}, l = D(e, "edge", u, "_d"), r === c && (u.width = s.width, u.height = s.height, u.dummy = "edge-label", u.labelpos = s.labelpos), e.setEdge(n, l, { weight: s.weight }, o), d === 0 && e.graph().dummyChains.push(l), n = l;
|
|
861
893
|
e.setEdge(n, i, { weight: s.weight }, o);
|
|
862
894
|
}
|
|
863
|
-
function
|
|
895
|
+
function Ge(e) {
|
|
864
896
|
e.graph().dummyChains.forEach((t) => {
|
|
865
897
|
let n = e.node(t), r = n.edgeLabel, i;
|
|
866
898
|
for (e.setEdge(n.edgeObj, r); n.dummy;) i = e.successors(t)[0], e.removeNode(t), r.points.push({
|
|
@@ -869,67 +901,67 @@ function Je(e) {
|
|
|
869
901
|
}), n.dummy === "edge-label" && (r.x = n.x, r.y = n.y, r.width = n.width, r.height = n.height), t = i, n = e.node(t);
|
|
870
902
|
});
|
|
871
903
|
}
|
|
872
|
-
function
|
|
904
|
+
function z(e) {
|
|
873
905
|
let t = {};
|
|
874
906
|
function n(r) {
|
|
875
907
|
let i = e.node(r);
|
|
876
908
|
if (Object.hasOwn(t, r)) return i.rank;
|
|
877
909
|
t[r] = !0;
|
|
878
|
-
let a = e.outEdges(r), o = a ? a.map((t) => t == null ? Infinity : n(t.w) - e.edge(t).minlen) : [], s =
|
|
910
|
+
let a = e.outEdges(r), o = a ? a.map((t) => t == null ? Infinity : n(t.w) - e.edge(t).minlen) : [], s = A(Math.min, o);
|
|
879
911
|
return s === Infinity && (s = 0), i.rank = s;
|
|
880
912
|
}
|
|
881
913
|
e.sources().forEach(n);
|
|
882
914
|
}
|
|
883
|
-
function
|
|
915
|
+
function B(e, t) {
|
|
884
916
|
return e.node(t.w).rank - e.node(t.v).rank - e.edge(t).minlen;
|
|
885
917
|
}
|
|
886
|
-
var
|
|
887
|
-
function
|
|
888
|
-
let t = new
|
|
918
|
+
var V = Ke;
|
|
919
|
+
function Ke(e) {
|
|
920
|
+
let t = new E({ directed: !1 }), n = e.nodes();
|
|
889
921
|
if (n.length === 0) throw Error("Graph must have at least one node");
|
|
890
922
|
let r = n[0], i = e.nodeCount();
|
|
891
923
|
t.setNode(r, {});
|
|
892
924
|
let a, o;
|
|
893
|
-
for (;
|
|
925
|
+
for (; qe(t, e) < i && (a = Je(t, e), a);) o = t.hasNode(a.v) ? B(e, a) : -B(e, a), Ye(t, e, o);
|
|
894
926
|
return t;
|
|
895
927
|
}
|
|
896
|
-
function
|
|
928
|
+
function qe(e, t) {
|
|
897
929
|
function n(r) {
|
|
898
930
|
let i = t.nodeEdges(r);
|
|
899
931
|
i && i.forEach((i) => {
|
|
900
932
|
let a = i.v, o = r === a ? i.w : a;
|
|
901
|
-
!e.hasNode(o) && !
|
|
933
|
+
!e.hasNode(o) && !B(t, i) && (e.setNode(o, {}), e.setEdge(r, o, {}), n(o));
|
|
902
934
|
});
|
|
903
935
|
}
|
|
904
936
|
return e.nodes().forEach(n), e.nodeCount();
|
|
905
937
|
}
|
|
906
|
-
function
|
|
938
|
+
function Je(e, t) {
|
|
907
939
|
return t.edges().reduce((n, r) => {
|
|
908
940
|
let i = Infinity;
|
|
909
|
-
return e.hasNode(r.v) !== e.hasNode(r.w) && (i =
|
|
941
|
+
return e.hasNode(r.v) !== e.hasNode(r.w) && (i = B(t, r)), i < n[0] ? [i, r] : n;
|
|
910
942
|
}, [Infinity, null])[1];
|
|
911
943
|
}
|
|
912
|
-
function
|
|
944
|
+
function Ye(e, t, n) {
|
|
913
945
|
e.nodes().forEach((e) => t.node(e).rank += n);
|
|
914
946
|
}
|
|
915
|
-
var { preorder:
|
|
916
|
-
|
|
917
|
-
function
|
|
918
|
-
e =
|
|
919
|
-
let t =
|
|
920
|
-
|
|
947
|
+
var { preorder: Xe, postorder: Ze } = v, Qe = H;
|
|
948
|
+
H.initLowLimValues = G, H.initCutValues = U, H.calcCutValue = W, H.leaveEdge = q, H.enterEdge = J, H.exchangeEdges = et;
|
|
949
|
+
function H(e) {
|
|
950
|
+
e = ve(e), z(e);
|
|
951
|
+
let t = V(e);
|
|
952
|
+
G(t), U(t, e);
|
|
921
953
|
let n, r;
|
|
922
|
-
for (; n =
|
|
954
|
+
for (; n = q(t);) r = J(t, e, n), et(t, e, n, r);
|
|
923
955
|
}
|
|
924
|
-
function
|
|
925
|
-
let n =
|
|
926
|
-
n = n.slice(0, n.length - 1), n.forEach((n) =>
|
|
956
|
+
function U(e, t) {
|
|
957
|
+
let n = Ze(e, e.nodes());
|
|
958
|
+
n = n.slice(0, n.length - 1), n.forEach((n) => $e(e, t, n));
|
|
927
959
|
}
|
|
928
|
-
function
|
|
960
|
+
function $e(e, t, n) {
|
|
929
961
|
let r = e.node(n).parent, i = e.edge(n, r);
|
|
930
|
-
i.cutvalue =
|
|
962
|
+
i.cutvalue = W(e, t, n);
|
|
931
963
|
}
|
|
932
|
-
function
|
|
964
|
+
function W(e, t, n) {
|
|
933
965
|
let r = e.node(n).parent, i = !0, a = t.edge(n, r), o = 0;
|
|
934
966
|
a ||= (i = !1, t.edge(r, n)), o = a.weight;
|
|
935
967
|
let s = t.nodeEdges(n);
|
|
@@ -937,82 +969,82 @@ function H(e, t, n) {
|
|
|
937
969
|
let s = a.v === n, c = s ? a.w : a.v;
|
|
938
970
|
if (c !== r) {
|
|
939
971
|
let r = s === i, l = t.edge(a).weight;
|
|
940
|
-
if (o += r ? l : -l,
|
|
972
|
+
if (o += r ? l : -l, nt(e, n, c)) {
|
|
941
973
|
let t = e.edge(n, c).cutvalue;
|
|
942
974
|
o += r ? -t : t;
|
|
943
975
|
}
|
|
944
976
|
}
|
|
945
977
|
}), o;
|
|
946
978
|
}
|
|
947
|
-
function
|
|
948
|
-
arguments.length < 2 && (t = e.nodes()[0]),
|
|
979
|
+
function G(e, t) {
|
|
980
|
+
arguments.length < 2 && (t = e.nodes()[0]), K(e, {}, 1, t);
|
|
949
981
|
}
|
|
950
|
-
function
|
|
982
|
+
function K(e, t, n, r, i) {
|
|
951
983
|
let a = n, o = e.node(r);
|
|
952
984
|
t[r] = !0;
|
|
953
985
|
let s = e.neighbors(r);
|
|
954
986
|
return s && s.forEach((i) => {
|
|
955
|
-
Object.hasOwn(t, i) || (n =
|
|
987
|
+
Object.hasOwn(t, i) || (n = K(e, t, n, i, r));
|
|
956
988
|
}), o.low = a, o.lim = n++, i ? o.parent = i : delete o.parent, n;
|
|
957
989
|
}
|
|
958
|
-
function
|
|
990
|
+
function q(e) {
|
|
959
991
|
return e.edges().find((t) => e.edge(t).cutvalue < 0);
|
|
960
992
|
}
|
|
961
|
-
function
|
|
993
|
+
function J(e, t, n) {
|
|
962
994
|
let r = n.v, i = n.w;
|
|
963
995
|
t.hasEdge(r, i) || (r = n.w, i = n.v);
|
|
964
996
|
let a = e.node(r), o = e.node(i), s = a, c = !1;
|
|
965
|
-
return a.lim > o.lim && (s = o, c = !0), t.edges().filter((t) => c ===
|
|
997
|
+
return a.lim > o.lim && (s = o, c = !0), t.edges().filter((t) => c === rt(e, e.node(t.v), s) && c !== rt(e, e.node(t.w), s)).reduce((e, n) => B(t, n) < B(t, e) ? n : e);
|
|
966
998
|
}
|
|
967
|
-
function
|
|
999
|
+
function et(e, t, n, r) {
|
|
968
1000
|
let i = n.v, a = n.w;
|
|
969
|
-
e.removeEdge(i, a), e.setEdge(r.v, r.w, {}),
|
|
1001
|
+
e.removeEdge(i, a), e.setEdge(r.v, r.w, {}), G(e), U(e, t), tt(e, t);
|
|
970
1002
|
}
|
|
971
|
-
function
|
|
1003
|
+
function tt(e, t) {
|
|
972
1004
|
let n = e.nodes().find((t) => !e.node(t).parent);
|
|
973
1005
|
if (!n) return;
|
|
974
|
-
let r =
|
|
1006
|
+
let r = Xe(e, [n]);
|
|
975
1007
|
r = r.slice(1), r.forEach((n) => {
|
|
976
1008
|
let r = e.node(n).parent, i = t.edge(n, r), a = !1;
|
|
977
1009
|
i || (i = t.edge(r, n), a = !0), t.node(n).rank = t.node(r).rank + (a ? i.minlen : -i.minlen);
|
|
978
1010
|
});
|
|
979
1011
|
}
|
|
980
|
-
function
|
|
1012
|
+
function nt(e, t, n) {
|
|
981
1013
|
return e.hasEdge(t, n);
|
|
982
1014
|
}
|
|
983
|
-
function
|
|
1015
|
+
function rt(e, t, n) {
|
|
984
1016
|
return n.low <= t.lim && t.lim <= n.lim;
|
|
985
1017
|
}
|
|
986
|
-
var
|
|
987
|
-
function
|
|
1018
|
+
var it = at;
|
|
1019
|
+
function at(e) {
|
|
988
1020
|
let t = e.graph().ranker;
|
|
989
1021
|
if (typeof t == "function") return t(e);
|
|
990
1022
|
switch (t) {
|
|
991
1023
|
case "network-simplex":
|
|
992
|
-
|
|
1024
|
+
Y(e);
|
|
993
1025
|
break;
|
|
994
1026
|
case "tight-tree":
|
|
995
|
-
|
|
1027
|
+
st(e);
|
|
996
1028
|
break;
|
|
997
1029
|
case "longest-path":
|
|
998
|
-
|
|
1030
|
+
ot(e);
|
|
999
1031
|
break;
|
|
1000
1032
|
case "none": break;
|
|
1001
|
-
default:
|
|
1033
|
+
default: Y(e);
|
|
1002
1034
|
}
|
|
1003
1035
|
}
|
|
1004
|
-
var
|
|
1005
|
-
function
|
|
1006
|
-
|
|
1036
|
+
var ot = z;
|
|
1037
|
+
function st(e) {
|
|
1038
|
+
z(e), V(e);
|
|
1007
1039
|
}
|
|
1008
|
-
function
|
|
1009
|
-
|
|
1040
|
+
function Y(e) {
|
|
1041
|
+
Qe(e);
|
|
1010
1042
|
}
|
|
1011
|
-
var
|
|
1012
|
-
function
|
|
1013
|
-
let t =
|
|
1043
|
+
var ct = lt;
|
|
1044
|
+
function lt(e) {
|
|
1045
|
+
let t = dt(e), n = e.graph();
|
|
1014
1046
|
Array.isArray(n.dummyChains) && n.dummyChains.forEach((n) => {
|
|
1015
|
-
let r = e.node(n), i = r.edgeObj, a =
|
|
1047
|
+
let r = e.node(n), i = r.edgeObj, a = ut(e, t, i.v, i.w), o = a.path, s = a.lca, c = 0, l = o[c], u = !0;
|
|
1016
1048
|
for (; n !== i.w;) {
|
|
1017
1049
|
if (r = e.node(n), u) {
|
|
1018
1050
|
for (; (l = o[c]) !== s && e.node(l).maxRank < r.rank;) c++;
|
|
@@ -1026,7 +1058,7 @@ function ft(e) {
|
|
|
1026
1058
|
}
|
|
1027
1059
|
});
|
|
1028
1060
|
}
|
|
1029
|
-
function
|
|
1061
|
+
function ut(e, t, n, r) {
|
|
1030
1062
|
let i = [], a = [], o = Math.min(t[n].low, t[r].low), s = Math.max(t[n].lim, t[r].lim), c;
|
|
1031
1063
|
c = n;
|
|
1032
1064
|
do
|
|
@@ -1039,7 +1071,7 @@ function pt(e, t, n, r) {
|
|
|
1039
1071
|
lca: l
|
|
1040
1072
|
};
|
|
1041
1073
|
}
|
|
1042
|
-
function
|
|
1074
|
+
function dt(e) {
|
|
1043
1075
|
let t = {}, n = 0;
|
|
1044
1076
|
function r(i) {
|
|
1045
1077
|
let a = n;
|
|
@@ -1048,17 +1080,17 @@ function mt(e) {
|
|
|
1048
1080
|
lim: n++
|
|
1049
1081
|
};
|
|
1050
1082
|
}
|
|
1051
|
-
return e.children(
|
|
1083
|
+
return e.children(I).forEach(r), t;
|
|
1052
1084
|
}
|
|
1053
|
-
function
|
|
1054
|
-
let t =
|
|
1085
|
+
function ft(e) {
|
|
1086
|
+
let t = D(e, "root", {}, "_root"), n = mt(e), r = Object.values(n), i = A(Math.max, r) - 1, a = 2 * i + 1;
|
|
1055
1087
|
e.graph().nestingRoot = t, e.edges().forEach((t) => e.edge(t).minlen *= a);
|
|
1056
|
-
let o =
|
|
1057
|
-
e.children(
|
|
1058
|
-
|
|
1088
|
+
let o = ht(e) + 1;
|
|
1089
|
+
e.children(I).forEach((r) => {
|
|
1090
|
+
pt(e, t, a, o, i, n, r);
|
|
1059
1091
|
}), e.graph().nodeRankFactor = a;
|
|
1060
1092
|
}
|
|
1061
|
-
function
|
|
1093
|
+
function pt(e, t, n, r, i, a, o) {
|
|
1062
1094
|
let s = e.children(o);
|
|
1063
1095
|
if (!s.length) {
|
|
1064
1096
|
o !== t && e.setEdge(t, o, {
|
|
@@ -1067,9 +1099,9 @@ function gt(e, t, n, r, i, a, o) {
|
|
|
1067
1099
|
});
|
|
1068
1100
|
return;
|
|
1069
1101
|
}
|
|
1070
|
-
let c =
|
|
1102
|
+
let c = Se(e, "_bt"), l = Se(e, "_bb"), u = e.node(o);
|
|
1071
1103
|
e.setParent(c, o), u.borderTop = c, e.setParent(l, o), u.borderBottom = l, s.forEach((s) => {
|
|
1072
|
-
|
|
1104
|
+
pt(e, t, n, r, i, a, s);
|
|
1073
1105
|
let u = e.node(s), d = u.borderTop ? u.borderTop : s, f = u.borderBottom ? u.borderBottom : s, p = u.borderTop ? r : 2 * r, m = d === f ? i - (a[o] ?? 0) + 1 : 1;
|
|
1074
1106
|
e.setEdge(c, d, {
|
|
1075
1107
|
weight: p,
|
|
@@ -1085,81 +1117,81 @@ function gt(e, t, n, r, i, a, o) {
|
|
|
1085
1117
|
minlen: i + (a[o] ?? 0)
|
|
1086
1118
|
});
|
|
1087
1119
|
}
|
|
1088
|
-
function
|
|
1120
|
+
function mt(e) {
|
|
1089
1121
|
let t = {};
|
|
1090
1122
|
function n(r, i) {
|
|
1091
1123
|
let a = e.children(r);
|
|
1092
1124
|
a && a.length && a.forEach((e) => n(e, i + 1)), t[r] = i;
|
|
1093
1125
|
}
|
|
1094
|
-
return e.children(
|
|
1126
|
+
return e.children(I).forEach((e) => n(e, 1)), t;
|
|
1095
1127
|
}
|
|
1096
|
-
function
|
|
1128
|
+
function ht(e) {
|
|
1097
1129
|
return e.edges().reduce((t, n) => t + e.edge(n).weight, 0);
|
|
1098
1130
|
}
|
|
1099
|
-
function
|
|
1131
|
+
function gt(e) {
|
|
1100
1132
|
let t = e.graph();
|
|
1101
1133
|
e.removeNode(t.nestingRoot), delete t.nestingRoot, e.edges().forEach((t) => {
|
|
1102
1134
|
e.edge(t).nestingEdge && e.removeEdge(t);
|
|
1103
1135
|
});
|
|
1104
1136
|
}
|
|
1105
|
-
var
|
|
1106
|
-
function
|
|
1137
|
+
var _t = vt;
|
|
1138
|
+
function vt(e) {
|
|
1107
1139
|
function t(n) {
|
|
1108
1140
|
let r = e.children(n), i = e.node(n);
|
|
1109
1141
|
if (r.length && r.forEach(t), i && Object.hasOwn(i, "minRank")) {
|
|
1110
1142
|
i.borderLeft = [], i.borderRight = [];
|
|
1111
|
-
for (let t = i.minRank, r = i.maxRank + 1; t < r; ++t)
|
|
1143
|
+
for (let t = i.minRank, r = i.maxRank + 1; t < r; ++t) yt(e, "borderLeft", "_bl", n, i, t), yt(e, "borderRight", "_br", n, i, t);
|
|
1112
1144
|
}
|
|
1113
1145
|
}
|
|
1114
|
-
e.children(
|
|
1146
|
+
e.children(I).forEach(t);
|
|
1115
1147
|
}
|
|
1116
|
-
function
|
|
1148
|
+
function yt(e, t, n, r, i, a) {
|
|
1117
1149
|
let o = {
|
|
1118
1150
|
width: 0,
|
|
1119
1151
|
height: 0,
|
|
1120
1152
|
rank: a,
|
|
1121
1153
|
borderType: t
|
|
1122
|
-
}, s = i[t][a - 1], c =
|
|
1154
|
+
}, s = i[t][a - 1], c = D(e, "border", o, n);
|
|
1123
1155
|
i[t][a] = c, e.setParent(c, r), s && e.setEdge(s, c, { weight: 1 });
|
|
1124
1156
|
}
|
|
1125
|
-
function
|
|
1157
|
+
function bt(e) {
|
|
1126
1158
|
let t = e.graph().rankdir?.toLowerCase();
|
|
1127
|
-
(t === "lr" || t === "rl") &&
|
|
1159
|
+
(t === "lr" || t === "rl") && St(e);
|
|
1128
1160
|
}
|
|
1129
|
-
function
|
|
1161
|
+
function xt(e) {
|
|
1130
1162
|
let t = e.graph().rankdir?.toLowerCase();
|
|
1131
|
-
(t === "bt" || t === "rl") &&
|
|
1163
|
+
(t === "bt" || t === "rl") && wt(e), (t === "lr" || t === "rl") && (Tt(e), St(e));
|
|
1132
1164
|
}
|
|
1133
|
-
function
|
|
1134
|
-
e.nodes().forEach((t) =>
|
|
1165
|
+
function St(e) {
|
|
1166
|
+
e.nodes().forEach((t) => Ct(e.node(t))), e.edges().forEach((t) => Ct(e.edge(t)));
|
|
1135
1167
|
}
|
|
1136
|
-
function
|
|
1168
|
+
function Ct(e) {
|
|
1137
1169
|
let t = e.width;
|
|
1138
1170
|
e.width = e.height, e.height = t;
|
|
1139
1171
|
}
|
|
1140
|
-
function
|
|
1141
|
-
e.nodes().forEach((t) =>
|
|
1172
|
+
function wt(e) {
|
|
1173
|
+
e.nodes().forEach((t) => X(e.node(t))), e.edges().forEach((t) => {
|
|
1142
1174
|
var n;
|
|
1143
1175
|
let r = e.edge(t);
|
|
1144
|
-
(n = r.points) == null || n.forEach(
|
|
1176
|
+
(n = r.points) == null || n.forEach(X), Object.hasOwn(r, "y") && X(r);
|
|
1145
1177
|
});
|
|
1146
1178
|
}
|
|
1147
|
-
function
|
|
1179
|
+
function X(e) {
|
|
1148
1180
|
e.y = -e.y;
|
|
1149
1181
|
}
|
|
1150
|
-
function
|
|
1151
|
-
e.nodes().forEach((t) =>
|
|
1182
|
+
function Tt(e) {
|
|
1183
|
+
e.nodes().forEach((t) => Z(e.node(t))), e.edges().forEach((t) => {
|
|
1152
1184
|
var n;
|
|
1153
1185
|
let r = e.edge(t);
|
|
1154
|
-
(n = r.points) == null || n.forEach(
|
|
1186
|
+
(n = r.points) == null || n.forEach(Z), Object.hasOwn(r, "x") && Z(r);
|
|
1155
1187
|
});
|
|
1156
1188
|
}
|
|
1157
|
-
function
|
|
1189
|
+
function Z(e) {
|
|
1158
1190
|
let t = e.x;
|
|
1159
1191
|
e.x = e.y, e.y = t;
|
|
1160
1192
|
}
|
|
1161
|
-
function
|
|
1162
|
-
let n = {}, r = e.nodes().filter((t) => !e.children(t).length), i = r.map((t) => e.node(t).rank), a =
|
|
1193
|
+
function Et(e, t = null) {
|
|
1194
|
+
let n = {}, r = e.nodes().filter((t) => !e.children(t).length), i = r.map((t) => e.node(t).rank), a = N(A(Math.max, i) + 1).map(() => []);
|
|
1163
1195
|
function o(t) {
|
|
1164
1196
|
if (n[t]) return;
|
|
1165
1197
|
n[t] = !0;
|
|
@@ -1170,17 +1202,17 @@ function kt(e, t = null) {
|
|
|
1170
1202
|
}
|
|
1171
1203
|
r.sort((t, n) => e.node(t).rank - e.node(n).rank).forEach(o);
|
|
1172
1204
|
function s(n, r) {
|
|
1173
|
-
return
|
|
1205
|
+
return ke(t, e.node(n), e.node(r));
|
|
1174
1206
|
}
|
|
1175
1207
|
return a;
|
|
1176
1208
|
}
|
|
1177
|
-
function
|
|
1209
|
+
function Dt(e, t) {
|
|
1178
1210
|
let n = 0;
|
|
1179
|
-
for (let r = 1; r < t.length; ++r) n +=
|
|
1211
|
+
for (let r = 1; r < t.length; ++r) n += Ot(e, t[r - 1], t[r]);
|
|
1180
1212
|
return n;
|
|
1181
1213
|
}
|
|
1182
|
-
function
|
|
1183
|
-
let r =
|
|
1214
|
+
function Ot(e, t, n) {
|
|
1215
|
+
let r = Oe(n, n.map((e, t) => t)), i = t.flatMap((t) => {
|
|
1184
1216
|
let n = e.outEdges(t);
|
|
1185
1217
|
return n ? n.map((t) => ({
|
|
1186
1218
|
pos: r[t.w],
|
|
@@ -1199,7 +1231,7 @@ function jt(e, t, n) {
|
|
|
1199
1231
|
c += e.weight * n;
|
|
1200
1232
|
}), c;
|
|
1201
1233
|
}
|
|
1202
|
-
function
|
|
1234
|
+
function kt(e, t = []) {
|
|
1203
1235
|
return t.map((t) => {
|
|
1204
1236
|
let n = e.inEdges(t);
|
|
1205
1237
|
if (!n || !n.length) return { v: t };
|
|
@@ -1222,7 +1254,7 @@ function Mt(e, t = []) {
|
|
|
1222
1254
|
}
|
|
1223
1255
|
});
|
|
1224
1256
|
}
|
|
1225
|
-
function
|
|
1257
|
+
function At(e, t) {
|
|
1226
1258
|
let n = {};
|
|
1227
1259
|
return e.forEach((e, t) => {
|
|
1228
1260
|
let r = {
|
|
@@ -1236,13 +1268,13 @@ function Nt(e, t) {
|
|
|
1236
1268
|
}), t.edges().forEach((e) => {
|
|
1237
1269
|
let t = n[e.v], r = n[e.w];
|
|
1238
1270
|
t !== void 0 && r !== void 0 && (r.indegree++, t.out.push(r));
|
|
1239
|
-
}),
|
|
1271
|
+
}), jt(Object.values(n).filter((e) => !e.indegree));
|
|
1240
1272
|
}
|
|
1241
|
-
function
|
|
1273
|
+
function jt(e) {
|
|
1242
1274
|
let t = [];
|
|
1243
1275
|
function n(e) {
|
|
1244
1276
|
return (t) => {
|
|
1245
|
-
t.merged || (t.barycenter === void 0 || e.barycenter === void 0 || t.barycenter >= e.barycenter) &&
|
|
1277
|
+
t.merged || (t.barycenter === void 0 || e.barycenter === void 0 || t.barycenter >= e.barycenter) && Mt(e, t);
|
|
1246
1278
|
};
|
|
1247
1279
|
}
|
|
1248
1280
|
function r(t) {
|
|
@@ -1254,63 +1286,63 @@ function Pt(e) {
|
|
|
1254
1286
|
let i = e.pop();
|
|
1255
1287
|
t.push(i), i.in.reverse().forEach(n(i)), i.out.forEach(r(i));
|
|
1256
1288
|
}
|
|
1257
|
-
return t.filter((e) => !e.merged).map((e) =>
|
|
1289
|
+
return t.filter((e) => !e.merged).map((e) => P(e, [
|
|
1258
1290
|
"vs",
|
|
1259
1291
|
"i",
|
|
1260
1292
|
"barycenter",
|
|
1261
1293
|
"weight"
|
|
1262
1294
|
]));
|
|
1263
1295
|
}
|
|
1264
|
-
function
|
|
1296
|
+
function Mt(e, t) {
|
|
1265
1297
|
let n = 0, r = 0;
|
|
1266
1298
|
e.weight && (n += e.barycenter * e.weight, r += e.weight), t.weight && (n += t.barycenter * t.weight, r += t.weight), e.vs = t.vs.concat(e.vs), e.barycenter = n / r, e.weight = r, e.i = Math.min(t.i, e.i), t.merged = !0;
|
|
1267
1299
|
}
|
|
1268
|
-
function
|
|
1300
|
+
function Nt(e, t, n, r, i) {
|
|
1269
1301
|
let a = {}, o = null, s = null, c = i;
|
|
1270
1302
|
typeof t == "boolean" ? (c = t, a = {}) : t && (a = t, o = n ?? null, s = r ?? null);
|
|
1271
|
-
let l =
|
|
1272
|
-
u.sort(
|
|
1303
|
+
let l = Te(e, (e) => Object.hasOwn(e, "barycenter")), u = l.lhs, d = l.rhs.sort((e, t) => t.i - e.i), f = [], p = 0, m = 0, h = 0;
|
|
1304
|
+
u.sort(Ft(s, o, !!c));
|
|
1273
1305
|
for (let [e, t] of Object.entries(a)) {
|
|
1274
1306
|
let n = u.findIndex((t) => t.vs[0] === e);
|
|
1275
1307
|
u.splice(n + 1, 0, t);
|
|
1276
1308
|
}
|
|
1277
|
-
h =
|
|
1278
|
-
h += e.vs.length, f.push(e.vs), p += e.barycenter * e.weight, m += e.weight, h =
|
|
1309
|
+
h = Pt(f, d, h), u.forEach((e) => {
|
|
1310
|
+
h += e.vs.length, f.push(e.vs), p += e.barycenter * e.weight, m += e.weight, h = Pt(f, d, h);
|
|
1279
1311
|
});
|
|
1280
1312
|
let g = { vs: f.flat(1) };
|
|
1281
1313
|
return m && (g.barycenter = p / m, g.weight = m), g;
|
|
1282
1314
|
}
|
|
1283
|
-
function
|
|
1315
|
+
function Pt(e, t, n) {
|
|
1284
1316
|
let r;
|
|
1285
1317
|
for (; t.length && (r = t[t.length - 1]).i <= n;) t.pop(), e.push(r.vs), n++;
|
|
1286
1318
|
return n;
|
|
1287
1319
|
}
|
|
1288
|
-
function
|
|
1320
|
+
function Ft(e, t, n) {
|
|
1289
1321
|
return (r, i) => {
|
|
1290
1322
|
if (r.barycenter < i.barycenter) return -1;
|
|
1291
1323
|
if (r.barycenter > i.barycenter) return 1;
|
|
1292
1324
|
if (e && (typeof r.vs[0] == "string" || typeof i.vs[0] == "string")) {
|
|
1293
|
-
let n =
|
|
1325
|
+
let n = ke(t, e.node(r.vs[0]), e.node(i.vs[0]));
|
|
1294
1326
|
if (n !== 0) return n;
|
|
1295
1327
|
}
|
|
1296
1328
|
return n ? i.i - r.i : r.i - i.i;
|
|
1297
1329
|
};
|
|
1298
1330
|
}
|
|
1299
|
-
function
|
|
1331
|
+
function It(e, t, n, r, i) {
|
|
1300
1332
|
var a, o;
|
|
1301
1333
|
let s = null, c = i;
|
|
1302
1334
|
typeof r == "boolean" ? (c = r, s = null) : r !== void 0 && (s = r);
|
|
1303
1335
|
let l = e.children(t), u = e.node(t), d = u ? u.borderLeft : void 0, f = u ? u.borderRight : void 0, p = {};
|
|
1304
1336
|
d && (l = l.filter((e) => e !== d && e !== f));
|
|
1305
|
-
let m =
|
|
1337
|
+
let m = kt(e, l);
|
|
1306
1338
|
m.forEach((t) => {
|
|
1307
1339
|
if (e.children(t.v).length) {
|
|
1308
|
-
let { result: r } =
|
|
1309
|
-
p[t.v] = r, Object.hasOwn(r, "barycenter") &&
|
|
1340
|
+
let { result: r } = It(e, t.v, n, s, c);
|
|
1341
|
+
p[t.v] = r, Object.hasOwn(r, "barycenter") && Rt(t, r);
|
|
1310
1342
|
}
|
|
1311
1343
|
});
|
|
1312
|
-
let h =
|
|
1313
|
-
|
|
1344
|
+
let h = At(m, n);
|
|
1345
|
+
Lt(h, p);
|
|
1314
1346
|
let g = {}, _ = !1;
|
|
1315
1347
|
for (let t = 0; t < h.length; t++) for (let n = t + 1; n < h.length; n++) if (!(!h[t] || !h[n] || !((a = h[t]) != null && a.barycenter) || !((o = h[n]) != null && o.barycenter)) && h[t]?.barycenter === h[n].barycenter) {
|
|
1316
1348
|
let r = h[t]?.vs[0] ?? "", i = h[n]?.vs[0] ?? "", a = e.node(r), o = e.node(i);
|
|
@@ -1320,7 +1352,7 @@ function zt(e, t, n, r, i) {
|
|
|
1320
1352
|
} else g[r] = h[n], h.splice(n, 1), n--;
|
|
1321
1353
|
else _ = !0;
|
|
1322
1354
|
}
|
|
1323
|
-
let v =
|
|
1355
|
+
let v = Nt(h, g, s, e, c);
|
|
1324
1356
|
if (d && f) {
|
|
1325
1357
|
v.vs = [
|
|
1326
1358
|
d,
|
|
@@ -1345,17 +1377,17 @@ function zt(e, t, n, r, i) {
|
|
|
1345
1377
|
writable: !0
|
|
1346
1378
|
}), v;
|
|
1347
1379
|
}
|
|
1348
|
-
function
|
|
1380
|
+
function Lt(e, t) {
|
|
1349
1381
|
e.forEach((e) => {
|
|
1350
1382
|
e.vs = e.vs.flatMap((e) => t[e] ? t[e].vs : e);
|
|
1351
1383
|
});
|
|
1352
1384
|
}
|
|
1353
|
-
function
|
|
1385
|
+
function Rt(e, t) {
|
|
1354
1386
|
e.barycenter === void 0 ? (e.barycenter = t.barycenter, e.weight = t.weight) : (e.barycenter = (e.barycenter * e.weight + t.barycenter * t.weight) / (e.weight + t.weight), e.weight += t.weight);
|
|
1355
1387
|
}
|
|
1356
|
-
function
|
|
1388
|
+
function zt(e, t, n, r) {
|
|
1357
1389
|
r ||= e.nodes();
|
|
1358
|
-
let i =
|
|
1390
|
+
let i = Bt(e), a = new E({ compound: !0 }).setGraph({ root: i }).setDefaultNodeLabel((t) => e.node(t));
|
|
1359
1391
|
return r.forEach((r) => {
|
|
1360
1392
|
let o = e.node(r), s = e.parent(r);
|
|
1361
1393
|
if (o.rank === t || o.minRank <= t && t <= o.maxRank) {
|
|
@@ -1371,12 +1403,12 @@ function Ht(e, t, n, r) {
|
|
|
1371
1403
|
}
|
|
1372
1404
|
}), a;
|
|
1373
1405
|
}
|
|
1374
|
-
function
|
|
1406
|
+
function Bt(e) {
|
|
1375
1407
|
let t;
|
|
1376
|
-
for (; e.hasNode(t =
|
|
1408
|
+
for (; e.hasNode(t = M("_root")););
|
|
1377
1409
|
return t;
|
|
1378
1410
|
}
|
|
1379
|
-
function
|
|
1411
|
+
function Vt(e, t, n) {
|
|
1380
1412
|
let r = {}, i;
|
|
1381
1413
|
n.forEach((n) => {
|
|
1382
1414
|
let a = e.parent(n), o, s;
|
|
@@ -1389,22 +1421,22 @@ function Wt(e, t, n) {
|
|
|
1389
1421
|
}
|
|
1390
1422
|
});
|
|
1391
1423
|
}
|
|
1392
|
-
function
|
|
1424
|
+
function Ht(e, t = {}, n = null) {
|
|
1393
1425
|
if (typeof t.customOrder == "function") {
|
|
1394
|
-
t.customOrder(e,
|
|
1426
|
+
t.customOrder(e, Ht);
|
|
1395
1427
|
return;
|
|
1396
1428
|
}
|
|
1397
|
-
let r =
|
|
1398
|
-
if (
|
|
1429
|
+
let r = j(e), i = Ut(e, N(1, r + 1), "inEdges"), a = Ut(e, N(r - 1, -1, -1), "outEdges"), o = Et(e, n);
|
|
1430
|
+
if (Gt(e, o), t.disableOptimalOrderHeuristic) return;
|
|
1399
1431
|
let s = Infinity, c, l = t.constraints || [];
|
|
1400
1432
|
for (let t = 0, r = 0; r < 4; ++t, ++r) {
|
|
1401
|
-
|
|
1402
|
-
let u =
|
|
1433
|
+
Wt(t % 2 ? i : a, t % 4 >= 2, l, n), o = k(e);
|
|
1434
|
+
let u = Dt(e, o);
|
|
1403
1435
|
u < s ? (r = 0, c = Object.assign({}, o), s = u) : u === s && (c = structuredClone(o));
|
|
1404
1436
|
}
|
|
1405
|
-
|
|
1437
|
+
Gt(e, c);
|
|
1406
1438
|
}
|
|
1407
|
-
function
|
|
1439
|
+
function Ut(e, t, n) {
|
|
1408
1440
|
let r = /* @__PURE__ */ new Map(), i = (e, t) => {
|
|
1409
1441
|
r.has(e) || r.set(e, []), r.get(e).push(t);
|
|
1410
1442
|
};
|
|
@@ -1413,48 +1445,48 @@ function Kt(e, t, n) {
|
|
|
1413
1445
|
if (typeof n.rank == "number" && i(n.rank, t), typeof n.minRank == "number" && typeof n.maxRank == "number") for (let e = n.minRank; e <= n.maxRank; e++) e !== n.rank && i(e, t);
|
|
1414
1446
|
}
|
|
1415
1447
|
return t.map(function(t) {
|
|
1416
|
-
return
|
|
1448
|
+
return zt(e, t, n, r.get(t) || []);
|
|
1417
1449
|
});
|
|
1418
1450
|
}
|
|
1419
|
-
function
|
|
1420
|
-
let i = !0, a = new
|
|
1451
|
+
function Wt(e, t, n, r) {
|
|
1452
|
+
let i = !0, a = new E();
|
|
1421
1453
|
e.forEach(function(e) {
|
|
1422
1454
|
n.forEach((e) => a.setEdge(e.left, e.right));
|
|
1423
|
-
let o = e.graph().root, { result: s, usedBias: c } =
|
|
1424
|
-
t && c && (i = !i), s.vs.forEach((t, n) => e.node(t).order = n),
|
|
1455
|
+
let o = e.graph().root, { result: s, usedBias: c } = It(e, o, a, r, i);
|
|
1456
|
+
t && c && (i = !i), s.vs.forEach((t, n) => e.node(t).order = n), Vt(e, a, s.vs);
|
|
1425
1457
|
});
|
|
1426
1458
|
}
|
|
1427
|
-
function
|
|
1459
|
+
function Gt(e, t) {
|
|
1428
1460
|
Object.values(t).forEach((t) => t.forEach((t, n) => e.node(t).order = n));
|
|
1429
1461
|
}
|
|
1430
|
-
function
|
|
1462
|
+
function Kt(e, t) {
|
|
1431
1463
|
let n = {};
|
|
1432
1464
|
function r(t, r) {
|
|
1433
1465
|
let i = 0, a = 0, o = t.length, s = r[r.length - 1];
|
|
1434
1466
|
return r.forEach((t, c) => {
|
|
1435
|
-
let l =
|
|
1467
|
+
let l = Jt(e, t), u = l ? e.node(l).order : o;
|
|
1436
1468
|
(l || t === s) && (r.slice(a, c + 1).forEach((t) => {
|
|
1437
1469
|
let r = e.predecessors(t);
|
|
1438
1470
|
r && r.forEach((r) => {
|
|
1439
1471
|
let a = e.node(r), o = a.order;
|
|
1440
|
-
(o < i || u < o) && !(a.dummy && e.node(t).dummy) &&
|
|
1472
|
+
(o < i || u < o) && !(a.dummy && e.node(t).dummy) && Yt(n, r, t);
|
|
1441
1473
|
});
|
|
1442
1474
|
}), a = c + 1, i = u);
|
|
1443
1475
|
}), r;
|
|
1444
1476
|
}
|
|
1445
1477
|
return t.length && t.reduce(r), n;
|
|
1446
1478
|
}
|
|
1447
|
-
function
|
|
1479
|
+
function qt(e, t) {
|
|
1448
1480
|
let n = {};
|
|
1449
1481
|
function r(t, r, i, a, o) {
|
|
1450
|
-
|
|
1482
|
+
N(r, i).forEach((r) => {
|
|
1451
1483
|
let i = t[r];
|
|
1452
1484
|
if (i !== void 0 && e.node(i).dummy) {
|
|
1453
1485
|
let t = e.predecessors(i);
|
|
1454
1486
|
t && t.forEach((t) => {
|
|
1455
1487
|
if (t === void 0) return;
|
|
1456
1488
|
let r = e.node(t);
|
|
1457
|
-
r.dummy && (r.order < a || r.order > o) &&
|
|
1489
|
+
r.dummy && (r.order < a || r.order > o) && Yt(n, t, i);
|
|
1458
1490
|
});
|
|
1459
1491
|
}
|
|
1460
1492
|
});
|
|
@@ -1475,13 +1507,13 @@ function Xt(e, t) {
|
|
|
1475
1507
|
}
|
|
1476
1508
|
return t.length && t.reduce(i), n;
|
|
1477
1509
|
}
|
|
1478
|
-
function
|
|
1510
|
+
function Jt(e, t) {
|
|
1479
1511
|
if (e.node(t).dummy) {
|
|
1480
1512
|
let n = e.predecessors(t);
|
|
1481
1513
|
if (n) return n.find((t) => e.node(t).dummy);
|
|
1482
1514
|
}
|
|
1483
1515
|
}
|
|
1484
|
-
function
|
|
1516
|
+
function Yt(e, t, n) {
|
|
1485
1517
|
if (t > n) {
|
|
1486
1518
|
let e = t;
|
|
1487
1519
|
t = n, n = e;
|
|
@@ -1489,7 +1521,7 @@ function Qt(e, t, n) {
|
|
|
1489
1521
|
let r = e[t];
|
|
1490
1522
|
r || (e[t] = r = {}), r[n] = !0;
|
|
1491
1523
|
}
|
|
1492
|
-
function
|
|
1524
|
+
function Xt(e, t, n) {
|
|
1493
1525
|
if (t > n) {
|
|
1494
1526
|
let e = t;
|
|
1495
1527
|
t = n, n = e;
|
|
@@ -1497,14 +1529,14 @@ function $t(e, t, n) {
|
|
|
1497
1529
|
let r = e[t];
|
|
1498
1530
|
return r !== void 0 && Object.hasOwn(r, n);
|
|
1499
1531
|
}
|
|
1500
|
-
function
|
|
1532
|
+
function Zt(e, t, n, r, i) {
|
|
1501
1533
|
let a = {}, o = {}, s = {};
|
|
1502
1534
|
return t.forEach((e) => {
|
|
1503
1535
|
e.forEach((e, t) => {
|
|
1504
1536
|
a[e] = e, o[e] = e, s[e] = t;
|
|
1505
1537
|
});
|
|
1506
1538
|
}), t.forEach((t) => {
|
|
1507
|
-
let c = -1, l = -1, u = !1, d = t, f = t.findIndex((t) => i?.includes(t) ||
|
|
1539
|
+
let c = -1, l = -1, u = !1, d = t, f = t.findIndex((t) => i?.includes(t) || sn(t, e, i));
|
|
1508
1540
|
f > 0 && (d = [
|
|
1509
1541
|
t[f],
|
|
1510
1542
|
...t.slice(0, f),
|
|
@@ -1512,7 +1544,7 @@ function en(e, t, n, r, i) {
|
|
|
1512
1544
|
], u = !0), d.forEach((t) => {
|
|
1513
1545
|
let d = r(t);
|
|
1514
1546
|
if (d && d.length) {
|
|
1515
|
-
i != null && i.includes(t) && (d = d.filter((t) =>
|
|
1547
|
+
i != null && i.includes(t) && (d = d.filter((t) => sn(t, e, i)));
|
|
1516
1548
|
let r = d.sort((e, t) => {
|
|
1517
1549
|
let n = s[e], r = s[t];
|
|
1518
1550
|
return (n === void 0 ? 0 : n) - (r === void 0 ? 0 : r);
|
|
@@ -1521,7 +1553,7 @@ function en(e, t, n, r, i) {
|
|
|
1521
1553
|
let i = r[e];
|
|
1522
1554
|
if (i === void 0) continue;
|
|
1523
1555
|
let d = s[i];
|
|
1524
|
-
if (d !== void 0 && o[t] === t && c < d && s[i] !== l &&
|
|
1556
|
+
if (d !== void 0 && o[t] === t && c < d && s[i] !== l && !Xt(n, t, i)) {
|
|
1525
1557
|
let e = a[i];
|
|
1526
1558
|
e !== void 0 && (o[i] = t, o[t] = a[t] = e, c = d, u &&= (c = -1, l = s[i] ?? -1, !1));
|
|
1527
1559
|
}
|
|
@@ -1533,8 +1565,8 @@ function en(e, t, n, r, i) {
|
|
|
1533
1565
|
align: o
|
|
1534
1566
|
};
|
|
1535
1567
|
}
|
|
1536
|
-
function
|
|
1537
|
-
let a = {}, o =
|
|
1568
|
+
function Qt(e, t, n, r, i = !1) {
|
|
1569
|
+
let a = {}, o = $t(e, t, n, i), s = i ? "borderLeft" : "borderRight";
|
|
1538
1570
|
function c(e, t) {
|
|
1539
1571
|
let n = o.nodes().slice(), r = {}, i = n.pop();
|
|
1540
1572
|
for (; i;) {
|
|
@@ -1573,8 +1605,8 @@ function tn(e, t, n, r, i = !1) {
|
|
|
1573
1605
|
t !== void 0 && (a[e] = a[t] ?? 0);
|
|
1574
1606
|
}), a;
|
|
1575
1607
|
}
|
|
1576
|
-
function
|
|
1577
|
-
let i = new
|
|
1608
|
+
function $t(e, t, n, r) {
|
|
1609
|
+
let i = new E(), a = e.graph(), o = an(a.nodesep, a.edgesep, r);
|
|
1578
1610
|
return t.forEach((t) => {
|
|
1579
1611
|
let r;
|
|
1580
1612
|
t.forEach((t) => {
|
|
@@ -1592,31 +1624,31 @@ function nn(e, t, n, r) {
|
|
|
1592
1624
|
});
|
|
1593
1625
|
}), i;
|
|
1594
1626
|
}
|
|
1595
|
-
function
|
|
1627
|
+
function en(e, t) {
|
|
1596
1628
|
return Object.values(t).reduce((t, n) => {
|
|
1597
1629
|
let r = -Infinity, i = Infinity;
|
|
1598
1630
|
Object.entries(n).forEach(([t, n]) => {
|
|
1599
|
-
let a =
|
|
1631
|
+
let a = on(e, t) / 2;
|
|
1600
1632
|
r = Math.max(n + a, r), i = Math.min(n - a, i);
|
|
1601
1633
|
});
|
|
1602
1634
|
let a = r - i;
|
|
1603
1635
|
return a < t[0] && (t = [a, n]), t;
|
|
1604
1636
|
}, [Infinity, null])[1];
|
|
1605
1637
|
}
|
|
1606
|
-
function
|
|
1607
|
-
let n = Object.values(t), r =
|
|
1638
|
+
function tn(e, t) {
|
|
1639
|
+
let n = Object.values(t), r = A(Math.min, n), i = A(Math.max, n);
|
|
1608
1640
|
["u", "d"].forEach((n) => {
|
|
1609
1641
|
["l", "r"].forEach((a) => {
|
|
1610
1642
|
let o = n + a, s = e[o];
|
|
1611
1643
|
if (!s || s === t) return;
|
|
1612
|
-
let c = Object.values(s), l = r -
|
|
1613
|
-
a !== "l" && (l = i -
|
|
1644
|
+
let c = Object.values(s), l = r - A(Math.min, c);
|
|
1645
|
+
a !== "l" && (l = i - A(Math.max, c)), l && (e[o] = F(s, (e) => e + l));
|
|
1614
1646
|
});
|
|
1615
1647
|
});
|
|
1616
1648
|
}
|
|
1617
|
-
function
|
|
1649
|
+
function nn(e, t = void 0) {
|
|
1618
1650
|
let n = e.ul;
|
|
1619
|
-
return n ?
|
|
1651
|
+
return n ? F(n, (n, r) => {
|
|
1620
1652
|
if (t) {
|
|
1621
1653
|
let n = e[t.toLowerCase()];
|
|
1622
1654
|
if (n && n[r] !== void 0) return n[r];
|
|
@@ -1628,17 +1660,17 @@ function on(e, t = void 0) {
|
|
|
1628
1660
|
return ((i[1] ?? 0) + (i[2] ?? 0)) / 2;
|
|
1629
1661
|
}) : {};
|
|
1630
1662
|
}
|
|
1631
|
-
function
|
|
1632
|
-
let n =
|
|
1663
|
+
function rn(e, t) {
|
|
1664
|
+
let n = k(e), r = Object.assign(Kt(e, n), qt(e, n)), i = {}, a;
|
|
1633
1665
|
return ["u", "d"].forEach((o) => {
|
|
1634
1666
|
a = o === "u" ? n : Object.values(n).reverse(), ["l", "r"].forEach((n) => {
|
|
1635
1667
|
n === "r" && (a = a.map((e) => Object.values(e).reverse()));
|
|
1636
|
-
let s =
|
|
1637
|
-
n === "r" && (c =
|
|
1668
|
+
let s = Zt(e, a, r, (t) => (o === "u" ? e.predecessors(t) : e.successors(t)) || [], t), c = Qt(e, a, s.root, s.align, n === "r");
|
|
1669
|
+
n === "r" && (c = F(c, (e) => -e)), i[o + n] = c;
|
|
1638
1670
|
});
|
|
1639
|
-
}),
|
|
1671
|
+
}), tn(i, en(e, i)), nn(i, e.graph().align);
|
|
1640
1672
|
}
|
|
1641
|
-
function
|
|
1673
|
+
function an(e, t, n) {
|
|
1642
1674
|
return (r, i, a) => {
|
|
1643
1675
|
let o = r.node(i), s = r.node(a), c = 0, l;
|
|
1644
1676
|
if (c += o.width / 2, Object.hasOwn(o, "labelpos")) switch (o.labelpos.toLowerCase()) {
|
|
@@ -1660,21 +1692,21 @@ function cn(e, t, n) {
|
|
|
1660
1692
|
return l && (c += n ? l : -l), c;
|
|
1661
1693
|
};
|
|
1662
1694
|
}
|
|
1663
|
-
function
|
|
1695
|
+
function on(e, t) {
|
|
1664
1696
|
return e.node(t).width;
|
|
1665
1697
|
}
|
|
1666
|
-
function
|
|
1698
|
+
function sn(e, t, n) {
|
|
1667
1699
|
if (!n) return !1;
|
|
1668
1700
|
let r = t.node(e)?.edgeObj;
|
|
1669
1701
|
if (!r || t.node(e).edgeLabel.reversed) return !1;
|
|
1670
1702
|
let i = n.indexOf(r?.v), a = n.indexOf(r?.w);
|
|
1671
1703
|
return i !== -1 && a !== -1 && i === (a + 1) % n.length || i === (a - 1) % n.length;
|
|
1672
1704
|
}
|
|
1673
|
-
function
|
|
1674
|
-
e =
|
|
1705
|
+
function cn(e, t) {
|
|
1706
|
+
e = ye(e), ln(e), Object.entries(rn(e, t)).forEach(([t, n]) => e.node(t).x = n);
|
|
1675
1707
|
}
|
|
1676
|
-
function
|
|
1677
|
-
let t =
|
|
1708
|
+
function ln(e) {
|
|
1709
|
+
let t = k(e), n = e.graph(), r = n.ranksep, i = n.rankalign, a = 0;
|
|
1678
1710
|
t.forEach((t) => {
|
|
1679
1711
|
let n = t.reduce((t, n) => {
|
|
1680
1712
|
let r = e.node(n).height ?? 0;
|
|
@@ -1686,11 +1718,11 @@ function fn(e) {
|
|
|
1686
1718
|
}), a += n + r;
|
|
1687
1719
|
});
|
|
1688
1720
|
}
|
|
1689
|
-
var
|
|
1690
|
-
function
|
|
1691
|
-
return
|
|
1721
|
+
var un = /* @__PURE__ */ new WeakMap();
|
|
1722
|
+
function dn(e, t = {}) {
|
|
1723
|
+
return pn(e, Ee, t), e;
|
|
1692
1724
|
}
|
|
1693
|
-
function
|
|
1725
|
+
function fn(e, t, n) {
|
|
1694
1726
|
let r = t;
|
|
1695
1727
|
for (; r !== void 0;) {
|
|
1696
1728
|
let t = e.parent(r);
|
|
@@ -1698,12 +1730,12 @@ function mn(e, t, n) {
|
|
|
1698
1730
|
r = t;
|
|
1699
1731
|
}
|
|
1700
1732
|
}
|
|
1701
|
-
function
|
|
1733
|
+
function pn(e, t, n) {
|
|
1702
1734
|
let r = e.nodes().filter((t) => e.children(t).length), i = {};
|
|
1703
1735
|
r.forEach((r) => {
|
|
1704
1736
|
let a = e.node(r);
|
|
1705
1737
|
if (a && a.rankdir) {
|
|
1706
|
-
let o = new
|
|
1738
|
+
let o = new E({
|
|
1707
1739
|
multigraph: !0,
|
|
1708
1740
|
compound: !0
|
|
1709
1741
|
});
|
|
@@ -1715,32 +1747,32 @@ function hn(e, t, n) {
|
|
|
1715
1747
|
let i = e.parent(t);
|
|
1716
1748
|
i && i !== r && s.includes(i) && o.setParent(t, i);
|
|
1717
1749
|
});
|
|
1718
|
-
let
|
|
1750
|
+
let c = /* @__PURE__ */ new Set();
|
|
1719
1751
|
e.edges().forEach((t) => {
|
|
1720
|
-
let n =
|
|
1752
|
+
let n = fn(e, t.v, r), i = fn(e, t.w, r);
|
|
1721
1753
|
if (n && i && n !== i) {
|
|
1722
1754
|
let r = `${n}\0${i}`;
|
|
1723
|
-
|
|
1755
|
+
c.has(r) || (c.add(r), o.setEdge(n, i, { ...e.edge(t) }));
|
|
1724
1756
|
}
|
|
1725
|
-
}),
|
|
1726
|
-
let
|
|
1727
|
-
|
|
1728
|
-
let
|
|
1757
|
+
}), pn(o, t, n);
|
|
1758
|
+
let l = wn(o);
|
|
1759
|
+
mn(l, t, n, null), hn(o, l);
|
|
1760
|
+
let u = Infinity, d = Infinity, f = -Infinity, p = -Infinity;
|
|
1729
1761
|
o.nodes().forEach((e) => {
|
|
1730
1762
|
if (e === r) return;
|
|
1731
1763
|
let t = o.node(e);
|
|
1732
|
-
t && typeof t.x == "number" && typeof t.y == "number" && typeof t.width == "number" && typeof t.height == "number" && (
|
|
1733
|
-
}), (!isFinite(
|
|
1734
|
-
let
|
|
1764
|
+
t && typeof t.x == "number" && typeof t.y == "number" && typeof t.width == "number" && typeof t.height == "number" && (u = Math.min(u, t.x - t.width / 2), f = Math.max(f, t.x + t.width / 2), d = Math.min(d, t.y - t.height / 2), p = Math.max(p, t.y + t.height / 2));
|
|
1765
|
+
}), (!isFinite(u) || !isFinite(d) || !isFinite(f) || !isFinite(p)) && (u = d = 0, f = p = 0);
|
|
1766
|
+
let m = f - u, h = p - d;
|
|
1735
1767
|
i[r] = {
|
|
1736
|
-
minX:
|
|
1737
|
-
minY:
|
|
1738
|
-
maxX:
|
|
1739
|
-
maxY:
|
|
1740
|
-
width:
|
|
1741
|
-
height:
|
|
1742
|
-
offsetX:
|
|
1743
|
-
offsetY:
|
|
1768
|
+
minX: u,
|
|
1769
|
+
minY: d,
|
|
1770
|
+
maxX: f,
|
|
1771
|
+
maxY: p,
|
|
1772
|
+
width: m,
|
|
1773
|
+
height: h,
|
|
1774
|
+
offsetX: u,
|
|
1775
|
+
offsetY: d
|
|
1744
1776
|
}, a._dagreClusterSubgraph = o;
|
|
1745
1777
|
}
|
|
1746
1778
|
});
|
|
@@ -1756,35 +1788,35 @@ function hn(e, t, n) {
|
|
|
1756
1788
|
let n = e.node(t);
|
|
1757
1789
|
n && n.rankdir && i[t] && s.set(t, (e.children(t) || []).filter((e) => e !== t));
|
|
1758
1790
|
});
|
|
1759
|
-
let
|
|
1791
|
+
let c = new Set([...s.values()].flat()), l = /* @__PURE__ */ new Map();
|
|
1760
1792
|
s.forEach((e, t) => {
|
|
1761
|
-
|
|
1793
|
+
c.has(t) || l.set(t, o(t));
|
|
1762
1794
|
});
|
|
1763
|
-
let
|
|
1764
|
-
for (let [t, n] of
|
|
1795
|
+
let u = new Set([...l.values()].flat()), d = (e) => {
|
|
1796
|
+
for (let [t, n] of l) if (n.includes(e)) return t;
|
|
1765
1797
|
return e;
|
|
1766
|
-
},
|
|
1798
|
+
}, f = [];
|
|
1767
1799
|
e.edges().forEach((t) => {
|
|
1768
|
-
(
|
|
1800
|
+
(u.has(t.v) || u.has(t.w)) && f.push({
|
|
1769
1801
|
edge: t,
|
|
1770
1802
|
label: e.edge(t)
|
|
1771
1803
|
});
|
|
1772
1804
|
});
|
|
1773
|
-
let
|
|
1774
|
-
|
|
1805
|
+
let p = /* @__PURE__ */ new Map();
|
|
1806
|
+
u.forEach((t) => {
|
|
1775
1807
|
let n = e.parent(t);
|
|
1776
|
-
|
|
1777
|
-
}),
|
|
1808
|
+
p.set(t, typeof n == "string" ? n : void 0);
|
|
1809
|
+
}), l.forEach((t, n) => {
|
|
1778
1810
|
let r = e.node(n), o = [];
|
|
1779
1811
|
t.forEach((t) => {
|
|
1780
1812
|
let n = e.node(t);
|
|
1781
1813
|
n && (o.push({
|
|
1782
1814
|
id: t,
|
|
1783
1815
|
node: n,
|
|
1784
|
-
parent:
|
|
1816
|
+
parent: p.get(t)
|
|
1785
1817
|
}), e.removeNode(t));
|
|
1786
1818
|
});
|
|
1787
|
-
let s =
|
|
1819
|
+
let s = f.filter(({ edge: e }) => t.includes(e.v) || t.includes(e.w)), c = i[n];
|
|
1788
1820
|
r && (a.push({
|
|
1789
1821
|
clusterId: n,
|
|
1790
1822
|
subgraph: r._dagreClusterSubgraph,
|
|
@@ -1794,20 +1826,20 @@ function hn(e, t, n) {
|
|
|
1794
1826
|
removedEdges: s
|
|
1795
1827
|
}), r.width = c.width, r.height = c.height);
|
|
1796
1828
|
});
|
|
1797
|
-
let
|
|
1798
|
-
|
|
1799
|
-
let r =
|
|
1829
|
+
let m = /* @__PURE__ */ new Set();
|
|
1830
|
+
f.forEach(({ edge: t, label: n }) => {
|
|
1831
|
+
let r = d(t.v), i = d(t.w);
|
|
1800
1832
|
if (r !== i && e.hasNode(r) && e.hasNode(i)) {
|
|
1801
1833
|
let t = `${r}\0${i}`;
|
|
1802
|
-
|
|
1834
|
+
m.has(t) || (m.add(t), e.setEdge(r, i, {
|
|
1803
1835
|
...n,
|
|
1804
1836
|
width: 0,
|
|
1805
1837
|
height: 0
|
|
1806
1838
|
}));
|
|
1807
1839
|
}
|
|
1808
1840
|
});
|
|
1809
|
-
let g =
|
|
1810
|
-
|
|
1841
|
+
let h = wn(e), g = mn(h, t, n, un.get(e) ?? null);
|
|
1842
|
+
un.set(e, g), hn(e, h), m.forEach((t) => {
|
|
1811
1843
|
let n = t.indexOf("\0"), r = t.slice(0, n), i = t.slice(n + 1);
|
|
1812
1844
|
e.hasEdge(r, i) && e.removeEdge(r, i);
|
|
1813
1845
|
}), a.forEach(({ clusterId: t, subgraph: n, bounds: r, removedNodes: i, removedEdges: a }) => {
|
|
@@ -1836,10 +1868,17 @@ function hn(e, t, n) {
|
|
|
1836
1868
|
}
|
|
1837
1869
|
});
|
|
1838
1870
|
}
|
|
1839
|
-
function
|
|
1840
|
-
|
|
1871
|
+
function mn(e, t, n, r = null) {
|
|
1872
|
+
var i, a;
|
|
1873
|
+
let o = n?.useDynamic !== !1, s = o && (i = r?.graph) != null ? i : null, c = o && (a = r?.rawNodes) != null ? a : null;
|
|
1874
|
+
t(" makeSpaceForEdgeLabels", () => Tn(e)), t(" removeSelfEdges", () => Pn(e)), t(" acyclic", () => ze(e, s)), t(" nestingGraph.run", () => ft(e)), t(" rank", () => it(ye(e))), t(" injectEdgeLabelProxies", () => En(e)), t(" removeEmptyRanks", () => xe(e)), t(" nestingGraph.cleanup", () => gt(e)), t(" normalizeRanks", () => be(e)), t(" assignRankMinMax", () => Dn(e)), t(" removeEdgeLabelProxies", () => On(e)), t(" normalize.run", () => Ue(e)), t(" parentDummyChains", () => ct(e)), t(" addBorderSegments", () => _t(e)), t(" order", () => Ht(e, n, c)), t(" insertSelfEdges", () => Fn(e)), t(" adjustCoordinateSystem", () => bt(e)), t(" position", () => cn(e, n.corePath)), t(" positionSelfEdges", () => In(e));
|
|
1875
|
+
let l = JSON.parse(JSON.stringify(e._nodes));
|
|
1876
|
+
return t(" removeBorderNodes", () => Nn(e)), t(" normalize.undo", () => Ge(e)), t(" fixupEdgeLabelCoords", () => jn(e)), t(" undoCoordinateSystem", () => xt(e)), t(" translateGraph", () => kn(e)), t(" assignNodeIntersects", () => An(e)), t(" reversePoints", () => Mn(e)), t(" acyclic.undo", () => Ve(e)), {
|
|
1877
|
+
graph: e,
|
|
1878
|
+
rawNodes: l
|
|
1879
|
+
};
|
|
1841
1880
|
}
|
|
1842
|
-
function
|
|
1881
|
+
function hn(e, t) {
|
|
1843
1882
|
e.nodes().forEach((n) => {
|
|
1844
1883
|
let r = e.node(n), i = t.node(n);
|
|
1845
1884
|
r && (r.x = i.x, r.y = i.y, r.order = i.order, r.rank = i.rank, t.children(n).length && (r.width = i.width, r.height = i.height));
|
|
@@ -1848,89 +1887,89 @@ function _n(e, t) {
|
|
|
1848
1887
|
r.points = i.points, Object.hasOwn(i, "x") && (r.x = i.x, r.y = i.y);
|
|
1849
1888
|
}), e.graph().width = t.graph().width, e.graph().height = t.graph().height;
|
|
1850
1889
|
}
|
|
1851
|
-
var
|
|
1890
|
+
var gn = [
|
|
1852
1891
|
"nodesep",
|
|
1853
1892
|
"edgesep",
|
|
1854
1893
|
"ranksep",
|
|
1855
1894
|
"marginx",
|
|
1856
1895
|
"marginy"
|
|
1857
|
-
],
|
|
1896
|
+
], _n = {
|
|
1858
1897
|
ranksep: 50,
|
|
1859
1898
|
edgesep: 20,
|
|
1860
1899
|
nodesep: 50,
|
|
1861
1900
|
rankdir: "TB",
|
|
1862
1901
|
rankalign: "center"
|
|
1863
|
-
},
|
|
1902
|
+
}, vn = [
|
|
1864
1903
|
"acyclicer",
|
|
1865
1904
|
"ranker",
|
|
1866
1905
|
"rankdir",
|
|
1867
1906
|
"align",
|
|
1868
1907
|
"rankalign"
|
|
1869
|
-
],
|
|
1908
|
+
], yn = [
|
|
1870
1909
|
"width",
|
|
1871
1910
|
"height",
|
|
1872
1911
|
"rank"
|
|
1873
|
-
],
|
|
1912
|
+
], bn = {
|
|
1874
1913
|
width: 0,
|
|
1875
1914
|
height: 0
|
|
1876
|
-
},
|
|
1915
|
+
}, xn = [
|
|
1877
1916
|
"minlen",
|
|
1878
1917
|
"weight",
|
|
1879
1918
|
"width",
|
|
1880
1919
|
"height",
|
|
1881
1920
|
"labeloffset"
|
|
1882
|
-
],
|
|
1921
|
+
], Sn = {
|
|
1883
1922
|
minlen: 1,
|
|
1884
1923
|
weight: 1,
|
|
1885
1924
|
width: 0,
|
|
1886
1925
|
height: 0,
|
|
1887
1926
|
labeloffset: 10,
|
|
1888
1927
|
labelpos: "r"
|
|
1889
|
-
},
|
|
1890
|
-
function
|
|
1891
|
-
let t = new
|
|
1928
|
+
}, Cn = ["labelpos"];
|
|
1929
|
+
function wn(e) {
|
|
1930
|
+
let t = new E({
|
|
1892
1931
|
multigraph: !0,
|
|
1893
1932
|
compound: !0
|
|
1894
1933
|
}), n = $(e.graph());
|
|
1895
|
-
return t.setGraph(Object.assign({},
|
|
1896
|
-
let r = Q($(e.node(n)),
|
|
1897
|
-
Object.keys(
|
|
1898
|
-
r[e] === void 0 && (r[e] =
|
|
1934
|
+
return t.setGraph(Object.assign({}, _n, Q(n, gn), P(n, vn))), e.nodes().forEach((n) => {
|
|
1935
|
+
let r = Q($(e.node(n)), yn);
|
|
1936
|
+
Object.keys(bn).forEach((e) => {
|
|
1937
|
+
r[e] === void 0 && (r[e] = bn[e]);
|
|
1899
1938
|
}), t.setNode(n, r);
|
|
1900
1939
|
let i = e.parent(n);
|
|
1901
1940
|
i !== void 0 && t.setParent(n, i);
|
|
1902
1941
|
}), e.edges().forEach((n) => {
|
|
1903
1942
|
let r = $(e.edge(n));
|
|
1904
|
-
t.setEdge(n, Object.assign({},
|
|
1943
|
+
t.setEdge(n, Object.assign({}, Sn, Q(r, xn), P(r, Cn)));
|
|
1905
1944
|
}), t;
|
|
1906
1945
|
}
|
|
1907
|
-
function
|
|
1946
|
+
function Tn(e) {
|
|
1908
1947
|
let t = e.graph();
|
|
1909
1948
|
t.ranksep /= 2, e.edges().forEach((n) => {
|
|
1910
1949
|
let r = e.edge(n);
|
|
1911
1950
|
r.minlen *= 2, (r.labelpos ?? "r").toLowerCase() !== "c" && (t.rankdir === "TB" || t.rankdir === "BT" ? r.width += r.labeloffset : r.height += r.labeloffset);
|
|
1912
1951
|
});
|
|
1913
1952
|
}
|
|
1914
|
-
function
|
|
1953
|
+
function En(e) {
|
|
1915
1954
|
e.edges().forEach((t) => {
|
|
1916
1955
|
let n = e.edge(t);
|
|
1917
1956
|
if (n.width && n.height) {
|
|
1918
1957
|
let n = e.node(t.v);
|
|
1919
|
-
|
|
1958
|
+
D(e, "edge-proxy", {
|
|
1920
1959
|
rank: (e.node(t.w).rank - n.rank) / 2 + n.rank,
|
|
1921
1960
|
e: t
|
|
1922
1961
|
}, "_ep");
|
|
1923
1962
|
}
|
|
1924
1963
|
});
|
|
1925
1964
|
}
|
|
1926
|
-
function
|
|
1965
|
+
function Dn(e) {
|
|
1927
1966
|
let t = 0;
|
|
1928
1967
|
e.nodes().forEach((n) => {
|
|
1929
1968
|
let r = e.node(n);
|
|
1930
1969
|
r.borderTop && (r.minRank = e.node(r.borderTop).rank, r.maxRank = e.node(r.borderBottom).rank, t = Math.max(t, r.maxRank));
|
|
1931
1970
|
}), e.graph().maxRank = t;
|
|
1932
1971
|
}
|
|
1933
|
-
function
|
|
1972
|
+
function On(e) {
|
|
1934
1973
|
e.nodes().forEach((t) => {
|
|
1935
1974
|
let n = e.node(t);
|
|
1936
1975
|
if (n.dummy === "edge-proxy") {
|
|
@@ -1939,7 +1978,7 @@ function An(e) {
|
|
|
1939
1978
|
}
|
|
1940
1979
|
});
|
|
1941
1980
|
}
|
|
1942
|
-
function
|
|
1981
|
+
function kn(e) {
|
|
1943
1982
|
let t = Infinity, n = 0, r = Infinity, i = 0, a = e.graph(), o = a.marginx || 0, s = a.marginy || 0;
|
|
1944
1983
|
function c(e) {
|
|
1945
1984
|
let a = e.x, o = e.y, s = e.width, c = e.height;
|
|
@@ -1958,14 +1997,14 @@ function jn(e) {
|
|
|
1958
1997
|
}), Object.hasOwn(i, "x") && (i.x -= t), Object.hasOwn(i, "y") && (i.y -= r);
|
|
1959
1998
|
}), a.width = n - t + o, a.height = i - r + s;
|
|
1960
1999
|
}
|
|
1961
|
-
function
|
|
2000
|
+
function An(e) {
|
|
1962
2001
|
e.edges().forEach((t) => {
|
|
1963
2002
|
if (t.v === t.w) return;
|
|
1964
2003
|
let n = e.edge(t), r = e.node(t.v), i = e.node(t.w), a, o;
|
|
1965
|
-
n.points ? (a = n.points[0], o = n.points[n.points.length - 1]) : (n.points = [], a = i, o = r), n.points.unshift(
|
|
2004
|
+
n.points ? (a = n.points[0], o = n.points[n.points.length - 1]) : (n.points = [], a = i, o = r), n.points.unshift(O(r, a)), n.points.push(O(i, o));
|
|
1966
2005
|
});
|
|
1967
2006
|
}
|
|
1968
|
-
function
|
|
2007
|
+
function jn(e) {
|
|
1969
2008
|
e.edges().forEach((t) => {
|
|
1970
2009
|
let n = e.edge(t);
|
|
1971
2010
|
if (Object.hasOwn(n, "x")) switch ((n.labelpos === "l" || n.labelpos === "r") && (n.width -= n.labeloffset), n.labelpos) {
|
|
@@ -1978,13 +2017,13 @@ function Nn(e) {
|
|
|
1978
2017
|
}
|
|
1979
2018
|
});
|
|
1980
2019
|
}
|
|
1981
|
-
function
|
|
2020
|
+
function Mn(e) {
|
|
1982
2021
|
e.edges().forEach((t) => {
|
|
1983
2022
|
let n = e.edge(t);
|
|
1984
2023
|
n.reversed && n.points.reverse();
|
|
1985
2024
|
});
|
|
1986
2025
|
}
|
|
1987
|
-
function
|
|
2026
|
+
function Nn(e) {
|
|
1988
2027
|
e.nodes().forEach((t) => {
|
|
1989
2028
|
if (e.children(t).length) {
|
|
1990
2029
|
let n = e.node(t), r = e.node(n.borderTop), i = e.node(n.borderBottom), a = e.node(n.borderLeft[n.borderLeft.length - 1]), o = e.node(n.borderRight[n.borderRight.length - 1]);
|
|
@@ -1994,7 +2033,7 @@ function Fn(e) {
|
|
|
1994
2033
|
e.node(t).dummy === "border" && e.removeNode(t);
|
|
1995
2034
|
});
|
|
1996
2035
|
}
|
|
1997
|
-
function
|
|
2036
|
+
function Pn(e) {
|
|
1998
2037
|
e.edges().forEach((t) => {
|
|
1999
2038
|
if (t.v === t.w) {
|
|
2000
2039
|
let n = e.node(t.v);
|
|
@@ -2005,13 +2044,13 @@ function In(e) {
|
|
|
2005
2044
|
}
|
|
2006
2045
|
});
|
|
2007
2046
|
}
|
|
2008
|
-
function
|
|
2009
|
-
|
|
2047
|
+
function Fn(e) {
|
|
2048
|
+
k(e).forEach((t) => {
|
|
2010
2049
|
let n = 0;
|
|
2011
2050
|
t.forEach((t, r) => {
|
|
2012
2051
|
let i = e.node(t);
|
|
2013
2052
|
typeof i.rank != "number" && (i.rank = 0), i.order = r + n, (i.selfEdges || []).forEach((t) => {
|
|
2014
|
-
|
|
2053
|
+
D(e, "selfedge", {
|
|
2015
2054
|
width: t.label.width,
|
|
2016
2055
|
height: t.label.height,
|
|
2017
2056
|
rank: i.rank,
|
|
@@ -2052,7 +2091,7 @@ function Ln(e) {
|
|
|
2052
2091
|
});
|
|
2053
2092
|
});
|
|
2054
2093
|
}
|
|
2055
|
-
function
|
|
2094
|
+
function In(e) {
|
|
2056
2095
|
e.nodes().forEach((t) => {
|
|
2057
2096
|
let n = e.node(t), r = (e) => typeof e == "number" && isFinite(e);
|
|
2058
2097
|
if (n.dummy === "selfedge") {
|
|
@@ -2125,7 +2164,7 @@ function Rn(e) {
|
|
|
2125
2164
|
});
|
|
2126
2165
|
}
|
|
2127
2166
|
function Q(e, t) {
|
|
2128
|
-
return
|
|
2167
|
+
return F(P(e, t), Number);
|
|
2129
2168
|
}
|
|
2130
2169
|
function $(e) {
|
|
2131
2170
|
let t = {};
|
|
@@ -2135,7 +2174,7 @@ function $(e) {
|
|
|
2135
2174
|
}
|
|
2136
2175
|
//#endregion
|
|
2137
2176
|
//#region src/erdDiagram.ts
|
|
2138
|
-
var
|
|
2177
|
+
var Ln = 160, Rn = 50, zn = 8, Bn = 24, Vn = 6, Hn = {
|
|
2139
2178
|
external: {
|
|
2140
2179
|
fill: "#f0f0f0",
|
|
2141
2180
|
stroke: "#b0b0b0"
|
|
@@ -2149,9 +2188,9 @@ var zn = 160, Bn = 50, Vn = 8, Hn = 24, Un = 6, Wn = {
|
|
|
2149
2188
|
stroke: "#c3d9f2",
|
|
2150
2189
|
strokeDasharray: "4 3"
|
|
2151
2190
|
}
|
|
2152
|
-
},
|
|
2153
|
-
function
|
|
2154
|
-
let i = r.nodeWidth ??
|
|
2191
|
+
}, Un = "#c0c0c0", Wn = "dpuse-tool-d3-erd-arrow";
|
|
2192
|
+
function Gn(t, n, r = {}) {
|
|
2193
|
+
let i = r.nodeWidth ?? Ln, o = r.nodeHeight ?? Rn, s = r.padding ?? zn, c = r.selfEdgeSize ?? Bn, l = r.cornerRadius ?? Vn, u = r.nodeColors ?? Hn, d = r.edgeColor ?? Un, f = r.orderConstraints ?? [];
|
|
2155
2194
|
function p() {
|
|
2156
2195
|
e(n).selectAll("svg").remove();
|
|
2157
2196
|
let r = new a.Graph();
|
|
@@ -2167,9 +2206,9 @@ function qn(t, n, r = {}) {
|
|
|
2167
2206
|
typeId: e.typeId
|
|
2168
2207
|
});
|
|
2169
2208
|
for (let e of t.edges) e.source !== e.target && r.setEdge(e.source, e.target);
|
|
2170
|
-
|
|
2209
|
+
dn(r, { constraints: f });
|
|
2171
2210
|
let { width: p = 0, height: m = 0 } = r.graph(), h = p + s * 2, g = m + s * 2, _ = e(n).append("svg").attr("viewBox", `0 0 ${String(h)} ${String(g)}`).attr("width", h).attr("height", g), v = _.append("g").attr("transform", `translate(${String(s)}, ${String(s)})`);
|
|
2172
|
-
_.append("defs").append("marker").attr("id",
|
|
2211
|
+
_.append("defs").append("marker").attr("id", Wn).attr("viewBox", "0 0 10 10").attr("refX", 9).attr("refY", 5).attr("markerWidth", 6).attr("markerHeight", 6).attr("orient", "auto-start-reverse").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("fill", d), v.append("g").attr("fill", "none").attr("stroke", d).attr("stroke-width", 1.25).selectAll("path").data(t.edges).join("path").attr("marker-end", `url(#${Wn})`).attr("d", (e) => e.source === e.target ? qn(r.node(e.source), c) : Kn(r.node(e.source), r.node(e.target), l));
|
|
2173
2212
|
let y = v.append("g").selectAll("g").data(r.nodes()).join("g").attr("transform", (e) => {
|
|
2174
2213
|
let t = r.node(e);
|
|
2175
2214
|
return `translate(${String((t.x ?? 0) - t.width / 2)}, ${String((t.y ?? 0) - t.height / 2)})`;
|
|
@@ -2189,7 +2228,7 @@ function qn(t, n, r = {}) {
|
|
|
2189
2228
|
}
|
|
2190
2229
|
};
|
|
2191
2230
|
}
|
|
2192
|
-
function
|
|
2231
|
+
function Kn(e, t, n) {
|
|
2193
2232
|
let r = e.x ?? 0, i = (e.y ?? 0) + e.height / 2, a = t.x ?? 0, o = (t.y ?? 0) - t.height / 2;
|
|
2194
2233
|
if (r === a) return `M ${String(r)} ${String(i)} L ${String(a)} ${String(o)}`;
|
|
2195
2234
|
let s = (i + o) / 2, c = Math.sign(a - r), l = Math.max(0, Math.min(n, s - i, o - s, Math.abs(a - r) / 2));
|
|
@@ -2202,11 +2241,11 @@ function Jn(e, t, n) {
|
|
|
2202
2241
|
`L ${String(a)} ${String(o)}`
|
|
2203
2242
|
].join(" ");
|
|
2204
2243
|
}
|
|
2205
|
-
function
|
|
2244
|
+
function qn(e, t) {
|
|
2206
2245
|
let n = (e.x ?? 0) + e.width / 2, r = n + t, i = (e.y ?? 0) - e.height / 4, a = (e.y ?? 0) + e.height / 4;
|
|
2207
2246
|
return `M ${String(n)} ${String(i)} C ${String(r)} ${String(i)}, ${String(r)} ${String(a)}, ${String(n)} ${String(a)}`;
|
|
2208
2247
|
}
|
|
2209
2248
|
//#endregion
|
|
2210
|
-
export {
|
|
2249
|
+
export { Gn as renderErdDiagram };
|
|
2211
2250
|
|
|
2212
|
-
//# sourceMappingURL=erdDiagram-
|
|
2251
|
+
//# sourceMappingURL=erdDiagram-Ds1hsQDD.js.map
|