@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/network/networkEnums.js

@@ -0,0 +1,53 @@
+// src/charts/network/networkEnums.ts
+/** What a node's area encodes, or what a positional axis reads. */
+var NetworkMetric = /* @__PURE__ */ function(NetworkMetric) {
+	NetworkMetric["Uniform"] = "uniform";
+	NetworkMetric["Degree"] = "degree";
+	NetworkMetric["Value"] = "value";
+	NetworkMetric["Strength"] = "strength";
+	NetworkMetric["Betweenness"] = "betweenness";
+	NetworkMetric["Closeness"] = "closeness";
+	NetworkMetric["PageRank"] = "pagerank";
+	NetworkMetric["KCore"] = "k-core";
+	return NetworkMetric;
+}({});
+/** Linear ordering of nodes along a line, a circle or a matrix edge. */
+var NetworkOrder = /* @__PURE__ */ function(NetworkOrder) {
+	NetworkOrder["Input"] = "input";
+	NetworkOrder["Group"] = "group";
+	NetworkOrder["Degree"] = "degree";
+	NetworkOrder["Community"] = "community";
+	NetworkOrder["CuthillMcKee"] = "cuthill-mckee";
+	NetworkOrder["Spectral"] = "spectral";
+	return NetworkOrder;
+}({});
+var NetworkEdge = /* @__PURE__ */ function(NetworkEdge) {
+	NetworkEdge["Straight"] = "straight";
+	NetworkEdge["Arc"] = "arc";
+	NetworkEdge["Curve"] = "curve";
+	NetworkEdge["Bundled"] = "bundled";
+	NetworkEdge["Tapered"] = "tapered";
+	NetworkEdge["Orthogonal"] = "orthogonal";
+	NetworkEdge["Bump"] = "bump";
+	return NetworkEdge;
+}({});
+var NetworkCommunity = /* @__PURE__ */ function(NetworkCommunity) {
+	NetworkCommunity["Attribute"] = "attribute";
+	NetworkCommunity["Louvain"] = "louvain";
+	NetworkCommunity["LabelPropagation"] = "label-propagation";
+	return NetworkCommunity;
+}({});
+var NetworkSpanning = /* @__PURE__ */ function(NetworkSpanning) {
+	NetworkSpanning["MinimumWeight"] = "minimum";
+	NetworkSpanning["MaximumWeight"] = "maximum";
+	NetworkSpanning["BreadthFirst"] = "breadth-first";
+	NetworkSpanning["DepthFirst"] = "depth-first";
+	NetworkSpanning["ShortestPath"] = "shortest-path";
+	return NetworkSpanning;
+}({});
+var NetworkFlip = /* @__PURE__ */ function(NetworkFlip) {
+	NetworkFlip["Horizontal"] = "horizontal";
+	NetworkFlip["Vertical"] = "vertical";
+	return NetworkFlip;
+}({});
+export { NetworkCommunity, NetworkEdge, NetworkFlip, NetworkMetric, NetworkOrder, NetworkSpanning };

package/dist/charts/pictorial/ArrowGlyphs.js

@@ -0,0 +1,191 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { extent, max, mean, rollups, scaleLinear } from "d3";
+// src/charts/pictorial/ArrowGlyphs.ts
+var ArrowStyle = /* @__PURE__ */ function(ArrowStyle) {
+	ArrowStyle["Simple"] = "simple";
+	ArrowStyle["Wedge"] = "wedge";
+	ArrowStyle["Block"] = "block";
+	ArrowStyle["Chevron"] = "chevron";
+	ArrowStyle["Tadpole"] = "tadpole";
+	return ArrowStyle;
+}({});
+var ArrowAnchor = /* @__PURE__ */ function(ArrowAnchor) {
+	ArrowAnchor["Tail"] = "tail";
+	ArrowAnchor["Middle"] = "middle";
+	ArrowAnchor["Tip"] = "tip";
+	return ArrowAnchor;
+}({});
+var ArrowEncoding = /* @__PURE__ */ function(ArrowEncoding) {
+	ArrowEncoding["Length"] = "length";
+	ArrowEncoding["Weight"] = "weight";
+	ArrowEncoding["Both"] = "both";
+	return ArrowEncoding;
+}({});
+var ArrowLayout = /* @__PURE__ */ function(ArrowLayout) {
+	ArrowLayout["Scattered"] = "scattered";
+	ArrowLayout["Binned"] = "binned";
+	return ArrowLayout;
+}({});
+var LATTICE = 11;
+var degrees = Math.PI / 180;
+/** Vector glyphs at positions: show direction and strength together, as in wind or flow fields. */
+var ArrowGlyphs = class extends CartesianChart {
+	static meta = {
+		id: "arrow-glyphs",
+		name: "Arrow glyphs",
+		family: ChartFamily.Pictorial,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Places an arrow at each position so its heading and size show direction and strength, as in a flow field.",
+		tags: [
+			"vector",
+			"quiver",
+			"direction",
+			"glyph"
+		],
+		sample: (seed) => SampleData.points(seed, 90, 3).map((point) => {
+			const x = Number(point.x), y = Number(point.y);
+			return {
+				x,
+				y,
+				angle: (Math.atan2(y - 40, x - 40) / degrees + 450) % 360,
+				magnitude: point.size
+			};
+		}),
+		variants: {
+			arrow: [
+				"simple",
+				"wedge",
+				"block",
+				"chevron",
+				"tadpole"
+			],
+			anchor: [
+				"middle",
+				"tail",
+				"tip"
+			],
+			encoding: [
+				"length",
+				"weight",
+				"both"
+			],
+			layout: ["scattered", "binned"]
+		}
+	};
+	defaults() {
+		return {
+			x: "x",
+			y: "y",
+			angle: "angle",
+			magnitude: "magnitude",
+			arrow: "simple",
+			anchor: "middle",
+			encoding: "length",
+			layout: "scattered"
+		};
+	}
+	raw() {
+		const { data, x, y, angle, magnitude } = this.options;
+		return data.flatMap((row) => {
+			const vector = {
+				x: Number(row[x]),
+				y: Number(row[y]),
+				angle: Number(row[angle]),
+				magnitude: Math.abs(Number(row[magnitude] ?? 0)),
+				count: 1
+			};
+			return [
+				vector.x,
+				vector.y,
+				vector.angle,
+				vector.magnitude
+			].every(Number.isFinite) ? [vector] : [];
+		});
+	}
+	vectors() {
+		const raw = this.raw();
+		if (this.options.layout !== "binned") return raw;
+		const [xLow = 0, xHigh = 1] = extent(raw, (d) => d.x), [yLow = 0, yHigh = 1] = extent(raw, (d) => d.y);
+		const stepX = (xHigh - xLow || 1) / LATTICE, stepY = (yHigh - yLow || 1) / Math.ceil(LATTICE * .65);
+		const cell = (value, low, step) => Math.floor((value - low) / step + 1e-9);
+		return rollups(raw, (members) => {
+			const east = mean(members, (d) => Math.sin(d.angle * degrees) * d.magnitude) ?? 0;
+			const north = mean(members, (d) => Math.cos(d.angle * degrees) * d.magnitude) ?? 0;
+			const first = members[0];
+			return {
+				x: xLow + (cell(first.x, xLow, stepX) + .5) * stepX,
+				y: yLow + (cell(first.y, yLow, stepY) + .5) * stepY,
+				angle: Math.atan2(east, north) / degrees,
+				magnitude: Math.hypot(east, north),
+				count: members.length
+			};
+		}, (d) => `${cell(d.x, xLow, stepX)}:${cell(d.y, yLow, stepY)}`).map(([, vector]) => vector);
+	}
+	scales(ctx) {
+		const vectors = this.raw();
+		const pad = (values) => {
+			const [low = 0, high = 1] = extent(values);
+			const margin = (high - low || 1) * .08;
+			return [low - margin, high + margin];
+		};
+		return {
+			x: scaleLinear(pad(vectors.map((d) => d.x)), [0, ctx.plot.width]).nice(),
+			y: scaleLinear(pad(vectors.map((d) => d.y)), [ctx.plot.height, 0]).nice()
+		};
+	}
+	/** Arrow pointing up (north) with its tail at y = 0, `length` tall and `thick` wide. */
+	shape(length, thick) {
+		const head = Math.min(length * .5, thick * 2.4), half = thick / 2, wing = thick * 1.4;
+		const up = (y) => -y;
+		switch (this.options.arrow) {
+			case "wedge": return `M${-wing},0L0,${up(length)}L${wing},0L0,${up(length * .14)}Z`;
+			case "block": return `M${-half * 1.6},0V${up(length - head)}H${-wing * 1.3}L0,${up(length)}L${wing * 1.3},${up(length - head)}H${half * 1.6}V0Z`;
+			case "chevron": return `M${-wing * 1.3},${up(length * .3)}L0,${up(length)}L${wing * 1.3},${up(length * .3)}L${wing * 1.3 - thick},${up(length * .3 - thick * .6)}L0,${up(length - thick * 1.6)}L${-wing * 1.3 + thick},${up(length * .3 - thick * .6)}Z`;
+			case "tadpole": return `M${-thick},${up(length - thick)}A${thick},${thick} 0 1 1 ${thick},${up(length - thick)}L0,0Z`;
+			default: return `M${-half},0V${up(length - head)}H${-wing}L0,${up(length)}L${wing},${up(length - head)}H${half}V0Z`;
+		}
+	}
+	plotMarks(ctx, { x, y }) {
+		const { anchor, encoding, magnitude } = this.options;
+		const vectors = this.vectors();
+		const top = max(vectors, (d) => d.magnitude) || 1;
+		const pitch = Math.sqrt(ctx.plot.width * ctx.plot.height / Math.max(1, vectors.length));
+		const longest = Math.min(36, pitch * .95);
+		const length = (d) => encoding === "weight" ? longest * .8 : Math.max(8, longest * Math.sqrt(d.magnitude / top));
+		const thick = (d) => encoding === "length" ? 2 : 1.4 + 3 * Math.sqrt(d.magnitude / top);
+		const lift = {
+			["tail"]: 0,
+			["middle"]: .5,
+			["tip"]: 1
+		}[anchor];
+		const clampX = (value) => Math.max(0, Math.min(ctx.plot.width, value)), clampY = (value) => Math.max(0, Math.min(ctx.plot.height, value));
+		const place = (d, scale = 1) => {
+			const reach = length(d);
+			const sin = Math.sin(d.angle * degrees), cos = Math.cos(d.angle * degrees);
+			const atX = x(d.x) - sin * reach * lift, atY = y(d.y) + cos * reach * lift;
+			const safeX = clampX(atX + sin * reach) - sin * reach, safeY = clampY(atY - cos * reach) + cos * reach;
+			return `translate(${clampX(safeX)},${clampY(safeY)}) rotate(${d.angle}) scale(${scale})`;
+		};
+		const color = (d) => ctx.palette.sequential(.3 + .7 * (d.magnitude / top));
+		const marks = ctx.marks("arrows", "path", vectors, (d) => `${d.x}:${d.y}`).attr("fill", color).attr("stroke-linejoin", "round");
+		ctx.set(marks, {
+			d: (d) => this.shape(length(d), thick(d)),
+			transform: (d) => place(d)
+		}, {
+			d: (d) => this.shape(length(d), thick(d)),
+			transform: (d) => place(d, 0)
+		}, 3);
+		ctx.hover(marks, (d) => ({
+			color: color(d),
+			rows: [
+				["Heading", `${Math.round((d.angle + 360) % 360)}°`],
+				[magnitude, +d.magnitude.toFixed(2)],
+				...d.count > 1 ? [["Rows", d.count]] : []
+			]
+		}));
+	}
+};
+export { ArrowAnchor, ArrowEncoding, ArrowGlyphs, ArrowLayout, ArrowStyle };

package/dist/charts/pictorial/BoxCanvas.js

@@ -0,0 +1,84 @@
+// src/charts/pictorial/BoxCanvas.ts
+/**
+* The slice of a 2D canvas that d3-cloud rasterises with, painting each word as its bounding box.
+* It stands in where the DOM has no canvas (SSR, jsdom), so a word cloud lays out everywhere.
+*/
+var BoxContext = class {
+	fillStyle = "";
+	strokeStyle = "";
+	textAlign = "center";
+	lineWidth = 0;
+	lineJoin = "round";
+	font = "10px serif";
+	alpha = /* @__PURE__ */ new Uint8Array(0);
+	stride = 0;
+	shift = [0, 0];
+	angle = 0;
+	resize(width, height) {
+		this.stride = width;
+		this.alpha = new Uint8Array(width * height);
+	}
+	save() {}
+	restore() {
+		this.shift = [0, 0];
+		this.angle = 0;
+	}
+	translate(x, y) {
+		this.shift = [x, y];
+	}
+	rotate(angle) {
+		this.angle = angle;
+	}
+	clearRect(_x, _y, width, height) {
+		for (let row = 0; row < height; row++) this.alpha.fill(0, row * this.stride, row * this.stride + width);
+	}
+	measureText(text) {
+		return { width: text.length * this.size * .56 };
+	}
+	fillText(text) {
+		this.paint(text, 0);
+	}
+	strokeText(text) {
+		this.paint(text, this.lineWidth / 2);
+	}
+	paint(text, pad) {
+		const half = this.measureText(text).width / 2 + pad, ascent = this.size * .74 + pad, descent = this.size * .2 + pad;
+		const reach = Math.ceil(Math.hypot(half, ascent));
+		const [cx, cy] = this.shift, cos = Math.cos(this.angle), sin = Math.sin(this.angle);
+		for (let y = -reach; y <= reach; y++) for (let x = -reach; x <= reach; x++) {
+			const u = x * cos + y * sin, v = y * cos - x * sin;
+			if (Math.abs(u) <= half && v >= -ascent && v <= descent) this.alpha[(cy + y) * this.stride + cx + x] = 255;
+		}
+	}
+	getImageData(_x, _y, width, height) {
+		const data = new Uint8ClampedArray(width * height * 4);
+		for (let row = 0; row < height; row++) for (let column = 0; column < width; column++) data[(row * width + column) * 4 + 3] = this.alpha[row * this.stride + column];
+		return { data };
+	}
+	get size() {
+		return Number.parseFloat(/([\d.]+)px/.exec(this.font)?.[1] ?? "10");
+	}
+};
+var BoxCanvas = class {
+	context = new BoxContext();
+	w = 0;
+	h = 0;
+	get width() {
+		return this.w;
+	}
+	set width(value) {
+		this.w = value;
+		this.context.resize(this.w, this.h);
+	}
+	get height() {
+		return this.h;
+	}
+	set height(value) {
+		this.h = value;
+		this.context.resize(this.w, this.h);
+	}
+	getContext() {
+		return this.context;
+	}
+};
+export { BoxCanvas };

package/dist/charts/pictorial/BubbleText.js

@@ -0,0 +1,240 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { TextMetrics } from "./TextMetrics.js";
+import { WordChart } from "./WordChart.js";
+import { ascending, forceCollide, forceSimulation, forceX, forceY, mean, packEnclose, packSiblings, scaleSqrt, sum } from "d3";
+// src/charts/pictorial/BubbleText.ts
+var BubbleTextLayout = /* @__PURE__ */ function(BubbleTextLayout) {
+	BubbleTextLayout["Pack"] = "pack";
+	BubbleTextLayout["Clusters"] = "clusters";
+	BubbleTextLayout["Rows"] = "rows";
+	BubbleTextLayout["Spiral"] = "spiral";
+	return BubbleTextLayout;
+}({});
+var BubbleTextOrder = /* @__PURE__ */ function(BubbleTextOrder) {
+	BubbleTextOrder["Weight"] = "weight";
+	BubbleTextOrder["Alphabetical"] = "alphabetical";
+	return BubbleTextOrder;
+}({});
+var WEIGHT = 600;
+/** Words inside circles whose area is the weight: a friendlier, more exact word cloud. */
+var BubbleText = class extends WordChart {
+	static meta = {
+		id: "bubble-text",
+		name: "Bubble text",
+		family: ChartFamily.Text,
+		dimension: Dimension.Two,
+		shape: DataShape.Text,
+		description: "Sets each word inside a circle whose area shows its weight, packed, clustered, in rows or on a spiral.",
+		tags: [
+			"circle pack",
+			"bubble cloud",
+			"text"
+		],
+		sample: (seed) => {
+			const groups = [...new Set(SampleData.categories(seed, 3, 1).map((row) => String(row.category)))];
+			return SampleData.words(seed).map((word, i) => ({
+				...word,
+				group: groups[i % groups.length]
+			}));
+		},
+		variants: {
+			layout: [
+				"pack",
+				"clusters",
+				"rows",
+				"spiral"
+			],
+			nested: [true, false],
+			order: ["weight", "alphabetical"],
+			showValues: [false, true]
+		},
+		valid: ({ layout, nested, order }) => {
+			if (layout === "pack" || layout === "clusters") return order === "weight";
+			return nested === false;
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			layout: "pack",
+			nested: true,
+			order: "weight",
+			showValues: false
+		};
+	}
+	/** Each group packs into its own circle at a common scale, then the circles share the width. */
+	packed(words, width, height) {
+		const names = this.options.nested && this.grouped(words) ? [...new Set(words.map((word) => word.group ?? "—"))] : ["all"];
+		const gap = .06 * (mean(words, (word) => Math.sqrt(word.value)) || 1);
+		const clusters = names.map((name) => {
+			const circles = words.filter((word) => name === "all" || word.group === name).map((word) => ({
+				word,
+				x: 0,
+				y: 0,
+				r: Math.sqrt(word.value) + gap
+			}));
+			packSiblings(circles);
+			return {
+				circles,
+				hull: packEnclose(circles) ?? {
+					x: 0,
+					y: 0,
+					r: 1
+				}
+			};
+		});
+		const across = sum(clusters, ({ hull }) => hull.r * 2);
+		const k = Math.min(width / across, height / Math.max(...clusters.map(({ hull }) => hull.r * 2)));
+		let cursor = (width - across * k) / 2;
+		return clusters.flatMap(({ circles, hull }) => {
+			const cx = cursor + hull.r * k;
+			cursor += hull.r * 2 * k;
+			return circles.map(({ word, x, y, r }) => ({
+				word,
+				x: cx + (x - hull.x) * k,
+				y: height / 2 + (y - hull.y) * k,
+				r: (r - gap) * k
+			}));
+		});
+	}
+	areaScale(words, total, fill) {
+		const sumValue = words.reduce((sum, word) => sum + word.value, 0) || 1;
+		const biggest = Math.sqrt(fill * total * this.domain(words)[1] / (Math.PI * sumValue));
+		return scaleSqrt([0, this.domain(words)[1]], [0, biggest]);
+	}
+	clusters(words, width, height) {
+		const radius = this.areaScale(words, width * height, .44);
+		const groups = [...new Set(words.map((word) => word.group ?? "—"))];
+		const nested = this.options.nested;
+		const anchor = (word) => nested ? (groups.indexOf(word.group ?? "—") + .5) / groups.length : .5;
+		const nodes = words.map((word, i) => ({
+			word,
+			r: Math.max(3, radius(word.value)),
+			tx: width * anchor(word),
+			ty: height / 2,
+			x: width * anchor(word) + Math.cos(i * 2.4) * (8 + i * 3),
+			y: height / 2 + Math.sin(i * 2.4) * (8 + i * 3)
+		}));
+		const layout = forceSimulation(nodes).force("x", forceX((d) => d.tx).strength(.08)).force("y", forceY((d) => d.ty).strength(.1)).force("collide", forceCollide((d) => d.r + 2).iterations(3)).stop();
+		for (let tick = 0; tick < 200; tick++) {
+			layout.tick();
+			for (const node of nodes) {
+				node.x = Math.max(node.r, Math.min(width - node.r, node.x));
+				node.y = Math.max(node.r, Math.min(height - node.r, node.y));
+			}
+		}
+		return nodes.map((node) => ({
+			word: node.word,
+			r: node.r,
+			x: node.x,
+			y: node.y
+		}));
+	}
+	rows(words, width, height) {
+		for (let fill = .7;; fill *= .9) {
+			const radius = this.areaScale(words, width * height, fill);
+			const lines = [[]];
+			let x = 0;
+			for (const word of words) {
+				const r = Math.max(3, radius(word.value));
+				if (x + r * 2 > width && x > 0) {
+					lines.push([]);
+					x = 0;
+				}
+				lines[lines.length - 1].push({
+					word,
+					r,
+					x: x + r,
+					y: 0
+				});
+				x += r * 2 + 2;
+			}
+			const heights = lines.map((line) => Math.max(...line.map((bubble) => bubble.r * 2)) + 2);
+			const used = heights.reduce((sum, value) => sum + value, 0);
+			if (used > height && fill > .05) continue;
+			let y = (height - used) / 2;
+			return lines.flatMap((line, i) => {
+				const offset = (width - (line[line.length - 1].x + line[line.length - 1].r)) / 2;
+				const middle = y + heights[i] / 2;
+				y += heights[i];
+				return line.map((bubble) => ({
+					...bubble,
+					x: bubble.x + offset,
+					y: middle
+				}));
+			});
+		}
+	}
+	spiral(words, width, height) {
+		const reach = Math.min(width, height) / 2;
+		const radius = this.areaScale(words, Math.PI * reach * reach, .68);
+		const placed = [];
+		for (const word of words) {
+			const r = Math.max(3, radius(word.value));
+			for (let t = 0;; t += .12) {
+				const x = Math.cos(t) * t * 1.5 * (width / (height || 1)), y = Math.sin(t) * t * 1.5;
+				if (placed.some((other) => Math.hypot(other.x - x, other.y - y) < other.r + r + 2) && t < 400) continue;
+				placed.push({
+					word,
+					r,
+					x,
+					y
+				});
+				break;
+			}
+		}
+		const fitX = Math.max(...placed.map((d) => Math.abs(d.x) + d.r)), fitY = Math.max(...placed.map((d) => Math.abs(d.y) + d.r));
+		const shrink = Math.min(1, width / 2 / fitX, height / 2 / fitY);
+		return placed.map((d) => ({
+			...d,
+			r: d.r * shrink,
+			x: width / 2 + d.x * shrink,
+			y: height / 2 + d.y * shrink
+		}));
+	}
+	draw(ctx) {
+		const { width, height } = ctx.plot;
+		const { layout, order, showValues, value } = this.options;
+		const words = this.words();
+		if (order === "alphabetical") words.sort((a, b) => ascending(a.text, b.text));
+		const bubbles = !words.length ? [] : layout === "clusters" ? this.clusters(words, width, height) : layout === "rows" ? this.rows(words, width, height) : layout === "spiral" ? this.spiral(words, width, height) : this.packed(words, width, height);
+		const top = this.domain(words)[1];
+		const grouped = this.grouped(words);
+		const fill = (d) => grouped ? ctx.palette.color(d.word.group ?? "—") : ctx.palette.sequential(.2 + .7 * Math.sqrt(d.word.value / top));
+		const circles = ctx.marks("bubbles", "circle", bubbles, (d) => d.word.text).attr("fill", fill);
+		ctx.set(circles, {
+			cx: (d) => d.x,
+			cy: (d) => d.y,
+			r: (d) => d.r
+		}, {
+			cx: (d) => d.x,
+			cy: (d) => d.y,
+			r: 0
+		}, 8);
+		ctx.hover(circles, (d) => ({
+			title: d.word.text,
+			color: fill(d),
+			rows: [[value, d.word.value]]
+		}));
+		const labelled = bubbles.flatMap((bubble) => {
+			const size = Math.min(bubble.r * .62, (bubble.r * 2 - 6) / TextMetrics.width(bubble.word.text, 1, WEIGHT));
+			return size >= 8.5 ? [{
+				bubble,
+				size
+			}] : [];
+		});
+		const shift = (d) => showValues && d.bubble.r >= 18 ? -d.size * .1 : d.size * .35;
+		const labels = ctx.marks("words", "text", labelled, (d) => d.bubble.word.text).attr("text-anchor", "middle").attr("pointer-events", "none").attr("font-family", ctx.theme.fontFamily).attr("font-weight", WEIGHT).attr("font-size", (d) => d.size).attr("fill", (d) => TextMetrics.ink(ctx, fill(d.bubble))).text((d) => d.bubble.word.text);
+		ctx.set(labels, {
+			x: (d) => d.bubble.x,
+			y: (d) => d.bubble.y + shift(d)
+		});
+		const numbers = ctx.marks("values", "text", labelled.filter((d) => showValues && d.bubble.r >= 18), (d) => d.bubble.word.text).attr("text-anchor", "middle").attr("pointer-events", "none").attr("font-family", ctx.theme.fontFamily).attr("font-size", 10).attr("fill", (d) => TextMetrics.ink(ctx, fill(d.bubble))).text((d) => d.bubble.word.value);
+		ctx.set(numbers, {
+			x: (d) => d.bubble.x,
+			y: (d) => d.bubble.y + d.size * .1 + 11
+		});
+	}
+};
+export { BubbleText, BubbleTextLayout, BubbleTextOrder };