@knowvah/dot-engine 0.1.0

package/dist/layout/fdp/ports.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Cluster expansion ports: after the parent layout positions a
+ * cluster's derived node, the angles of its edges induce boundary
+ * ports for the cluster's own recursive layout.
+ *
+ * Spec read at the 15.0.0 tag.
+ *
+ * @see lib/fdpgen/layout.c:getEdgeList / genPorts / expandCluster
+ *      (15.0.0)
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import { type Bport } from './fdp-model.js';
+/** Edge record for angular sorting. @see lib/fdpgen/layout.c:erec */
+interface Erec {
+    e: Edge;
+    alpha: number;
+    dist2: number;
+}
+/**
+ * Counterclockwise-sorted list of the derived edges at n, with ties
+ * broken apart angularly. Assumes g has an initial layout.
+ * @see lib/fdpgen/layout.c:getEdgeList
+ */
+export declare function getEdgeList(n: Node, g: Graph): Erec[];
+/**
+ * Append the ports corresponding to one derived edge at n to pp,
+ * fanning multi-edges between alpha and bnd. Real-edge order reverses
+ * when n is the later-created endpoint (C pointer comparison).
+ * @see lib/fdpgen/layout.c:genPorts
+ */
+export declare function genPorts(n: Node, er: Erec, pp: Bport[], idx: number, bnd: number): number;
+/**
+ * Attach ports induced by the layout of cg to the cluster subgraph
+ * that derived node n represents.
+ * @see lib/fdpgen/layout.c:expandCluster
+ */
+export declare function expandCluster(n: Node, cg: Graph): Graph;
+export {};
+//# sourceMappingURL=ports.d.ts.map

package/dist/layout/fdp/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../../src/layout/fdp/ports.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EACL,KAAK,KAAK,EAKX,MAAM,gBAAgB,CAAC;AAKxB,qEAAqE;AACrE,UAAU,IAAI;IACZ,CAAC,EAAE,IAAI,CAAC;IACR,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAgCD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE,CAmBrD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GACvD,MAAM,CAcR;AAoBD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,GAAG,KAAK,CAuBvD"}

package/dist/layout/fdp/tlayout-init.d.ts

@@ -0,0 +1,21 @@
+/**
+ * fdp initial placement: seed the RNG, size the boundary ellipse/box,
+ * place ports on the ellipse and free nodes within it.
+ *
+ * drand48 call order is load-bearing (exact LCG port in
+ * src/common/random.ts); node iteration is the component's id order
+ * and the per-node edge scan is out-edges then in-edges (agfstedge).
+ *
+ * Spec read at the 15.0.0 tag.
+ *
+ * @see lib/fdpgen/tlayout.c:initPositions (15.0.0)
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Point } from '../../model/geom.js';
+import { type Bport } from './fdp-model.js';
+/**
+ * Create the initial layout of one derived component.
+ * @see lib/fdpgen/tlayout.c:initPositions
+ */
+export declare function initPositions(g: Graph, pp: Bport[] | null): Point;
+//# sourceMappingURL=tlayout-init.d.ts.map

package/dist/layout/fdp/tlayout-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tlayout-init.d.ts","sourceRoot":"","sources":["../../../src/layout/fdp/tlayout-init.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAGlD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EACL,KAAK,KAAK,EAMX,MAAM,gBAAgB,CAAC;AA4KxB;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,IAAI,GAAG,KAAK,CA0BjE"}

package/dist/layout/fdp/tlayout-parms.d.ts

@@ -0,0 +1,98 @@
+/**
+ * fdp layout parameters: the fdp_parms process defaults, the static
+ * parms_t working set, the cooling schedule, and parameter resolution
+ * from graph attributes.
+ *
+ * Spec read at the 15.0.0 tag.
+ *
+ * @see lib/fdpgen/tlayout.c (15.0.0) — parms_t, fdp_initParams,
+ *      init_params, cool, reset_params
+ * @see lib/common/globals.c (15.0.0) — fdpParms defaults
+ */
+import type { Graph } from '../../model/graph.js';
+import { type XParams } from './fdp-model.js';
+/** @see lib/fdpgen/tlayout.c:EXPFACTOR */
+export declare const EXPFACTOR = 1.2;
+/** @see lib/neatogen/neato.h:INIT_SELF */
+export declare const INIT_SELF = 0;
+/** @see lib/neatogen/neato.h:INIT_REGULAR */
+export declare const INIT_REGULAR = 1;
+/** @see lib/neatogen/neato.h:INIT_RANDOM */
+export declare const INIT_RANDOM = 2;
+/**
+ * Process-level fdp defaults ("possibly set via command line; -1
+ * indicates unset"). The CLI flags (-L*) are not ported; the struct is
+ * kept because fdp_initParams and init_edge read it.
+ *
+ * @see lib/common/globals.c:fdpParms
+ * @see lib/fdpgen/fdp.h:fdpParms_t
+ */
+export declare const fdpParms: {
+    useGrid: number;
+    useNew: number;
+    numIters: number;
+    unscaled: number;
+    C: number;
+    Tfact: number;
+    K: number;
+    T0: number;
+};
+/** @see lib/fdpgen/tlayout.c:parms_t */
+export interface TParms {
+    useGrid: number;
+    useNew: number;
+    seed: number;
+    numIters: number;
+    maxIters: number;
+    unscaled: number;
+    C: number;
+    Tfact: number;
+    K: number;
+    T0: number;
+    smode: number;
+    Cell: number;
+    Wd: number;
+    Ht: number;
+    pass1: number;
+    loopcnt: number;
+}
+/** Module-level mutable state, mirroring the C static. @see tlayout.c:parms */
+export declare const parms: TParms;
+/** Linear cooling schedule. @see lib/fdpgen/tlayout.c:cool */
+export declare function cool(t: number): number;
+/** @see lib/fdpgen/tlayout.c:reset_params */
+export declare function resetParams(): void;
+/**
+ * Parse the graph "start" attribute into an init mode and seed.
+ * (The TS neato setSeed has a different shape; this is the C original.)
+ *
+ * When INIT_RANDOM is selected without a numeric seed, C uses
+ * time(NULL); Date.now() seconds substitute (non-deterministic in C
+ * too, so parity is unaffected).
+ *
+ * @see lib/neatogen/neatoinit.c:setSeed (15.0.0)
+ */
+export declare function setSeedFdp(g: Graph, dflt: number, seedRef: {
+    value: number;
+}): number;
+/**
+ * Classify the "start" value prefix (self/regular/random keyword or a
+ * bare numeric seed). @see lib/neatogen/neatoinit.c:setSeed
+ */
+export declare function classifyStart(p: string, dflt: number): {
+    init: number;
+    rest: string;
+};
+/**
+ * Initialize parameters from the root graph's attributes.
+ * @see lib/fdpgen/tlayout.c:fdp_initParams
+ */
+export declare function fdpInitParams(g: Graph): void;
+/**
+ * Set parameters for the expansion phase from the initial-layout
+ * parameters; auto-derive T0 from graph size when unset.
+ * @returns whether resetParams must be called after this layout pass
+ * @see lib/fdpgen/tlayout.c:init_params
+ */
+export declare function initParams(g: Graph, xpms: XParams): boolean;
+//# sourceMappingURL=tlayout-parms.d.ts.map

package/dist/layout/fdp/tlayout-parms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tlayout-parms.d.ts","sourceRoot":"","sources":["../../../src/layout/fdp/tlayout-parms.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,KAAK,OAAO,EAAc,MAAM,gBAAgB,CAAC;AAM1D,0CAA0C;AAC1C,eAAO,MAAM,SAAS,MAAM,CAAC;AAU7B,0CAA0C;AAC1C,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,6CAA6C;AAC7C,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,4CAA4C;AAC5C,eAAO,MAAM,WAAW,IAAI,CAAC;AAQ7B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;CASpB,CAAC;AAMF,wCAAwC;AACxC,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,+EAA+E;AAC/E,eAAO,MAAM,KAAK,EAAE,MAInB,CAAC;AAEF,8DAA8D;AAC9D,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC;AAED,6CAA6C;AAC7C,wBAAgB,WAAW,IAAI,IAAI,CAElC;AAMD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACzB,MAAM,CAaR;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAOhC;AAMD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAsB5C;AAeD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CA2B3D"}

package/dist/layout/fdp/tlayout.d.ts

@@ -0,0 +1,43 @@
+/**
+ * fdp initial layout — grid-accelerated Fruchterman–Reingold on point
+ * nodes with boundary ports.
+ *
+ * Spec read at the 15.0.0 tag: the post-tag tree reorders doRep floats
+ * (hypot vs sqrt(x²·y²)) and adds an Mlimit cutoff; the golden refs are
+ * 15.0.0 output, so neither is ported.
+ *
+ * All math is double precision (unlike neato's float32 stress kernel).
+ * Force-accumulation order is load-bearing: node iteration is the
+ * component's id order, edge iteration is the graph edge order, and
+ * grid cells walk in ascending (i, j) order.
+ *
+ * Parameter state lives in tlayout-parms.ts; initial placement in
+ * tlayout-init.ts.
+ *
+ * @see lib/fdpgen/tlayout.c (15.0.0)
+ */
+import type { Graph } from '../../model/graph.js';
+import { type XParams } from './fdp-model.js';
+export { fdpInitParams, fdpParms, setSeedFdp, INIT_RANDOM, INIT_REGULAR, INIT_SELF } from './tlayout-parms.js';
+/**
+ * Coincident-node fallback: re-roll the delta with rand() until the pair is
+ * non-zero, mirroring C's `while` loops (doRep re-rolls while dist==0,
+ * applyAttr while dist2==0; both re-roll until (xdelta,ydelta) ≠ (0,0), which
+ * for the integer 5−rand()%10 deltas is equivalent). macOS libc rand() is the
+ * Park–Miller MINSTD stream (crand). fdp seeds only srand48 (a separate
+ * drand48 placement stream), so this rand() stream starts unseeded ⇒ srand(1)
+ * (reset per render in fdpLayoutEngine) and is shared, in call order, across
+ * tlayout doRep/applyAttr and xlayout doRep.
+ * @see lib/fdpgen/tlayout.c:doRep / applyAttr
+ * @see lib/fdpgen/xlayout.c:doRep
+ */
+export declare function coincidentDelta(): {
+    xdelta: number;
+    ydelta: number;
+};
+/**
+ * Lay out one derived component g, respecting its boundary ports.
+ * @see lib/fdpgen/tlayout.c:fdp_tLayout
+ */
+export declare function fdpTLayout(g: Graph, xpms: XParams): void;
+//# sourceMappingURL=tlayout.d.ts.map

package/dist/layout/fdp/tlayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tlayout.d.ts","sourceRoot":"","sources":["../../../src/layout/fdp/tlayout.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAKlD,OAAO,EAEL,KAAK,OAAO,EAMb,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAM/G;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,IAAI;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAQpE;AA8ND;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAyBxD"}

package/dist/layout/fdp/xlayout.d.ts

@@ -0,0 +1,26 @@
+/**
+ * fdp expansion layout: grow the point-node layout so sized nodes do
+ * not overlap, by force iteration with overlap-aware repulsion.
+ *
+ * Spec read at the 15.0.0 tag (the post-tag Mlimit force cutoff is
+ * deliberately NOT ported — the golden refs predate it).
+ *
+ * The default overlap attribute is "9:prism": up to 9 x_layout tries,
+ * then removeOverlapAs with the remaining mode. x_layout does NOT always
+ * converge (many cluster/derived graphs reach the mode dispatch), so
+ * removeOverlapAs wires the ported neato adjust machinery: AM_PRISM via
+ * fdpAdjust, the scale family via scAdjust. On the GTS reference build
+ * overlap=false resolves to AM_PRISM (value 1000), not a no-op.
+ *
+ * @see lib/fdpgen/xlayout.c (15.0.0)
+ */
+import type { Graph } from '../../model/graph.js';
+import { type XParams } from './fdp-model.js';
+/**
+ * Overlap-removal dispatch on the overlap attribute:
+ *   ""/null → default "9:prism"; "n:mode" → n x_layout tries, then
+ *   removeOverlap with mode; "true" → keep overlaps.
+ * @see lib/fdpgen/xlayout.c:fdp_xLayout
+ */
+export declare function fdpXLayout(g: Graph, xpms: XParams): void;
+//# sourceMappingURL=xlayout.d.ts.map

package/dist/layout/fdp/xlayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xlayout.d.ts","sourceRoot":"","sources":["../../../src/layout/fdp/xlayout.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAKlD,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,gBAAgB,CAAC;AAsQxB;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAMxD"}

package/dist/layout/neato/bfs.d.ts

@@ -0,0 +1,43 @@
+/** @see lib/neatogen/bfs.c */
+import type { VtxData } from './dijkstra.js';
+/** Sentinel for unreachable nodes (INT_MAX). @internal */
+export declare const BFS_UNREACHABLE = 2147483647;
+/** Initialise dist array; returns a queue seeded with `src`. @internal */
+export declare function bfsInit(src: number, n: number, dist: Int32Array): number[];
+/**
+ * Replace unreachable nodes (-1) with `closestDist + 10`.
+ * Matches the disconnected-graph handling in bfs.c.
+ * @internal
+ */
+export declare function bfsFixDisconnected(n: number, dist: Int32Array, closestDist: number): void;
+/** Process one BFS vertex: enqueue unvisited neighbours. @internal */
+export declare function bfsVisitNeighbors(vertex: number, graph: VtxData[], dist: Int32Array, queue: number[]): number;
+/**
+ * Single-source BFS (unweighted) from `src`.
+ * Populates `dist` with hop-distances; unreachable nodes get `BFS_UNREACHABLE`.
+ *
+ * @see lib/neatogen/bfs.c:bfs
+ */
+export declare function bfs(src: number, graph: VtxData[], n: number, dist: Int32Array): void;
+/**
+ * Index into a packed upper-triangular array of length n*(n+1)/2.
+ * Requires i <= j.
+ *
+ * @see lib/neatogen/stress.c:compute_apsp_packed
+ */
+export declare function packedIndex(i: number, j: number, n: number): number;
+/**
+ * All-pairs shortest paths (unweighted BFS) in packed upper-triangular form.
+ * Returns Float32Array of length n*(n+1)/2.
+ *
+ * @see lib/neatogen/stress.c:compute_apsp_packed
+ */
+export declare function computeApspPacked(graph: VtxData[], n: number): Float32Array;
+/**
+ * All-pairs shortest paths (weighted Dijkstra) in packed upper-triangular form.
+ * Returns Float32Array of length n*(n+1)/2.
+ *
+ * @see lib/neatogen/stress.c:compute_weighted_apsp_packed
+ */
+export declare function computeWeightedApspPacked(graph: VtxData[], n: number): Float32Array;
+//# sourceMappingURL=bfs.d.ts.map

package/dist/layout/neato/bfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bfs.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/bfs.ts"],"names":[],"mappings":"AACA,8BAA8B;AAE9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,0DAA0D;AAC1D,eAAO,MAAM,eAAe,aAAa,CAAC;AAM1C,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAI1E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,UAAU,EAChB,WAAW,EAAE,MAAM,GAClB,IAAI,CAIN;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EAAE,EAChB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAWR;AAMD;;;;;GAKG;AACH,wBAAgB,GAAG,CACjB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EAAE,EAChB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,UAAU,GACf,IAAI,CASN;AAMD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EAAE,EAChB,CAAC,EAAE,MAAM,GACR,YAAY,CAQd;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,EAAE,EAChB,CAAC,EAAE,MAAM,GACR,YAAY,CAQd"}

package/dist/layout/neato/cdt-surface.d.ts

@@ -0,0 +1,16 @@
+/** Triangulated surface. @see lib/neatogen/delaunay.h:surface_t */
+export interface Surface {
+    nfaces: number;
+    /** vertex indices of face i: faces[3i..3i+2] (CCW) */
+    faces: number[];
+    /** face indices sharing a side with face i (−1 padded): neigh[3i..3i+2] */
+    neigh: number[];
+}
+/**
+ * Build the constrained Delaunay surface over n points with nsegs directed
+ * constraint segments (segs[2k], segs[2k+1]), removing hole faces.
+ * Returns null when no proper triangulation exists.
+ * @see lib/neatogen/delaunay.c:tri / mkSurface
+ */
+export declare function mkSurface(x: number[], y: number[], n: number, segs: number[], nsegs: number): Surface | null;
+//# sourceMappingURL=cdt-surface.d.ts.map

package/dist/layout/neato/cdt-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdt-surface.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/cdt-surface.ts"],"names":[],"mappings":"AAsCA,mEAAmE;AACnE,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2EAA2E;IAC3E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAukBD;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GACjE,OAAO,GAAG,IAAI,CAwDhB"}

package/dist/layout/neato/conjgrad.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Conjugate gradient solvers for packed symmetric float matrices.
+ * @see lib/neatogen/conjgrad.c
+ */
+/**
+ * Subtract mean from `v` in-place (orthogonalize against constant vector).
+ * Matches `orthog1f` in lib/neatogen/matrix_ops.c.
+ * @see lib/neatogen/matrix_ops.c:orthog1f
+ */
+export declare function orthog1f(n: number, v: Float32Array): void;
+/**
+ * Multiply packed symmetric matrix `A` by vector `x`, writing result to `y`.
+ * `A` is upper-triangular, row-major, length n*(n+1)/2.
+ * Matches `right_mult_with_vector_ff` in lib/neatogen/matrix_ops.c.
+ * @see lib/neatogen/matrix_ops.c:right_mult_with_vector_ff
+ */
+export declare function rightMultVecFF(A: Float32Array, n: number, x: Float32Array, y: Float32Array): void;
+/** Maximum absolute value in float array. @internal */
+export declare function maxAbsF(n: number, v: Float32Array): number;
+/** Inner product of two float arrays. @internal */
+export declare function dotF(n: number, a: Float32Array, b: Float32Array): number;
+/** CG state bundle. @internal */
+interface CgState {
+    r: Float32Array;
+    p: Float32Array;
+    Ap: Float32Array;
+    rr: number;
+}
+/**
+ * Initialise CG state from A, x, b (with orthogonalization).
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+export declare function cgInit(A: Float32Array, x: Float32Array, b: Float32Array, n: number): CgState;
+/**
+ * Update p and rr after a non-final CG step.
+ * Returns 1 on zero-length error, 0 on success.
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+export declare function cgUpdateDirection(n: number, alpha: number, state: CgState): number;
+/**
+ * Execute one CG iteration on packed matrix A.
+ * Returns 0 = continue, 1 = zero-length error, 2 = p·Ap zero (done).
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+export declare function cgStep(A: Float32Array, x: Float32Array, n: number, state: CgState, last: boolean): number;
+/** Options for {@link conjugateGradientMkernel}. */
+export interface CgOptions {
+    tol: number;
+    maxIterations: number;
+}
+/**
+ * Conjugate gradient solver for packed symmetric float matrix `A`.
+ * Solves A·x = b in place (x is both initial guess and output).
+ * `b` and `x` are orthogonalized against 1 before and during iteration.
+ * Returns 0 on success, 1 if a zero-length vector is encountered.
+ *
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+export declare function conjugateGradientMkernel(A: Float32Array, x: Float32Array, b: Float32Array, n: number, opts: CgOptions): number;
+export {};
+//# sourceMappingURL=conjgrad.d.ts.map

package/dist/layout/neato/conjgrad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conjgrad.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/conjgrad.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,GAAG,IAAI,CAKzD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,GACd,IAAI,CASN;AAED,uDAAuD;AACvD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM,CAO1D;AAED,mDAAmD;AACnD,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM,CAIxE;AAED,iCAAiC;AACjC,UAAU,OAAO;IACf,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;IAChB,EAAE,EAAE,YAAY,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,wBAAgB,MAAM,CACpB,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,MAAM,GACR,OAAO,CAST;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,GACb,MAAM,CASR;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CACpB,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,OAAO,GACZ,MAAM,CAWR;AAED,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,SAAS,GACd,MAAM,CASR"}

package/dist/layout/neato/delaunay.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Sign of the incircle determinant: > 0 iff d is strictly inside the
+ * circumcircle of ccw triangle (a,b,c); the sign flips for cw triangles,
+ * so callers pass an orientation factor.
+ */
+export declare function incircle(px: number[], py: number[], a: number, b: number, c: number, d: number): number;
+/** Robust orientation: > 0 for ccw (a,b,c). */
+export declare function orient2d(px: number[], py: number[], a: number, b: number, c: number): number;
+export interface Tri {
+    a: number;
+    b: number;
+    c: number;
+    /** +1 ccw / −1 cw — fixed at creation so incircle signs are comparable */
+    orient: number;
+}
+export declare function makeTri(px: number[], py: number[], a: number, b: number, c: number): Tri;
+/** Insert point p, retriangulating the cavity of triangles whose
+ * circumcircle strictly contains it. */
+export declare function bwInsert(px: number[], py: number[], tris: Tri[], p: number): void;
+/** Bowyer–Watson over deduplicated point ids; null if no proper face. */
+export declare function bowyerWatson(px: number[], py: number[], ids: number[]): Tri[] | null;
+/**
+ * Compute the Delaunay edge list for n points. Returns pairs [i,j,...] in
+ * sorted (i,j) order, or the sorted-chain fallback for collinear input.
+ * @see lib/neatogen/delaunay.c:delaunay_tri
+ */
+export declare function delaunayTri(xv: number[], yv: number[], n: number): number[];
+//# sourceMappingURL=delaunay.d.ts.map

package/dist/layout/neato/delaunay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delaunay.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/delaunay.ts"],"names":[],"mappings":"AAwFA;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GACrE,MAAM,CAsBR;AAED,+CAA+C;AAC/C,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAc5F;AAMD,MAAM,WAAW,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,CAExF;AAED;wCACwC;AACxC,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAsBjF;AAED,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,CAmBpF;AAMD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAmD3E"}

package/dist/layout/neato/dijkstra.d.ts

@@ -0,0 +1,80 @@
+/** @see lib/neatogen/dijkstra.c */
+import type { GraphSgd } from './sgd.js';
+/**
+ * Sparse-graph vertex descriptor used by neato layout algorithms.
+ * Matches `vtx_data` in lib/neatogen/sparsegraph.h.
+ *
+ * - `nedges`: total entries including self at index 0
+ * - `edges[0]` = self-index; `edges[1..]` = neighbor indices
+ * - `ewgts[k]` = edge weight for `edges[k]`
+ *
+ * @see lib/neatogen/sparsegraph.h:vtx_data
+ */
+export interface VtxData {
+    nedges: number;
+    edges: number[];
+    ewgts: number[];
+}
+/**
+ * A term used by the SGD layout engine.
+ * Matches `term_sgd` in lib/neatogen/sgd.h.
+ * @see lib/neatogen/sgd.h:term_sgd
+ */
+export interface TermSgd {
+    i: number;
+    j: number;
+    d: number;
+    w: number;
+}
+/** Push vertex index `idx` into the heap. @internal */
+export declare function heapPush(heap: number[], dist: Float32Array, idx: number): void;
+/** Sift the root down to restore heap order after replacing it. @internal */
+export declare function heapSiftDown(heap: number[], dist: Float32Array): void;
+/** Pop and return the vertex with minimum distance. @internal */
+export declare function heapPop(heap: number[], dist: Float32Array): number;
+/** Build a min-heap from all nodes except `src`. @internal */
+export declare function heapBuildExcluding(src: number, n: number, dist: Float32Array): number[];
+/** Initialise dist array from source edges. @internal */
+export declare function dijkstraInitDist(src: number, graph: VtxData[], n: number, dist: Float32Array): void;
+/** Relax all outgoing edges of `closest`. @internal */
+export declare function dijkstraRelax(closest: number, closestDist: number, graph: VtxData[], dist: Float32Array, heap: number[]): void;
+/**
+ * Single-source shortest paths (weighted) from `src`.
+ * Populates `dist` with Float32 distances; unreachable nodes get Infinity.
+ * Equivalent to `dijkstra_f` in lib/neatogen/dijkstra.c.
+ *
+ * @see lib/neatogen/dijkstra.c:dijkstra_f
+ */
+export declare function dijkstra(src: number, graph: VtxData[], n: number, dist: Float32Array): void;
+/**
+ * BFS single-source distances for unweighted graphs.
+ * Fills `dist` with hop counts; unreachable nodes get BFS_INF (0x7fffffff).
+ * edges[0] of each vertex is the self-loop and is skipped.
+ * @see lib/neatogen/bfs.c:bfs
+ */
+export declare function bfsDistances(src: number, graph: VtxData[], n: number, dist: Float32Array): void;
+/**
+ * All-pairs shortest paths (unweighted), packed upper-triangular.
+ * Length n*(n+1)/2; index for (i,j) j>=i: i*(2n-i-1)/2 + j.
+ * @see lib/neatogen/stress.c:compute_apsp_packed
+ */
+export declare function computeApspPacked(graph: VtxData[], n: number): Float32Array;
+/**
+ * All-pairs shortest paths (weighted), packed upper-triangular.
+ * Length n*(n+1)/2.
+ * @see lib/neatogen/stress.c:compute_weighted_apsp_packed
+ */
+export declare function computeWeightedApspPacked(graph: VtxData[], n: number): Float32Array;
+/** Initialise SGD dists from source's adjacency list. @internal */
+export declare function sgdInitDist(graph: GraphSgd, src: number, dists: Float32Array): void;
+/** Relax SGD neighbours of `closest` and push updates onto `heap`. @internal */
+export declare function sgdRelaxNeighbors(graph: GraphSgd, closest: number, d: number, dists: Float32Array, heap: number[]): void;
+/**
+ * Single-source shortest paths for the SGD engine.
+ * Writes terms for all reachable `j < src` and pinned nodes.
+ * Returns the count of terms written.
+ *
+ * @see lib/neatogen/dijkstra.c:dijkstra_sgd
+ */
+export declare function dijkstraSgd(graph: GraphSgd, src: number, terms: TermSgd[]): number;
+//# sourceMappingURL=dijkstra.d.ts.map

package/dist/layout/neato/dijkstra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dijkstra.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/dijkstra.ts"],"names":[],"mappings":"AACA,mCAAmC;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AASD,uDAAuD;AACvD,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,MAAM,GACV,IAAI,CAWN;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAcrE;AAED,iEAAiE;AACjE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,CAOlE;AAED,8DAA8D;AAC9D,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,YAAY,GACjB,MAAM,EAAE,CAMV;AAMD,yDAAyD;AACzD,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EAAE,EAChB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,YAAY,GACjB,IAAI,CAKN;AAED,uDAAuD;AACvD,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,MAAM,EAAE,GACb,IAAI,CAUN;AAMD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EAAE,EAChB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,YAAY,GACjB,IAAI,CASN;AAMD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EAAE,EAChB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,YAAY,GACjB,IAAI,CAeN;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAS3E;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,EAAE,EAChB,CAAC,EAAE,MAAM,GACR,YAAY,CASd;AAMD,mEAAmE;AACnE,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,EACf,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,YAAY,GAClB,IAAI,CAMN;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,MAAM,EAAE,GACb,IAAI,CAUN;AAMD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,EACf,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EAAE,GACf,MAAM,CAgBR"}

package/dist/layout/neato/fdp-adjust.d.ts

@@ -0,0 +1,31 @@
+/**
+ * adjustNodes overlap-mode dispatch including AM_PRISM — the reference
+ * binary is built with GTS+SFDP, so `overlap=false` (or any value that is
+ * neither a named mode nor a recognizable boolean) resolves to PRISM, not
+ * to a no-op. `overlap=true` (or unset) is AM_NONE.
+ *
+ * @see lib/neatogen/adjust.c:getAdjustMode / adjustMode table
+ * @see lib/neatogen/adjust.c:fdpAdjust / removeOverlapWith / adjustNodes
+ */
+import type { Graph } from '../../model/graph.js';
+/**
+ * Resolved PRISM try count for `flag`, or null when the mode is not PRISM
+ * (AM_NONE, a scale-family mode, or an unported named mode). Note
+ * "prism0" IS prism with ntry=0 — remove_overlap still applies the
+ * initial scaling before its `if (!ntry) return`.
+ * @see adjust.c:getAdjustMode
+ */
+export declare function overlapPrismTries(flag: string | undefined): number | null;
+/**
+ * PRISM node-overlap removal over ND_pos (inches).
+ * @see lib/neatogen/adjust.c:fdpAdjust
+ */
+export declare function fdpAdjust(g: Graph, ntry: number): void;
+/**
+ * Full adjustNodes: scale-family via scAdjust, PRISM via fdpAdjust,
+ * everything else a no-op (AM_NONE, or a mode with no divergent corpus
+ * coverage — see sc-adjust module doc).
+ * @see lib/neatogen/adjust.c:adjustNodes / removeOverlapWith
+ */
+export declare function adjustNodesFull(g: Graph): number;
+//# sourceMappingURL=fdp-adjust.d.ts.map

package/dist/layout/neato/fdp-adjust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fdp-adjust.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/fdp-adjust.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAuClD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAUzE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAgCtD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAShD"}

package/dist/layout/neato/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Neato layout engine entry point.
+ *
+ * Wires together neatoInitNode, setSeed, solveModel, removeOverlap,
+ * splineEdges, neatoTranslate, and neatoSetAspect into the full neato
+ * layout pipeline, and exports NEATO_LAYOUT_ENGINE for registration with
+ * GvcContext.
+ *
+ * @see lib/neatogen/neatoinit.c:neato_layout
+ * @see lib/neatogen/neatoprocs.h
+ */
+import type { Graph } from '../../model/graph.js';
+import type { LayoutEngine } from '../../gvc/context.js';
+export { MODE_KK, MODE_MAJOR, MODE_HIER, MODE_IPSEP, MODE_SGD, MODEL_SHORTPATH, MODEL_CIRCUIT, MODEL_SUBSET, MODEL_MDS, neatoInitNode, setSeed, solveModel, neatoTranslate, neatoSetAspect, neatoCleanup, } from './init.js';
+/**
+ * Parse `g.info.mode` string into a numeric mode constant.
+ * Defaults to MODE_MAJOR when unset or unrecognised.
+ *
+ * @see lib/neatogen/neato.h:neatoMode
+ */
+export declare function parseMode(g: Graph): number;
+/**
+ * Parse `g.info.model` string into a numeric model constant.
+ * Defaults to MODEL_SHORTPATH when unset or unrecognised.
+ *
+ * @see lib/neatogen/neato.h:neatoModel
+ */
+export declare function parseModel(g: Graph): number;
+/**
+ * Apply VPSC overlap removal unless `g.info.overlap === 'false'`.
+ *
+ * @see lib/neatogen/neatoinit.c:neato_layout (removeOverlapWith call)
+ */
+export declare function maybeRemoveOverlap(g: Graph): void;
+/**
+ * Full neato layout pipeline for a single graph.
+ *
+ * Pipeline (matches neato_layout in C):
+ * 1. Init common node geometry (lw, rw, ht defaults)
+ * 2. Init each node (pos, UF_size, default width/height)
+ * 3. Parse mode and seed from graph attributes
+ * 4. Solve the layout (SGD, stress majorization, or KK)
+ * 5. Optionally remove overlaps via VPSC
+ * 6. Route edges as splines
+ * 7. Translate so minimum position is (0,0)
+ * 8. Convert inches → points into coord
+ *
+ * @see lib/neatogen/neatoinit.c:neato_layout
+ */
+export declare function neatoLayout(g: Graph): void;
+/**
+ * LayoutEngine descriptor for registration with GvcContext.
+ *
+ * @see lib/gvc/gvplugin.h:gvlayout_engine_s
+ * @see lib/neatogen/neatoprocs.h
+ */
+export declare const NEATO_LAYOUT_ENGINE: LayoutEngine;
+//# sourceMappingURL=index.d.ts.map

package/dist/layout/neato/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/index.ts"],"names":[],"mappings":"AACA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AA0CzD,OAAO,EACL,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EACpD,eAAe,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EACvD,aAAa,EAAE,OAAO,EAAE,UAAU,EAClC,cAAc,EAAE,cAAc,EAAE,YAAY,GAC7C,MAAM,WAAW,CAAC;AAenB;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAI1C;AAcD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAK3C;AAMD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CA6BjD;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CA0D1C;AAqED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAIjC,CAAC"}