@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/network/HiveChart.js

@@ -0,0 +1,195 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GraphMetrics } from "./GraphMetrics.js";
+import { NetworkMetric } from "./networkEnums.js";
+import { NetworkChart } from "./NetworkChart.js";
+import { NetworkSamples } from "./NetworkSamples.js";
+// src/charts/network/HiveChart.ts
+/** What assigns a node to an axis. */
+var HiveAxis = /* @__PURE__ */ function(HiveAxis) {
+	HiveAxis["Group"] = "group";
+	HiveAxis["Role"] = "role";
+	HiveAxis["Connectivity"] = "connectivity";
+	return HiveAxis;
+}({});
+/** What places a node along its axis. */
+var HivePosition = /* @__PURE__ */ function(HivePosition) {
+	HivePosition["Degree"] = "degree";
+	HivePosition["Rank"] = "rank";
+	HivePosition["Value"] = "value";
+	HivePosition["Betweenness"] = "betweenness";
+	return HivePosition;
+}({});
+var HiveEdge = /* @__PURE__ */ function(HiveEdge) {
+	HiveEdge["Curved"] = "curved";
+	HiveEdge["Straight"] = "straight";
+	return HiveEdge;
+}({});
+var TWO_PI = Math.PI * 2;
+/** A hive plot: node position comes from measured properties, so two networks can be compared by eye. */
+var HiveChart = class extends NetworkChart {
+	static meta = {
+		id: "hive-chart",
+		name: "Hive plot",
+		family: ChartFamily.Network,
+		dimension: Dimension.Two,
+		shape: DataShape.Graph,
+		description: "Positions nodes on radial axes by measured properties, giving a repeatable picture of network structure.",
+		tags: [
+			"network",
+			"hive",
+			"radial",
+			"linear layout"
+		],
+		sample: (seed) => NetworkSamples.clustered(seed, 42, 3),
+		variants: {
+			axisBy: [
+				"group",
+				"role",
+				"connectivity"
+			],
+			position: [
+				"degree",
+				"rank",
+				"value",
+				"betweenness"
+			],
+			doubled: [false, true],
+			link: ["curved", "straight"],
+			hole: [.16, .3]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			axisBy: "group",
+			position: "degree",
+			doubled: false,
+			link: "curved",
+			hole: .16
+		};
+	}
+	axisOf(model) {
+		const { axisBy } = this.options;
+		if (axisBy === "role") {
+			const role = (node) => !node.indegree ? 0 : !node.outdegree ? 1 : 2;
+			return {
+				names: [
+					"Sources",
+					"Sinks",
+					"Connectors"
+				],
+				of: role
+			};
+		}
+		if (axisBy === "connectivity") {
+			const sorted = [...model.nodes.map((node) => node.degree)].sort((a, b) => a - b);
+			const low = sorted[Math.floor(sorted.length / 3)], high = sorted[Math.floor(sorted.length * 2 / 3)];
+			return {
+				names: [
+					"Low degree",
+					"Mid degree",
+					"High degree"
+				],
+				of: (node) => node.degree <= low ? 0 : node.degree <= high ? 1 : 2
+			};
+		}
+		const names = model.groups;
+		return {
+			names,
+			of: (node) => names.indexOf(node.group)
+		};
+	}
+	spread(model, of) {
+		const { position } = this.options;
+		if (position === "rank") {
+			const result = model.nodes.map(() => 0), axes = /* @__PURE__ */ new Map();
+			for (const node of model.nodes) axes.set(of(node), [...axes.get(of(node)) ?? [], node]);
+			for (const members of axes.values()) members.sort((a, b) => b.degree - a.degree || a.index - b.index).forEach((node, i) => {
+				result[node.index] = members.length > 1 ? i / (members.length - 1) : .5;
+			});
+			return result;
+		}
+		const metric = {
+			["degree"]: NetworkMetric.Degree,
+			["value"]: NetworkMetric.Value,
+			["betweenness"]: NetworkMetric.Betweenness
+		}[position];
+		const scores = GraphMetrics.of(model, metric), low = Math.min(...scores), high = Math.max(...scores);
+		return scores.map((score) => high > low ? (score - low) / (high - low) : .5);
+	}
+	drawNetwork(ctx, model) {
+		const { doubled, link: style, hole } = this.options;
+		const { names, of } = this.axisOf(model), spread = this.spread(model, of);
+		const count = names.length, tilt = -Math.PI / 2;
+		const outer = Math.min(ctx.plot.width, ctx.plot.height) / 2 - 16, inner = outer * hole;
+		const centre = {
+			x: ctx.plot.width / 2,
+			y: ctx.plot.height / 2
+		};
+		const split = Math.min(.3, Math.PI / count / 2.6);
+		const theta = (axis, clone) => tilt + axis / count * TWO_PI + (doubled ? clone ? split : -split : 0);
+		const polar = (angle, r) => ({
+			x: centre.x + Math.cos(angle) * r,
+			y: centre.y + Math.sin(angle) * r
+		});
+		const radius = (node) => inner + spread[node.index] * (outer - inner);
+		const dotRadius = Math.min(4, Math.max(2.5, (outer - inner) / 16));
+		const rails = Array.from({ length: count }, (_, axis) => (doubled ? [0, 1] : [0]).map((clone) => ({
+			key: `${axis}/${clone}`,
+			axis,
+			clone
+		}))).flat();
+		const lines = ctx.marks("rails", "line", rails, (d) => d.key).attr("stroke", ctx.theme.axis).attr("stroke-width", 2).attr("stroke-linecap", "round");
+		ctx.set(lines, {
+			x1: (d) => polar(theta(d.axis, d.clone), inner).x,
+			y1: (d) => polar(theta(d.axis, d.clone), inner).y,
+			x2: (d) => polar(theta(d.axis, d.clone), outer).x,
+			y2: (d) => polar(theta(d.axis, d.clone), outer).y
+		});
+		const unwrap = (angle) => Math.atan2(Math.sin(angle), Math.cos(angle));
+		const clones = (a, b) => {
+			if (!doubled) return [0, 0];
+			if (a === b) return [0, 1];
+			return unwrap(theta(b, 0) - theta(a, 0)) > 0 ? [1, 0] : [0, 1];
+		};
+		const path = (link) => {
+			const a = of(link.source), b = of(link.target), [ca, cb] = clones(a, b);
+			const ta = theta(a, ca), tb = theta(b, cb), ra = radius(link.source), rb = radius(link.target);
+			const p = polar(ta, ra), q = polar(tb, rb);
+			const head = `M${p.x.toFixed(2)},${p.y.toFixed(2)}`, end = `${q.x.toFixed(2)},${q.y.toFixed(2)}`;
+			if (style === "straight") return `${head}L${end}`;
+			const mean = (ra + rb) / 2;
+			const c = polar(a === b && !doubled ? ta + .5 : ta + unwrap(tb - ta) / 2, a === b && !doubled ? mean * 1.08 : mean * (count > 2 ? 1.05 : .7));
+			return `${head}Q${c.x.toFixed(2)},${c.y.toFixed(2)} ${end}`;
+		};
+		const width = this.widths(model, false);
+		const edges = model.links.map((link) => ({
+			link,
+			d: path(link),
+			width: width(link) * .8,
+			...this.edgeTone(ctx, link),
+			opacity: .45
+		}));
+		const paths = this.paintEdges(ctx, edges);
+		const placed = model.nodes.flatMap((node) => (doubled ? [0, 1] : [0]).map((clone) => ({
+			node,
+			key: `${node.id}/${clone}`,
+			r: dotRadius,
+			...polar(theta(of(node), clone), radius(node))
+		})));
+		this.paintNodes(ctx, model, placed, paths);
+		const labels = names.map((name, axis) => {
+			const angle = tilt + axis / count * TWO_PI, { x, y } = polar(angle, outer + 8);
+			const side = Math.cos(angle);
+			return {
+				key: name,
+				text: name,
+				x: Math.max(0, Math.min(ctx.plot.width, x)),
+				y: Math.max(6, Math.min(ctx.plot.height - 6, y)),
+				anchor: Math.abs(side) < .2 ? "middle" : side > 0 ? "start" : "end"
+			};
+		});
+		this.paintAxisLabels(ctx, labels);
+	}
+};
+export { HiveAxis, HiveChart, HiveEdge, HivePosition };

package/dist/charts/network/LabelPlacer.js

@@ -0,0 +1,95 @@
+// src/charts/network/LabelPlacer.ts
+var CHAR = 6.2;
+var HEIGHT = 13;
+var hits = (a, b) => a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
+/** Greedy label placement: tries four sides of each node, keeps what fits, drops what collides. */
+var LabelPlacer = class {
+	static clip(text, room) {
+		const fits = Math.floor(room / CHAR);
+		if (text.length <= fits) return text;
+		return fits < 3 ? "" : `${text.slice(0, fits - 1)}…`;
+	}
+	/** `seeds` come in priority order; `obstacles` are circles labels should stay off. */
+	static place(seeds, plot, obstacles, limit) {
+		const placed = [], taken = [];
+		const nodes = obstacles.map(({ x, y, r }) => ({
+			x0: x - r,
+			x1: x + r,
+			y0: y - r,
+			y1: y + r
+		}));
+		for (const seed of seeds) {
+			if (placed.length >= limit) break;
+			const text = this.clip(seed.text, 90);
+			if (!text) continue;
+			const width = text.length * CHAR, gap = seed.r + 3;
+			const sides = [
+				{
+					key: seed.key,
+					text,
+					x: seed.x + gap,
+					y: seed.y + 4,
+					anchor: "start",
+					box: {
+						x0: seed.x + gap,
+						x1: seed.x + gap + width,
+						y0: seed.y - HEIGHT / 2,
+						y1: seed.y + HEIGHT / 2
+					}
+				},
+				{
+					key: seed.key,
+					text,
+					x: seed.x - gap,
+					y: seed.y + 4,
+					anchor: "end",
+					box: {
+						x0: seed.x - gap - width,
+						x1: seed.x - gap,
+						y0: seed.y - HEIGHT / 2,
+						y1: seed.y + HEIGHT / 2
+					}
+				},
+				{
+					key: seed.key,
+					text,
+					x: seed.x,
+					y: seed.y - gap - 3,
+					anchor: "middle",
+					box: {
+						x0: seed.x - width / 2,
+						x1: seed.x + width / 2,
+						y0: seed.y - gap - HEIGHT,
+						y1: seed.y - gap
+					}
+				},
+				{
+					key: seed.key,
+					text,
+					x: seed.x,
+					y: seed.y + gap + 10,
+					anchor: "middle",
+					box: {
+						x0: seed.x - width / 2,
+						x1: seed.x + width / 2,
+						y0: seed.y + gap,
+						y1: seed.y + gap + HEIGHT
+					}
+				}
+			];
+			const first = seed.side ? [
+				"right",
+				"left",
+				"top",
+				"bottom"
+			].indexOf(seed.side) : 0;
+			const side = [...sides.slice(first), ...sides.slice(0, first)].find(({ box }) => box.x0 >= 0 && box.y0 >= 0 && box.x1 <= plot.width && box.y1 <= plot.height && !taken.some((other) => hits(box, other)) && !nodes.some((other) => hits(box, other)));
+			if (!side) continue;
+			taken.push(side.box);
+			const { box: _, ...label } = side;
+			placed.push(label);
+		}
+		return placed;
+	}
+};
+export { LabelPlacer };

package/dist/charts/network/NetworkChart.js

@@ -0,0 +1,189 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { GraphMetrics } from "./GraphMetrics.js";
+import { LabelPlacer } from "./LabelPlacer.js";
+import { NetworkMetric } from "./networkEnums.js";
+import { NetworkModel } from "./NetworkModel.js";
+import { scaleLinear } from "d3";
+// src/charts/network/NetworkChart.ts
+var ARROW = "M0,0L-8,3.6L-6.4,0L-8,-3.6Z";
+/** Base of the network module: cleans the graph once, and owns how links, nodes and labels are drawn. */
+var NetworkChart = class extends Chart2D {
+	defaults() {
+		return {
+			nodeId: "id",
+			nodeGroup: "group",
+			nodeValue: "value",
+			linkSource: "source",
+			linkTarget: "target",
+			linkValue: "value",
+			labels: 8
+		};
+	}
+	model() {
+		return NetworkModel.from(this.options.data, this.options);
+	}
+	draw(ctx) {
+		const source = this.model();
+		const model = source.nodes.length ? this.view(source) : source;
+		if (!model.nodes.length) {
+			ctx.root.selectAll("*").remove();
+			return;
+		}
+		for (const group of model.groups) ctx.palette.color(group);
+		this.drawNetwork(ctx, model);
+	}
+	/** The graph actually drawn; override to filter, regroup or roll up. */
+	view(model) {
+		return model;
+	}
+	/** Categories past the palette share one grey, so they share one legend entry. */
+	legendItems() {
+		const muted = this.theme.inkMuted, items = super.legendItems(), named = items.filter((item) => item.color !== muted);
+		return named.length < items.length ? [...named, {
+			key: "Other",
+			color: muted
+		}] : items;
+	}
+	table() {
+		return {
+			columns: [
+				"source",
+				"target",
+				"value"
+			],
+			rows: this.model().links.map((link) => [
+				link.source.id,
+				link.target.id,
+				link.value
+			])
+		};
+	}
+	/** Radius per node index. Area is linear in the metric, above a legible minimum. */
+	radii(model, metric, ctx) {
+		const room = Math.sqrt(ctx.plot.width * ctx.plot.height / model.nodes.length);
+		const floor = Math.max(2.5, Math.min(4.5, room * .13)), top = Math.max(floor + 1, Math.min(13, room * .3));
+		if (metric === NetworkMetric.Uniform) return model.nodes.map(() => Math.min(5, floor + .5));
+		const scores = GraphMetrics.of(model, metric), high = Math.max(...scores) || 1;
+		return scores.map((score) => Math.sqrt(floor ** 2 + score / high * (top ** 2 - floor ** 2)));
+	}
+	/** Rescales radii together so the largest stays within `limit`; relative area is preserved. */
+	capped(radii, limit) {
+		const scale = Math.min(1, Math.max(limit, 2) / Math.max(...radii));
+		return radii.map((r) => r * scale);
+	}
+	edgeTone(ctx, link) {
+		return link.source.group === link.target.group ? {
+			color: ctx.palette.color(link.source.group),
+			opacity: .5
+		} : {
+			color: ctx.theme.inkMuted,
+			opacity: .45
+		};
+	}
+	/** Line width per link, or a constant when weights are not encoded. */
+	widths(model, weighted) {
+		if (!weighted) return () => 1.5;
+		const top = Math.max(...model.links.map((link) => link.value), 1);
+		const scale = scaleLinear([0, top], [.75, 4.5]);
+		return (link) => scale(link.value);
+	}
+	linkTip(link) {
+		return {
+			title: `${link.source.label} → ${link.target.label}`,
+			rows: [["Weight", link.value]]
+		};
+	}
+	nodeTip(ctx, node) {
+		return {
+			title: node.label,
+			color: ctx.palette.color(node.group),
+			rows: [
+				["Group", node.group],
+				["Links", node.degree],
+				["Value", node.value]
+			]
+		};
+	}
+	paintEdges(ctx, edges) {
+		const paths = ctx.marks("edges", "path", edges, (edge) => edge.link.key).attr("fill", (edge) => edge.solid ? edge.color : "none").attr("stroke", (edge) => edge.solid ? "none" : edge.color).attr("stroke-width", (edge) => edge.width).attr("stroke-linecap", "round");
+		ctx.set(paths, {
+			d: (edge) => edge.d,
+			opacity: (edge) => edge.opacity
+		}, {
+			d: (edge) => edge.d,
+			opacity: 0
+		});
+		ctx.hover(paths, (edge) => this.linkTip(edge.link));
+		const tips = edges.filter((edge) => edge.tip);
+		const arrows = ctx.marks("arrows", "path", tips, (edge) => edge.link.key).attr("d", ARROW).attr("fill", (edge) => edge.color);
+		const placed = (edge) => `translate(${edge.tip.x.toFixed(2)},${edge.tip.y.toFixed(2)}) rotate(${(edge.tip.angle * 180 / Math.PI).toFixed(1)})`;
+		ctx.set(arrows, {
+			transform: placed,
+			opacity: (edge) => Math.min(1, edge.opacity + .35)
+		}, {
+			transform: placed,
+			opacity: 0
+		});
+		return paths;
+	}
+	paintNodes(ctx, model, placed, edges) {
+		const dots = ctx.marks("nodes", "circle", placed, (d) => d.key ?? d.node.id).attr("fill", (d) => ctx.palette.color(d.node.group)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: (d) => d.x,
+			cy: (d) => d.y,
+			r: (d) => d.r
+		}, {
+			cx: (d) => d.x,
+			cy: (d) => d.y,
+			r: 0
+		}, Math.min(6, 240 / placed.length));
+		ctx.hover(dots, (d) => this.nodeTip(ctx, d.node));
+		if (edges) this.linkFocus(model, dots, edges);
+		return dots;
+	}
+	/** While a node is hovered, only it, its neighbours and their links stay lit. */
+	linkFocus(model, dots, edges) {
+		dots.on("pointermove.network", (_, { node }) => {
+			const near = /* @__PURE__ */ new Set([node.id, ...(model.neighbours[node.index] ?? []).map((other) => other.id)]);
+			dots.style("opacity", (d) => near.has(d.node.id) ? null : .2);
+			edges.style("opacity", ({ link }) => link.source.id === node.id || link.target.id === node.id ? null : .08);
+		}).on("pointerleave.network", () => edges.style("opacity", null));
+	}
+	/** Labels the best-connected nodes wherever a label fits. */
+	paintLabels(ctx, placed, limit = this.options.labels ?? 8) {
+		const seeds = [...placed].sort((a, b) => b.r - a.r || b.node.degree - a.node.degree).map(({ node, x, y, r, side }) => ({
+			key: node.id,
+			text: node.label,
+			x,
+			y,
+			r,
+			side
+		}));
+		const text = LabelPlacer.place(seeds, ctx.plot, placed, limit);
+		const labels = ctx.marks("labels", "text", text, (d) => d.key).text((d) => d.text).attr("text-anchor", (d) => d.anchor).attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke").attr("pointer-events", "none");
+		ctx.text(labels, 11, "secondary");
+		ctx.set(labels, {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			opacity: 1
+		}, {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			opacity: 0
+		});
+	}
+	/** Fixed-position text for axes and rings: no collision search, the caller spaces it. */
+	paintAxisLabels(ctx, labels, name = "axis-labels", size = 11) {
+		const at = (d) => d.rotate ? `translate(${d.x.toFixed(2)},${d.y.toFixed(2)}) rotate(${d.rotate.toFixed(1)})` : `translate(${d.x.toFixed(2)},${d.y.toFixed(2)})`;
+		const text = ctx.marks(name, "text", labels, (d) => d.key).text((d) => d.text).attr("text-anchor", (d) => d.anchor ?? "middle").attr("dy", "0.32em").attr("pointer-events", "none").attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke");
+		ctx.text(text, size, "secondary");
+		ctx.set(text, {
+			transform: at,
+			opacity: 1
+		}, {
+			transform: at,
+			opacity: 0
+		});
+	}
+};
+export { NetworkChart };

package/dist/charts/network/NetworkModel.js

@@ -0,0 +1,119 @@
+// src/charts/network/NetworkModel.ts
+var number = (value, fallback) => {
+	const parsed = typeof value === "number" ? value : typeof value === "string" && value !== "" ? Number(value) : NaN;
+	return Number.isFinite(parsed) ? parsed : fallback;
+};
+var endpoint = (value, id) => value !== null && typeof value === "object" ? value[id] : value;
+/**
+* Immutable, cleaned view of a caller's graph. Nodes named only by links are created, repeated
+* node ids keep the first row, parallel links merge by summing, self-loops and null ends are dropped.
+*/
+var NetworkModel = class NetworkModel {
+	nodes;
+	links;
+	byId = /* @__PURE__ */ new Map();
+	neighbours;
+	sortedGroups = false;
+	constructor(nodes, links) {
+		this.nodes = nodes;
+		this.links = links;
+		for (const node of nodes) this.byId.set(node.id, node);
+		const sets = nodes.map(() => /* @__PURE__ */ new Map());
+		for (const { source, target } of links) {
+			sets[source.index].set(target.id, target);
+			sets[target.index].set(source.id, source);
+		}
+		this.neighbours = sets.map((set) => [...set.values()]);
+	}
+	static from(data, fields = {}) {
+		const { nodeId = "id", nodeGroup = "group", nodeValue = "value", nodeLabel, linkSource = "source", linkTarget = "target", linkValue = "value" } = fields;
+		const seen = /* @__PURE__ */ new Map();
+		const add = (id, raw) => {
+			const hit = seen.get(id);
+			if (hit) {
+				if (raw && !hit.raw) Object.assign(hit, NetworkModel.fill(raw, nodeGroup, nodeValue, nodeLabel, id));
+				return hit;
+			}
+			const node = {
+				id,
+				index: seen.size,
+				degree: 0,
+				indegree: 0,
+				outdegree: 0,
+				strength: 0,
+				...NetworkModel.fill(raw, nodeGroup, nodeValue, nodeLabel, id)
+			};
+			seen.set(id, node);
+			return node;
+		};
+		for (const raw of data?.nodes ?? []) {
+			const id = raw?.[nodeId];
+			if (id !== null && id !== void 0) add(String(id), raw);
+		}
+		const merged = /* @__PURE__ */ new Map();
+		for (const raw of data?.links ?? []) {
+			const a = endpoint(raw?.[linkSource], nodeId), b = endpoint(raw?.[linkTarget], nodeId);
+			if (a === null || a === void 0 || b === null || b === void 0 || String(a) === String(b)) continue;
+			const source = add(String(a), null), target = add(String(b), null);
+			const key = `${source.id}\u0000${target.id}`, value = Math.abs(number(raw[linkValue], 1)), hit = merged.get(key);
+			if (hit) hit.value += value;
+			else merged.set(key, {
+				key,
+				source,
+				target,
+				value,
+				raw
+			});
+		}
+		return NetworkModel.build([...seen.values()], [...merged.values()]);
+	}
+	static fill(raw, group, value, label, id) {
+		return {
+			raw,
+			group: String(raw?.[group] ?? "Ungrouped"),
+			value: Math.abs(number(raw?.[value], 1)),
+			label: String((label && raw?.[label]) ?? id)
+		};
+	}
+	static build(nodes, links) {
+		for (const node of nodes) node.degree = node.indegree = node.outdegree = node.strength = 0;
+		for (const { source, target, value } of links) {
+			source.outdegree++;
+			target.indegree++;
+			source.strength += value;
+			target.strength += value;
+		}
+		const model = new NetworkModel(nodes, links);
+		for (const node of nodes) node.degree = model.neighbours[node.index].length;
+		return model;
+	}
+	/** Copy keeping only `keep`, in that order, and the links among them. */
+	subgraph(keep, links) {
+		const nodes = keep.map((node, index) => ({
+			...node,
+			index
+		}));
+		const lookup = new Map(nodes.map((node) => [node.id, node]));
+		return NetworkModel.build(nodes, this.links.filter((link) => lookup.has(link.source.id) && lookup.has(link.target.id) && (links?.(link) ?? true)).map((link) => ({
+			...link,
+			source: lookup.get(link.source.id),
+			target: lookup.get(link.target.id)
+		})));
+	}
+	/** Copy whose nodes belong to `label(node)` instead of their own group. */
+	regroup(label, sorted = false) {
+		const copy = this.subgraph(this.nodes);
+		for (const node of copy.nodes) node.group = label(this.nodes[node.index]);
+		copy.sortedGroups = sorted;
+		return copy;
+	}
+	/** Group names, in first-seen order unless the groups were assigned in rank order. */
+	get groups() {
+		const names = [...new Set(this.nodes.map((node) => node.group))];
+		return this.sortedGroups ? names.sort((a, b) => a.localeCompare(b, "en", { numeric: true })) : names;
+	}
+	get hub() {
+		return this.nodes.reduce((best, node) => !best || node.degree > best.degree ? node : best, void 0);
+	}
+};
+export { NetworkModel };