@knowvah/dot-engine 0.1.0

package/src/model/layoutParams.ts

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * LayoutParams, RatioKind, and FontnameKind — supporting types for GraphInfo.
+ * Ported from lib/common/types.h:layout_t and lib/common/types.h:ratio_t.
+ *
+ * @see lib/common/types.h:layout_t
+ * @see lib/common/types.h:ratio_t
+ * @see lib/common/types.h:fontname_kind
+ */
+
+import type { Point } from './geom.js';
+
+// ---------------------------------------------------------------------------
+// ratio_t — @see lib/common/types.h:ratio_t
+// ---------------------------------------------------------------------------
+
+/**
+ * Ratio kind matching ratio_t enum.
+ * R_NONE=0, R_VALUE, R_FILL, R_COMPRESS, R_AUTO, R_EXPAND
+ *
+ * @see lib/common/types.h:ratio_t
+ */
+export type RatioKind =
+  | 'none'
+  | 'value'
+  | 'fill'
+  | 'compress'
+  | 'auto'
+  | 'expand';
+
+// ---------------------------------------------------------------------------
+// fontname_kind — @see lib/common/types.h:fontname_kind
+// ---------------------------------------------------------------------------
+
+/**
+ * Controls SVG font-name mangling.
+ * NATIVEFONTS=0, PSFONTS=1, SVGFONTS=2
+ *
+ * @see lib/common/types.h:fontname_kind
+ */
+export const FontnameKind = {
+  NativeFonts: 0,
+  PsFonts: 1,
+  SvgFonts: 2,
+} as const;
+export type FontnameKind = (typeof FontnameKind)[keyof typeof FontnameKind];
+
+// ---------------------------------------------------------------------------
+// layout_t — @see lib/common/types.h:layout_t
+// ---------------------------------------------------------------------------
+
+/**
+ * Graph-level layout parameters; stored via GD_drawing.
+ *
+ * @see lib/common/types.h:layout_t
+ * @see lib/common/types.h:GD_drawing
+ */
+export interface LayoutParams {
+  /** Coordinate quantization step. @see lib/common/types.h:layout_t.quantum */
+  quantum: number;
+  /** Output scale factor. @see lib/common/types.h:layout_t.scale */
+  scale: number;
+  /**
+   * Aspect ratio; set only when ratioKind === 'value'.
+   * @see lib/common/types.h:layout_t.ratio
+   */
+  ratio: number;
+  /** Dots per inch. @see lib/common/types.h:layout_t.dpi */
+  dpi: number;
+  /** Page margin. @see lib/common/types.h:layout_t.margin */
+  margin: Point;
+  /** Page size. @see lib/common/types.h:layout_t.page */
+  page: Point;
+  /** Desired graph drawing size. @see lib/common/types.h:layout_t.size */
+  size: Point;
+  /** Fit graph to page. @see lib/common/types.h:layout_t.filled */
+  filled: boolean;
+  /** Landscape orientation. @see lib/common/types.h:layout_t.landscape */
+  landscape: boolean;
+  /** Center graph on page. @see lib/common/types.h:layout_t.centered */
+  centered: boolean;
+  /** Ratio mode. @see lib/common/types.h:layout_t.ratio_kind */
+  ratioKind: RatioKind;
+  /**
+   * Whether parallel edges should be concentrated into fewer edges.
+   * @see lib/common/globals.h:Concentrate
+   */
+  concentrate?: boolean;
+  /**
+   * Parsed xdot data; typed fully in a later batch.
+   * @see lib/common/types.h:layout_t.xdots
+   */
+  xdots: unknown | null;
+  /**
+   * Graph identifier string.
+   * @see lib/common/types.h:layout_t.id
+   */
+  id: string | null;
+}
+
+/**
+ * Construct a `LayoutParams` mirroring C's calloc-zeroed `layout_t` (GD_drawing),
+ * with the given fields overridden. C zero-inits every field, then `graph_init`
+ * sets only the ones it parses (ratio_kind, size, filled, …); this factory keeps
+ * the unset fields at their C-zero defaults so callers populate just what they
+ * need. @see lib/common/types.h:layout_t (allocated via agbindrec/calloc)
+ */
+export function makeDrawing(overrides: Partial<LayoutParams>): LayoutParams {
+  const zero: Point = { x: 0, y: 0 };
+  return {
+    quantum: 0,
+    scale: 0,
+    ratio: 0,
+    dpi: 0,
+    margin: { ...zero },
+    page: { ...zero },
+    size: { ...zero },
+    filled: false,
+    landscape: false,
+    centered: false,
+    ratioKind: 'none',
+    xdots: null,
+    id: null,
+    ...overrides,
+  };
+}

package/src/model/node.ts

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * TypeScript port of Agnode_t from lib/cgraph/cgraph.h.
+ *
+ * @see lib/cgraph/cgraph.h:Agnode_s
+ */
+
+import type { Edge } from './edge.js';
+import type { Graph } from './graph.js';
+import { type NodeInfo, makeNodeInfo } from './nodeInfo.js';
+
+/**
+ * Represents an Agnode_t — a graph node.
+ *
+ * In the C implementation, Agnode_t embeds Agobj_t (tag + data), holds a
+ * pointer to its root graph, and contains an embedded Agsubnode_t for the
+ * main graph. Per-graph membership is tracked via Agsubnode_t records in
+ * libcdt dicts. Here node identity is object identity (pointer comparison
+ * in C maps to reference equality in TypeScript).
+ *
+ * The `info` field replaces the agbindrec / ND_* mechanism (AD-1).
+ *
+ * @see lib/cgraph/cgraph.h:Agnode_s
+ * @see lib/cgraph/cgraph.h:Agsubnode_s
+ */
+export class Node {
+  /**
+   * Unique integer ID per root graph; maps to AGID in the C implementation.
+   * @see lib/cgraph/cgraph.h:AGID
+   */
+  readonly id: number;
+
+  /** Node name; agnameof equivalent. @see lib/cgraph/cgraph.h:agnameof */
+  readonly name: string;
+
+  /**
+   * String attributes (agget/agset equivalents).
+   * @see lib/cgraph/cgraph.h:Agattr_s
+   */
+  attrs: Map<string, string>;
+
+  /**
+   * Layout-engine info; replaces ND_* macros via agbindrec (AD-1).
+   * @see lib/cgraph/cgraph.h:agbindrec
+   */
+  info: NodeInfo;
+
+  /**
+   * Root graph that owns this node.
+   * @see lib/cgraph/cgraph.h:Agnode_s
+   */
+  readonly root: Graph;
+
+  /**
+   * Frozen snapshot of the node-attribute defaults (`node [...]`) in effect —
+   * from the declaring subgraph up through its ancestors — at the moment this
+   * node was first created. Captured at creation (not read live at render) so
+   * that a `node [...]` declared *after* this node in the same or an ancestor
+   * scope does not retroactively apply, matching DOT semantics. Present on
+   * parser-built nodes (even when empty); undefined on programmatically created
+   * nodes, which fall back to live graph defaults in `nodeAttr`.
+   */
+  nodeDefaultsSnapshot?: Map<string, string>;
+
+  /** @see lib/cgraph/node.c:agnode */
+  constructor(id: number, name: string, root: Graph) {
+    this.id = id;
+    this.name = name;
+    this.attrs = new Map();
+    this.info = makeNodeInfo();
+    this.root = root;
+  }
+
+  /**
+   * Returns out-edges of this node in graph g (where this node is the tail).
+   *
+   * ORDER: cgraph's per-node out-edge dict sorts by the SEQ of the edge's
+   * out-half node — the HEAD — then by edge seq (edge.c:agedgeseqcmpf,
+   * Ag_mainedge_seq_disc). Iteration is therefore by (head creation order,
+   * edge creation order), NOT by plain edge insertion order. This ordering
+   * is load-bearing for emission order and for force-accumulation order in
+   * the iterative engines.
+   *
+   * INVARIANT: In the C cgraph library, the adjacency list for a node begins
+   * with the node's own self-loop (index 0), and neighbor traversal MUST start
+   * at index 1. This convention originates from lib/cgraph/edge.c and
+   * agfstedge/agnxtedge. In this TypeScript implementation, self-loops are
+   * included in outEdges() but are excluded from inEdges() — matching the
+   * agnxtedge behavior that skips self-loops as in-edges. Callers iterating
+   * over neighbors must account for self-loop edges appearing in outEdges().
+   *
+   * @see lib/cgraph/edge.c:agfstout
+   * @see lib/cgraph/edge.c:agnxtout
+   * @see lib/cgraph/edge.c:agedgeseqcmpf
+   */
+  outEdges(g: Graph): Edge[] {
+    return g.edges
+      .filter((e) => e.tail === this)
+      .sort((a, b) => (a.head.id - b.head.id) || (a.seq - b.seq));
+  }
+
+  /**
+   * Returns in-edges of this node in graph g (where this node is the head).
+   * Self-loops are excluded per C agnxtedge semantics. Ordered by the SEQ
+   * of the in-half node — the TAIL — then edge seq (agedgeseqcmpf).
+   *
+   * @see lib/cgraph/edge.c:agfstin
+   * @see lib/cgraph/edge.c:agnxtin
+   * @see lib/cgraph/edge.c:agnxtedge (skips self-loops as in-edges)
+   * @see lib/cgraph/edge.c:agedgeseqcmpf
+   */
+  inEdges(g: Graph): Edge[] {
+    return g.edges
+      .filter((e) => e.head === this && e.tail !== this)
+      .sort((a, b) => (a.tail.id - b.tail.id) || (a.seq - b.seq));
+  }
+}
+
+/**
+ * Build a tail→out-edges index for graph `g`. Each list is identical to
+ * `node.outEdges(g)` (tail === node, self-loops included, sorted by head.id then
+ * seq), but the whole index is O(E log E) instead of O(N·E log E) from calling
+ * outEdges once per node. Use at sites that loop every node's out-edges and do
+ * not mutate `g.edges` during the loop. @see Node.outEdges
+ */
+export function buildOutEdgeIndex(g: Graph): Map<Node, Edge[]> {
+  const m = new Map<Node, Edge[]>();
+  for (const e of g.edges) {
+    const l = m.get(e.tail);
+    if (l !== undefined) l.push(e);
+    else m.set(e.tail, [e]);
+  }
+  for (const l of m.values()) {
+    l.sort((a, b) => (a.head.id - b.head.id) || (a.seq - b.seq));
+  }
+  return m;
+}

package/src/model/nodeInfo.ts

@@ -0,0 +1,424 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * TypeScript port of Agnodeinfo_t from lib/common/types.h.
+ *
+ * All ND_* macros in the C source expand into this struct via AGDATA().
+ * In TypeScript, ND_* accesses become direct property reads/writes on NodeInfo.
+ *
+ * @see lib/common/types.h:Agnodeinfo_t
+ * @see lib/common/types.h:ND_* macros
+ */
+
+import type { Point, Box } from './geom.js';
+import type { Edge } from './edge.js';
+import type { Graph } from './graph.js';
+import type { Node } from './node.js';
+import type { NodeAlgData } from './algData.js';
+
+// Per-engine ND_alg data types live in ./algData.js (split out to keep this
+// file under the size cap). Re-exported here so existing importers of
+// './nodeInfo.js' continue to resolve them unchanged.
+export type {
+  DotAlgData, NeatoAlgData, FdpAlgData, FdpDndata, CircoNData, CircoCData,
+  TwopiAlgData, OsageAlgData, PatchworkAlgData, NodeAlgData,
+} from './algData.js';
+export { THETA_UNSET } from './algData.js';
+
+// ---------------------------------------------------------------------------
+// Edge list helper type (mirrors elist in types.h)
+// ---------------------------------------------------------------------------
+
+/**
+ * Dynamic edge list, ported from the C `elist` struct.
+ *
+ * @see lib/common/types.h: typedef struct elist { edge_t **list; size_t size; }
+ */
+export interface EdgeList {
+  list: Edge[];
+  size: number;
+}
+
+// ---------------------------------------------------------------------------
+// NodeInfo interface
+// ---------------------------------------------------------------------------
+
+/**
+ * Node-level layout info record, ported from Agnodeinfo_t in lib/common/types.h.
+ *
+ * This interface replaces all ND_* macro accesses in the C source. Required
+ * (always-present) fields mirror the non-pointer, non-conditional fields of
+ * Agnodeinfo_t. Optional fields correspond to pointer fields and to fields
+ * gated by #ifndef DOT_ONLY / #ifndef NEATO_ONLY.
+ *
+ * @see lib/common/types.h:Agnodeinfo_t
+ * @see lib/common/types.h:ND_* macros
+ */
+export interface NodeInfo {
+  // -------------------------------------------------------------------------
+  // Required fields — always present, non-pointer in C
+  // -------------------------------------------------------------------------
+
+  /** Final layout coordinate (node center). @see lib/common/types.h:ND_coord */
+  coord: Point;
+
+  /** Node width in inches. @see lib/common/types.h:ND_width */
+  width: number;
+
+  /** Node height in inches. @see lib/common/types.h:ND_height */
+  height: number;
+
+  /** Bounding box. @see lib/common/types.h:ND_bb */
+  bb: Box;
+
+  /** Total height in points. @see lib/common/types.h:ND_ht */
+  ht: number;
+
+  /** Left half-width in points. @see lib/common/types.h:ND_lw */
+  lw: number;
+
+  /** Right half-width in points. @see lib/common/types.h:ND_rw */
+  rw: number;
+
+  /**
+   * Width in points with penwidth taken into account.
+   * @see lib/common/types.h:ND_outline_width
+   */
+  outline_width: number;
+
+  /**
+   * Height in points with penwidth taken into account.
+   * @see lib/common/types.h:ND_outline_height
+   */
+  outline_height: number;
+
+  /**
+   * Pre-periphery-growth node width in inches: the box the innermost
+   * vertex ring is scaled to before peripheries step outward. Only set
+   * by the measurer sizing path; consumed by multi-periphery vertex
+   * generation. (C keeps the equivalent implicitly — poly_init builds
+   * vertices and bb in one pass.)
+   * @see lib/common/shapes.c:poly_init
+   */
+  base_width?: number;
+
+  /** Pre-periphery-growth node height in inches. @see base_width */
+  base_height?: number;
+
+  /**
+   * Layout state (char in C). @see lib/common/types.h:ND_state
+   */
+  state: number;
+
+  /**
+   * Node state for GUI ops (unsigned char in C).
+   * Bitfield values: GUI_STATE_ACTIVE, GUI_STATE_SELECTED,
+   * GUI_STATE_VISITED, GUI_STATE_DELETED.
+   * @see lib/common/types.h:ND_gui_state
+   */
+  gui_state: number;
+
+  /** True if node represents a cluster. @see lib/common/types.h:ND_clustnode */
+  clustnode: boolean;
+
+  // -------------------------------------------------------------------------
+  // Optional pointer / engine-specific fields
+  // -------------------------------------------------------------------------
+
+  /**
+   * Main node label (textlabel_t* in C).
+   * Typed as unknown until textlabel_t is ported in Batch 5b.
+   * @see lib/common/types.h:ND_label
+   */
+  label?: unknown;
+
+  /**
+   * External node label (textlabel_t* in C).
+   * Typed as unknown until textlabel_t is ported in Batch 5b.
+   * @see lib/common/types.h:ND_xlabel
+   */
+  xlabel?: unknown;
+
+  /**
+   * Node shape descriptor (shape_desc* in C).
+   * Typed as unknown until shape_desc is ported.
+   * @see lib/common/types.h:ND_shape
+   */
+  shape?: unknown;
+
+  /**
+   * Shape-specific data (polygon_t*, field_t*, or engine struct in C).
+   * Typed as unknown until the concrete shape types are ported.
+   * @see lib/common/types.h:ND_shape_info
+   */
+  shape_info?: unknown;
+
+  // -------------------------------------------------------------------------
+  // Fields from #ifndef NEATO_ONLY block
+  // -------------------------------------------------------------------------
+
+  /**
+   * During the dot rank-assignment phase this field holds the assigned rank
+   * (integer row in the layered graph).
+   *
+   * DUAL-USE WARNING: During the dot position phase (x-coordinate assignment),
+   * `rank` is REPURPOSED as the x-coordinate by network simplex. Do not read
+   * this field as a rank value while the position phase is active. The field
+   * is restored to its rank value by `set_xcoords` at the end of the position
+   * phase. See lib/dotgen/position.c and AD-8.
+   *
+   * @see lib/common/types.h:ND_rank
+   */
+  rank?: number;
+
+  /**
+   * Initial order for ordered edges; also used in crossing-minimization.
+   * @see lib/common/types.h:ND_order
+   */
+  order?: number;
+
+  /**
+   * AD-8: True while the position phase is active and `rank` holds an
+   * x-coordinate instead of a rank index. Set before rank(g,2,…) is called;
+   * cleared by setXcoords after ND_coord.x is populated.
+   * @see lib/dotgen/position.c:set_xcoords
+   */
+  rankIsXCoord?: boolean;
+
+  /** @see lib/common/types.h:ND_mval */
+  mval?: number;
+
+  /**
+   * Fast-graph / spanning-tree node type (char in C).
+   * @see lib/common/types.h:ND_node_type
+   */
+  node_type?: number;
+
+  /**
+   * Rank type classification (char in C).
+   * @see lib/common/types.h:ND_ranktype
+   */
+  ranktype?: number;
+
+  /**
+   * Weight class (char in C).
+   * @see lib/common/types.h:ND_weight_class
+   */
+  weight_class?: number;
+
+  /**
+   * Visited / traversal mark (size_t in C).
+   * @see lib/common/types.h:ND_mark
+   */
+  mark?: number;
+
+  /**
+   * On-stack flag for DFS (char in C).
+   * @see lib/common/types.h:ND_onstack
+   */
+  onstack?: number;
+
+  /**
+   * True if edge has port info. @see lib/common/types.h:ND_has_port
+   */
+  has_port?: boolean;
+
+  /**
+   * Showboxes flag (unsigned char in C).
+   * @see lib/common/types.h:ND_showboxes
+   */
+  showboxes?: number;
+
+  // Edge adjacency lists (elist fields)
+
+  /** In-edges. @see lib/common/types.h:ND_in */
+  in?: EdgeList;
+
+  /** Out-edges. @see lib/common/types.h:ND_out */
+  out?: EdgeList;
+
+  /** Flat in-edges (same-rank). @see lib/common/types.h:ND_flat_in */
+  flat_in?: EdgeList;
+
+  /** Flat out-edges (same-rank). @see lib/common/types.h:ND_flat_out */
+  flat_out?: EdgeList;
+
+  /** Other (non-tree, non-flat) edges. @see lib/common/types.h:ND_other */
+  other?: EdgeList;
+
+  /** Saved in-edges (for virtual node removal). @see lib/common/types.h:ND_save_in */
+  save_in?: EdgeList;
+
+  /** Saved out-edges (for virtual node removal). @see lib/common/types.h:ND_save_out */
+  save_out?: EdgeList;
+
+  /** Network-simplex tree in-edges. @see lib/common/types.h:ND_tree_in */
+  tree_in?: EdgeList;
+
+  /** Network-simplex tree out-edges. @see lib/common/types.h:ND_tree_out */
+  tree_out?: EdgeList;
+
+  // Doubly-linked list through fast-graph
+
+  /** Next node in doubly-linked fast-graph list. @see lib/common/types.h:ND_next */
+  next?: Node;
+
+  /** Previous node in doubly-linked fast-graph list. @see lib/common/types.h:ND_prev */
+  prev?: Node;
+
+  // Network-simplex fields
+
+  /**
+   * Network-simplex spanning-tree parent edge.
+   * @see lib/common/types.h:ND_par
+   */
+  par?: Edge;
+
+  /** Low limit for network simplex. @see lib/common/types.h:ND_low */
+  low?: number;
+
+  /** Limit for network simplex subtree. @see lib/common/types.h:ND_lim */
+  lim?: number;
+
+  /** Priority for network simplex edge selection. @see lib/common/types.h:ND_priority */
+  priority?: number;
+
+  // Union-find / collapsing
+
+  /** Union-find tree size. @see lib/common/types.h:ND_UF_size */
+  UF_size?: number;
+
+  /** Union-find parent node. @see lib/common/types.h:ND_UF_parent */
+  UF_parent?: Node;
+
+  /** Representative node for a collapsed set. @see lib/common/types.h:ND_rep */
+  rep?: Node;
+
+  /** Set leader for min/max rank. @see lib/common/types.h:ND_set */
+  set?: Node;
+
+  /** Cluster subgraph that this node belongs to. @see lib/common/types.h:ND_clust */
+  clust?: Graph;
+
+  /**
+   * Flat-edge label constraint edge stored in ND_alg during dot position phase.
+   * Set by flat.c when a virtual node hosts a flat-edge label; read by
+   * make_LR_constraints and dotsplines.c.
+   * @see lib/dotgen/flat.c:ND_alg (flat edge label usage)
+   */
+  posAlg?: Edge;
+
+  // -------------------------------------------------------------------------
+  // Fields from #ifndef DOT_ONLY block (neato/fdp/sfdp)
+  // -------------------------------------------------------------------------
+
+  /**
+   * True if the node's position is pinned (pos attribute with !).
+   * @see lib/common/types.h:ND_pinned
+   */
+  pinned?: boolean;
+
+  /**
+   * True if the node has a user-supplied `pos=` (C's ND_pinned >= P_SET, i.e.
+   * hasPos). Distinct from {@link pinned} (P_PIN, isFixed): a plain `pos=`
+   * seeds the initial layout without fixing the node. neato uses it to start
+   * majorization from the input positions (user_pos + hasPos).
+   * @see lib/neatogen/neatoinit.c:user_pos; lib/common/macros.h:hasPos
+   */
+  posSet?: boolean;
+
+  /**
+   * Internal integer node ID used by neato/fdp.
+   * @see lib/common/types.h:ND_id
+   */
+  id?: number;
+
+  /**
+   * Index into the priority queue heap (neato/fdp).
+   * @see lib/common/types.h:ND_heapindex
+   */
+  heapindex?: number;
+
+  /**
+   * BFS hop count from the starting node (neato/fdp).
+   * @see lib/common/types.h:ND_hops
+   */
+  hops?: number;
+
+  /**
+   * N-dimensional position vector (length = ndim).
+   * @see lib/common/types.h:ND_pos
+   */
+  pos?: number[];
+
+  /**
+   * Distance value used by neato stress majorization.
+   * @see lib/common/types.h:ND_dist
+   */
+  dist?: number;
+
+  // -------------------------------------------------------------------------
+  // Engine algorithm data (AD-7)
+  // -------------------------------------------------------------------------
+
+  /**
+   * Per-engine algorithm data. Each layout engine stores a different struct
+   * in ND_alg; the `kind` discriminant identifies which engine's data is
+   * active without unsafe casting (AD-7).
+   *
+   * @see lib/common/types.h:ND_alg
+   */
+  alg?: NodeAlgData;
+}
+
+// ---------------------------------------------------------------------------
+// Factory function
+// ---------------------------------------------------------------------------
+
+/**
+ * Constructs a zero-valued NodeInfo with all required fields set to their
+ * zero/false initial state and all optional fields absent (undefined).
+ *
+ * Mirrors the effect of calloc-initializing an Agnodeinfo_t in C.
+ *
+ * @see lib/common/types.h:Agnodeinfo_t
+ * @see lib/cgraph/node.c:agnode (initial record allocation via agbindrec)
+ */
+export function makeNodeInfo(): NodeInfo {
+  // C agbindrec calloc-zeroes the WHOLE Agnodeinfo_t struct, so every ND_*
+  // field exists from creation at a fixed offset. The port mirrors that:
+  // pre-declaring EVERY optional field (value-preserving `undefined` — same
+  // semantics as absent under the `?? 0`/truthy accessors) pins a single V8
+  // hidden class for all NodeInfo objects. Without this, fields added lazily
+  // during layout (par/low/lim/rank/tree_in/tree_out/...) drove NodeInfo into
+  // dictionary (slow) mode — the dominant cost of the network-simplex DFS hot
+  // path on large graphs (~26x per-op vs C). No code reads node.info via
+  // `in`/spread/Object.keys, so adding the keys is behavior-free (verified
+  // identical across the full dot corpus). Keep in sync with NodeInfo.
+  return {
+    coord: { x: 0, y: 0 },
+    width: 0,
+    height: 0,
+    bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } },
+    ht: 0,
+    lw: 0,
+    rw: 0,
+    outline_width: 0,
+    outline_height: 0,
+    state: 0,
+    gui_state: 0,
+    clustnode: false,
+    // --- lazily-assigned fields, pre-declared to lock the hidden class ---
+    base_width: undefined, base_height: undefined, label: undefined, xlabel: undefined,
+    shape: undefined, shape_info: undefined, rank: undefined, order: undefined,
+    rankIsXCoord: undefined, mval: undefined, node_type: undefined, ranktype: undefined,
+    weight_class: undefined, mark: undefined, onstack: undefined, has_port: undefined,
+    showboxes: undefined, in: undefined, out: undefined, flat_in: undefined,
+    flat_out: undefined, other: undefined, save_in: undefined, save_out: undefined,
+    tree_in: undefined, tree_out: undefined, next: undefined, prev: undefined,
+    par: undefined, low: undefined, lim: undefined, priority: undefined,
+    UF_size: undefined, UF_parent: undefined, rep: undefined, set: undefined,
+    clust: undefined, posAlg: undefined, pinned: undefined, id: undefined,
+    heapindex: undefined, hops: undefined, pos: undefined, dist: undefined, alg: undefined,
+  };
+}