@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/genomics/CircosPlot.js

@@ -0,0 +1,319 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { RadialChart } from "../../core/RadialChart.js";
+import { CircosFrame } from "./CircosFrame.js";
+import { GenomeAssembly } from "./GenomeAssembly.js";
+import { GenomeSamples } from "./GenomeSamples.js";
+import { GenomeStainScale } from "./GenomeStainScale.js";
+import { CircosIdeogram, CircosLinkMark, CircosLinkScope, CircosScale, CircosTrackMark, GenomeBandLevel } from "./genomicsEnums.js";
+import { arc, ascending, extent, groups, lineRadial, quantile, scaleLinear } from "d3";
+// src/charts/genomics/CircosPlot.ts
+var TICK_STEPS = [
+	1,
+	2,
+	5,
+	10,
+	25,
+	50,
+	100
+];
+var point = (angle, radius) => `${+(radius * Math.sin(angle)).toFixed(2)} ${+(-radius * Math.cos(angle)).toFixed(2)}`;
+/** Show a whole genome at once: chromosomes around a circle, data tracks inside, and links for rearrangements or synteny. */
+var CircosPlot = class extends RadialChart {
+	#shown = /* @__PURE__ */ new Set();
+	static meta = {
+		id: "circos-plot",
+		name: "Circos plot",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Genome,
+		description: "Lays chromosomes around a circular ideogram with concentric data tracks and links joining distant genomic loci.",
+		tags: [
+			"genomics",
+			"circular",
+			"ideogram",
+			"synteny",
+			"structural variants"
+		],
+		sample: (seed) => GenomeSamples.cancerGenome(seed),
+		variants: {
+			ideogram: [CircosIdeogram.Banded, CircosIdeogram.Plain],
+			trackMark: [
+				CircosTrackMark.Histogram,
+				CircosTrackMark.Heatmap,
+				CircosTrackMark.Line,
+				CircosTrackMark.Scatter
+			],
+			linkMark: [
+				CircosLinkMark.Ribbon,
+				CircosLinkMark.Bezier,
+				CircosLinkMark.None
+			],
+			linkScope: [
+				CircosLinkScope.All,
+				CircosLinkScope.Inter,
+				CircosLinkScope.Intra
+			],
+			scale: [CircosScale.Proportional, CircosScale.Focus]
+		},
+		valid: (v) => v.linkMark !== CircosLinkMark.None || v.linkScope === CircosLinkScope.All
+	};
+	defaults() {
+		return {
+			ideogram: CircosIdeogram.Banded,
+			trackMark: CircosTrackMark.Histogram,
+			linkMark: CircosLinkMark.Ribbon,
+			linkScope: CircosLinkScope.All,
+			scale: CircosScale.Proportional,
+			opening: 30,
+			magnify: 5
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 12,
+			bottom: 8,
+			left: 12
+		};
+	}
+	/** Colours are fixed by the full link list, so a class keeps its colour when scope filters it out. */
+	legendItems() {
+		return this.palette.items().filter((item) => this.#shown.has(item.key));
+	}
+	#assembly() {
+		return new GenomeAssembly(this.options.data, this.options.bandFields, this.options.ideogram === CircosIdeogram.Banded ? GenomeBandLevel.Published : GenomeBandLevel.Band);
+	}
+	table() {
+		return this.#assembly().table([
+			"links",
+			"tracks",
+			"bands"
+		]);
+	}
+	#links(assembly) {
+		const { linkMark, linkScope, linkFields } = this.options;
+		if (linkMark === CircosLinkMark.None) return [];
+		return assembly.links(linkFields).filter(({ a, b }) => linkScope === CircosLinkScope.All || linkScope === CircosLinkScope.Intra === (a.chrom === b.chrom));
+	}
+	#frame(assembly, radius) {
+		const { scale, focus, magnify, opening } = this.options;
+		const ends = assembly.links(this.options.linkFields).flatMap(({ a, b }) => [a.chrom, b.chrom]);
+		const zoomed = scale === CircosScale.Focus ? assembly.busiest(ends, focus)?.name : void 0;
+		return new CircosFrame(assembly.chromosomes, radius, opening * Math.PI / 180, zoomed, magnify);
+	}
+	#drawIdeogram(ctx, frame, inner, outer) {
+		const banded = this.options.ideogram === CircosIdeogram.Banded;
+		const stain = new GenomeStainScale(ctx.theme);
+		const shape = arc().innerRadius(inner).outerRadius(outer).startAngle((d) => d.a0).endAngle((d) => d.a1);
+		const items = banded ? frame.sectors.flatMap((sector) => sector.chromosome.bands.map((band) => ({
+			band,
+			a0: frame.angle(sector.chromosome.name, band.start),
+			a1: frame.angle(sector.chromosome.name, band.end)
+		}))) : [];
+		const bands = ctx.marks("bands", "path", items, (d) => d.band.key).attr("fill", (d) => stain.fill(d.band));
+		ctx.set(bands, {
+			d: (d) => shape(d),
+			"fill-opacity": 1
+		}, { "fill-opacity": 0 });
+		ctx.hover(bands, ({ band }) => ({
+			title: `${band.chrom}${band.name}`,
+			rows: [["Stain", band.stain], ["Position", GenomeAssembly.span(band.start, band.end)]]
+		}));
+		const shells = ctx.marks("sectors", "path", frame.sectors, (d) => d.chromosome.name).attr("fill", banded ? "none" : ctx.theme.axis).attr("stroke", banded ? ctx.theme.inkMuted : "none").attr("stroke-width", .75).attr("pointer-events", banded ? "none" : null);
+		ctx.set(shells, { d: (d) => shape(d) });
+		if (!banded) ctx.hover(shells, (d) => ({
+			title: `Chromosome ${d.chromosome.name}`,
+			rows: [["Length", GenomeAssembly.megabases(d.chromosome.length)]]
+		}));
+	}
+	/** Mb ticks outside the ideogram: a step that is legible at this radius, with larger ones labelled. */
+	#drawTicks(ctx, frame, outer, labelled) {
+		const ticks = frame.sectors.flatMap((sector) => {
+			const px = (mb) => sector.perBp * mb * 1e6 * outer;
+			const minor = TICK_STEPS.find((step) => px(step) >= 6) ?? 100;
+			const major = TICK_STEPS.find((step) => step % minor === 0 && px(step) >= 26) ?? minor * 4;
+			return Array.from({ length: Math.floor(sector.chromosome.length / 1e6 / minor) + 1 }, (_, i) => {
+				const mb = i * minor;
+				return {
+					key: `${sector.chromosome.name}:${mb}`,
+					a: sector.a0 + mb * 1e6 * sector.perBp,
+					major: mb % major === 0,
+					label: `${mb}`
+				};
+			});
+		});
+		const reach = (d) => outer + (d.major ? 5 : 3);
+		const lines = ctx.marks("axis-ticks", "line", ticks, (d) => d.key).attr("stroke", ctx.theme.inkMuted).attr("stroke-width", (d) => d.major ? 1 : .6);
+		const xy = (a, r) => point(a, r).split(" ").map(Number);
+		ctx.set(lines, {
+			x1: (d) => xy(d.a, outer)[0],
+			y1: (d) => xy(d.a, outer)[1],
+			x2: (d) => xy(d.a, reach(d))[0],
+			y2: (d) => xy(d.a, reach(d))[1]
+		});
+		const shown = labelled ? ticks.filter((d) => d.major && d.label !== "0") : [];
+		const labels = ctx.marks("tick-labels", "text", shown, (d) => d.key);
+		ctx.text(labels, 8, "muted").attr("dy", "0.33em").attr("pointer-events", "none").attr("text-anchor", (d) => Math.sin(d.a) >= 0 ? "start" : "end").attr("transform", (d) => {
+			const [x, y] = xy(d.a, outer + 7), degrees = d.a * 180 / Math.PI - 90;
+			return `translate(${x},${y}) rotate(${Math.sin(d.a) >= 0 ? degrees : degrees + 180})`;
+		}).text((d) => d.label);
+		return labelled ? 24 : 7;
+	}
+	#drawNames(ctx, frame, radius) {
+		const centre = (d) => (d.a0 + d.a1) / 2;
+		let last = -Infinity;
+		const clear = frame.sectors.filter((d) => {
+			const at = centre(d) * radius;
+			if (at - last < 5.2 * d.chromosome.name.length + 2) return false;
+			last = at;
+			return true;
+		});
+		const names = ctx.marks("chromosome-names", "text", clear, (d) => d.chromosome.name);
+		ctx.text(names, 9.5).attr("text-anchor", "middle").attr("dy", "0.33em").attr("pointer-events", "none").attr("transform", (d) => `translate(${point(centre(d), radius).replace(" ", ",")})`).text((d) => d.chromosome.name);
+	}
+	#rings(rows, ctx, top, thick) {
+		return groups(rows, (row) => row.track).map(([name, own], i) => {
+			const outer = top - i * (thick + 3), inner = outer - thick;
+			const [low = 0, high = 1] = extent(own, (row) => row.value);
+			const signed = low < 0;
+			const reach = quantile(own.map((row) => Math.abs(row.value)).sort(ascending), .98) || Math.max(Math.abs(low), Math.abs(high)) || 1;
+			const radius = scaleLinear(signed ? [-reach, reach] : [0, reach], [inner, outer]).clamp(true);
+			const shade = signed ? (value) => ctx.palette.diverging(value / reach) : (value) => ctx.palette.sequential(.15 + .85 * value / reach);
+			return {
+				name,
+				rows: own,
+				inner,
+				outer,
+				base: signed ? radius(0) : inner,
+				radius,
+				shade,
+				signed
+			};
+		});
+	}
+	#drawRings(ctx, frame, rings, assembly) {
+		const mark = this.options.trackMark;
+		const plates = rings.flatMap((ring) => frame.sectors.map((sector) => ({
+			key: `${ring.name}:${sector.chromosome.name}`,
+			ring,
+			a0: sector.a0,
+			a1: sector.a1
+		})));
+		const backing = arc().innerRadius((d) => d.ring.inner).outerRadius((d) => d.ring.outer).startAngle((d) => d.a0).endAngle((d) => d.a1);
+		const plate = ctx.marks("track-plates", "path", plates, (d) => d.key).attr("fill", ctx.theme.grid).attr("fill-opacity", .45).attr("pointer-events", "none");
+		ctx.set(plate, { d: (d) => backing(d) });
+		const midlines = rings.filter((ring) => ring.signed).flatMap((ring) => frame.sectors.map((sector) => ({
+			key: `${ring.name}:${sector.chromosome.name}`,
+			ring,
+			a0: sector.a0,
+			a1: sector.a1
+		})));
+		const zero = arc().innerRadius((d) => d.ring.base - .3).outerRadius((d) => d.ring.base + .3).startAngle((d) => d.a0).endAngle((d) => d.a1);
+		ctx.set(ctx.marks("track-zero", "path", midlines, (d) => d.key).attr("fill", ctx.theme.axis).attr("pointer-events", "none"), { d: (d) => zero(d) });
+		const bins = rings.flatMap((ring) => ring.rows.map((row) => ({
+			...row,
+			ring,
+			a0: frame.angle(row.chrom, row.start),
+			a1: Math.max(frame.angle(row.chrom, row.end), frame.angle(row.chrom, row.start) + .002)
+		})));
+		const tip = (d) => ({
+			title: assembly.locus(d.chrom, d.start),
+			color: d.ring.shade(d.value),
+			rows: [[d.track, d.value], ["Position", GenomeAssembly.span(d.start, d.end)]]
+		});
+		const area = mark === CircosTrackMark.Histogram || mark === CircosTrackMark.Heatmap;
+		const shape = arc().startAngle((d) => d.a0).endAngle((d) => d.a1).innerRadius((d) => mark === CircosTrackMark.Heatmap ? d.ring.inner : Math.min(d.ring.base, d.ring.radius(d.value))).outerRadius((d) => mark === CircosTrackMark.Heatmap ? d.ring.outer : Math.max(d.ring.base, d.ring.radius(d.value)));
+		const fills = ctx.marks("track-bins", "path", area ? bins : [], (d) => `${d.track}:${d.chrom}:${d.start}`).attr("fill", (d) => d.ring.shade(d.value));
+		ctx.set(fills, {
+			d: (d) => shape(d),
+			"fill-opacity": 1
+		}, { "fill-opacity": 0 });
+		ctx.hover(fills, tip);
+		const shown = mark === CircosTrackMark.Scatter ? bins : [];
+		const xy = (d) => point((d.a0 + d.a1) / 2, d.ring.radius(d.value)).split(" ").map(Number);
+		const dots = ctx.marks("track-dots", "circle", shown, (d) => `${d.track}:${d.chrom}:${d.start}`).attr("fill", (d) => d.ring.shade(d.value));
+		ctx.set(dots, {
+			cx: (d) => xy(d)[0],
+			cy: (d) => xy(d)[1],
+			r: (d) => d.ring.outer - d.ring.inner >= 20 ? 2.4 : 1.6
+		}, { r: 0 });
+		ctx.hover(dots, tip);
+		const paths = mark !== CircosTrackMark.Line ? [] : rings.flatMap((ring) => groups(ring.rows, (row) => row.chrom).map(([chrom, own]) => ({
+			key: `${ring.name}:${chrom}`,
+			ring,
+			chrom,
+			own
+		})));
+		const lines = ctx.marks("track-lines", "path", paths, (d) => d.key).attr("fill", "none").attr("stroke", (d) => ctx.palette.color(d.ring.name)).attr("stroke-width", 1.5).attr("stroke-linejoin", "round");
+		const trace = (d) => lineRadial().angle((row) => frame.angle(row.chrom, (row.start + row.end) / 2)).radius((row) => d.ring.radius(row.value))(d.own);
+		ctx.set(lines, {
+			d: trace,
+			"stroke-opacity": 1
+		}, { "stroke-opacity": 0 });
+		ctx.hover(lines, (d) => ({
+			title: `Chromosome ${d.chrom}`,
+			color: ctx.palette.color(d.ring.name),
+			rows: [[d.ring.name, `${+Math.min(...d.own.map((row) => row.value)).toFixed(2)} to ${+Math.max(...d.own.map((row) => row.value)).toFixed(2)}`]]
+		}));
+	}
+	/** Track names sit horizontally in the opening at 12 o'clock, when they fit its width there. */
+	#drawTrackNames(ctx, frame, rings) {
+		const fitting = rings.filter((ring) => frame.opening > 0 && ring.name.length * 4.9 <= 2 * (ring.inner + ring.outer) / 2 * Math.tan(frame.opening / 2) - 4);
+		const names = ctx.marks("track-names", "text", fitting, (d) => d.name);
+		ctx.text(names, 8.5, "muted").attr("text-anchor", "middle").attr("dy", "0.33em").attr("pointer-events", "none").attr("x", 0).attr("y", (d) => -(d.inner + d.outer) / 2).text((d) => d.name);
+	}
+	#drawLinks(ctx, frame, links, radius, assembly) {
+		const ribbon = this.options.linkMark === CircosLinkMark.Ribbon;
+		const thin = 2 / radius;
+		/** Quadratic control point: through the centre for opposite loci, near the rim for close ones. */
+		const control = (a, b) => {
+			const turn = Math.atan2(Math.sin(b - a), Math.cos(b - a)), separation = Math.abs(turn);
+			return point(a + turn / 2, Math.min(radius * .74, radius * (1 - separation / Math.PI) ** 1.6));
+		};
+		const shape = ({ a, b }) => {
+			const a0 = frame.angle(a.chrom, a.start), a1 = Math.max(frame.angle(a.chrom, a.end), a0 + thin);
+			const b0 = frame.angle(b.chrom, b.start), b1 = Math.max(frame.angle(b.chrom, b.end), b0 + thin);
+			if (!ribbon) {
+				const from = (a0 + a1) / 2, to = (b0 + b1) / 2;
+				return `M${point(from, radius)}Q${control(from, to)} ${point(to, radius)}`;
+			}
+			const rim = `A${radius} ${radius} 0 0 1`;
+			return `M${point(a0, radius)}${rim} ${point(a1, radius)}Q${control(a1, b0)} ${point(b0, radius)}${rim} ${point(b1, radius)}Q${control(b1, a0)} ${point(a0, radius)}Z`;
+		};
+		const color = (d) => ctx.palette.color(d.kind);
+		const paths = ctx.marks("links", "path", links, (d) => d.key).attr("fill", ribbon ? color : "none").attr("stroke", ribbon ? "none" : color).attr("stroke-width", radius < 60 ? 1.25 : 2).attr("stroke-linecap", "round");
+		ctx.set(paths, {
+			d: shape,
+			opacity: ribbon ? .72 : .85
+		}, { opacity: 0 }, 8);
+		ctx.hover(paths, (d) => ({
+			title: d.name,
+			color: color(d),
+			rows: [
+				["Class", d.kind],
+				[assembly.locus(d.a.chrom, d.a.start), GenomeAssembly.span(d.a.start, d.a.end)],
+				[assembly.locus(d.b.chrom, d.b.start), GenomeAssembly.span(d.b.start, d.b.end)],
+				...d.value == null ? [] : [["Value", d.value]]
+			]
+		}));
+	}
+	drawRadial(ctx, { radius }) {
+		const assembly = this.#assembly();
+		const wide = radius >= 150;
+		const ideogramOuter = Math.max(24, radius - 10 - (wide ? 22 : 6));
+		const ideogramInner = ideogramOuter - Math.max(6, Math.min(14, radius * .075));
+		const frame = this.#frame(assembly, ideogramOuter);
+		this.#drawNames(ctx, frame, radius - 5);
+		this.#drawTicks(ctx, frame, ideogramOuter, wide);
+		this.#drawIdeogram(ctx, frame, ideogramInner, ideogramOuter);
+		const thick = Math.max(6, Math.min(30, radius * .1));
+		for (const link of assembly.links(this.options.linkFields)) ctx.palette.color(link.kind);
+		const links = this.#links(assembly);
+		const rings = this.#rings(assembly.tracks(this.options.trackFields), ctx, ideogramInner - 3, thick);
+		this.#drawRings(ctx, frame, rings, assembly);
+		this.#drawTrackNames(ctx, frame, rings);
+		this.#shown = /* @__PURE__ */ new Set([...links.map((link) => link.kind), ...this.options.trackMark === CircosTrackMark.Line ? rings.map((ring) => ring.name) : []]);
+		this.#drawLinks(ctx, frame, links, Math.max(12, ideogramInner - 5 - rings.length * (thick + 3)), assembly);
+	}
+};
+export { CircosPlot };

package/dist/charts/genomics/GenomeAssembly.js

@@ -0,0 +1,218 @@
+import { GenomeBandLevel } from "./genomicsEnums.js";
+// src/charts/genomics/GenomeAssembly.ts
+var BAND_FIELDS = {
+	chrom: "chrom",
+	start: "start",
+	end: "end",
+	band: "band",
+	stain: "stain"
+};
+var TRACK_FIELDS = {
+	chrom: "chrom",
+	start: "start",
+	end: "end",
+	value: "value",
+	track: "track"
+};
+var LINK_FIELDS = {
+	chrom1: "chrom1",
+	start1: "start1",
+	end1: "end1",
+	chrom2: "chrom2",
+	start2: "start2",
+	end2: "end2",
+	name: "name",
+	kind: "kind",
+	value: "value"
+};
+var ANNOTATION_FIELDS = {
+	chrom: "chrom",
+	start: "start",
+	end: "end",
+	label: "label",
+	group: "group",
+	value: "value"
+};
+var SEX_ORDER = [
+	"X",
+	"Y",
+	"M",
+	"MT"
+];
+var ORDINARY = /^(gneg|gpos\d*)$/;
+var number = (cell) => cell == null || cell === "" ? NaN : +cell;
+var nameOf = (cell) => String(cell ?? "").replace(/^chr/i, "");
+var densityOf = (stain) => stain.startsWith("gpos") ? (+stain.slice(4) || 100) / 100 : 0;
+var stainOf = (density) => density < .125 ? "gneg" : `gpos${Math.round(density * 4) * 25}`;
+var rank = (name) => {
+	const numeric = +name;
+	if (Number.isFinite(numeric)) return numeric;
+	const sex = SEX_ORDER.indexOf(name.toUpperCase());
+	return sex < 0 ? 2e3 : 1e3 + sex;
+};
+/** Normalises band, track, link and annotation rows onto one reference, in karyotype order. */
+var GenomeAssembly = class GenomeAssembly {
+	data;
+	chromosomes;
+	#byName;
+	constructor(data, bandFields, level = GenomeBandLevel.Published) {
+		this.data = data;
+		const fields = {
+			...BAND_FIELDS,
+			...bandFields
+		};
+		const seen = /* @__PURE__ */ new Set();
+		const groups = /* @__PURE__ */ new Map();
+		for (const row of this.#parts.bands ?? []) {
+			const chrom = nameOf(row[fields.chrom]), start = Math.max(0, number(row[fields.start])), end = number(row[fields.end]);
+			const key = `${chrom}:${start}`;
+			if (!chrom || !(end > start) || seen.has(key)) continue;
+			seen.add(key);
+			const stain = String(row[fields.stain] ?? "gneg");
+			const band = {
+				key,
+				chrom,
+				start,
+				end,
+				name: String(row[fields.band] ?? ""),
+				stain,
+				density: densityOf(stain)
+			};
+			if (!groups.has(chrom)) groups.set(chrom, []);
+			groups.get(chrom).push(band);
+		}
+		this.chromosomes = [...groups].map(([name, bands]) => {
+			const sorted = GenomeAssembly.coarsen(bands.sort((a, b) => a.start - b.start), level);
+			const acen = sorted.filter((band) => band.stain === "acen");
+			const centromere = acen.length ? acen.length > 1 ? acen[0].end : (acen[0].start + acen[0].end) / 2 : null;
+			return {
+				name,
+				length: sorted.at(-1).end,
+				bands: sorted,
+				centromere
+			};
+		}).sort((a, b) => rank(a.name) - rank(b.name) || a.name.localeCompare(b.name));
+		this.#byName = new Map(this.chromosomes.map((chromosome) => [chromosome.name, chromosome]));
+	}
+	get #parts() {
+		return Array.isArray(this.data) ? { bands: this.data } : this.data ?? { bands: [] };
+	}
+	/** Merges neighbours that share a parent band. Centromere, heterochromatin and stalk stay whole. */
+	static coarsen(bands, level) {
+		if (level === GenomeBandLevel.Published) return bands;
+		const parent = (name) => (level === GenomeBandLevel.Band ? /^[pq]\d+/ : /^[pq]\d+(\.\d)?/).exec(name)?.[0] ?? name;
+		const runs = [];
+		for (const band of bands) {
+			const last = runs.at(-1), head = last?.[0];
+			if (head && ORDINARY.test(head.stain) && ORDINARY.test(band.stain) && parent(head.name) === parent(band.name)) last.push(band);
+			else runs.push([band]);
+		}
+		return runs.map((run) => {
+			if (run.length === 1 && !ORDINARY.test(run[0].stain)) return run[0];
+			const first = run[0], end = run.at(-1).end;
+			const density = run.reduce((sum, band) => sum + band.density * (band.end - band.start), 0) / (end - first.start);
+			return {
+				...first,
+				end,
+				name: parent(first.name),
+				density,
+				stain: stainOf(density)
+			};
+		});
+	}
+	at(chrom) {
+		return this.#byName.get(nameOf(chrom));
+	}
+	/** Standard cytogenetic locus of a position, such as `17p13.1`. */
+	locus(chrom, position) {
+		const chromosome = this.at(chrom);
+		return `${chrom}${(chromosome?.bands.find((item) => position < item.end) ?? chromosome?.bands.at(-1))?.name ?? ""}`;
+	}
+	#interval(chrom, startCell, endCell, value = NaN, track = "") {
+		const chromosome = this.at(chrom), start = number(startCell);
+		if (!chromosome || !Number.isFinite(start)) return null;
+		const end = number(endCell);
+		const low = Math.max(0, Math.min(start, Number.isFinite(end) ? end : start));
+		return {
+			chrom: chromosome.name,
+			start: Math.min(low, chromosome.length),
+			end: Math.min(Math.max(start, Number.isFinite(end) ? end : start), chromosome.length),
+			value,
+			track
+		};
+	}
+	tracks(fields) {
+		const f = {
+			...TRACK_FIELDS,
+			...fields
+		};
+		return (this.#parts.tracks ?? []).flatMap((row) => {
+			const value = number(row[f.value]);
+			const interval = Number.isFinite(value) ? this.#interval(row[f.chrom], row[f.start], row[f.end], value, String(row[f.track] ?? "Track")) : null;
+			return interval ? [interval] : [];
+		});
+	}
+	links(fields) {
+		const f = {
+			...LINK_FIELDS,
+			...fields
+		};
+		return (this.#parts.links ?? []).flatMap((row, i) => {
+			const a = this.#interval(row[f.chrom1], row[f.start1], row[f.end1]), b = this.#interval(row[f.chrom2], row[f.start2], row[f.end2]);
+			if (!a || !b) return [];
+			const value = number(row[f.value]), name = String(row[f.name] ?? `Link ${i + 1}`);
+			return [{
+				key: `${i}:${name}`,
+				a,
+				b,
+				name,
+				kind: String(row[f.kind] ?? "Link"),
+				value: Number.isFinite(value) ? value : null
+			}];
+		});
+	}
+	annotations(fields) {
+		const f = {
+			...ANNOTATION_FIELDS,
+			...fields
+		};
+		return (this.#parts.annotations ?? []).flatMap((row, i) => {
+			const interval = this.#interval(row[f.chrom], row[f.start], row[f.end]);
+			if (!interval) return [];
+			const value = number(row[f.value]), label = String(row[f.label] ?? "");
+			return [{
+				key: `${i}:${label}`,
+				chrom: interval.chrom,
+				start: interval.start,
+				end: interval.end,
+				label,
+				group: String(row[f.group] ?? "Annotation"),
+				value: Number.isFinite(value) ? value : null
+			}];
+		});
+	}
+	/** Chromosome named by `focus`, else the one most of `names` fall on. */
+	busiest(names, focus) {
+		const asked = focus ? this.at(focus) : void 0;
+		if (asked) return asked;
+		const counts = /* @__PURE__ */ new Map();
+		for (const name of names) counts.set(name, (counts.get(name) ?? 0) + 1);
+		return [...this.chromosomes].sort((a, b) => (counts.get(b.name) ?? 0) - (counts.get(a.name) ?? 0))[0];
+	}
+	/** The first non-empty table, in the order given, for `chart.table()`. */
+	table(order) {
+		const rows = order.map((key) => this.#parts[key]).find((list) => list?.length) ?? [];
+		const columns = Object.keys(rows[0] ?? {});
+		return {
+			columns,
+			rows: rows.map((row) => columns.map((column) => row[column]))
+		};
+	}
+	static megabases(bp) {
+		return `${+(bp / 1e6).toFixed(bp < 1e7 ? 2 : 1)} Mb`;
+	}
+	static span(start, end) {
+		return end > start ? `${GenomeAssembly.megabases(start)} – ${GenomeAssembly.megabases(end)}` : GenomeAssembly.megabases(start);
+	}
+};
+export { GenomeAssembly };