@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/radial/radialEnums.js

@@ -0,0 +1,201 @@
+// src/charts/radial/radialEnums.ts
+var PolarSort = /* @__PURE__ */ function(PolarSort) {
+	PolarSort["Data"] = "data";
+	PolarSort["Descending"] = "descending";
+	PolarSort["Ascending"] = "ascending";
+	return PolarSort;
+}({});
+/** Angular extent: whole circle, 270° dial, or upper half disc. */
+var PolarSpan = /* @__PURE__ */ function(PolarSpan) {
+	PolarSpan["Full"] = "full";
+	PolarSpan["Gauge"] = "gauge";
+	PolarSpan["Half"] = "half";
+	return PolarSpan;
+}({});
+var PolarLabels = /* @__PURE__ */ function(PolarLabels) {
+	PolarLabels["Rim"] = "rim";
+	PolarLabels["Tip"] = "tip";
+	PolarLabels["None"] = "none";
+	return PolarLabels;
+}({});
+var PolarDirection = /* @__PURE__ */ function(PolarDirection) {
+	PolarDirection["Outward"] = "outward";
+	PolarDirection["Inward"] = "inward";
+	return PolarDirection;
+}({});
+var PolarLayout = /* @__PURE__ */ function(PolarLayout) {
+	PolarLayout["Overlay"] = "overlay";
+	PolarLayout["Concentric"] = "concentric";
+	return PolarLayout;
+}({});
+var RadarGrid = /* @__PURE__ */ function(RadarGrid) {
+	RadarGrid["Polygon"] = "polygon";
+	RadarGrid["Circle"] = "circle";
+	return RadarGrid;
+}({});
+var RadarScaling = /* @__PURE__ */ function(RadarScaling) {
+	RadarScaling["Linear"] = "linear";
+	RadarScaling["Sqrt"] = "sqrt";
+	RadarScaling["Log"] = "log";
+	RadarScaling["PerAxis"] = "per-axis";
+	return RadarScaling;
+}({});
+var RadarLayout = /* @__PURE__ */ function(RadarLayout) {
+	RadarLayout["Overlay"] = "overlay";
+	RadarLayout["Facets"] = "facets";
+	return RadarLayout;
+}({});
+var RadialBarStack = /* @__PURE__ */ function(RadialBarStack) {
+	RadialBarStack["Total"] = "total";
+	RadialBarStack["Stacked"] = "stacked";
+	RadialBarStack["Grouped"] = "grouped";
+	return RadialBarStack;
+}({});
+var CircularBarplotArrange = /* @__PURE__ */ function(CircularBarplotArrange) {
+	CircularBarplotArrange["Grouped"] = "grouped";
+	CircularBarplotArrange["Stacked"] = "stacked";
+	return CircularBarplotArrange;
+}({});
+var RadialColumnMark = /* @__PURE__ */ function(RadialColumnMark) {
+	RadialColumnMark["Column"] = "column";
+	RadialColumnMark["Lollipop"] = "lollipop";
+	return RadialColumnMark;
+}({});
+var RadialBaseline = /* @__PURE__ */ function(RadialBaseline) {
+	RadialBaseline["Hole"] = "hole";
+	RadialBaseline["Mean"] = "mean";
+	RadialBaseline["Range"] = "range";
+	return RadialBaseline;
+}({});
+var RadialStackOffset = /* @__PURE__ */ function(RadialStackOffset) {
+	RadialStackOffset["None"] = "none";
+	RadialStackOffset["Expand"] = "expand";
+	RadialStackOffset["Silhouette"] = "silhouette";
+	RadialStackOffset["Wiggle"] = "wiggle";
+	return RadialStackOffset;
+}({});
+var RadialStackOrder = /* @__PURE__ */ function(RadialStackOrder) {
+	RadialStackOrder["Data"] = "data";
+	RadialStackOrder["Ascending"] = "ascending";
+	RadialStackOrder["InsideOut"] = "inside-out";
+	return RadialStackOrder;
+}({});
+var TimeSpiralMark = /* @__PURE__ */ function(TimeSpiralMark) {
+	TimeSpiralMark["Ribbon"] = "ribbon";
+	TimeSpiralMark["Bars"] = "bars";
+	TimeSpiralMark["Heat"] = "heat";
+	TimeSpiralMark["Dots"] = "dots";
+	TimeSpiralMark["Line"] = "line";
+	return TimeSpiralMark;
+}({});
+var TimeSpiralGrowth = /* @__PURE__ */ function(TimeSpiralGrowth) {
+	TimeSpiralGrowth["Archimedean"] = "archimedean";
+	TimeSpiralGrowth["Logarithmic"] = "logarithmic";
+	return TimeSpiralGrowth;
+}({});
+var CoxcombLayering = /* @__PURE__ */ function(CoxcombLayering) {
+	CoxcombLayering["LargestBack"] = "largest-back";
+	CoxcombLayering["Stacked"] = "stacked";
+	return CoxcombLayering;
+}({});
+var CoxcombLayout = /* @__PURE__ */ function(CoxcombLayout) {
+	CoxcombLayout["Single"] = "single";
+	CoxcombLayout["Twin"] = "twin";
+	return CoxcombLayout;
+}({});
+var ClockMark = /* @__PURE__ */ function(ClockMark) {
+	ClockMark["Wedges"] = "wedges";
+	ClockMark["Area"] = "area";
+	ClockMark["Heat"] = "heat";
+	ClockMark["Dots"] = "dots";
+	return ClockMark;
+}({});
+var ClockDial = /* @__PURE__ */ function(ClockDial) {
+	ClockDial["Day"] = "day";
+	ClockDial["Split"] = "split";
+	return ClockDial;
+}({});
+var ClockOrigin = /* @__PURE__ */ function(ClockOrigin) {
+	ClockOrigin["Midnight"] = "midnight";
+	ClockOrigin["Noon"] = "noon";
+	return ClockOrigin;
+}({});
+var WindBinning = /* @__PURE__ */ function(WindBinning) {
+	WindBinning["Equal"] = "equal";
+	WindBinning["Quantile"] = "quantile";
+	return WindBinning;
+}({});
+var CircularHeatCell = /* @__PURE__ */ function(CircularHeatCell) {
+	CircularHeatCell["Arc"] = "arc";
+	CircularHeatCell["Dot"] = "dot";
+	return CircularHeatCell;
+}({});
+var CircularHeatOrder = /* @__PURE__ */ function(CircularHeatOrder) {
+	CircularHeatOrder["Data"] = "data";
+	CircularHeatOrder["RowMean"] = "row-mean";
+	return CircularHeatOrder;
+}({});
+var RadialHistogramBinning = /* @__PURE__ */ function(RadialHistogramBinning) {
+	RadialHistogramBinning["Sturges"] = "sturges";
+	RadialHistogramBinning["Scott"] = "scott";
+	RadialHistogramBinning["SquareRoot"] = "square-root";
+	return RadialHistogramBinning;
+}({});
+var RadialHistogramMark = /* @__PURE__ */ function(RadialHistogramMark) {
+	RadialHistogramMark["Wedge"] = "wedge";
+	RadialHistogramMark["Rose"] = "rose";
+	RadialHistogramMark["Outline"] = "outline";
+	return RadialHistogramMark;
+}({});
+var SunburstBarSizing = /* @__PURE__ */ function(SunburstBarSizing) {
+	SunburstBarSizing["Bars"] = "bars";
+	SunburstBarSizing["Partition"] = "partition";
+	return SunburstBarSizing;
+}({});
+var SunburstBarLevels = /* @__PURE__ */ function(SunburstBarLevels) {
+	SunburstBarLevels["All"] = "all";
+	SunburstBarLevels["Top"] = "top";
+	return SunburstBarLevels;
+}({});
+var PolarOverlay = /* @__PURE__ */ function(PolarOverlay) {
+	PolarOverlay["None"] = "none";
+	PolarOverlay["Centroids"] = "centroids";
+	PolarOverlay["Hull"] = "hull";
+	return PolarOverlay;
+}({});
+var RadialDumbbellConnector = /* @__PURE__ */ function(RadialDumbbellConnector) {
+	RadialDumbbellConnector["Line"] = "line";
+	RadialDumbbellConnector["Capsule"] = "capsule";
+	RadialDumbbellConnector["Arrow"] = "arrow";
+	return RadialDumbbellConnector;
+}({});
+var RadialDumbbellSort = /* @__PURE__ */ function(RadialDumbbellSort) {
+	RadialDumbbellSort["Data"] = "data";
+	RadialDumbbellSort["Gap"] = "gap";
+	RadialDumbbellSort["High"] = "high";
+	return RadialDumbbellSort;
+}({});
+var RadialBoxMark = /* @__PURE__ */ function(RadialBoxMark) {
+	RadialBoxMark["Box"] = "box";
+	RadialBoxMark["Violin"] = "violin";
+	RadialBoxMark["Strip"] = "strip";
+	return RadialBoxMark;
+}({});
+var RadialWhisker = /* @__PURE__ */ function(RadialWhisker) {
+	RadialWhisker["Tukey"] = "tukey";
+	RadialWhisker["Percentile"] = "percentile";
+	RadialWhisker["MinMax"] = "min-max";
+	return RadialWhisker;
+}({});
+var RadialGanttLayout = /* @__PURE__ */ function(RadialGanttLayout) {
+	RadialGanttLayout["Rows"] = "rows";
+	RadialGanttLayout["Packed"] = "packed";
+	return RadialGanttLayout;
+}({});
+var RadialGanttSort = /* @__PURE__ */ function(RadialGanttSort) {
+	RadialGanttSort["Start"] = "start";
+	RadialGanttSort["Group"] = "group";
+	RadialGanttSort["Duration"] = "duration";
+	return RadialGanttSort;
+}({});
+export { CircularBarplotArrange, CircularHeatCell, CircularHeatOrder, ClockDial, ClockMark, ClockOrigin, CoxcombLayering, CoxcombLayout, PolarDirection, PolarLabels, PolarLayout, PolarOverlay, PolarSort, PolarSpan, RadarGrid, RadarLayout, RadarScaling, RadialBarStack, RadialBaseline, RadialBoxMark, RadialColumnMark, RadialDumbbellConnector, RadialDumbbellSort, RadialGanttLayout, RadialGanttSort, RadialHistogramBinning, RadialHistogramMark, RadialStackOffset, RadialStackOrder, RadialWhisker, SunburstBarLevels, SunburstBarSizing, TimeSpiralGrowth, TimeSpiralMark, WindBinning };

package/dist/charts/scatter/BeeswarmScatter.js

@@ -0,0 +1,151 @@
+import { ChartFamily, DataShape, Dimension, Orientation, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { CategoryScatterBase } from "./CategoryScatterBase.js";
+import { ascending, forceCollide, forceSimulation, forceX, forceY, max, scaleSqrt } from "d3";
+// src/charts/scatter/BeeswarmScatter.ts
+var BeeswarmLayout = /* @__PURE__ */ function(BeeswarmLayout) {
+	BeeswarmLayout["Dodge"] = "dodge";
+	BeeswarmLayout["Force"] = "force";
+	BeeswarmLayout["Stacked"] = "stacked-dots";
+	return BeeswarmLayout;
+}({});
+var BeeswarmSide = /* @__PURE__ */ function(BeeswarmSide) {
+	BeeswarmSide["Both"] = "two-sided";
+	BeeswarmSide["One"] = "one-sided";
+	return BeeswarmSide;
+}({});
+var BeeswarmLanes = /* @__PURE__ */ function(BeeswarmLanes) {
+	BeeswarmLanes["PerGroup"] = "per-group";
+	BeeswarmLanes["Shared"] = "shared";
+	return BeeswarmLanes;
+}({});
+/** Each point nudged just far enough to avoid its neighbours, so the swarm's shape is the distribution. */
+var BeeswarmScatter = class extends CategoryScatterBase {
+	static meta = {
+		id: "beeswarm-scatter",
+		name: "Beeswarm scatter",
+		family: ChartFamily.Distribution,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Packs points along one measure without overlap, keeping each observation individually visible.",
+		tags: [
+			"swarm",
+			"dodge",
+			"wilkinson dot plot"
+		],
+		sample: (seed) => SampleData.points(seed, 120, 3).map((row) => ({
+			group: row.group,
+			value: row.y,
+			size: row.size
+		})),
+		variants: {
+			orientation: [Orientation.Horizontal, Orientation.Vertical],
+			layout: [
+				"dodge",
+				"force",
+				"stacked-dots"
+			],
+			side: ["two-sided", "one-sided"],
+			lanes: ["per-group", "shared"],
+			sized: [false, true],
+			scale: [ScaleKind.Linear, ScaleKind.Log]
+		},
+		valid: (v) => !(v.layout === "stacked-dots" && v.sized) && !(v.layout === "force" && v.side === "one-sided")
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			orientation: Orientation.Horizontal,
+			layout: "dodge",
+			side: "two-sided",
+			lanes: "per-group",
+			sized: false,
+			radius: 3.5
+		};
+	}
+	/** Greedy dodge: sorted by value, each dot takes the free offset closest to the lane axis. */
+	dodge(bees) {
+		const placed = [];
+		const oneSided = this.options.side === "one-sided";
+		for (const bee of [...bees].sort((a, b) => ascending(a.along, b.along))) {
+			const near = placed.filter((other) => Math.abs(other.along - bee.along) < other.radius + bee.radius + 1);
+			bee.offset = [0, ...near.flatMap((other) => {
+				const gap = other.radius + bee.radius + 1;
+				const rise = Math.sqrt(Math.max(0, gap ** 2 - (other.along - bee.along) ** 2));
+				return [other.offset + rise, other.offset - rise];
+			})].filter((offset) => !oneSided || offset >= 0).sort((a, b) => Math.abs(a) - Math.abs(b)).find((offset) => near.every((other) => (other.along - bee.along) ** 2 + (other.offset - offset) ** 2 >= (other.radius + bee.radius + .9) ** 2)) ?? 0;
+			placed.push(bee);
+		}
+	}
+	force(bees) {
+		const nodes = bees.map((bee) => ({
+			x: bee.along,
+			y: 0,
+			home: bee.along,
+			r: bee.radius + 1
+		}));
+		forceSimulation(nodes).stop().force("x", forceX((d) => d.home).strength(1)).force("y", forceY(0).strength(.08)).force("collide", forceCollide((d) => d.r)).tick(160);
+		nodes.forEach((node, i) => {
+			bees[i].along = node.x;
+			bees[i].offset = node.y;
+		});
+	}
+	/** Wilkinson dot plot: dots snap into value bins and stack from the axis. */
+	stack(bees) {
+		const step = (this.options.radius + 1) * 2;
+		const columns = /* @__PURE__ */ new Map();
+		for (const bee of [...bees].sort((a, b) => ascending(a.along, b.along))) {
+			const bin = Math.round(bee.along / step), height = columns.get(bin) ?? 0;
+			columns.set(bin, height + 1);
+			bee.along = bin * step;
+			bee.offset = (this.options.side === "one-sided" ? height : Math.ceil(height / 2) * (height % 2 ? 1 : -1)) * step;
+		}
+	}
+	arrange(bees) {
+		const { layout } = this.options;
+		if (layout === "force") this.force(bees);
+		else if (layout === "stacked-dots") this.stack(bees);
+		else this.dodge(bees);
+	}
+	laneOf(group) {
+		return this.options.lanes === "shared" ? "" : group;
+	}
+	plotLanes(ctx, axes, lanes) {
+		const vertical = this.vertical, oneSided = this.options.side === "one-sided";
+		const all = lanes.flatMap((lane) => lane.points);
+		all.forEach((point) => ctx.palette.color(point.group));
+		const area = scaleSqrt([0, max(all, (point) => point.size) || 1], [1.5, this.options.radius * 2.2]);
+		const radius = (point) => this.options.sized ? area(point.size) : this.options.radius;
+		const bees = lanes.flatMap((lane) => {
+			const base = lane.center + (oneSided ? (vertical ? -1 : 1) * (lane.breadth / 2 - 4) : 0);
+			const swarm = lane.points.map((point) => ({
+				...point,
+				along: axes.value(point.value),
+				radius: radius(point),
+				offset: 0,
+				center: base
+			}));
+			this.arrange(swarm);
+			const reach = Math.max(1, ...swarm.map((bee) => Math.abs(bee.offset) + bee.radius));
+			const squeeze = Math.min(1, (oneSided ? lane.breadth - 8 : lane.breadth / 2) / reach);
+			return swarm.map((bee) => ({
+				...bee,
+				offset: (oneSided ? (vertical ? 1 : -1) * Math.abs(bee.offset) : bee.offset) * squeeze
+			}));
+		});
+		const cx = (d) => vertical ? d.center + d.offset : d.along;
+		const cy = (d) => vertical ? d.along : d.center + d.offset;
+		const dots = ctx.marks("dots", "circle", bees, (d) => d.index).attr("fill", (d) => ctx.palette.color(d.group)).attr("stroke", ctx.theme.surface).attr("stroke-width", 1);
+		ctx.set(dots, {
+			cx,
+			cy,
+			r: (d) => d.radius
+		}, {
+			cx: (d) => vertical ? d.center : d.along,
+			cy: (d) => vertical ? d.along : d.center,
+			r: 0
+		}, 1);
+		ctx.hover(dots, (d) => this.tooltip(ctx, d));
+	}
+};
+export { BeeswarmLanes, BeeswarmLayout, BeeswarmScatter, BeeswarmSide };

package/dist/charts/scatter/BinnedScatterBase.js

@@ -0,0 +1,51 @@
+import { ScatterBase } from "./ScatterBase.js";
+// src/charts/scatter/BinnedScatterBase.ts
+var BinEncoding = /* @__PURE__ */ function(BinEncoding) {
+	BinEncoding["Color"] = "color";
+	BinEncoding["Size"] = "size";
+	BinEncoding["Both"] = "color-and-size";
+	return BinEncoding;
+}({});
+var BinCount = /* @__PURE__ */ function(BinCount) {
+	BinCount["Linear"] = "linear-count";
+	BinCount["Sqrt"] = "sqrt-count";
+	BinCount["Log"] = "log-count";
+	return BinCount;
+}({});
+/** Shared count-to-mark mapping for charts that aggregate points into cells. */
+var BinnedScatterBase = class extends ScatterBase {
+	defaults() {
+		return {
+			...super.defaults(),
+			encoding: "color",
+			count: "linear-count",
+			raw: false
+		};
+	}
+	/** Share of the peak in 0..1 after the count transform. */
+	share(count, peak) {
+		const { count: kind } = this.options;
+		if (kind === "log-count") return Math.log1p(count) / Math.log1p(peak);
+		if (kind === "sqrt-count") return Math.sqrt(count / peak);
+		return count / peak;
+	}
+	shade(ctx, share) {
+		return ctx.palette.sequential(this.options.encoding === "size" ? .62 : .14 + share * .86);
+	}
+	/** Linear size scale of a cell, so mark area stays proportional to the share. */
+	extent(share) {
+		return this.options.encoding === "color" ? 1 : Math.sqrt(share);
+	}
+	drawRaw(ctx, points) {
+		const dots = ctx.marks("raw", "circle", this.options.raw ? points : [], (d) => d.index).attr("fill", ctx.theme.inkMuted).attr("fill-opacity", .5);
+		ctx.set(dots, {
+			cx: (d) => d.px,
+			cy: (d) => d.py,
+			r: 1.5
+		});
+	}
+	legendItems() {
+		return [];
+	}
+};
+export { BinCount, BinEncoding, BinnedScatterBase };

package/dist/charts/scatter/BubbleChart.js

@@ -0,0 +1,123 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ScatterBase, ScatterMarker, ScatterScaling } from "./ScatterBase.js";
+import { descending, forceCollide, forceSimulation, forceX, forceY, format, max, scaleSqrt } from "d3";
+// src/charts/scatter/BubbleChart.ts
+var BubblePlacement = /* @__PURE__ */ function(BubblePlacement) {
+	BubblePlacement["Exact"] = "exact";
+	BubblePlacement["Separated"] = "separated";
+	return BubblePlacement;
+}({});
+/** Scatter with a third measure in bubble area. Separated placement trades exact position for legibility. */
+var BubbleChart = class extends ScatterBase {
+	static meta = {
+		id: "bubble-scatter",
+		name: "Bubble chart",
+		family: ChartFamily.Relationship,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Adds a third measure to a scatter plot by mapping value to bubble area.",
+		tags: [
+			"bubble",
+			"three measures",
+			"gapminder"
+		],
+		sample: (seed) => SampleData.points(seed, 26).map((row, i) => ({
+			...row,
+			label: `${String(row.group)[0]}${i + 1}`
+		})),
+		variants: {
+			scaling: [
+				ScatterScaling.Linear,
+				ScatterScaling.SemilogX,
+				ScatterScaling.SemilogY,
+				ScatterScaling.LogLog
+			],
+			maxRadius: [
+				24,
+				16,
+				30
+			],
+			placement: ["exact", "separated"],
+			sizeKey: [true, false],
+			labelled: [3, 0]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			maxRadius: 24,
+			placement: "exact",
+			sizeKey: true,
+			labelled: 3,
+			marker: ScatterMarker.Circle
+		};
+	}
+	inset() {
+		return this.options.maxRadius;
+	}
+	bubbles(points, area) {
+		const bubbles = points.map((point) => ({
+			...point,
+			radius: Math.max(2, area(Math.max(0, point.size)))
+		})).sort((a, b) => descending(a.radius, b.radius));
+		if (this.options.placement !== "separated") return bubbles;
+		const nodes = bubbles.map((bubble) => ({
+			...bubble,
+			x: bubble.px,
+			y: bubble.py,
+			home: [bubble.px, bubble.py]
+		}));
+		forceSimulation(nodes).stop().force("x", forceX((d) => d.home[0]).strength(.25)).force("y", forceY((d) => d.home[1]).strength(.25)).force("collide", forceCollide((d) => d.radius + 1.5).iterations(3)).tick(120);
+		return bubbles.map((bubble, i) => ({
+			...bubble,
+			px: nodes[i].x,
+			py: nodes[i].y
+		}));
+	}
+	plotPoints(ctx, _axes, points) {
+		const { width, height } = ctx.plot;
+		const top = max(points, (point) => point.size) || 1;
+		const area = scaleSqrt([0, top], [0, this.options.maxRadius]);
+		const bubbles = this.bubbles(points, area).map((bubble) => ({
+			...bubble,
+			px: Math.min(width - bubble.radius, Math.max(bubble.radius, bubble.px)),
+			py: Math.min(height - bubble.radius, Math.max(bubble.radius, bubble.py))
+		}));
+		this.drawDots(ctx, bubbles, {
+			radius: (point) => point.radius,
+			marker: ScatterMarker.Circle
+		}).attr("fill-opacity", .82);
+		this.drawLabels(ctx, bubbles);
+		if (this.options.sizeKey) this.drawSizeKey(ctx, area, top, bubbles);
+	}
+	drawLabels(ctx, bubbles) {
+		const named = bubbles.filter((bubble) => bubble.label && bubble.label.length * 5.8 < bubble.radius * 2 - 4).slice(0, this.options.labelled);
+		const labels = ctx.marks("bubble-labels", "text", named, (d) => d.index).attr("text-anchor", "middle").attr("dy", "0.35em").attr("pointer-events", "none").text((d) => d.label);
+		ctx.text(labels, 10.5).attr("fill", (d) => ctx.palette.inkOn(this.hue(ctx, d)));
+		ctx.set(labels, {
+			x: (d) => d.px,
+			y: (d) => d.py
+		});
+	}
+	drawSizeKey(ctx, area, top, bubbles) {
+		const round = +top.toPrecision(1), steps = [round, round / 4];
+		const biggest = area(round);
+		const corner = this.quietCorner(ctx, bubbles);
+		const cx = corner.anchor === "start" ? corner.x + biggest : corner.x - biggest - 26;
+		const base = corner.y < ctx.plot.height / 2 ? corner.y - 8 + biggest * 2 : corner.y + 12;
+		const rings = ctx.marks("size-key", "circle", steps, (d) => d).attr("fill", "none").attr("stroke", ctx.theme.axis);
+		ctx.set(rings, {
+			cx,
+			cy: (d) => base - area(d),
+			r: (d) => area(d)
+		});
+		const notes = ctx.marks("size-key-text", "text", steps, (d) => d).text((d) => format("~s")(d));
+		ctx.text(notes, 10, "muted");
+		ctx.set(notes, {
+			x: cx + biggest + 4,
+			y: (d) => base - area(d) * 2 + 8
+		});
+	}
+};
+export { BubbleChart, BubblePlacement };