@knowvah/dot-engine 0.1.0

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

@@ -0,0 +1,166 @@
+/**
+ * Stochastic Gradient Descent (SGD) layout engine for neato.
+ * Ported from lib/neatogen/sgd.c.
+ *
+ * @see lib/neatogen/sgd.c
+ * @see lib/neatogen/sgd.h
+ */
+import type { Graph } from '../../model/graph.js';
+import type { TermSgd } from './dijkstra.js';
+import type { RkState } from '../../util/mt19937.js';
+/** Shortest-path distance model. @see lib/neatogen/defs.h */
+export declare const MODEL_SHORTPATH = 0;
+/** Circuit resistance distance model (falls back to MODEL_SHORTPATH). */
+export declare const MODEL_CIRCUIT = 1;
+/** Subset / Jaccard distance model. @see lib/neatogen/defs.h */
+export declare const MODEL_SUBSET = 2;
+/** MDS distance model (falls back to MODEL_SHORTPATH). */
+export declare const MODEL_MDS = 3;
+/**
+ * Compressed-sparse-row adjacency structure for the SGD Dijkstra pass.
+ * `pinneds[i]` is true if node i is position-fixed.
+ *
+ * @see lib/neatogen/sgd.h:graph_sgd
+ */
+export interface GraphSgd {
+    n: number;
+    /** CSR row pointers, length n+1. */
+    sources: number[];
+    /** CSR column indices. */
+    targets: number[];
+    weights: Float32Array;
+    /** true if node is position-fixed. */
+    pinneds: boolean[];
+}
+/**
+ * Assign sequential `info.id` to all nodes and count non-self-loop edge ends.
+ * @internal
+ * @see lib/neatogen/sgd.c:extract_adjacency (first pass)
+ */
+export declare function assignNodeIds(g: Graph): {
+    nNodes: number;
+    nEdges: number;
+};
+/**
+ * Append CSR entries for all non-self-loop edges incident on node `np`.
+ * Returns the number of edges appended.
+ * @internal
+ */
+export declare function fillNodeEdges(np: import('../../model/node.js').Node, g: Graph, graph: GraphSgd, edgeOffset: number): number;
+/**
+ * Populate the CSR sources/targets/weights/pinneds arrays.
+ * @internal
+ * @see lib/neatogen/sgd.c:extract_adjacency (second pass)
+ */
+export declare function fillCsrEdges(g: Graph, graph: GraphSgd): void;
+/**
+ * Compute degree of node `j` and its intersection with neighbour-set `nI`.
+ * Populates scratch array `nJ` (reset on return).
+ * Returns `{ degJ, intersect }`.
+ * @internal
+ */
+export declare function subsetDegreeJ(graph: GraphSgd, j: number, nI: Uint8Array, nJ: Uint8Array): {
+    degJ: number;
+    intersect: number;
+};
+/**
+ * Process all edges from node `i` in the subset model, updating weights.
+ * @internal
+ */
+export declare function subsetNodeWeights(graph: GraphSgd, i: number, nI: Uint8Array, nJ: Uint8Array): void;
+/**
+ * Recompute CSR edge weights using the Jaccard (subset) model.
+ * @internal
+ * @see lib/neatogen/sgd.c:extract_adjacency (MODEL_SUBSET block)
+ */
+export declare function applySubsetWeights(graph: GraphSgd): void;
+/**
+ * Build a GraphSgd CSR structure from the graph.
+ * Self-loops are skipped. For MODEL_SUBSET, edge weights are recomputed.
+ *
+ * @see lib/neatogen/sgd.c:extract_adjacency
+ */
+export declare function extractAdjacency(g: Graph, model: number): GraphSgd;
+/**
+ * Run Dijkstra from each unfixed node and accumulate SGD terms.
+ * Matches the term-building loop in sgd.c.
+ *
+ * @see lib/neatogen/sgd.c:sgd (term-building loop)
+ */
+export declare function sgdBuildTerms(graph: GraphSgd): TermSgd[];
+/**
+ * In-place Fisher-Yates shuffle of a TermSgd array using MT19937.
+ *
+ * @see lib/neatogen/sgd.c:fisheryates_shuffle
+ */
+export declare function fisheryatesShuffle(terms: TermSgd[], state: RkState): void;
+/**
+ * Assign random initial positions to unpinned nodes with no position set.
+ * Uses MT19937 for deterministic, seed-controlled output.
+ *
+ * @see lib/neatogen/stuff.c:initial_positions
+ * @see lib/neatogen/stuff.c:randompos
+ */
+export declare function initialPositions(g: Graph, state: RkState): void;
+/**
+ * Compute the annealing schedule parameters from the term weights.
+ *
+ * eta_max = 1/w_min; eta_min = DFLT_TOLERANCE/w_max
+ * lambda  = log(eta_max/eta_min) / (maxIter - 1)
+ *
+ * @see lib/neatogen/sgd.c:sgd (initialise annealing schedule)
+ */
+export declare function computeSchedule(terms: TermSgd[], maxIter: number): {
+    etaMax: number;
+    lambda: number;
+};
+/**
+ * Apply one SGD sweep over all terms at step size `eta`.
+ *
+ * @see lib/neatogen/sgd.c:sgd (inner ij-loop)
+ */
+export declare function sgdIteration(pos: Float64Array, terms: TermSgd[], unfixed: boolean[], eta: number): void;
+/**
+ * Copy node positions from graph into a flat Float64Array (x, y interleaved).
+ * @internal
+ * @see lib/neatogen/sgd.c:sgd (copy initial positions into pos[])
+ */
+export declare function posToArray(g: Graph, n: number): Float64Array;
+/**
+ * Write positions from flat Float64Array back into graph node info.
+ * @internal
+ * @see lib/neatogen/sgd.c:sgd (copy temporary positions back into graph_t)
+ */
+export declare function posFromArray(g: Graph, pos: Float64Array): void;
+/**
+ * Build the `unfixed` boolean array (true = node may be moved).
+ * @internal
+ * @see lib/neatogen/sgd.c:sgd (unfixed[] array setup)
+ */
+export declare function buildUnfixed(g: Graph, n: number): boolean[];
+/**
+ * Normalise the model constant, falling back unsupported models to
+ * MODEL_SHORTPATH with a warning.
+ *
+ * @see lib/neatogen/sgd.c:sgd (model fallback block)
+ */
+export declare function resolveModel(model: number): number;
+/** Optimisation loop: shuffle and step for MAX_ITER iterations. @see lib/neatogen/sgd.c:sgd */
+export declare function runSgdLoop(pos: Float64Array, terms: TermSgd[], unfixed: boolean[], sched: {
+    etaMax: number;
+    lambda: number;
+}, state: RkState): void;
+/**
+ * Run the SGD layout algorithm on graph `g`.
+ *
+ * MODEL_CIRCUIT and MODEL_MDS are not yet supported and fall back to
+ * MODEL_SHORTPATH with a console.warn (matching agwarningf in C).
+ *
+ * Node positions are written to `node.info.pos` ([x, y]).
+ * Nodes with `node.info.pinned === true` are not moved.
+ * `g.info.seed` controls the MT19937 seed (default 0).
+ *
+ * @see lib/neatogen/sgd.c:sgd
+ */
+export declare function sgdLayout(g: Graph, model: number): void;
+//# sourceMappingURL=sgd.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgd.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/sgd.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAMrD,6DAA6D;AAC7D,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,yEAAyE;AACzE,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,gEAAgE;AAChE,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,0DAA0D;AAC1D,eAAO,MAAM,SAAS,IAAI,CAAC;AAa3B;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,oCAAoC;IACpC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,0BAA0B;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,YAAY,CAAC;IACtB,sCAAsC;IACtC,OAAO,EAAE,OAAO,EAAE,CAAC;CACpB;AAMD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAY1E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,OAAO,qBAAqB,EAAE,IAAI,EACtC,CAAC,EAAE,KAAK,EACR,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,MAAM,GACjB,MAAM,CAcR;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAU5D;AAMD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,QAAQ,EACf,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,UAAU,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAWrC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,EACf,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,UAAU,GACb,IAAI,CAaN;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAMxD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAclE;AAMD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,EAAE,CAWxD;AAMD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAOzE;AAMD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAS/D;AAMD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,EAAE,MAAM,GACd;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAWpC;AAMD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,EAAE,OAAO,EAAE,EAClB,GAAG,EAAE,MAAM,GACV,IAAI,CAcN;AAMD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAU5D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAQ9D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAO3D;AAMD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAclD;AAED,+FAA+F;AAC/F,wBAAgB,UAAU,CACxB,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,EAAE,OAAO,EAAE,EAClB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzC,KAAK,EAAE,OAAO,GACb,IAAI,CAMN;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAuBvD"}

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

@@ -0,0 +1,153 @@
+/**
+ * Neato spline routing entry point.
+ *
+ * Faithful port of lib/neatogen/neatosplines.c — splineEdges dispatch,
+ * makeObstacle, makeSelfArcs, and supporting helpers.
+ *
+ * Full multispline.c routing is stubbed: when pathplan-based routing is
+ * attempted but would require multi-path resolution, the code falls back to
+ * straight-line edges. This covers the acceptance criteria surface area.
+ *
+ * @see lib/neatogen/neatosplines.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { Point } from '../../model/geom.js';
+import type { SplineInfo } from '../../common/types.js';
+import type { ExpandT } from './sep-factor.js';
+import type { Poly, VConfig } from '../../pathplan/types.js';
+import { newSpline } from '../../common/splines-clip.js';
+export { EDGETYPE_NONE, EDGETYPE_LINE, EDGETYPE_ORTHO, EDGETYPE_PLINE, EDGETYPE_SPLINE, } from '../dot/splines.js';
+export declare const EDGETYPE_CURVED = 2;
+/** Open visibility config produced by obsOpen(). */
+type VisConfig = VConfig;
+/** @see lib/neatogen/neatosplines.c:swap_ends_p */
+export declare function swapEndsP(_e: unknown): boolean;
+/** @see lib/neatogen/neatosplines.c:spline_merge */
+export declare function splineMerge(_n: unknown): boolean;
+/** @see lib/neatogen/neatosplines.c:sinfo */
+export declare const SINFO: SplineInfo;
+/**
+ * Obstacle polygon reflecting the node's geometry, vertices in CW order:
+ * the shape's own outline-periphery vertices (+margin) for polygons, an
+ * 8-gon circumscribed about the outline ellipse for ellipses, the field
+ * box for records, the node box for EPSF. Null = unsupported shape (the
+ * node is skipped as an obstacle, C returns NULL).
+ *
+ * @see lib/neatogen/neatosplines.c:makeObstacle
+ */
+export declare function makeObstacle(n: Node, pmargin: ExpandT): Poly | null;
+/**
+ * The isOrtho branch of C makeObstacle for SH_POLY/SH_POINT nodes: the
+ * obstacle is the node's OUTLINE box (size + penwidth outline) with NO
+ * margin — margin stays {0,0}, so tightly packed layouts (osage's 4pt
+ * gutters) remain a legal arrangement and the maze routes them; the
+ * margined rectangle makes neighbours touch and forces the straight
+ * fallback. Records fall through to the margined box like C's SH_RECORD
+ * branch (no isOrtho special case there).
+ *
+ * @see lib/neatogen/neatosplines.c:makeObstacle (isOrtho, vs[0..3])
+ */
+export declare function makeOrthoObstacle(n: Node, sep: ExpandT): Poly | null;
+/**
+ * Install a straight-line (two-point) spline on an edge.
+ *
+ * Used when pathplan routing is unavailable or edgetype == EDGETYPE_LINE.
+ *
+ * @see lib/neatogen/neatosplines.c (straight-line fallback in spline_edges_)
+ */
+export declare function makeStraightEdge(e: Edge, sinfo: SplineInfo): void;
+/**
+ * Route self-loop edges via makeSelfEdge, handling single and chained cases.
+ * Under concentrate only the representative is routed (C: cnt==1||Concentrate).
+ *
+ * @see lib/neatogen/neatosplines.c:makeSelfArcs
+ */
+export declare function makeSelfArcs(e: Edge, stepx: number): void;
+/**
+ * Coalesce equivalent edges, mirroring the C splineEdges wrapper
+ * (neatosplines.c:753-773): the FIRST edge of a class (agfstnode/agfstout
+ * order) becomes the leader with ED_count = 1 (set by newitem on dict
+ * insert); each later member increments the leader's count, gets count 0,
+ * and is prepended to the leader's ED_to_virt chain. The routing loop then
+ * skips count==0 members and routes the leader's whole chain (or only the
+ * representative under concentrate).
+ *
+ * @see lib/neatogen/neatosplines.c:splineEdges (find equivalent edges)
+ * @see lib/neatogen/neatosplines.c:newitem (ED_count(leader) = 1)
+ */
+export declare function coalesceEdges(g: Graph): void;
+/**
+ * The pathfinding half of C's two passes: ED_path(e) = getPath(e, vconfig).
+ * @see lib/neatogen/neatosplines.c:getPath
+ */
+export declare function edgePath(e: Edge, vconfig: VisConfig): Point[];
+/** @see lib/neatogen/neatosplines.c:makeSpline */
+export declare function makeSplineEdge(e: Edge, obstacles: Poly[], vconfig: VisConfig, edgetype: number): void;
+/** @see lib/neatogen/neatosplines.c:spline_edges_ */
+export declare function splineEdgesImpl(g: Graph, sep: ExpandT, edgetype: number): void;
+/**
+ * Main spline routing entry point for neato layout.
+ *
+ * Dispatch:
+ * 1. EDGETYPE_NONE  → skip
+ * 2. EDGETYPE_LINE  → straight lines for all edges
+ * 3. EDGETYPE_ORTHO → orthoEdges (if obstacles legal, else straight)
+ * 4. EDGETYPE_SPLINE / EDGETYPE_PLINE → pathplan routing with straight fallback
+ *
+ * @see lib/neatogen/neatosplines.c:spline_edges0, spline_edges1, splineEdges
+ */
+export declare function splineEdges(g: Graph): void;
+/**
+ * Graph bounding box in points derived from node pos (inches) and node
+ * sizes, expanded by any existing edge splines. xlabels are not ported
+ * (no engine sets them yet).
+ * @see lib/common/utils.c:compute_bb
+ */
+export declare function computeBBFromPos(g: Graph): {
+    ll: Point;
+    ur: Point;
+};
+/**
+ * T1 (iterative-parity-campaign, batch-1) injection hook: when
+ * `GVTS_POS_INJECT` names a dump file, overwrite `n.info.pos` for every
+ * matching node name before this module's own routing runs — mirroring the
+ * native `spline_edges` entry point where the session-local POS_DUMP patch
+ * captures oracle `ND_pos` (see
+ * `plans/iterative-parity-campaign/diagrams/injection-recipe.md`). This lets
+ * the attribution harness separate "port routing/emission is wrong" from
+ * "the port's own node placement is just a different (but internally
+ * consistent) FP-drift outcome" for the iterative engines (D1: pre-routing
+ * `ND_pos` stage only).
+ *
+ * Dump lines look like `GVTS_POS <name> <x> <y>` (any other line, e.g. dot's
+ * own stderr warnings mixed into the same capture, is ignored). Reads via
+ * `process.getBuiltinModule` rather than a static `node:fs` import so the
+ * browser bundle (esbuild, no `--platform=node`) never tries to resolve a
+ * Node builtin — this whole function is inert (returns immediately) unless
+ * `process` exists and `GVTS_POS_INJECT` is set, which is true only inside
+ * the Node test harness, never in a browser render.
+ *
+ * An optional `GVTS_BB <llx> <lly> <urx> <ury>` line (points) overwrites the
+ * graph bb as well. It is emitted only by the *fdp* dump site, and it is
+ * load-bearing there: neato/sfdp reach this hook at the top of `spline_edges`,
+ * one line ABOVE the `compute_bb` that derives GD_bb — so their bb is a pure
+ * function of the injected positions and needs no injection of its own. fdp is
+ * the exception: `GD_bb` is a product of `fdpLayout` itself (`finalCC` →
+ * `setBB`, layout.c:1030), which has already run and returned by the time the
+ * hook fires, so without this line the injected render keeps the port's OWN
+ * (drifted) bb while emitting the oracle's node positions — a bb that belongs
+ * to neither layout. That mismatch, not any defect in the port's bb code, is
+ * what made `graph/bb`+`graph/_draw_` the largest not-cleared fdp bucket (60
+ * ids, bb short on 24 and TALL on 18 — a sign-split no bb bug can produce).
+ * The bb is layout-stage state exactly like `ND_pos`; neutralizing it is what
+ * lets the comparison isolate routing/emission, which is all the harness
+ * claims to measure.
+ * @see lib/fdpgen/layout.c:1063 fdp_layout
+ */
+export declare function injectOraclePositions(g: Graph): void;
+export declare function splineEdgesShifted(g: Graph): void;
+export { newSpline };
+export type { Poly as NeatoPoly };
+//# sourceMappingURL=splines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"splines.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/splines.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;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,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAwB,MAAM,uBAAuB,CAAC;AAG9E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAO7D,OAAO,EAAE,SAAS,EAAkB,MAAM,8BAA8B,CAAC;AAwBzE,OAAO,EACL,aAAa,EAAE,aAAa,EAAE,cAAc,EAC5C,cAAc,EAAE,eAAe,GAChC,MAAM,mBAAmB,CAAC;AAC3B,eAAO,MAAM,eAAe,IAAI,CAAC;AAYjC,oDAAoD;AACpD,KAAK,SAAS,GAAG,OAAO,CAAC;AAOzB,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAkB;AAEjE,oDAAoD;AACpD,wBAAgB,WAAW,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAkB;AAEnE,6CAA6C;AAC7C,eAAO,MAAM,KAAK,EAAE,UAKnB,CAAC;AA2JF;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAkBnE;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAkCpE;AA0BD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAIjE;AAyBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAiBzD;AAkCD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAkB5C;AA4DD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,EAAE,CAO7D;AAED,kDAAkD;AAClD,wBAAgB,cAAc,CAC5B,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAC/D,IAAI,CAIN;AA8ND,qDAAqD;AACrD,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAS9E;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAqB1C;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,KAAK,CAAA;CAAE,CAoBnE;AA4BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CA0DpD;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAkBjD;AAMD,OAAO,EAAE,SAAS,EAAE,CAAC;AACrB,YAAY,EAAE,IAAI,IAAI,SAAS,EAAE,CAAC"}

package/dist/layout/neato/stress-kernel.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Dense k-D stress majorization — a float32-faithful port of
+ * stress_majorization_kD_mkernel and conjugate_gradient_mkernel.
+ * Replicates C numerics exactly (decision D3): float storage and
+ * chained-operation rounding via Math.fround, double accumulators
+ * where C uses double/long double (long double == double on AArch64
+ * macOS, where the reference SVGs were generated).
+ *
+ * smart_init (sparse subspace estimation) is not ported — no `start`
+ * attr in the suite, so checkStart always yields INIT_RANDOM.
+ *
+ * @see lib/neatogen/stress.c:stress_majorization_kD_mkernel
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+import type { Node } from '../../model/node.js';
+import { type VtxData } from './dijkstra.js';
+/** Stress options bit: weight exponent (1 or 2). @see lib/neatogen/stress.h */
+export declare const OPT_EXP_FLAG = 2;
+/** Stress options bit: smart initialisation. @see lib/neatogen/stress.h */
+export declare const OPT_SMART_INIT = 1;
+/**
+ * Packed all-pairs shortest paths over unit weights (BFS hops).
+ * @see lib/neatogen/stress.c:compute_apsp_packed
+ */
+export declare function computeApspPacked(graph: VtxData[], n: number): Float32Array;
+/**
+ * Packed all-pairs shortest paths over float edge lengths.
+ * @see lib/neatogen/stress.c:compute_weighted_apsp_packed
+ */
+export declare function computeWeightedApspPacked(graph: VtxData[], n: number): Float32Array;
+/**
+ * Random (drand48) or user-position layout initialisation; centers
+ * each axis. Returns true if some node is pinned.
+ * @see lib/neatogen/stress.c:initLayout
+ */
+export declare function initLayout(n: number, dim: number, coords: Float64Array[], nodes: Node[]): boolean;
+export declare function conjugateGradientMkernel(A: Float32Array, x: Float32Array, b: Float32Array, n: number, tol: number, maxIterations: number): number;
+/** Options for stressMajorizationKDMkernel. */
+export interface StressOpts {
+    dim: number;
+    /** opt_exp_flag (2 = squared weights, default) | opt_smart_init. */
+    opts: number;
+    /** MODEL_* — only the resulting Dij matters here; pass it in. */
+    maxi: number;
+    epsilon: number;
+}
+/**
+ * Dense stress majorization. Mutates dCoords in place; returns the
+ * iteration count (negative on error).
+ * @see lib/neatogen/stress.c:stress_majorization_kD_mkernel
+ */
+export declare function stressMajorizationKDMkernel(Dij: Float32Array, n: number, dCoords: Float64Array[], nodes: Node[], o: StressOpts): number;
+//# sourceMappingURL=stress-kernel.d.ts.map

package/dist/layout/neato/stress-kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stress-kernel.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/stress-kernel.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAY,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAqBvD,+EAA+E;AAC/E,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,2EAA2E;AAC3E,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAS3E;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CASnF;AAkBD;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAC5D,OAAO,CAgBT;AA0CD,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAC5D,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GACjC,MAAM,CAqBR;AAqHD,+CAA+C;AAC/C,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,UAAU,GAClF,MAAM,CA8CR"}

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

@@ -0,0 +1,158 @@
+/**
+ * Stress majorization layout engine for neato.
+ *
+ * Ports lib/neatogen/stress.c: stress_majorization_kD_mkernel and helpers.
+ * Kahan summation replaces C's `long double DegType` for diagonal accumulation.
+ *
+ * Implementation note: all logic lives in static class methods. Lizard 1.22.1
+ * loses function boundaries between consecutive top-level functions — it
+ * correctly resets its parser at class boundaries. Thin exported wrappers
+ * delegate to static methods so the public API is unchanged.
+ *
+ * @see lib/neatogen/stress.c
+ * @see lib/neatogen/stress.h
+ */
+import type { VtxData } from './dijkstra.js';
+/** Inner CG solver tolerance. @see lib/neatogen/stress.h:tolerance_cg */
+export declare const TOLERANCE_CG = 0.001;
+/** Default max outer iterations. @see lib/neatogen/stress.h:DFLT_ITERATIONS */
+export declare const DFLT_ITERATIONS = 200;
+/** Outer stress convergence epsilon. @see lib/neatogen/stress.h:DFLT_TOLERANCE */
+export declare const DFLT_TOLERANCE = 0.0001;
+/** Smart-init flag in opts bitmask. */
+export declare const OPT_SMART_INIT = 4;
+/** Exponent flag in opts bitmask (exp=2 when set, exp=1 when clear). */
+export declare const OPT_EXP_FLAG = 3;
+/** Model: MDS (user-supplied edge lengths). */
+export declare const MODEL_MDS = 1;
+/** Model: circuit (effective resistance, falls back to BFS). */
+export declare const MODEL_CIRCUIT = 2;
+/** Model: subset (degree-reweighted BFS). */
+export declare const MODEL_SUBSET = 3;
+/** Kahan compensated-summation accumulator for Laplacian diagonal. */
+export interface KahanAcc {
+    sum: number;
+    c: number;
+}
+/** Argument bundle for stressMajorizationKD — keeps param count ≤5. */
+export interface StressOpts {
+    dim: number;
+    opts: number;
+    model: number;
+    maxi: number;
+    /**
+     * Distance exponent: 1 (default) or 2.
+     * Derived from opts bitmask inside stressMajorizationKD and injected
+     * into the bundle before each inner-loop call; not supplied by callers.
+     * @see lib/neatogen/stress.c:stress_majorization_kD_mkernel (exp assignment)
+     */
+    exp?: number;
+}
+/** Context bundle for position Laplacian construction. */
+export interface Lap1Ctx {
+    coords: Float32Array[];
+    lap1: Float32Array;
+    lap2: Float32Array;
+    degrees: KahanAcc[];
+    n: number;
+    dim: number;
+    exp: number;
+}
+/** Kahan summation helpers. */
+export declare class KahanHelper {
+    /** Add `v` to `acc` with Kahan compensation. */
+    static add(acc: KahanAcc, v: number): void;
+    /** Allocate n zero-initialised KahanAcc entries. */
+    static makeArr(n: number): KahanAcc[];
+}
+/** Helpers for building and using the weight Laplacian lap2. */
+export declare class Lap2Helper {
+    /** Invert non-zero packed entries in-place. */
+    static invertPacked(Dij: Float32Array): void;
+    /** Accumulate off-diagonal row i into degrees[] via Kahan. */
+    static accumRow(Dij: Float32Array, degrees: KahanAcc[], n: number, i: number): void;
+    /** Write Kahan sums into packed diagonal entries of arr. */
+    static writeDiag(arr: Float32Array, degrees: KahanAcc[], n: number): void;
+    /**
+     * Build weight Laplacian from packed Dij in-place.
+     * Off-diagonal w_ij = 1/d^exp; diagonal via Kahan summation.
+     * @see lib/neatogen/stress.c (Laplacian section)
+     */
+    static buildLap2(Dij: Float32Array, n: number, exp: number): void;
+}
+/** @see Lap2Helper.buildLap2 */
+export declare function buildLap2(Dij: Float32Array, n: number, exp: number): void;
+/** Helpers for building position Laplacian lap1. */
+export declare class Lap1Helper {
+    /** Squared Euclidean distance between node i and node i+1+j. */
+    static squaredDist(ctx: Lap1Ctx, i: number, j: number): number;
+    /** Compute invDist[0..n-i-2] = 1/dist clamped for overflow. */
+    static computeInvDist(ctx: Lap1Ctx, i: number, invDist: Float32Array): void;
+    /** Fill off-diagonal entries for row i; accumulate into degrees[]. */
+    static fillRow(ctx: Lap1Ctx, invDist: Float32Array, i: number): void;
+    /** Seed lap1 off-diagonals with sqrt(lap2) for exp=2. */
+    static seedSqrt(ctx: Lap1Ctx): void;
+    /**
+     * Build position-weighted Laplacian from current coords.
+     * @see lib/neatogen/stress.c (inner Laplacian construction loop)
+     */
+    static buildLap1(ctx: Lap1Ctx): void;
+}
+/** @see Lap1Helper.buildLap1 */
+export declare function buildLap1(ctx: Lap1Ctx): void;
+/** Stress and quadratic form helpers. */
+export declare class StressHelper {
+    /** Compute coords[k] · (Lap * coords[k]) summed over k. */
+    static quadForm(coords: Float32Array[], lap: Float32Array, dim: number, n: number): number;
+    /**
+     * Compute stress = 2·trace(X'L1X) + n(n-1)/2 - trace(X'L2X).
+     * @see lib/neatogen/stress.c (new_stress computation block)
+     */
+    static computeStress(coords: Float32Array[], lap1: Float32Array, lap2: Float32Array, dim: number, n: number): number;
+}
+/** @see StressHelper.computeStress */
+export declare function computeStress(coords: Float32Array[], lap1: Float32Array, lap2: Float32Array, dim: number, n: number): number;
+/** Distance model and orthogonalization helpers. */
+export declare class DijHelper {
+    /** True if any edge has a non-unit weight. */
+    static hasNonUnitWeights(graph: VtxData[]): boolean;
+    /**
+     * Compute packed APSP for the given model.
+     * MODEL_CIRCUIT falls back to BFS (not yet ported).
+     */
+    static computeDij(graph: VtxData[], n: number, model: number): Float32Array;
+    /** Orthogonalize a Float64Array against the constant vector. */
+    static orthog1d(n: number, v: Float64Array): void;
+}
+/** Coordinate helpers: conversion, copying, random initialization. */
+export declare class CoordHelper {
+    /** Copy a Float64Array axis into a new Float32Array. */
+    static toF32(src: Float64Array, n: number): Float32Array;
+    /** Build dim Float32 working arrays from dCoords. */
+    static makeFloat(dCoords: Float64Array[], dim: number, n: number): Float32Array[];
+    /** Copy Float32 working coords back to Float64 output. */
+    static copyBack(coords: Float32Array[], dCoords: Float64Array[], dim: number, n: number): void;
+    /**
+     * Initialise dCoords from rng() and orthogonalize each axis.
+     * @see lib/neatogen/stress.c:initLayout (random branch)
+     */
+    static initRandom(n: number, dim: number, dCoords: Float64Array[], rng: () => number): void;
+}
+/** @see CoordHelper.initRandom */
+export declare function initCoords(n: number, dim: number, dCoords: Float64Array[], rng: () => number): void;
+/** CG solver helpers. */
+export declare class SolveHelper {
+    /** Solve one axis via CG. Returns true on failure. */
+    static solveAxis(lap2: Float32Array, coord: Float32Array, bk: Float32Array, n: number): boolean;
+    /** Solve all dim axes. Returns true if any fails. */
+    static solveAll(coords: Float32Array[], b: Float32Array[], lap2: Float32Array, dim: number, n: number): boolean;
+    /** Compute b[k] = lap1 * coords[k] for all axes. */
+    static computeB(lap1: Float32Array, coords: Float32Array[], b: Float32Array[], dim: number, n: number): void;
+}
+/**
+ * Full dense k-D stress majorization (Kamada-Kawai energy minimization).
+ * Returns iteration count or -1 on CG failure.
+ * @see lib/neatogen/stress.c:stress_majorization_kD_mkernel
+ */
+export declare function stressMajorizationKD(graph: VtxData[], n: number, dCoords: Float64Array[], sopts: StressOpts): number;
+//# sourceMappingURL=stress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stress.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/stress.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAY7C,yEAAyE;AACzE,eAAO,MAAM,YAAY,QAAO,CAAC;AAEjC,+EAA+E;AAC/E,eAAO,MAAM,eAAe,MAAM,CAAC;AAEnC,kFAAkF;AAClF,eAAO,MAAM,cAAc,SAAO,CAAC;AAEnC,uCAAuC;AACvC,eAAO,MAAM,cAAc,IAAM,CAAC;AAElC,wEAAwE;AACxE,eAAO,MAAM,YAAY,IAAM,CAAC;AAEhC,+CAA+C;AAC/C,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,gEAAgE;AAChE,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,6CAA6C;AAC7C,eAAO,MAAM,YAAY,IAAI,CAAC;AAM9B,sEAAsE;AACtE,MAAM,WAAW,QAAQ;IAAG,GAAG,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;CAAE;AAErD,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,0DAA0D;AAC1D,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAOD,+BAA+B;AAC/B,qBAAa,WAAW;IACtB,gDAAgD;IAChD,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAO1C,oDAAoD;IACpD,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE;CAKtC;AAOD,gEAAgE;AAChE,qBAAa,UAAU;IACrB,+CAA+C;IAC/C,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAM5C,8DAA8D;IAC9D,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAQnF,4DAA4D;IAC5D,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOzE;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;CASlE;AAED,gCAAgC;AAChC,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAEzE;AAOD,oDAAoD;AACpD,qBAAa,UAAU;IACrB,gEAAgE;IAChE,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAS9D,+DAA+D;IAC/D,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI;IAS3E,sEAAsE;IACtE,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAWpE,yDAAyD;IACzD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAMnC;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;CASrC;AAED,gCAAgC;AAChC,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAA+B;AAO5E,yCAAyC;AACzC,qBAAa,YAAY;IACvB,2DAA2D;IAC3D,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAU1F;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;CAMrH;AAED,sCAAsC;AACtC,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5H;AAOD,oDAAoD;AACpD,qBAAa,SAAS;IACpB,8CAA8C;IAC9C,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO;IASnD;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY;IAS3E,gEAAgE;IAChE,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,GAAG,IAAI;CAMlD;AAMD,sEAAsE;AACtE,qBAAa,WAAW;IACtB,wDAAwD;IACxD,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY;IAMxD,qDAAqD;IACrD,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE;IAMjF,0DAA0D;IAC1D,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAM9F;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI;CAM5F;AAED,kCAAkC;AAClC,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,CAEnG;AAMD,yBAAyB;AACzB,qBAAa,WAAW;IACtB,sDAAsD;IACtD,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAI/F,qDAAqD;IACrD,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAO/G,oDAAoD;IACpD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;CAG7G;AA0BD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAuBpH"}