@invana/graph-datasets 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,577 @@
+/**
+ * Les Misérables character co-occurrence network.
+ *
+ * Character relationships from Victor Hugo's *Les Misérables* novel —
+ * 77 characters, 254 undirected co-occurrence edges weighted by how many
+ * scenes they share. Each character belongs to one of 11 "groups" (loosely:
+ * the cluster of characters they appear with most). Useful as a small but
+ * structurally-rich force-directed layout demo.
+ *
+ * Source: Donald E. Knuth, *The Stanford GraphBase: A Platform for
+ * Combinatorial Computing*, 1993. Adapted from the D3.js examples.
+ *
+ * Export shape is structurally compatible with `GraphData` from
+ * `@invana/graph` — pass it straight to `graph.setData()`.
+ *
+ * @example
+ * import { lesMiserables } from '@invana/graph-datasets';
+ * graph.setData(lesMiserables);
+ */
+interface LesMiserablesNodeData {
+    /** Co-occurrence cluster (0–10). Used for colour-by-group in stories. */
+    group: number;
+}
+interface LesMiserablesEdgeData {
+    /** Number of scenes the two characters share (edge weight, 1–31). */
+    value: number;
+}
+interface LesMiserablesNode {
+    id: string;
+    data: LesMiserablesNodeData;
+}
+interface LesMiserablesEdge {
+    id: string;
+    source: string;
+    target: string;
+    data: LesMiserablesEdgeData;
+}
+interface LesMiserablesData {
+    nodes: LesMiserablesNode[];
+    edges: LesMiserablesEdge[];
+}
+/** Les Misérables co-occurrence network — pass straight to `graph.setData()`. */
+declare const lesMiserables: LesMiserablesData;
+
+/**
+ * Procedurally-generated tree, for force-layout stress tests and
+ * tree-shaped demos.
+ *
+ * Node `i + 1`'s parent is node `floor(sqrt(i))`, which yields a
+ * branchy, square-root-balanced tree in O(n) time with no RNG.
+ *
+ * The export uses a minimal `{ index }` / `{ source, target }` shape.
+ * Map it onto `GraphNode` / `GraphEdge` at the call site (see the
+ * `RandomTree` story for an example).
+ *
+ * @example
+ * import { generateRandomTree } from '@invana/graph-datasets';
+ * const tree = generateRandomTree(500);
+ */
+interface RandomTreeNode {
+    index: number;
+}
+interface RandomTreeEdge {
+    source: number;
+    target: number;
+}
+interface RandomTreeData {
+    nodes: RandomTreeNode[];
+    edges: RandomTreeEdge[];
+}
+declare const generateRandomTree: (numNodes: number) => RandomTreeData;
+
+/**
+ * The classic **Flare** software hierarchy — the same dataset used in
+ * d3-hierarchy's tidy / radial / treemap examples.
+ *
+ * Two shapes are exposed:
+ *  - `flareHierarchy` — the original nested `{name, value?, children?}` tree.
+ *  - `flareAsGraph()` — a flat `{nodes, edges}` projection that drops
+ *    straight into `GraphLayer.setData`. Each edge points from parent to
+ *    child, so a hierarchy layout (e.g. `D3HierarchyLayout`) can read the
+ *    topology directly off `edge.source → edge.target`.
+ *
+ * @example
+ * import { flareAsGraph } from '@invana/graph-datasets';
+ * graphLayer.setData(flareAsGraph());
+ */
+/** Node shape in the original Flare hierarchy. Leaves carry `value`; inner
+ *  nodes carry `children`. The root has neither field guaranteed. */
+interface FlareNode {
+    name: string;
+    value?: number;
+    children?: FlareNode[];
+}
+/** A single node in the flat projection. The id is the slash-joined path
+ *  from the root (e.g. `flare/analytics/cluster/AgglomerativeCluster`) so
+ *  it survives duplicate `name` values across branches. */
+interface FlareGraphNode {
+    id: string;
+    data: {
+        /** Original `name` field. Convenient for labels once those land. */
+        name: string;
+        /** Depth from root. Root is 0. */
+        depth: number;
+        /** True iff this node has no children. */
+        isLeaf: boolean;
+        /** Original `value` field, if present (only on leaves). */
+        value?: number;
+        /**
+         * Top-level category — the depth-1 ancestor's name (e.g. `analytics`,
+         * `animate`, `data`, ...). Depth-1 nodes carry their own name here;
+         * the root (depth 0) carries `undefined`. Drives categorical colour
+         * in the bubble-chart layout, since every leaf inherits the same
+         * `group` as every other leaf under the same top-level branch.
+         */
+        group?: string;
+    };
+}
+/** A single parent→child edge in the flat projection. */
+interface FlareGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+}
+/** Output of {@link flareAsGraph}. */
+interface FlareGraphData {
+    nodes: FlareGraphNode[];
+    edges: FlareGraphEdge[];
+}
+/** The original Flare hierarchy in its nested form. */
+declare const flareHierarchy: FlareNode;
+/**
+ * Flatten {@link flareHierarchy} to a `{nodes, edges}` shape compatible with
+ * `GraphLayer.setData`. BFS-traverses the tree, assigning slash-joined path
+ * ids so duplicate names across branches stay distinct.
+ */
+declare function flareAsGraph(): FlareGraphData;
+
+/**
+ * Flare **with synthetic class-imports** — companion to {@link flareAsGraph}
+ * for the d3 *Hierarchical Edge Bundling* demo
+ * (https://observablehq.com/@d3/hierarchical-edge-bundling/2).
+ *
+ * The Observable demo ships a flat `flare-imports.json` where every leaf
+ * class carries an `imports: string[]` list of other class names it
+ * "depends on". We don't bundle that file (no network fetch available at
+ * dataset-build time); instead we generate a deterministic synthetic
+ * imports graph over the existing nested `flare.json`, biased so that:
+ *
+ *  - each leaf imports a small handful of other leaves (1–5);
+ *  - ~70% of imports stay inside the leaf's depth-1 package
+ *    (`flare.analytics`, `flare.vis`, ...); the rest reach across packages.
+ *
+ * That bias is what *makes* hierarchical edge bundling worth looking at:
+ * intra-package edges form dense, tightly-bundled arcs through one parent;
+ * inter-package edges sweep across the centre. Visually it reproduces the
+ * d3 demo faithfully; only the specific source/target pairs differ.
+ *
+ * The generator is seeded by the leaf's id, so the same call always
+ * produces the same edges — stories stay snapshot-stable across reloads.
+ *
+ * @example
+ * import { flareImportsAsGraph } from '@invana/graph-datasets';
+ * const { nodes, treeEdges, importEdges } = flareImportsAsGraph();
+ * graph.setData({ nodes, edges: treeEdges });
+ * await new D3HierarchyLayout({ mode: 'radial-cluster' }).apply(graph);
+ * // ... then swap to importEdges and render with `pathType: 'bundle'`.
+ */
+
+/** A synthetic leaf→leaf import edge. */
+interface FlareImportEdge {
+    id: string;
+    source: string;
+    target: string;
+}
+/** Output of {@link flareImportsAsGraph}. */
+interface FlareImportsGraphData {
+    nodes: FlareGraphNode[];
+    /** Parent→child edges from the flare hierarchy. Feed these to the layout. */
+    treeEdges: FlareGraphEdge[];
+    /** Synthetic leaf→leaf import edges. Render these as bundled curves. */
+    importEdges: FlareImportEdge[];
+}
+/** Options for {@link flareImportsAsGraph}. */
+interface FlareImportsOptions {
+    /** Minimum import out-degree per leaf. Default `1`. */
+    readonly minImportsPerLeaf?: number;
+    /** Maximum import out-degree per leaf. Default `5`. */
+    readonly maxImportsPerLeaf?: number;
+    /**
+     * Probability that a generated import targets a leaf in the same depth-1
+     * package as its source (vs a leaf in any other package). Default `0.7`
+     * — produces a dense-intra-package + sparse-cross-package mix that
+     * bundles cleanly through the hierarchy.
+     */
+    readonly intraGroupBias?: number;
+}
+/**
+ * Build the Flare hierarchy plus a deterministic synthetic imports graph
+ * over its leaves. See module doc for the generation policy.
+ */
+declare function flareImportsAsGraph(opts?: FlareImportsOptions): FlareImportsGraphData;
+
+/**
+ * **H-1B 2019** — USCIS H-1B employer petition counts for fiscal year 2019,
+ * aggregated into a **State → City → Employer** hierarchy. The same dataset
+ * used in the d3 [`pack-rollup`](https://observablehq.com/@d3/pack-rollup/2)
+ * example. Source: [USCIS H-1B Data Hub](https://www.uscis.gov/h-1b-data-hub).
+ *
+ * Aggregation was done offline (see `tools/build-h1b2019.ts` or the
+ * data-import note below) so the package ships a single static JSON instead
+ * of a 1.8 MB CSV that would need parsing at import time. The leaf `value` is
+ * the sum of all four petition outcomes for that employer / city / state:
+ *
+ *     value = InitialApprovals + InitialDenials
+ *           + ContinuingApprovals + ContinuingDenials
+ *
+ * matching d3.rollup's:
+ *
+ *     d3.rollup(rows, D => d3.sum(D, d => d.IA + d.ID + d.CA + d.CD),
+ *               d => d.State, d => d.City, d => d.Employer)
+ *
+ * Employers with a zero total are pruned during aggregation — d3.pack treats
+ * zero-value leaves as 0-radius circles, so removing them avoids cluttering
+ * the layout with invisible nodes.
+ *
+ * Two shapes are exposed, mirroring the Flare API:
+ *  - `h1b2019Hierarchy` — the original nested `{name, value?, children?}` tree.
+ *  - `h1b2019AsGraph()` — flat `{nodes, edges}` projection, ready for
+ *    `GraphLayer.setData`.
+ *
+ * @example
+ * import { h1b2019AsGraph } from '@invana/graph-datasets';
+ * graphLayer.setData(h1b2019AsGraph());
+ */
+/**
+ * Node shape in the rolled-up H-1B hierarchy. Identical structure to
+ * {@link FlareNode}: leaves carry `value`, inner nodes (root, states, cities)
+ * carry `children`.
+ */
+interface H1B2019Node {
+    name: string;
+    value?: number;
+    children?: H1B2019Node[];
+}
+/**
+ * A single node in the flat projection. The id is the slash-joined path
+ * from the root (e.g. `H-1B 2019/CA/SAN JOSE/GOOGLE LLC`) so duplicate
+ * employer / city names across states stay distinct.
+ */
+interface H1B2019GraphNode {
+    id: string;
+    data: {
+        /** Original `name` field — state abbreviation, city name, or employer. */
+        name: string;
+        /** Depth from root. Root = 0, state = 1, city = 2, employer = 3. */
+        depth: number;
+        /** True iff this node has no children (i.e. an employer leaf). */
+        isLeaf: boolean;
+        /** Sum of petition counts for this leaf. Inner nodes omit it. */
+        value?: number;
+        /**
+         * Top-level category — the depth-1 ancestor's name (the U.S. state
+         * abbreviation, e.g. `CA`, `NY`, `TX`). Depth-1 nodes carry their own
+         * name here; the root (depth 0) carries `undefined`. Drives categorical
+         * colouring by state for bubble-chart-style renders.
+         */
+        group?: string;
+    };
+}
+/** A single parent→child edge in the flat projection. */
+interface H1B2019GraphEdge {
+    id: string;
+    source: string;
+    target: string;
+}
+/** Output of {@link h1b2019AsGraph}. */
+interface H1B2019GraphData {
+    nodes: H1B2019GraphNode[];
+    edges: H1B2019GraphEdge[];
+}
+/** The H-1B 2019 hierarchy in its nested form. */
+declare const h1b2019Hierarchy: H1B2019Node;
+/**
+ * Flatten {@link h1b2019Hierarchy} to a `{nodes, edges}` shape compatible with
+ * `GraphLayer.setData`. BFS-traverses the tree, assigning slash-joined path
+ * ids so duplicate names across branches stay distinct.
+ *
+ * Returns ~55 states + ~3 000 cities + ~22 000 employer leaves; allocating
+ * each call is cheap (one pass over a 1 MB JSON), so consumers can re-call
+ * after filtering settings change without caching.
+ */
+declare function h1b2019AsGraph(): H1B2019GraphData;
+
+/**
+ * The classic **Tree of Life** — a small phylogenetic tree of 145 prokaryote +
+ * eukaryote species partitioned into the three top-level kingdoms (Bacteria,
+ * Eukaryota, Archaea). It's the dataset behind d3's
+ * [Tree of Life](https://observablehq.com/@d3/tree-of-life) example, sourced
+ * from Ciccarelli et al. (2006).
+ *
+ * Two shapes are exposed:
+ *  - `lifeTreeHierarchy` — the parsed Newick tree as a `{name, length, children?}`
+ *    nested object.
+ *  - `lifeTreeAsGraph()` — a flat `{nodes, edges}` projection that drops
+ *    straight into `GraphLayer.setData`. Each edge points from parent to
+ *    child; each node carries its inherited `kingdom` so consumers can colour
+ *    sub-trees by domain of life.
+ *
+ * @example
+ * import { lifeTreeAsGraph } from '@invana/graph-datasets';
+ * graphLayer.setData(lifeTreeAsGraph());
+ */
+/** The three domains of life. Set on every node beneath a top-level clade. */
+type LifeTreeKingdom = 'Bacteria' | 'Eukaryota' | 'Archaea';
+/** Node shape in the parsed Newick hierarchy. */
+interface LifeTreeNode {
+    /** Clade or species name. May be empty for anonymous internal nodes. */
+    name: string;
+    /** Branch length to parent (substitution rate). `undefined` on the root. */
+    length?: number;
+    /** Child clades. Leaves omit this field. */
+    children?: LifeTreeNode[];
+}
+/** A single node in the flat projection. */
+interface LifeTreeGraphNode {
+    id: string;
+    data: {
+        /** Original Newick name. Empty for anonymous internal clades. */
+        name: string;
+        /** Depth from root. Root is 0. */
+        depth: number;
+        /** True iff this node has no children. */
+        isLeaf: boolean;
+        /** Branch length to parent (substitution rate). `undefined` on the root. */
+        length?: number;
+        /**
+         * Top-level domain of life. Inherited from the nearest ancestor whose name
+         * is `'Bacteria'`, `'Eukaryota'`, or `'Archaea'`. The root and its two
+         * pre-domain wrapper nodes have no kingdom.
+         */
+        kingdom?: LifeTreeKingdom;
+    };
+}
+/** A single parent→child edge in the flat projection. */
+interface LifeTreeGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+}
+/** Output of {@link lifeTreeAsGraph}. */
+interface LifeTreeGraphData {
+    nodes: LifeTreeGraphNode[];
+    edges: LifeTreeGraphEdge[];
+}
+/** The parsed Tree of Life as a nested hierarchy. Computed once. */
+declare const lifeTreeHierarchy: LifeTreeNode;
+/**
+ * Flatten {@link lifeTreeHierarchy} to a `{nodes, edges}` shape compatible
+ * with `GraphLayer.setData`. BFS-traverses the tree, assigning slash-joined
+ * path ids so anonymous internal clades — and duplicate names across branches
+ * — stay distinct. Each node carries its inherited `kingdom`.
+ *
+ * The Newick source reuses generic clade labels (e.g. `Bacteria_subclade`)
+ * across many sibling positions, so a plain slash-path can collide. When that
+ * happens, the colliding child gets a numeric suffix (`_2`, `_3`, …) so every
+ * emitted id is unique while the readable path is preserved in the common
+ * case.
+ */
+declare function lifeTreeAsGraph(): LifeTreeGraphData;
+
+/**
+ * UK energy-flow dataset — the canonical d3-sankey example fixture.
+ *
+ * 48 nodes, 68 weighted links representing 2050 UK energy flows from
+ * supply (coal reserves, oil reserves, nuclear, renewables, imports) →
+ * intermediate carriers (oil, gas, electricity grid, solid / liquid /
+ * gaseous fuels) → end use (industry, heating, transport, losses).
+ *
+ * Source: DECC 2050 Pathways (UK Department of Energy and Climate Change),
+ * via Tom Counsell's d3-sankey example used since 2012. Reproduced from
+ * `https://bost.ocks.org/mike/sankey/energy.json`. Distributed by the
+ * original author under the same MIT terms as `d3-sankey`.
+ *
+ * Two shapes are exposed:
+ *  - `ukEnergyFlow` — the original `{nodes:[{name}], links:[{source,target,value}]}`
+ *    shape (numeric indices on the links), suitable for direct use with
+ *    `d3.sankey()`.
+ *  - `ukEnergyFlowAsGraph()` — a `{nodes, edges}` projection ready for
+ *    `GraphLayer.setData`. Node ids are the original `name` field; edge
+ *    ids are `<source>--<target>` (no duplicates in this dataset).
+ *
+ * @example
+ * import { ukEnergyFlowAsGraph } from '@invana/graph-datasets';
+ * graphLayer.setData(ukEnergyFlowAsGraph());
+ */
+/** Original (numeric-index) node shape. */
+interface UkEnergyFlowNode {
+    name: string;
+}
+/** Original (numeric-index) link shape — `source` / `target` are indices
+ *  into the `nodes` array. */
+interface UkEnergyFlowLink {
+    source: number;
+    target: number;
+    value: number;
+}
+/** Original `{nodes, links}` shape (matches d3-sankey's expected input). */
+interface UkEnergyFlow {
+    nodes: UkEnergyFlowNode[];
+    links: UkEnergyFlowLink[];
+}
+/** Node in the flat `{nodes, edges}` projection. */
+interface UkEnergyFlowGraphNode {
+    id: string;
+    data: {
+        /** Original `name` field — used by Sankey labels. */
+        name: string;
+        /**
+         * Categorical bucket derived from the node name's first whitespace-
+         * separated word (`'Solar PV'` becomes `'Solar'`, `'Coal reserves'`
+         * becomes `'Coal'`). Mirrors the d3 example's first-word replace key
+         * so a 10-colour ordinal scale produces the same grouping as the
+         * canonical Observable port.
+         */
+        category: string;
+    };
+}
+/** Edge in the flat projection. `value` is the flow magnitude (TWh). */
+interface UkEnergyFlowGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    data: {
+        value: number;
+    };
+}
+/** Output of {@link ukEnergyFlowAsGraph}. */
+interface UkEnergyFlowGraphData {
+    nodes: UkEnergyFlowGraphNode[];
+    edges: UkEnergyFlowGraphEdge[];
+}
+/** Original dataset, untouched. Pass straight to `d3.sankey()` if you want
+ *  to drive the layout yourself; otherwise use {@link ukEnergyFlowAsGraph}. */
+declare const ukEnergyFlow: UkEnergyFlow;
+/**
+ * Project {@link ukEnergyFlow} to `{nodes, edges}` for `GraphLayer.setData`.
+ *
+ * The mapping:
+ *  - Numeric link endpoints → string ids (the node `name`).
+ *  - Each node carries `data.category` for colour grouping.
+ *  - Edge ids are `<source>--<target>`; the source dataset has no duplicate
+ *    pairs, so no extra disambiguation is needed.
+ */
+declare function ukEnergyFlowAsGraph(): UkEnergyFlowGraphData;
+
+/**
+ * Old Faithful geyser eruptions — 272 measurements.
+ *
+ * Each record pairs an eruption's duration in minutes (`eruptions`, 1.5–5.1)
+ * with the time in minutes until the next eruption (`waiting`, 43–96). The
+ * dataset is famously bimodal — two distinct (short, short-wait) and
+ * (long, long-wait) clusters — which makes it a canonical demo for 2D
+ * density estimators. This is the source dataset behind the Observable
+ * [`@d3/density-contours`](https://observablehq.com/@d3/density-contours)
+ * example.
+ *
+ * Source: W. Härdle (1991), *Smoothing Techniques with Implementation in S*,
+ * New York: Springer. Public domain; bundled with R as `datasets::faithful`.
+ *
+ * The exported `oldFaithful` is a nodes-only `GraphData` ready for
+ * `GraphLayer.setData()` — each point becomes a node positioned at
+ * `(waiting, eruptions * 20)` so that the two axes have comparable spread in
+ * world units (waiting ≈ 53 units of range, scaled eruptions ≈ 72 units).
+ * No edges.
+ *
+ * @example
+ * import { oldFaithful } from '@invana/graph-datasets';
+ * graph.setData(oldFaithful);
+ */
+interface OldFaithfulPoint {
+    /** Eruption duration in minutes. */
+    eruptions: number;
+    /** Minutes elapsed before the next eruption. */
+    waiting: number;
+}
+interface OldFaithfulNodeData extends OldFaithfulPoint {
+    /**
+     * Bimodal cluster the point most likely belongs to — `'short'` for the
+     * brief eruption / short-wait cluster, `'long'` for the long-duration /
+     * long-wait cluster. Determined by a 3-minute split on `eruptions`.
+     * Useful for colour-by-cluster stories.
+     */
+    cluster: 'short' | 'long';
+}
+interface OldFaithfulNode {
+    id: string;
+    data: OldFaithfulNodeData;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+interface OldFaithfulGraphData {
+    nodes: OldFaithfulNode[];
+    edges: never[];
+}
+declare const oldFaithful: OldFaithfulGraphData;
+
+/**
+ * `air-routes` — world airports + land outline geo data.
+ *
+ * Companion dataset for the maplibre stories. Mirrors the data referenced
+ * by Observable's
+ * [`@d3/world-airports`](https://observablehq.com/@d3/world-airports) —
+ * `airports.csv` (Natural Earth airports point set) and a 1:50m
+ * land-only TopoJSON for the basemap stroke.
+ *
+ * See `air-routes/README.md` for sources, licensing, and the exact files
+ * the JSON in this folder was derived from.
+ *
+ * @example
+ * ```ts
+ * import { airports, landTopology } from '@invana/graph-datasets';
+ *
+ * for (const a of airports) {
+ *   const { x, y } = mapLayer.project([a.lng, a.lat]);
+ *   // ...
+ * }
+ * ```
+ */
+/** A single airport point. */
+interface Airport {
+    /** Airport name from the source CSV (e.g. `"London Heathrow Airport"`). */
+    name: string;
+    /** Longitude in degrees, WGS-84. */
+    lng: number;
+    /** Latitude in degrees, WGS-84. */
+    lat: number;
+}
+/**
+ * Loose TopoJSON shape — the world-50m land outline used by the d3
+ * notebook. Typed structurally (no `topojson-specification` dep) since
+ * consumers either pass this straight to `topojson-client.feature(...)`
+ * or pluck `.objects.land` directly.
+ */
+interface LandTopology {
+    type: 'Topology';
+    bbox?: [number, number, number, number];
+    transform?: {
+        scale: [number, number];
+        translate: [number, number];
+    };
+    arcs: number[][][];
+    objects: {
+        land: {
+            type: 'MultiPolygon' | 'GeometryCollection';
+            arcs?: unknown;
+            geometries?: unknown[];
+        };
+    };
+}
+/**
+ * All `2980` airport points from `airports.csv`. Order matches the source
+ * CSV; ids are not assigned here because the source has no stable id
+ * column — story code typically synthesizes ids from the array index
+ * (`'ap-' + i`).
+ */
+declare const airports: Airport[];
+/**
+ * 1:50m world land outline as TopoJSON. Pair with `topojson-client.feature`
+ * to materialize the GeoJSON `MultiPolygon`, then sample with `d3-geo`'s
+ * `geoPath` over a custom canvas projection.
+ */
+declare const landTopology: LandTopology;
+
+export { type Airport, type FlareGraphData, type FlareGraphEdge, type FlareGraphNode, type FlareImportEdge, type FlareImportsGraphData, type FlareImportsOptions, type FlareNode, type H1B2019GraphData, type H1B2019GraphEdge, type H1B2019GraphNode, type H1B2019Node, type LandTopology, type LesMiserablesData, type LesMiserablesEdge, type LesMiserablesEdgeData, type LesMiserablesNode, type LesMiserablesNodeData, type LifeTreeGraphData, type LifeTreeGraphEdge, type LifeTreeGraphNode, type LifeTreeKingdom, type LifeTreeNode, type OldFaithfulGraphData, type OldFaithfulNode, type OldFaithfulNodeData, type OldFaithfulPoint, type RandomTreeData, type RandomTreeEdge, type RandomTreeNode, type UkEnergyFlow, type UkEnergyFlowGraphData, type UkEnergyFlowGraphEdge, type UkEnergyFlowGraphNode, type UkEnergyFlowLink, type UkEnergyFlowNode, airports, flareAsGraph, flareHierarchy, flareImportsAsGraph, generateRandomTree, h1b2019AsGraph, h1b2019Hierarchy, landTopology, lesMiserables, lifeTreeAsGraph, lifeTreeHierarchy, oldFaithful, ukEnergyFlow, ukEnergyFlowAsGraph };